✨ Move param dec to class

The parameter decorator is now not applied on the class after the
class declaration, but instead added as class decorator itself.

This is imitated from TypeScript compilation.
It leads to more consistency between compilers and increases
compatibility of libraries that depend on this behavior.

Furthermore the `design:type` decorator is also added to each decorated
class (with value `Function`, as TSC does as well).

Author: wtho

README.md

@@ -143,13 +143,3 @@ export const lazyInject = fixPropertyDecorator(originalLazyInject);
   concrete values (like classes, etc.). In order to resolve this, we emit the
   following: `typeof Type === 'undefined' ? Object : Type`. The code has the
   advantage of not throwing. If you know a better way to do this, let me know!
-- Parameter decorators are emitted right _after_ the `ClassDeclaration` node,
-  like:
-
-  ```js
-  let A = (/* ... */)
-  Inject()(A.prototype, 'methodName', 1);
-  ```
-
-  I'm not sure if this can cause issue with scoping, if you get in troubles with
-  this kind of decorators, please open an issue.

src/metadata/metadataVisitor.ts

@@ -2,6 +2,24 @@ import { NodePath } from '@babel/traverse';
 import { types as t } from '@babel/core';
 import { serializeType } from './serializeType';
 
+function createMetadataDesignDecorator(
+  design: 'design:type' | 'design:paramtypes' | 'design:returntype' | 'design:typeinfo',
+  typeArg: t.Expression | t.SpreadElement | t.JSXNamespacedName | t.ArgumentPlaceholder
+): t.Decorator {
+  return t.decorator(
+    t.callExpression(
+      t.memberExpression(
+        t.identifier('Reflect'),
+        t.identifier('metadata')
+      ),
+      [
+        t.stringLiteral(design),
+        typeArg
+      ]
+    )
+  )
+}
+
 export function metadataVisitor(
   classPath: NodePath<t.ClassDeclaration>,
   path: NodePath<t.ClassProperty | t.ClassMethod>
@@ -17,21 +35,22 @@ export function metadataVisitor(
       if (!decorators || decorators.length === 0) return;
 
       decorators!.push(
-        t.decorator(
-          t.callExpression(
-            t.memberExpression(
-              t.identifier('Reflect'),
-              t.identifier('metadata')
-            ),
-            [
-              t.stringLiteral('design:paramtypes'),
-              t.arrayExpression(
-                field.params.map(param => serializeType(classPath, param))
-              )
-            ]
+        createMetadataDesignDecorator(
+          'design:type',
+          t.identifier('Function')
+        )
+      );
+      decorators!.push(
+        createMetadataDesignDecorator(
+          'design:paramtypes',
+          t.arrayExpression(
+            field.params.map(param => serializeType(classPath, param))
           )
         )
       );
+      // Hint: `design:returntype` could also be implemented here, although this seems
+      // quite complicated to achieve without the TypeScript compiler.
+      // See https://github.com/microsoft/TypeScript/blob/f807b57356a8c7e476fedc11ad98c9b02a9a0e81/src/compiler/transformers/ts.ts#L1315
       break;
 
     case 'ClassProperty':
@@ -44,14 +63,9 @@ export function metadataVisitor(
         return;
 
       field.decorators!.push(
-        t.decorator(
-          t.callExpression(
-            t.memberExpression(
-              t.identifier('Reflect'),
-              t.identifier('metadata')
-            ),
-            [t.stringLiteral('design:type'), serializeType(classPath, field)]
-          )
+        createMetadataDesignDecorator(
+          'design:type',
+          serializeType(classPath, field)
         )
       );
       break;

src/parameter/parameterVisitor.ts

@@ -1,6 +1,45 @@
 import { NodePath } from '@babel/traverse';
 import { types as t } from '@babel/core';
 
+/**
+ * Helper function to create a field/class decorator from a parameter decorator.
+ * Field/class decorators get three arguments: the class, the name of the method
+ * (or 'undefined' in the case of the constructor) and the position index of the
+ * parameter in the argument list.
+ * Some of this information, the index, is only available at transform time, and
+ * has to be stored. The other arguments are part of the decorator signature and
+ * will be passed to the decorator anyway. But the decorator has to be called
+ * with all three arguments at runtime, so this creates a function wrapper, which
+ * takes the target and the key, and adds the index to it.
+ *
+ * Inject() becomes function(target, key) { return Inject()(target, key, 0) }
+ *
+ * @param paramIndex the index of the parameter inside the function call
+ * @param decoratorExpression the decorator expression, the return object of SomeParameterDecorator()
+ * @param isConstructor indicates if the key should be set to 'undefined'
+ */
+function createParamDecorator(
+  paramIndex: number,
+  decoratorExpression: t.Expression,
+  isConstructor: boolean = false
+) {
+  return t.decorator(
+    t.functionExpression(
+      null, // anonymous function
+      [t.identifier('target'), t.identifier('key')],
+      t.blockStatement([
+        t.returnStatement(
+          t.callExpression(decoratorExpression, [
+            t.identifier('target'),
+            t.identifier(isConstructor ? 'undefined' : 'key'),
+            t.numericLiteral(paramIndex)
+          ])
+        )
+      ])
+    )
+  );
+}
+
 export function parameterVisitor(
   classPath: NodePath<t.ClassDeclaration>,
   path: NodePath<t.ClassMethod> | NodePath<t.ClassProperty>
@@ -10,7 +49,6 @@ export function parameterVisitor(
   if (path.node.key.type !== 'Identifier') return;
 
   const methodPath = path as NodePath<t.ClassMethod>;
-  const methodName = path.node.key.name;
   const params = methodPath.get('params') || [];
 
   params.slice().forEach(function(param) {
@@ -24,30 +62,32 @@ export function parameterVisitor(
 
     if (identifier == null) return;
 
-    let resultantDecorator;
+    let resultantDecorator: t.Decorator | undefined;
 
     ((param.node as t.Identifier).decorators || [])
       .slice()
       .forEach(function(decorator) {
-        const className = classPath.node!.id!.name;
-
         if (methodPath.node.kind === 'constructor') {
-          resultantDecorator = t.callExpression(decorator.expression, [
-            t.identifier(className),
-            t.identifier('undefined'),
-            t.numericLiteral(param.key as number)
-          ]);
+          resultantDecorator = createParamDecorator(
+            param.key as number,
+            decorator.expression,
+            true
+          );
+          if (!classPath.node.decorators) {
+            classPath.node.decorators = [];
+          }
+          classPath.node.decorators.push(resultantDecorator);
         } else {
-          resultantDecorator = t.callExpression(decorator.expression, [
-            t.identifier(`${className}.prototype`),
-            t.stringLiteral(methodName),
-            t.numericLiteral(param.key as number)
-          ]);
+          resultantDecorator = createParamDecorator(
+            param.key as number,
+            decorator.expression,
+            false
+          );
+          if (!methodPath.node.decorators) {
+            methodPath.node.decorators = [];
+          }
+          methodPath.node.decorators.push(resultantDecorator);
         }
-
-        const expression = t.expressionStatement(resultantDecorator);
-
-        classPath.insertAfter(expression);
       });
 
     if (resultantDecorator) {

test/__fixtures__/generics/output.js

@@ -1,13 +1,14 @@
-var _dec, _dec2, _class, _class2;
+var _dec, _dec2, _dec3, _dec4, _dec5, _class, _class2;
 
 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 MyClass = (_dec = Reflect.metadata("design:paramtypes", [typeof Generic === "undefined" ? Object : Generic, typeof Generic === "undefined" ? Object : Generic]), _dec2 = Reflect.metadata("design:paramtypes", [typeof Inter === "undefined" ? Object : Inter, typeof InterGen === "undefined" ? Object : InterGen]), Decorate(_class = _dec(_class = (_class2 = class MyClass {
+let MyClass = (_dec = Reflect.metadata("design:type", Function), _dec2 = Reflect.metadata("design:paramtypes", [typeof Generic === "undefined" ? Object : Generic, typeof Generic === "undefined" ? Object : Generic]), _dec3 = function (target, key) {
+  return Arg()(target, key, 1);
+}, _dec4 = Reflect.metadata("design:type", Function), _dec5 = Reflect.metadata("design:paramtypes", [typeof Inter === "undefined" ? Object : Inter, typeof InterGen === "undefined" ? Object : InterGen]), Decorate(_class = _dec(_class = _dec2(_class = (_class2 = class MyClass {
   constructor(generic, generic2) {
     this.generic = generic;
   }
 
   method(generic, generic2) {}
 
-}, (_applyDecoratedDescriptor(_class2.prototype, "method", [Run, _dec2], Object.getOwnPropertyDescriptor(_class2.prototype, "method"), _class2.prototype)), _class2)) || _class) || _class);
-Arg()(MyClass.prototype, "method", 1);
+}, (_applyDecoratedDescriptor(_class2.prototype, "method", [Run, _dec3, _dec4, _dec5], Object.getOwnPropertyDescriptor(_class2.prototype, "method"), _class2.prototype)), _class2)) || _class) || _class) || _class);

test/__fixtures__/nest-injection/output.js

@@ -1,4 +1,4 @@
-var _dec, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _class, _class2, _descriptor, _descriptor2, _temp;
+var _dec, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _dec9, _dec10, _class, _class2, _descriptor, _descriptor2, _temp;
 
 function _initializerDefineProperty(target, property, descriptor, context) { if (!descriptor) return; Object.defineProperty(target, property, { enumerable: descriptor.enumerable, configurable: descriptor.configurable, writable: descriptor.writable, value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 }); }
 
@@ -7,7 +7,7 @@ function _applyDecoratedDescriptor(target, property, decorators, descriptor, con
 function _initializerWarningHelper(descriptor, context) { throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and set to use loose mode. ' + 'To use proposal-class-properties in spec mode with decorators, wait for ' + 'the next major version of decorators in stage 2.'); }
 
 import { AppService } from './app.service';
-export let AppController = (_dec = Controller(), _dec2 = Reflect.metadata("design:paramtypes", [typeof AppService === "undefined" ? Object : AppService]), _dec3 = Inject(), _dec4 = Reflect.metadata("design:type", typeof AppService === "undefined" ? Object : AppService), _dec5 = Inject(), _dec6 = Reflect.metadata("design:type", typeof AppService === "undefined" ? Object : AppService), _dec7 = Get(), _dec8 = Reflect.metadata("design:paramtypes", []), _dec(_class = _dec2(_class = (_class2 = (_temp = class AppController {
+export let AppController = (_dec = Controller(), _dec2 = Reflect.metadata("design:type", Function), _dec3 = Reflect.metadata("design:paramtypes", [typeof AppService === "undefined" ? Object : AppService]), _dec4 = Inject(), _dec5 = Reflect.metadata("design:type", typeof AppService === "undefined" ? Object : AppService), _dec6 = Inject(), _dec7 = Reflect.metadata("design:type", typeof AppService === "undefined" ? Object : AppService), _dec8 = Get(), _dec9 = Reflect.metadata("design:type", Function), _dec10 = Reflect.metadata("design:paramtypes", []), _dec(_class = _dec2(_class = _dec3(_class = (_class2 = (_temp = class AppController {
   constructor(appService) {
     this.appService = appService;
 
@@ -20,14 +20,14 @@ export let AppController = (_dec = Controller(), _dec2 = Reflect.metadata("desig
     return this.appService.getHello();
   }
 
-}, _temp), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "appService", [_dec3, _dec4], {
+}, _temp), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "appService", [_dec4, _dec5], {
   configurable: true,
   enumerable: true,
   writable: true,
   initializer: null
-}), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "appService2", [_dec5, _dec6], {
+}), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "appService2", [_dec6, _dec7], {
   configurable: true,
   enumerable: true,
   writable: true,
   initializer: null
-}), _applyDecoratedDescriptor(_class2.prototype, "getHello", [_dec7, _dec8], Object.getOwnPropertyDescriptor(_class2.prototype, "getHello"), _class2.prototype)), _class2)) || _class) || _class);
+}), _applyDecoratedDescriptor(_class2.prototype, "getHello", [_dec8, _dec9, _dec10], Object.getOwnPropertyDescriptor(_class2.prototype, "getHello"), _class2.prototype)), _class2)) || _class) || _class) || _class);

test/__fixtures__/parameter-decorator-typed/output.js

@@ -1,16 +1,26 @@
-var _dec, _dec2, _class, _dec3, _dec4, _dec5, _class2, _class3;
+var _dec, _dec2, _dec3, _class, _dec4, _dec5, _dec6, _dec7, _dec8, _dec9, _dec10, _dec11, _dec12, _dec13, _dec14, _dec15, _class2, _class3, _dec16, _dec17, _dec18, _dec19, _dec20, _dec21, _dec22, _dec23, _class4, _class5;
 
 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; }
 
 class Injected {}
 
-class MyClass {
+let MyClass = (_dec = function (target, key) {
+  return inject()(target, undefined, 0);
+}, _dec2 = Reflect.metadata("design:type", Function), _dec3 = Reflect.metadata("design:paramtypes", [typeof Injected === "undefined" ? Object : Injected]), _dec(_class = _dec2(_class = _dec3(_class = class MyClass {
   constructor(parameter) {}
 
-}
-
-inject()(MyClass, undefined, 0);
-let MyOtherClass = (_dec = decorate('named'), _dec2 = Reflect.metadata("design:paramtypes", [typeof Injected === "undefined" ? Object : Injected, typeof Schema === "undefined" ? Object : Schema]), (_class = class MyOtherClass {
+}) || _class) || _class) || _class);
+let MyOtherClass = (_dec4 = function (target, key) {
+  return inject()(target, undefined, 0);
+}, _dec5 = function (target, key) {
+  return inject('KIND')(target, undefined, 1);
+}, _dec6 = Reflect.metadata("design:type", Function), _dec7 = Reflect.metadata("design:paramtypes", [typeof Injected === "undefined" ? Object : Injected, typeof Injected === "undefined" ? Object : Injected]), _dec8 = function (target, key) {
+  return demo()(target, key, 0);
+}, _dec9 = Reflect.metadata("design:type", Function), _dec10 = Reflect.metadata("design:paramtypes", [String, void 0]), _dec11 = decorate('named'), _dec12 = function (target, key) {
+  return inject()(target, key, 0);
+}, _dec13 = function (target, key) {
+  return arg()(target, key, 1);
+}, _dec14 = Reflect.metadata("design:type", Function), _dec15 = Reflect.metadata("design:paramtypes", [typeof Injected === "undefined" ? Object : Injected, typeof Schema === "undefined" ? Object : Schema]), _dec4(_class2 = _dec5(_class2 = _dec6(_class2 = _dec7(_class2 = (_class3 = class MyOtherClass {
   constructor(parameter, otherParam) {
     this.parameter = parameter;
   }
@@ -19,20 +29,18 @@ let MyOtherClass = (_dec = decorate('named'), _dec2 = Reflect.metadata("design:p
 
   method(param, schema) {}
 
-}, (_applyDecoratedDescriptor(_class.prototype, "method", [_dec, _dec2], Object.getOwnPropertyDescriptor(_class.prototype, "method"), _class.prototype)), _class));
-arg()(MyOtherClass.prototype, "method", 1);
-inject()(MyOtherClass.prototype, "method", 0);
-demo()(MyOtherClass.prototype, "methodUndecorated", 0);
-inject('KIND')(MyOtherClass, undefined, 1);
-inject()(MyOtherClass, undefined, 0);
-let DecoratedClass = (_dec3 = Reflect.metadata("design:paramtypes", [typeof Injected === "undefined" ? Object : Injected, typeof Injected === "undefined" ? Object : Injected]), _dec4 = decorate('example'), _dec5 = Reflect.metadata("design:paramtypes", [String]), Decorate(_class2 = _dec3(_class2 = (_class3 = class DecoratedClass {
+}, (_applyDecoratedDescriptor(_class3.prototype, "methodUndecorated", [_dec8, _dec9, _dec10], Object.getOwnPropertyDescriptor(_class3.prototype, "methodUndecorated"), _class3.prototype), _applyDecoratedDescriptor(_class3.prototype, "method", [_dec11, _dec12, _dec13, _dec14, _dec15], Object.getOwnPropertyDescriptor(_class3.prototype, "method"), _class3.prototype)), _class3)) || _class2) || _class2) || _class2) || _class2);
+let DecoratedClass = (_dec16 = function (target, key) {
+  return inject()(target, undefined, 0);
+}, _dec17 = function (target, key) {
+  return inject()(target, undefined, 1);
+}, _dec18 = Reflect.metadata("design:type", Function), _dec19 = Reflect.metadata("design:paramtypes", [typeof Injected === "undefined" ? Object : Injected, typeof Injected === "undefined" ? Object : Injected]), _dec20 = decorate('example'), _dec21 = function (target, key) {
+  return inject()(target, key, 0);
+}, _dec22 = Reflect.metadata("design:type", Function), _dec23 = Reflect.metadata("design:paramtypes", [String]), Decorate(_class4 = _dec16(_class4 = _dec17(_class4 = _dec18(_class4 = _dec19(_class4 = (_class5 = class DecoratedClass {
   constructor(module, otherModule) {
     this.module = module;
   }
 
   method(param) {}
 
-}, (_applyDecoratedDescriptor(_class3.prototype, "method", [_dec4, _dec5], Object.getOwnPropertyDescriptor(_class3.prototype, "method"), _class3.prototype)), _class3)) || _class2) || _class2);
-inject()(DecoratedClass.prototype, "method", 0);
-inject()(DecoratedClass, undefined, 1);
-inject()(DecoratedClass, undefined, 0);
+}, (_applyDecoratedDescriptor(_class5.prototype, "method", [_dec20, _dec21, _dec22, _dec23], Object.getOwnPropertyDescriptor(_class5.prototype, "method"), _class5.prototype)), _class5)) || _class4) || _class4) || _class4) || _class4) || _class4);