Decorators 2 Transform [WIP]

packages/babel-core/src/transformation/file/index.js

@@ -223,13 +223,12 @@ export default class File extends Store {
     return id;
   }
 
-  addHelper(name: string): Object {
+  addHelper(name: string, deps: Array<string>): Object {
     const declar = this.declarations[name];
     if (declar) return declar;
 
     if (!this.usedHelpers[name]) {
       this.metadata.usedHelpers.push(name);
-      this.usedHelpers[name] = true;
     }
 
     const generator = this.get("helperGenerator");
@@ -241,7 +240,18 @@ export default class File extends Store {
       return t.memberExpression(runtime, t.identifier(name));
     }
 
-    const ref = getHelper(name);
+    const opts = {};
+    if (deps) {
+      for (const dep in deps) {
+        if (!this.usedHelpers[name]) {
+          throw "Helper dependencies must be added to the file first";
+        } else {
+          opts["babelHelpers." + dep] = this.usedHelpers[name];
+        }
+      }
+    }
+
+    const ref = getHelper(name, opts);
     const uid = (this.declarations[name] = this.scope.generateUidIdentifier(
       name,
     ));
@@ -260,6 +270,8 @@ export default class File extends Store {
       });
     }
 
+    this.usedHelpers[name] = uid.name;
+
     return uid;
   }
 

packages/babel-helpers/src/helpers.js

@@ -270,6 +270,174 @@ helpers.createClass = template(`
   })()
 `);
 
+//NOTE: convention is 'descriptor' is used for element descriptors, while 'propertyDescriptor' is used for
+//property descriptor in all helpers related to decorators-2
+helpers.decorate = template(`
+  (function (constructor, undecorated, memberDecorators, heritage) {
+    const prototype = constructor.prototype;
+    let finishers = [];
+    const elementDescriptors = {}; // elementDescriptors is meant to be an array, so this will be converted later
+    const staticElementDescriptors = {};
+
+    for (const [key, isStatic] of undecorated) {
+      const map = isStatic? staticElementDescriptors : elementDescriptors;
+      const target = isStatic ? constructor : prototype;
+      const propertyDescriptor = Object.getOwnPropertyDescriptor(target, key);
+      map[key] = babelHelpers.makeElementDescriptor(
+        "property",
+        key,
+        isStatic,
+        propertyDescriptor,
+      );
+    }
+
+    // decorate and store in elementDescriptors or staticElementDescriptors
+    for (const [key, decorators, isStatic] of memberDecorators) {
+      const map = isStatic ? staticElementDescriptors : elementDescriptors;
+      const target = isStatic ? constructor : prototype;
+      const propertyDescriptor = 
+        map[key] && map[key].descriptor || Object.getOwnPropertyDescriptor(target, key);
+
+      const elementDescriptor = babelHelpers.makeElementDescriptor(
+        "property",
+        key,
+        isStatic,
+        propertyDescriptor,
+      );
+
+      const decorated = babelHelpers.decorateElement(elementDescriptor, decorators);
+
+      map[key] = decorated.descriptor;
+
+      for (const extra of decorated.extras) {
+        // extras is an array of element descriptors
+        const map = extra.isStatic? staticElementDescriptors : elementDescriptors;
+        // TODO: refactor to use proper merging logic here. currently it's just overriding
+        map[extra.key] = extra;
+      }
+
+      finishers = finishers.concat(decorated.finishers);
+    }
+
+    return function(classDecorators) {
+      const result = babelHelpers.decorateClass(
+        constructor,
+        classDecorators,
+        heritage,
+        Object.values(elementDescriptors).concat(Object.values(staticElementDescriptors))
+      );
+
+      finishers = finishers.concat(result.finishers);
+      //TODO: heritage hacks so result.constructor has the correct prototype and instanceof results
+      //NOTE: step 38 and 39 in spec, refer to some "initialize" state which hasn't been implemented,
+      //because it's unlikely to stay in future versions of the spec
+
+      for (const elementDescriptor of result.elements) {
+        const target = elementDescriptor.isStatic ? constructor : prototype;
+        Object.defineProperty(
+          target,
+          elementDescriptor.key,
+          elementDescriptor.descriptor
+        );
+      }
+
+      for (let finisher of finishers) {
+        finisher.call(undefined, result.constructor);
+      }
+
+      return result.constructor;
+    };
+  });
+`);
+
+//TODO guarding against malformed descriptors returned by decorators
+helpers.decorateElement = template(`
+  (function (descriptor, decorators) {
+    //spec uses the param "element" instead of "descriptor" and finds descriptor from it
+    let extras = [];
+    let finishers = [];
+
+    let previousDescriptor = descriptor;
+
+    for (let i = decorators.length - 1; i >= 0; i--) {
+      const decorator = decorators[i];
+      const shallowClone = {
+        configurable: previousDescriptor.descriptor.configurable,
+        enumerable: previousDescriptor.descriptor.enumerable,
+        writable: previousDescriptor.descriptor.writable,
+        value: previousDescriptor.descriptor.value
+      }
+
+      const result = decorator(previousDescriptor);
+
+      if (!shallowClone.configurable) {
+        let check = 
+          result.descriptor.configurable === shallowClone.configurable &&
+          result.descriptor.enumerable === shallowClone.enumerable &&
+          result.descriptor.writable === shallowClone.writable &&
+          result.descriptor.value === shallowClone.value;
+
+        if (!check) {
+          throw new Error("Decorator tried to change unconfigurable property descriptor");
+        }
+      }
+
+      //TODO: why does .finisher exist on an elementDescriptor? the following conditional deviates from 
+      //the spec because it uses result.finishers rather than result.descriptor.finisher
+      if (result.finishers) {
+        finishers = finishers.concat(result.finishers);
+      }
+
+      previousDescriptor = result.descriptor;
+
+      const extrasObject = result.extras;
+
+      if (extrasObject) {
+        for (const extra of extrasObject) {
+          extras.push(extra);
+        }
+      }
+    }
+
+    extras = babelHelpers.mergeDuplicateElements(extras);
+
+    return { descriptor: previousDescriptor, extras, finishers };
+  });
+`);
+
+helpers.decorateClass = template(`
+  (function (constructor, decorators, heritage, elementDescriptors) {
+    let elements = elementDescriptors;
+    let finishers = [];
+
+    let previousConstructor = constructor;
+
+    for (let i = decorators.length - 1; i >= 0; i--) {
+      const decorator = decorators[i];
+      const result = decorator(
+        previousConstructor,
+        heritage,
+        elements
+      );
+
+      previousConstructor = result.constructor;
+
+      if (result.finishers) {
+        // result.finishers is called 'finisher' in the spec
+        finishers = finishers.concat(result.finishers);
+      }
+
+      if (result.elements) {
+        elements = elements.concat(result.elements); //FIXME: for some reason using for of exhausts heap here
+      }
+
+      elements = babelHelpers.mergeDuplicateElements(elements);
+    }
+
+    return { constructor: previousConstructor, elements, finishers };
+  });
+`);
+
 helpers.defineEnumerableProperties = template(`
   (function (obj, descs) {
     for (var key in descs) {
@@ -417,6 +585,54 @@ helpers.interopRequireWildcard = template(`
   })
 `);
 
+helpers.makeElementDescriptor = template(`
+  (function (kind, key, isStatic, descriptor, finisher) {
+    var elementDescriptor = { kind, key, isStatic, descriptor};
+    if (finisher) {
+      elementDescriptor.finisher = finisher;
+    }
+    return elementDescriptor;
+  });
+`);
+
+/** 
+ * NOTE: Details for merging haven't been decided on by TC39.
+ * The following function implements a reasonable merging strategy - which 
+ * is to merge getters and setters, and to override everything else 
+ **/
+helpers.mergeDuplicateElements = template(`
+  (function (elements) {
+    let elementMap = {};
+    let staticElementMap = {};
+
+    for (let elementDescriptor of elements) {
+      let map = elementDescriptor.isStatic? staticElementMap : elementMap;
+
+      if (!map[elementDescriptor.key]) {
+        map[elementDescriptor.key] = elementDescriptor;
+      } else {
+        let prev = map[elementDescriptor.key];
+        let isDataDescriptor = !!prev.descriptor.value;
+        let newIsDataDescriptor = !!elementDescriptor.descriptor.value;
+
+        if (!newIsDataDescriptor && !isDataDescriptor) {
+          // if both are accessor descriptors, merge getters and setters
+          let get = elementDescriptor.descriptor.get || prev.descriptor.get;
+          let set = elementDescriptor.descriptor.set || prev.descriptor.set;
+
+          let descriptor = Object.assign({}, elementDescriptor.descriptor, {get, set});
+
+          map[elementDescriptor.key] = Object.assign({}, elementDescriptor, {descriptor});
+        } else {
+          map[elementDescriptor.key] = elementDescriptor; // overrideprevious descriptor
+        }
+      }
+    }
+
+    return Object.values(elementMap).concat(Object.values(staticElementMap)); 
+  });
+`);
+
 helpers.newArrowCheck = template(`
   (function (innerThis, boundThis) {
     if (innerThis !== boundThis) {

packages/babel-helpers/src/index.js

@@ -1,10 +1,10 @@
 import helpers from "./helpers";
 
-export function get(name) {
+export function get(name, opts) {
   const fn = helpers[name];
   if (!fn) throw new ReferenceError(`Unknown helper ${name}`);
 
-  return fn().expression;
+  return fn(opts).expression;
 }
 
 export const list = Object.keys(helpers)

packages/babel-plugin-syntax-decorators-2/.npmignore

@@ -0,0 +1,3 @@
+src
+test
+*.log

packages/babel-plugin-syntax-decorators-2/README.md

@@ -0,0 +1,35 @@
+# babel-plugin-syntax-decorators-2
+
+> Updated parsing of decorators.
+
+## Installation
+
+```sh
+npm install --save-dev babel-plugin-syntax-decorators-2
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["syntax-decorators-2"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins syntax-decorators-2 script.js
+```
+
+### Via Node API
+
+```javascript
+require("babel-core").transform("code", {
+  plugins: ["syntax-decorators-2"]
+});
+```

packages/babel-plugin-syntax-decorators-2/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "babel-plugin-syntax-decorators-2",
+  "version": "7.0.0-alpha.19",
+  "description": "Updated parsing of decorators",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-decorators-2",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {},
+  "devDependencies": {}
+}

packages/babel-plugin-syntax-decorators-2/src/index.js

@@ -0,0 +1,7 @@
+export default function() {
+  return {
+    manipulateOptions(opts, parserOpts) {
+      parserOpts.plugins.push("decorators2");
+    },
+  };
+}

packages/babel-plugin-transform-decorators-2/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "babel-plugin-transform-decorators-2",
+  "version": "7.0.0-alpha.19",
+  "author": "Peeyush Kushwaha <peeyush.p97@gmail.com>",
+  "license": "MIT",
+  "description": "Transformer for stage-2 decorators",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-decorators-2",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel",
+    "babel-plugin",
+    "decorators"
+  ],
+  "dependencies": {
+    "babel-plugin-syntax-decorators-2": "7.0.0-alpha.19"
+  },
+  "devDependencies": {
+    "babel-helper-plugin-test-runner": "7.0.0-alpha.19",
+    "babel-helper-transform-fixture-test-runner": "7.0.0-alpha.19",
+    "babel-plugin-transform-decorators-2": "7.0.0-alpha.19"
+  }
+}