Ensure decorators provided by Ember are handled when the identifier is aliased.

tldr; decorator paths are not always included in
`path.scope.getBinding(local.name)`

In some circumstances, decorators are not included in the reference
paths for a local binding when the decorator identifier name is also
defined _within_ the method being decorated. This is likely a bug in
Babel, that should be reported and fixed.

Author: Robert Jackson

__tests__/index-test.js

@@ -444,16 +444,16 @@ export default class MyController extends Controller {
       ['@babel/plugin-proposal-decorators', { legacy: true }],
     ]);
 
-    expect(actual)
-      .toEqual(`var _class;
+    expect(actual).toEqual(`var _dec, _class;
 
 function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }
 
-let MyController = (_class = class MyController extends Ember.Controller {
+let MyController = (_dec = Ember._action, (_class = class MyController extends Ember.Controller {
   addAction(action) {
     this.actions.pushObject(action);
   }
-}, (_applyDecoratedDescriptor(_class.prototype, "addAction", [Ember._action], Object.getOwnPropertyDescriptor(_class.prototype, "addAction"), _class.prototype)), _class);
+
+}, (_applyDecoratedDescriptor(_class.prototype, "addAction", [_dec], Object.getOwnPropertyDescriptor(_class.prototype, "addAction"), _class.prototype)), _class));
 export { MyController as default };`);
   });
 });

src/index.js

@@ -13,6 +13,24 @@ function isIgnored(ignore, importPath, exportName) {
   }
 }
 
+function isDecorator(moduleName, importName) {
+  switch (moduleName) {
+    case '@ember/service':
+      return importName === 'inject';
+    case '@ember/controller':
+      return importName === 'inject';
+    case '@glimmer/tracking':
+      return importName === 'tracked';
+    case '@ember/object/compat':
+      return importName === 'dependentKeyCompat';
+    case '@ember/object':
+      return ['action', 'computed'].includes(importName);
+    case '@ember/object/computed':
+      // only the default import of this module is not a decorator
+      return importName !== 'default';
+  }
+}
+
 module.exports = function (babel) {
   const t = babel.types;
 
@@ -165,10 +183,36 @@ module.exports = function (babel) {
                 ])
               );
             } else {
-              // Replace the occurences of the imported name with the global name.
               let binding = path.scope.getBinding(local.name);
+              let referencePaths = binding.referencePaths;
+
+              if (isDecorator(importPath, importName)) {
+                // tldr; decorator paths are not always included in `path.scope.getBinding(local.name)`
+                //
+                // In some circumstances, decorators are not included in the
+                // reference paths for a local binding when the decorator
+                // identifier name is also defined _within_ the method being
+                // decorated. This is likely a bug in Babel, that should be
+                // reported and fixed.
+                //
+                // in order to fix that, we have to manually traverse to gather
+                // the decorator references **before** the
+                // @babel/plugin-proposal-decorators runs (because it removes
+                // them)
+                path.parentPath.traverse({
+                  Decorator(decoratorPath) {
+                    if (
+                      decoratorPath.node.expression.type === 'Identifier' &&
+                      decoratorPath.node.expression.name === local.name
+                    ) {
+                      referencePaths.push(decoratorPath.get('expression'));
+                    }
+                  },
+                });
+              }
 
-              binding.referencePaths.forEach((referencePath) => {
+              // Replace the occurences of the imported name with the global name.
+              referencePaths.forEach((referencePath) => {
                 if (!isTypescriptNode(referencePath.parentPath)) {
                   referencePath.replaceWith(getMemberExpressionFor(global));
                 }