Rename all proposal plugins to -proposal- from -transform- (#6570)

packages/babel-plugin-proposal-decorators/test/fixtures/class-constructors/mutate-existing-constructor/exec.js

@@ -0,0 +1,10 @@
+function dec(cls){
+  cls.staticProp = "prop";
+}
+
+@dec
+class Parent {
+  parent() {};
+}
+
+assert.equal(Parent.staticProp, "prop");

packages/babel-plugin-proposal-decorators/test/fixtures/class-constructors/return-new-constructor/exec.js

@@ -0,0 +1,13 @@
+function dec(cls){
+  return class Child extends cls {
+    child(){}
+  };
+}
+
+@dec
+class Parent {
+  parent(){}
+}
+
+assert.equal(typeof Parent.prototype.parent, "function")
+assert.equal(typeof Parent.prototype.child, "function")

packages/babel-plugin-proposal-decorators/test/fixtures/class-export-default/exec.js

@@ -0,0 +1,14 @@
+const calls = [];
+
+function foo(target) {
+  calls.push(target.name);
+}
+
+@foo
+export default class Foo {
+  bar() {
+    class Baz {}
+  }
+}
+
+assert.deepEqual(calls, ["Foo"]);

packages/babel-plugin-proposal-decorators/test/fixtures/class-ordering/order/exec.js

@@ -0,0 +1,28 @@
+const calls = [];
+
+function dec(id){
+  calls.push(id);
+  return function() {};
+}
+
+@dec(1)
+@dec(2)
+class Example {
+  @dec(3)
+  @dec(4)
+  method1() {};
+
+  @dec(5)
+  @dec(6)
+  prop1 = 1;
+
+  @dec(7)
+  @dec(8)
+  method2() {};
+
+  @dec(9)
+  @dec(10)
+  prop2 = 2;
+}
+
+assert.deepEqual(calls, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

packages/babel-plugin-proposal-decorators/test/fixtures/class-ordering/reverse-order/exec.js

@@ -0,0 +1,29 @@
+const calls = [];
+
+function dec(id){
+  return function(){
+    calls.push(id);
+  };
+}
+
+@dec(10)
+@dec(9)
+class Example2 {
+  @dec(2)
+  @dec(1)
+  method1() {};
+
+  @dec(4)
+  @dec(3)
+  prop1 = 1;
+
+  @dec(6)
+  @dec(5)
+  method2() {};
+
+  @dec(8)
+  @dec(7)
+  prop2 = 2;
+}
+
+assert.deepEqual(calls, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

packages/babel-plugin-proposal-decorators/test/fixtures/class-prototype-methods/mutate-descriptor/exec.js

@@ -0,0 +1,115 @@
+function dec(target, name, descriptor) {
+  assert(target);
+  assert.equal(typeof name, "string");
+  assert.equal(typeof descriptor, "object");
+
+  target.decoratedProps = (target.decoratedProps || []).concat([name]);
+
+  let value = descriptor.value;
+  Object.assign(descriptor, {
+    enumerable: name.indexOf("enum") !== -1,
+    configurable: name.indexOf("conf") !== -1,
+    writable: name.indexOf("write") !== -1,
+    value: function(...args) {
+      return "__" + value.apply(this, args) + "__";
+    },
+  });
+}
+
+class Example {
+  @dec
+  enumconfwrite(){
+    return 1;
+  }
+
+  @dec
+  enumconf(){
+    return 2;
+  }
+
+  @dec
+  enumwrite(){
+    return 3;
+  }
+
+  @dec
+  enum(){
+    return 4;
+  }
+
+  @dec
+  confwrite(){
+    return 5;
+  }
+
+  @dec
+  conf(){
+    return 6;
+  }
+
+  @dec
+  write(){
+    return 7;
+  }
+
+  @dec
+  _(){
+    return 8;
+  }
+}
+
+assert(Example.prototype.hasOwnProperty('decoratedProps'));
+assert.deepEqual(Example.prototype.decoratedProps, [
+  "enumconfwrite",
+  "enumconf",
+  "enumwrite",
+  "enum",
+  "confwrite",
+  "conf",
+  "write",
+  "_",
+]);
+
+const inst = new Example();
+
+const descs = Object.getOwnPropertyDescriptors(Example.prototype);
+
+assert(descs.enumconfwrite.enumerable);
+assert(descs.enumconfwrite.writable);
+assert(descs.enumconfwrite.configurable);
+assert.equal(inst.enumconfwrite(), "__1__");
+
+assert(descs.enumconf.enumerable);
+assert.equal(descs.enumconf.writable, false);
+assert(descs.enumconf.configurable);
+assert.equal(inst.enumconf(), "__2__");
+
+assert(descs.enumwrite.enumerable);
+assert(descs.enumwrite.writable);
+assert.equal(descs.enumwrite.configurable, false);
+assert.equal(inst.enumwrite(), "__3__");
+
+assert(descs.enum.enumerable);
+assert.equal(descs.enum.writable, false);
+assert.equal(descs.enum.configurable, false);
+assert.equal(inst.enum(), "__4__");
+
+assert.equal(descs.confwrite.enumerable, false);
+assert(descs.confwrite.writable);
+assert(descs.confwrite.configurable);
+assert.equal(inst.confwrite(), "__5__");
+
+assert.equal(descs.conf.enumerable, false);
+assert.equal(descs.conf.writable, false);
+assert(descs.conf.configurable);
+assert.equal(inst.conf(), "__6__");
+
+assert.equal(descs.write.enumerable, false);
+assert(descs.write.writable);
+assert.equal(descs.write.configurable, false);
+assert.equal(inst.write(), "__7__");
+
+assert.equal(descs._.enumerable, false);
+assert.equal(descs._.writable, false);
+assert.equal(descs._.configurable, false);
+assert.equal(inst._(), "__8__");

packages/babel-plugin-proposal-decorators/test/fixtures/class-prototype-methods/numeric-props/exec.js

@@ -0,0 +1,10 @@
+function dec(target, name, descriptor) {
+  assert(target);
+  assert.equal(name, 4);
+  assert.equal(typeof descriptor, "object");
+}
+
+class Example {
+  @dec
+  4() {};
+}

packages/babel-plugin-proposal-decorators/test/fixtures/class-prototype-methods/return-descriptor/exec.js

@@ -0,0 +1,117 @@
+function dec(target, name, descriptor) {
+  assert(target);
+  assert.equal(typeof name, "string");
+  assert.equal(typeof descriptor, "object");
+
+  target.decoratedProps = (target.decoratedProps || []).concat([name]);
+
+  let value = descriptor.value;
+  return {
+    enumerable: name.indexOf('enum') !== -1,
+    configurable: name.indexOf('conf') !== -1,
+    writable: name.indexOf('write') !== -1,
+    value: function(...args){
+      return '__' + value.apply(this, args) + '__';
+    },
+  };
+}
+
+class Example {
+  @dec
+  enumconfwrite() {
+    return 1;
+  }
+
+  @dec
+  enumconf() {
+    return 2;
+  }
+
+  @dec
+  enumwrite() {
+    return 3;
+  }
+
+  @dec
+  enum() {
+    return 4;
+  }
+
+  @dec
+  confwrite() {
+    return 5;
+  }
+
+  @dec
+  conf() {
+    return 6;
+  }
+
+  @dec
+  write() {
+    return 7;
+  }
+
+  @dec
+  _() {
+    return 8;
+  }
+}
+
+
+assert(Example.prototype.hasOwnProperty('decoratedProps'));
+assert.deepEqual(Example.prototype.decoratedProps, [
+  "enumconfwrite",
+  "enumconf",
+  "enumwrite",
+  "enum",
+  "confwrite",
+  "conf",
+  "write",
+  "_",
+]);
+
+
+const inst = new Example();
+
+const descs = Object.getOwnPropertyDescriptors(Example.prototype);
+
+assert(descs.enumconfwrite.enumerable);
+assert(descs.enumconfwrite.writable);
+assert(descs.enumconfwrite.configurable);
+assert.equal(inst.enumconfwrite(), "__1__");
+
+assert(descs.enumconf.enumerable);
+assert.equal(descs.enumconf.writable, false);
+assert(descs.enumconf.configurable);
+assert.equal(inst.enumconf(), "__2__");
+
+assert(descs.enumwrite.enumerable);
+assert(descs.enumwrite.writable);
+assert.equal(descs.enumwrite.configurable, false);
+assert.equal(inst.enumwrite(), "__3__");
+
+assert(descs.enum.enumerable);
+assert.equal(descs.enum.writable, false);
+assert.equal(descs.enum.configurable, false);
+assert.equal(inst.enum(), "__4__");
+
+assert.equal(descs.confwrite.enumerable, false);
+assert(descs.confwrite.writable);
+assert(descs.confwrite.configurable);
+assert.equal(inst.confwrite(), "__5__");
+
+assert.equal(descs.conf.enumerable, false);
+assert.equal(descs.conf.writable, false);
+assert(descs.conf.configurable);
+assert.equal(inst.conf(), "__6__");
+
+assert.equal(descs.write.enumerable, false);
+assert(descs.write.writable);
+assert.equal(descs.write.configurable, false);
+assert.equal(inst.write(), "__7__");
+
+assert.equal(descs._.enumerable, false);
+assert.equal(descs._.writable, false);
+assert.equal(descs._.configurable, false);
+assert.equal(inst._(), "__8__");

packages/babel-plugin-proposal-decorators/test/fixtures/class-prototype-methods/string-props/exec.js

@@ -0,0 +1,10 @@
+function dec(target, name, descriptor) {
+  assert(target);
+  assert.equal(name, "str");
+  assert.equal(typeof descriptor, "object");
+}
+
+class Example {
+   @dec
+   "str"() {};
+}

packages/babel-plugin-proposal-decorators/test/fixtures/class-prototype-properties/child-classes-properties/exec.js

@@ -0,0 +1,27 @@
+function dec(target, name, descriptor){
+  assert(target);
+  assert.equal(typeof name, "string");
+  assert.equal(typeof descriptor, "object");
+
+  target.decoratedProps = (target.decoratedProps || []).concat([name]);
+
+  let initializer = descriptor.initializer;
+  descriptor.initializer = function(...args){
+    return "__" + initializer.apply(this, args) + "__";
+  };
+}
+
+class Base {
+  @dec
+  prop2 = 4;
+}
+
+class Example extends Base {
+  @dec
+  prop = 3;
+}
+
+let inst = new Example();
+
+assert.equal(inst.prop, "__3__");
+assert.equal(inst.prop2, "__4__");

packages/babel-plugin-proposal-decorators/test/fixtures/class-prototype-properties/mutate-descriptor/exec.js

@@ -0,0 +1,99 @@
+function dec(target, name, descriptor) {
+  assert(target);
+  assert.equal(typeof name, "string");
+  assert.equal(typeof descriptor, "object");
+
+  target.decoratedProps = (target.decoratedProps || []).concat([name]);
+
+  let initializer = descriptor.initializer;
+  Object.assign(descriptor, {
+    enumerable: name.indexOf('enum') !== -1,
+    configurable: name.indexOf('conf') !== -1,
+    writable: name.indexOf('write') !== -1,
+    initializer: function(...args){
+      return '__' + initializer.apply(this, args) + '__';
+    },
+  });
+}
+
+class Example {
+  @dec
+  enumconfwrite = 1;
+
+  @dec
+  enumconf = 2;
+
+  @dec
+  enumwrite = 3;
+
+  @dec
+  enum = 4;
+
+  @dec
+  confwrite = 5;
+
+  @dec
+  conf = 6;
+
+  @dec
+  write = 7;
+
+  @dec
+  _ = 8;
+}
+
+const inst = new Example();
+
+assert(Example.prototype.hasOwnProperty("decoratedProps"));
+assert.deepEqual(inst.decoratedProps, [
+  "enumconfwrite",
+  "enumconf",
+  "enumwrite",
+  "enum",
+  "confwrite",
+  "conf",
+  "write",
+  "_",
+]);
+
+const descs = Object.getOwnPropertyDescriptors(inst);
+
+assert(descs.enumconfwrite.enumerable);
+assert(descs.enumconfwrite.writable);
+assert(descs.enumconfwrite.configurable);
+assert.equal(inst.enumconfwrite, "__1__");
+
+assert(descs.enumconf.enumerable);
+assert.equal(descs.enumconf.writable, false);
+assert(descs.enumconf.configurable);
+assert.equal(inst.enumconf, "__2__");
+
+assert(descs.enumwrite.enumerable);
+assert(descs.enumwrite.writable);
+assert.equal(descs.enumwrite.configurable, false);
+assert.equal(inst.enumwrite, "__3__");
+
+assert(descs.enum.enumerable);
+assert.equal(descs.enum.writable, false);
+assert.equal(descs.enum.configurable, false);
+assert.equal(inst.enum, "__4__");
+
+assert.equal(descs.confwrite.enumerable, false);
+assert(descs.confwrite.writable);
+assert(descs.confwrite.configurable);
+assert.equal(inst.confwrite, "__5__");
+
+assert.equal(descs.conf.enumerable, false);
+assert.equal(descs.conf.writable, false);
+assert(descs.conf.configurable);
+assert.equal(inst.conf, "__6__");
+
+assert.equal(descs.write.enumerable, false);
+assert(descs.write.writable);
+assert.equal(descs.write.configurable, false);
+assert.equal(inst.write, "__7__");
+
+assert.equal(descs._.enumerable, false);
+assert.equal(descs._.writable, false);
+assert.equal(descs._.configurable, false);
+assert.equal(inst._, "__8__");

packages/babel-plugin-proposal-decorators/test/fixtures/class-prototype-properties/mutate-initialzer/exec.js

@@ -0,0 +1,27 @@
+function dec(target, name, descriptor){
+  assert(target);
+  assert.equal(name, "prop");
+  assert.equal(typeof descriptor, "object");
+
+  let {initializer} = descriptor;
+  delete descriptor.initializer;
+  delete descriptor.writable;
+
+  let value;
+  descriptor.get = function(){
+    if (initializer){
+      value = '__' + initializer.call(this) + '__';
+      initializer = null;
+    }
+    return value;
+  };
+}
+
+class Example {
+  @dec
+  prop = 3;
+}
+
+let inst = new Example();
+
+assert.equal(inst.prop, "__3__");

packages/babel-plugin-proposal-decorators/test/fixtures/class-prototype-properties/properties-without-initializer/exec.js

@@ -0,0 +1,11 @@
+function dec(target, name, descriptor) {
+
+}
+
+class Example {
+  @dec prop;
+}
+
+let inst = new Example();
+assert(inst.hasOwnProperty("prop"));
+assert.equal(inst.prop, undefined);

packages/babel-plugin-proposal-decorators/test/fixtures/class-prototype-properties/return-descriptor/exec.js

@@ -0,0 +1,99 @@
+function dec(target, name, descriptor) {
+  assert(target);
+  assert.equal(typeof name, "string");
+  assert.equal(typeof descriptor, "object");
+
+  target.decoratedProps = (target.decoratedProps || []).concat([name]);
+
+  let initializer = descriptor.initializer;
+  return {
+    enumerable: name.indexOf('enum') !== -1,
+    configurable: name.indexOf('conf') !== -1,
+    writable: name.indexOf('write') !== -1,
+    initializer: function(...args){
+      return '__' + initializer.apply(this, args) + '__';
+    },
+  };
+}
+
+class Example {
+  @dec
+  enumconfwrite = 1;
+
+  @dec
+  enumconf = 2;
+
+  @dec
+  enumwrite = 3;
+
+  @dec
+  enum = 4;
+
+  @dec
+  confwrite = 5;
+
+  @dec
+  conf = 6;
+
+  @dec
+  write = 7;
+
+  @dec
+  _ = 8;
+}
+
+const inst = new Example();
+
+assert(Example.prototype.hasOwnProperty("decoratedProps"));
+assert.deepEqual(inst.decoratedProps, [
+  "enumconfwrite",
+  "enumconf",
+  "enumwrite",
+  "enum",
+  "confwrite",
+  "conf",
+  "write",
+  "_",
+]);
+
+const descs = Object.getOwnPropertyDescriptors(inst);
+
+assert(descs.enumconfwrite.enumerable);
+assert(descs.enumconfwrite.writable);
+assert(descs.enumconfwrite.configurable);
+assert.equal(inst.enumconfwrite, "__1__");
+
+assert(descs.enumconf.enumerable);
+assert.equal(descs.enumconf.writable, false);
+assert(descs.enumconf.configurable);
+assert.equal(inst.enumconf, "__2__");
+
+assert(descs.enumwrite.enumerable);
+assert(descs.enumwrite.writable);
+assert.equal(descs.enumwrite.configurable, false);
+assert.equal(inst.enumwrite, "__3__");
+
+assert(descs.enum.enumerable);
+assert.equal(descs.enum.writable, false);
+assert.equal(descs.enum.configurable, false);
+assert.equal(inst.enum, "__4__");
+
+assert.equal(descs.confwrite.enumerable, false);
+assert(descs.confwrite.writable);
+assert(descs.confwrite.configurable);
+assert.equal(inst.confwrite, "__5__");
+
+assert.equal(descs.conf.enumerable, false);
+assert.equal(descs.conf.writable, false);
+assert(descs.conf.configurable);
+assert.equal(inst.conf, "__6__");
+
+assert.equal(descs.write.enumerable, false);
+assert(descs.write.writable);
+assert.equal(descs.write.configurable, false);
+assert.equal(inst.write, "__7__");
+
+assert.equal(descs._.enumerable, false);
+assert.equal(descs._.writable, false);
+assert.equal(descs._.configurable, false);
+assert.equal(inst._, "__8__");

packages/babel-plugin-proposal-decorators/test/fixtures/class-static-methods/mutate-descriptor/exec.js

@@ -0,0 +1,113 @@
+function dec(target, name, descriptor) {
+  assert(target);
+  assert.equal(typeof name, "string");
+  assert.equal(typeof descriptor, "object");
+
+  target.decoratedProps = (target.decoratedProps || []).concat([name]);
+
+  let value = descriptor.value;
+  Object.assign(descriptor, {
+    enumerable: name.indexOf("enum") !== -1,
+    configurable: name.indexOf("conf") !== -1,
+    writable: name.indexOf("write") !== -1,
+    value: function(...args) {
+      return "__" + value.apply(this, args) + "__";
+    },
+  });
+}
+
+class Example {
+  @dec
+  static enumconfwrite(){
+    return 1;
+  }
+
+  @dec
+  static enumconf(){
+    return 2;
+  }
+
+  @dec
+  static enumwrite(){
+    return 3;
+  }
+
+  @dec
+  static enum(){
+    return 4;
+  }
+
+  @dec
+  static confwrite(){
+    return 5;
+  }
+
+  @dec
+  static conf(){
+    return 6;
+  }
+
+  @dec
+  static write(){
+    return 7;
+  }
+
+  @dec
+  static _(){
+    return 8;
+  }
+}
+
+assert(Example.hasOwnProperty("decoratedProps"));
+assert.deepEqual(Example.decoratedProps, [
+  "enumconfwrite",
+  "enumconf",
+  "enumwrite",
+  "enum",
+  "confwrite",
+  "conf",
+  "write",
+  "_",
+]);
+
+const descs = Object.getOwnPropertyDescriptors(Example);
+
+assert(descs.enumconfwrite.enumerable);
+assert(descs.enumconfwrite.writable);
+assert(descs.enumconfwrite.configurable);
+assert.equal(Example.enumconfwrite(), "__1__");
+
+assert(descs.enumconf.enumerable);
+assert.equal(descs.enumconf.writable, false);
+assert(descs.enumconf.configurable);
+assert.equal(Example.enumconf(), "__2__");
+
+assert(descs.enumwrite.enumerable);
+assert(descs.enumwrite.writable);
+assert.equal(descs.enumwrite.configurable, false);
+assert.equal(Example.enumwrite(), "__3__");
+
+assert(descs.enum.enumerable);
+assert.equal(descs.enum.writable, false);
+assert.equal(descs.enum.configurable, false);
+assert.equal(Example.enum(), "__4__");
+
+assert.equal(descs.confwrite.enumerable, false);
+assert(descs.confwrite.writable);
+assert(descs.confwrite.configurable);
+assert.equal(Example.confwrite(), "__5__");
+
+assert.equal(descs.conf.enumerable, false);
+assert.equal(descs.conf.writable, false);
+assert(descs.conf.configurable);
+assert.equal(Example.conf(), "__6__");
+
+assert.equal(descs.write.enumerable, false);
+assert(descs.write.writable);
+assert.equal(descs.write.configurable, false);
+assert.equal(Example.write(), "__7__");
+
+assert.equal(descs._.enumerable, false);
+assert.equal(descs._.writable, false);
+assert.equal(descs._.configurable, false);
+assert.equal(Example._(), "__8__");

packages/babel-plugin-proposal-decorators/test/fixtures/class-static-methods/numeric-props/exec.js

@@ -0,0 +1,10 @@
+function dec(target, name, descriptor){
+  assert(target);
+  assert.equal(name, 4);
+  assert.equal(typeof descriptor, "object");
+}
+
+class Example {
+  @dec
+  static 4() {}
+}

packages/babel-plugin-proposal-decorators/test/fixtures/class-static-methods/return-descriptor/exec.js

@@ -0,0 +1,114 @@
+function dec(target, name, descriptor) {
+  assert(target);
+  assert.equal(typeof name, "string");
+  assert.equal(typeof descriptor, "object");
+
+  target.decoratedProps = (target.decoratedProps || []).concat([name]);
+
+  let value = descriptor.value;
+  return {
+    enumerable: name.indexOf('enum') !== -1,
+    configurable: name.indexOf('conf') !== -1,
+    writable: name.indexOf('write') !== -1,
+    value: function(...args){
+      return '__' + value.apply(this, args) + '__';
+    },
+  };
+}
+
+class Example {
+  @dec
+  static enumconfwrite() {
+    return 1;
+  }
+
+  @dec
+  static enumconf() {
+    return 2;
+  }
+
+  @dec
+  static enumwrite() {
+    return 3;
+  }
+
+  @dec
+  static enum() {
+    return 4;
+  }
+
+  @dec
+  static confwrite() {
+    return 5;
+  }
+
+  @dec
+  static conf() {
+    return 6;
+  }
+
+  @dec
+  static write() {
+    return 7;
+  }
+
+  @dec
+  static _() {
+    return 8;
+  }
+}
+
+
+assert(Example.hasOwnProperty("decoratedProps"));
+assert.deepEqual(Example.decoratedProps, [
+  "enumconfwrite",
+  "enumconf",
+  "enumwrite",
+  "enum",
+  "confwrite",
+  "conf",
+  "write",
+  "_",
+]);
+
+const descs = Object.getOwnPropertyDescriptors(Example);
+
+assert(descs.enumconfwrite.enumerable);
+assert(descs.enumconfwrite.writable);
+assert(descs.enumconfwrite.configurable);
+assert.equal(Example.enumconfwrite(), "__1__");
+
+assert(descs.enumconf.enumerable);
+assert.equal(descs.enumconf.writable, false);
+assert(descs.enumconf.configurable);
+assert.equal(Example.enumconf(), "__2__");
+
+assert(descs.enumwrite.enumerable);
+assert(descs.enumwrite.writable);
+assert.equal(descs.enumwrite.configurable, false);
+assert.equal(Example.enumwrite(), "__3__");
+
+assert(descs.enum.enumerable);
+assert.equal(descs.enum.writable, false);
+assert.equal(descs.enum.configurable, false);
+assert.equal(Example.enum(), "__4__");
+
+assert.equal(descs.confwrite.enumerable, false);
+assert(descs.confwrite.writable);
+assert(descs.confwrite.configurable);
+assert.equal(Example.confwrite(), "__5__");
+
+assert.equal(descs.conf.enumerable, false);
+assert.equal(descs.conf.writable, false);
+assert(descs.conf.configurable);
+assert.equal(Example.conf(), "__6__");
+
+assert.equal(descs.write.enumerable, false);
+assert(descs.write.writable);
+assert.equal(descs.write.configurable, false);
+assert.equal(Example.write(), "__7__");
+
+assert.equal(descs._.enumerable, false);
+assert.equal(descs._.writable, false);
+assert.equal(descs._.configurable, false);
+assert.equal(Example._(), "__8__");

packages/babel-plugin-proposal-decorators/test/fixtures/class-static-methods/string-props/exec.js

@@ -0,0 +1,10 @@
+function dec(target, name, descriptor) {
+  assert(target);
+  assert.equal(name, "str");
+  assert.equal(typeof descriptor, "object");
+}
+
+class Example {
+   @dec
+   static "str"() {};
+}

packages/babel-plugin-proposal-decorators/test/fixtures/class-static-properties/mutate-descriptor/exec.js

@@ -0,0 +1,99 @@
+function dec(target, name, descriptor) {
+  assert(target);
+  assert.equal(typeof name, "string");
+  assert.equal(typeof descriptor, "object");
+
+  target.decoratedProps = (target.decoratedProps || []).concat([name]);
+
+  let initializer = descriptor.initializer;
+  Object.assign(descriptor, {
+    enumerable: name.indexOf("enum") !== -1,
+    configurable: name.indexOf("conf") !== -1,
+    writable: name.indexOf("write") !== -1,
+    initializer: function(...args){
+      return '__' + initializer.apply(this, args) + '__';
+    },
+  });
+}
+
+class Example {
+  @dec
+  static enumconfwrite = 1;
+
+  @dec
+  static enumconf = 2;
+
+  @dec
+  static enumwrite = 3;
+
+  @dec
+  static enum = 4;
+
+  @dec
+  static confwrite = 5;
+
+  @dec
+  static conf = 6;
+
+  @dec
+  static write = 7;
+
+  @dec
+  static _ = 8;
+}
+
+const inst = new Example();
+
+assert(Example.hasOwnProperty("decoratedProps"));
+assert.deepEqual(Example.decoratedProps, [
+  "enumconfwrite",
+  "enumconf",
+  "enumwrite",
+  "enum",
+  "confwrite",
+  "conf",
+  "write",
+  "_",
+]);
+
+const descs = Object.getOwnPropertyDescriptors(Example);
+
+assert(descs.enumconfwrite.enumerable);
+assert(descs.enumconfwrite.writable);
+assert(descs.enumconfwrite.configurable);
+assert.equal(Example.enumconfwrite, "__1__");
+
+assert(descs.enumconf.enumerable);
+assert.equal(descs.enumconf.writable, false);
+assert(descs.enumconf.configurable);
+assert.equal(Example.enumconf, "__2__");
+
+assert(descs.enumwrite.enumerable);
+assert(descs.enumwrite.writable);
+assert.equal(descs.enumwrite.configurable, false);
+assert.equal(Example.enumwrite, "__3__");
+
+assert(descs.enum.enumerable);
+assert.equal(descs.enum.writable, false);
+assert.equal(descs.enum.configurable, false);
+assert.equal(Example.enum, "__4__");
+
+assert.equal(descs.confwrite.enumerable, false);
+assert(descs.confwrite.writable);
+assert(descs.confwrite.configurable);
+assert.equal(Example.confwrite, "__5__");
+
+assert.equal(descs.conf.enumerable, false);
+assert.equal(descs.conf.writable, false);
+assert(descs.conf.configurable);
+assert.equal(Example.conf, "__6__");
+
+assert.equal(descs.write.enumerable, false);
+assert(descs.write.writable);
+assert.equal(descs.write.configurable, false);
+assert.equal(Example.write, "__7__");
+
+assert.equal(descs._.enumerable, false);
+assert.equal(descs._.writable, false);
+assert.equal(descs._.configurable, false);
+assert.equal(Example._, "__8__");

packages/babel-plugin-proposal-decorators/test/fixtures/class-static-properties/mutate-initialzer/exec.js

@@ -0,0 +1,25 @@
+function dec(target, name, descriptor){
+  assert(target);
+  assert.equal(name, "prop");
+  assert.equal(typeof descriptor, "object");
+
+  let {initializer} = descriptor;
+  delete descriptor.initializer;
+  delete descriptor.writable;
+
+  let value;
+  descriptor.get = function(){
+    if (initializer){
+      value = '__' + initializer.call(this) + '__';
+      initializer = null;
+    }
+    return value;
+  };
+}
+
+class Example {
+  @dec
+  static prop = 3;
+}
+
+assert.equal(Example.prop, "__3__");

packages/babel-plugin-proposal-decorators/test/fixtures/class-static-properties/properties-without-initializer/exec.js

@@ -0,0 +1,10 @@
+function dec(target, name, descriptor) {
+
+}
+
+class Example {
+  @dec static prop;
+}
+
+assert(Example.hasOwnProperty("prop"));
+assert.equal(Example.prop, undefined);

packages/babel-plugin-proposal-decorators/test/fixtures/class-static-properties/return-descriptor/exec.js

@@ -0,0 +1,99 @@
+function dec(target, name, descriptor) {
+  assert(target);
+  assert.equal(typeof name, "string");
+  assert.equal(typeof descriptor, "object");
+
+  target.decoratedProps = (target.decoratedProps || []).concat([name]);
+
+  let initializer = descriptor.initializer;
+  return {
+    enumerable: name.indexOf('enum') !== -1,
+    configurable: name.indexOf('conf') !== -1,
+    writable: name.indexOf('write') !== -1,
+    initializer: function(...args){
+      return '__' + initializer.apply(this, args) + '__';
+    },
+  };
+}
+
+class Example {
+  @dec
+  static enumconfwrite = 1;
+
+  @dec
+  static enumconf = 2;
+
+  @dec
+  static enumwrite = 3;
+
+  @dec
+  static enum = 4;
+
+  @dec
+  static confwrite = 5;
+
+  @dec
+  static conf = 6;
+
+  @dec
+  static write = 7;
+
+  @dec
+  static _ = 8;
+}
+
+const inst = new Example();
+
+assert(Example.hasOwnProperty("decoratedProps"));
+assert.deepEqual(Example.decoratedProps, [
+  "enumconfwrite",
+  "enumconf",
+  "enumwrite",
+  "enum",
+  "confwrite",
+  "conf",
+  "write",
+  "_",
+]);
+
+const descs = Object.getOwnPropertyDescriptors(Example);
+
+assert(descs.enumconfwrite.enumerable);
+assert(descs.enumconfwrite.writable);
+assert(descs.enumconfwrite.configurable);
+assert.equal(Example.enumconfwrite, "__1__");
+
+assert(descs.enumconf.enumerable);
+assert.equal(descs.enumconf.writable, false);
+assert(descs.enumconf.configurable);
+assert.equal(Example.enumconf, "__2__");
+
+assert(descs.enumwrite.enumerable);
+assert(descs.enumwrite.writable);
+assert.equal(descs.enumwrite.configurable, false);
+assert.equal(Example.enumwrite, "__3__");
+
+assert(descs.enum.enumerable);
+assert.equal(descs.enum.writable, false);
+assert.equal(descs.enum.configurable, false);
+assert.equal(Example.enum, "__4__");
+
+assert.equal(descs.confwrite.enumerable, false);
+assert(descs.confwrite.writable);
+assert(descs.confwrite.configurable);
+assert.equal(Example.confwrite, "__5__");
+
+assert.equal(descs.conf.enumerable, false);
+assert.equal(descs.conf.writable, false);
+assert(descs.conf.configurable);
+assert.equal(Example.conf, "__6__");
+
+assert.equal(descs.write.enumerable, false);
+assert(descs.write.writable);
+assert.equal(descs.write.configurable, false);
+assert.equal(Example.write, "__7__");
+
+assert.equal(descs._.enumerable, false);
+assert.equal(descs._.writable, false);
+assert.equal(descs._.configurable, false);
+assert.equal(Example._, "__8__");

packages/babel-plugin-proposal-decorators/test/fixtures/object-methods/mutate-descriptor/exec.js

@@ -0,0 +1,113 @@
+function dec(target, name, descriptor) {
+  assert(target);
+  assert.equal(typeof name, "string");
+  assert.equal(typeof descriptor, "object");
+
+  target.decoratedProps = (target.decoratedProps || []).concat([name]);
+
+  let value = descriptor.value;
+  Object.assign(descriptor, {
+    enumerable: name.indexOf("enum") !== -1,
+    configurable: name.indexOf("conf") !== -1,
+    writable: name.indexOf("write") !== -1,
+    value: function(...args) {
+      return "__" + value.apply(this, args) + "__";
+    },
+  });
+}
+
+const inst = {
+  @dec
+  enumconfwrite(){
+    return 1;
+  },
+
+  @dec
+  enumconf(){
+    return 2;
+  },
+
+  @dec
+  enumwrite(){
+    return 3;
+  },
+
+  @dec
+  enum(){
+    return 4;
+  },
+
+  @dec
+  confwrite(){
+    return 5;
+  },
+
+  @dec
+  conf(){
+    return 6;
+  },
+
+  @dec
+  write(){
+    return 7;
+  },
+
+  @dec
+  _(){
+    return 8;
+  },
+}
+
+assert(inst.hasOwnProperty('decoratedProps'));
+assert.deepEqual(inst.decoratedProps, [
+  "enumconfwrite",
+  "enumconf",
+  "enumwrite",
+  "enum",
+  "confwrite",
+  "conf",
+  "write",
+  "_",
+]);
+
+const descs = Object.getOwnPropertyDescriptors(inst);
+
+assert(descs.enumconfwrite.enumerable);
+assert(descs.enumconfwrite.writable);
+assert(descs.enumconfwrite.configurable);
+assert.equal(inst.enumconfwrite(), "__1__");
+
+assert(descs.enumconf.enumerable);
+assert.equal(descs.enumconf.writable, false);
+assert(descs.enumconf.configurable);
+assert.equal(inst.enumconf(), "__2__");
+
+assert(descs.enumwrite.enumerable);
+assert(descs.enumwrite.writable);
+assert.equal(descs.enumwrite.configurable, false);
+assert.equal(inst.enumwrite(), "__3__");
+
+assert(descs.enum.enumerable);
+assert.equal(descs.enum.writable, false);
+assert.equal(descs.enum.configurable, false);
+assert.equal(inst.enum(), "__4__");
+
+assert.equal(descs.confwrite.enumerable, false);
+assert(descs.confwrite.writable);
+assert(descs.confwrite.configurable);
+assert.equal(inst.confwrite(), "__5__");
+
+assert.equal(descs.conf.enumerable, false);
+assert.equal(descs.conf.writable, false);
+assert(descs.conf.configurable);
+assert.equal(inst.conf(), "__6__");
+
+assert.equal(descs.write.enumerable, false);
+assert(descs.write.writable);
+assert.equal(descs.write.configurable, false);
+assert.equal(inst.write(), "__7__");
+
+assert.equal(descs._.enumerable, false);
+assert.equal(descs._.writable, false);
+assert.equal(descs._.configurable, false);
+assert.equal(inst._(), "__8__");

packages/babel-plugin-proposal-decorators/test/fixtures/object-methods/numeric-props/exec.js

@@ -0,0 +1,11 @@
+function dec(target, name, descriptor){
+  assert(target);
+  assert.equal(name, 4);
+  assert.equal(typeof descriptor, "object");
+}
+
+const inst = {
+  @dec
+  4(){
+  }
+};

packages/babel-plugin-proposal-decorators/test/fixtures/object-methods/return-descriptor/exec.js

@@ -0,0 +1,113 @@
+function dec(target, name, descriptor) {
+  assert(target);
+  assert.equal(typeof name, "string");
+  assert.equal(typeof descriptor, "object");
+
+  target.decoratedProps = (target.decoratedProps || []).concat([name]);
+
+  let value = descriptor.value;
+  return {
+    enumerable: name.indexOf('enum') !== -1,
+    configurable: name.indexOf('conf') !== -1,
+    writable: name.indexOf('write') !== -1,
+    value: function(...args){
+      return '__' + value.apply(this, args) + '__';
+    },
+  };
+}
+
+const inst = {
+  @dec
+  enumconfwrite(){
+    return 1;
+  },
+
+  @dec
+  enumconf(){
+    return 2;
+  },
+
+  @dec
+  enumwrite(){
+    return 3;
+  },
+
+  @dec
+  enum(){
+    return 4;
+  },
+
+  @dec
+  confwrite(){
+    return 5;
+  },
+
+  @dec
+  conf(){
+    return 6;
+  },
+
+  @dec
+  write(){
+    return 7;
+  },
+
+  @dec
+  _(){
+    return 8;
+  },
+}
+
+assert(inst.hasOwnProperty('decoratedProps'));
+assert.deepEqual(inst.decoratedProps, [
+  "enumconfwrite",
+  "enumconf",
+  "enumwrite",
+  "enum",
+  "confwrite",
+  "conf",
+  "write",
+  "_",
+]);
+
+const descs = Object.getOwnPropertyDescriptors(inst);
+
+assert(descs.enumconfwrite.enumerable);
+assert(descs.enumconfwrite.writable);
+assert(descs.enumconfwrite.configurable);
+assert.equal(inst.enumconfwrite(), "__1__");
+
+assert(descs.enumconf.enumerable);
+assert.equal(descs.enumconf.writable, false);
+assert(descs.enumconf.configurable);
+assert.equal(inst.enumconf(), "__2__");
+
+assert(descs.enumwrite.enumerable);
+assert(descs.enumwrite.writable);
+assert.equal(descs.enumwrite.configurable, false);
+assert.equal(inst.enumwrite(), "__3__");
+
+assert(descs.enum.enumerable);
+assert.equal(descs.enum.writable, false);
+assert.equal(descs.enum.configurable, false);
+assert.equal(inst.enum(), "__4__");
+
+assert.equal(descs.confwrite.enumerable, false);
+assert(descs.confwrite.writable);
+assert(descs.confwrite.configurable);
+assert.equal(inst.confwrite(), "__5__");
+
+assert.equal(descs.conf.enumerable, false);
+assert.equal(descs.conf.writable, false);
+assert(descs.conf.configurable);
+assert.equal(inst.conf(), "__6__");
+
+assert.equal(descs.write.enumerable, false);
+assert(descs.write.writable);
+assert.equal(descs.write.configurable, false);
+assert.equal(inst.write(), "__7__");
+
+assert.equal(descs._.enumerable, false);
+assert.equal(descs._.writable, false);
+assert.equal(descs._.configurable, false);
+assert.equal(inst._(), "__8__");

packages/babel-plugin-proposal-decorators/test/fixtures/object-methods/string-props/exec.js

@@ -0,0 +1,12 @@
+function dec(target, name, descriptor){
+  assert(target);
+  assert.equal(name, "str");
+  assert.equal(typeof descriptor, "object");
+}
+
+const inst = {
+  @dec
+  "str"(){
+
+  }
+};

packages/babel-plugin-proposal-decorators/test/fixtures/object-ordering/order/exec.js

@@ -0,0 +1,25 @@
+const calls = [];
+function dec(id){
+  calls.push(id);
+  return function(){};
+}
+
+const obj = {
+  @dec(1)
+  @dec(2)
+  method1(){},
+
+  @dec(3)
+  @dec(4)
+  prop1: 1,
+
+  @dec(5)
+  @dec(6)
+  method2(){},
+
+  @dec(7)
+  @dec(8)
+  prop2: 2,
+}
+
+assert.deepEqual(calls, [1, 2, 3, 4, 5, 6, 7, 8]);

packages/babel-plugin-proposal-decorators/test/fixtures/object-ordering/reverse-order/exec.js

@@ -0,0 +1,26 @@
+const calls = [];
+function dec(id){
+  return function(){
+    calls.push(id);
+  };
+}
+
+const obj = {
+  @dec(2)
+  @dec(1)
+  method1(){},
+
+  @dec(4)
+  @dec(3)
+  prop1: 1,
+
+  @dec(6)
+  @dec(5)
+  method2(){},
+
+  @dec(8)
+  @dec(7)
+  prop2: 2,
+}
+
+assert.deepEqual(calls, [1, 2, 3, 4, 5, 6, 7, 8]);

packages/babel-plugin-proposal-decorators/test/fixtures/object-properties/mutate-descriptor/exec.js

@@ -0,0 +1,98 @@
+function dec(target, name, descriptor) {
+  assert(target);
+  assert.equal(typeof name, "string");
+  assert.equal(typeof descriptor, "object");
+
+  target.decoratedProps = (target.decoratedProps || []).concat([name]);
+
+  let initializer = descriptor.initializer;
+  Object.assign(descriptor, {
+    enumerable: name.indexOf("enum") !== -1,
+    configurable: name.indexOf("conf") !== -1,
+    writable: name.indexOf("write") !== -1,
+    initializer: function(...args){
+      return '__' + initializer.apply(this, args) + '__';
+    },
+  });
+}
+
+const inst = {
+  @dec
+  enumconfwrite: 1,
+
+  @dec
+  enumconf: 2,
+
+  @dec
+  enumwrite: 3,
+
+  @dec
+  enum: 4,
+
+  @dec
+  confwrite: 5,
+
+  @dec
+  conf: 6,
+
+  @dec
+  write: 7,
+
+  @dec
+  _: 8,
+};
+
+
+assert(inst.hasOwnProperty("decoratedProps"));
+assert.deepEqual(inst.decoratedProps, [
+  "enumconfwrite",
+  "enumconf",
+  "enumwrite",
+  "enum",
+  "confwrite",
+  "conf",
+  "write",
+  "_",
+]);
+
+const descs = Object.getOwnPropertyDescriptors(inst);
+
+assert(descs.enumconfwrite.enumerable);
+assert(descs.enumconfwrite.writable);
+assert(descs.enumconfwrite.configurable);
+assert.equal(inst.enumconfwrite, "__1__");
+
+assert(descs.enumconf.enumerable);
+assert.equal(descs.enumconf.writable, false);
+assert(descs.enumconf.configurable);
+assert.equal(inst.enumconf, "__2__");
+
+assert(descs.enumwrite.enumerable);
+assert(descs.enumwrite.writable);
+assert.equal(descs.enumwrite.configurable, false);
+assert.equal(inst.enumwrite, "__3__");
+
+assert(descs.enum.enumerable);
+assert.equal(descs.enum.writable, false);
+assert.equal(descs.enum.configurable, false);
+assert.equal(inst.enum, "__4__");
+
+assert.equal(descs.confwrite.enumerable, false);
+assert(descs.confwrite.writable);
+assert(descs.confwrite.configurable);
+assert.equal(inst.confwrite, "__5__");
+
+assert.equal(descs.conf.enumerable, false);
+assert.equal(descs.conf.writable, false);
+assert(descs.conf.configurable);
+assert.equal(inst.conf, "__6__");
+
+assert.equal(descs.write.enumerable, false);
+assert(descs.write.writable);
+assert.equal(descs.write.configurable, false);
+assert.equal(inst.write, "__7__");
+
+assert.equal(descs._.enumerable, false);
+assert.equal(descs._.writable, false);
+assert.equal(descs._.configurable, false);
+assert.equal(inst._, "__8__");

packages/babel-plugin-proposal-decorators/test/fixtures/object-properties/mutate-initialzer/exec.js

@@ -0,0 +1,25 @@
+function dec(target, name, descriptor){
+  assert(target);
+  assert.equal(name, "prop");
+  assert.equal(typeof descriptor, "object");
+
+  let {initializer} = descriptor;
+  delete descriptor.initializer;
+  delete descriptor.writable;
+
+  let value;
+  descriptor.get = function(){
+    if (initializer){
+      value = '__' + initializer.call(this) + '__';
+      initializer = null;
+    }
+    return value;
+  };
+}
+
+let inst = {
+  @dec
+  prop: 3
+};
+
+assert.equal(inst.prop, "__3__");

packages/babel-plugin-proposal-decorators/test/fixtures/object-properties/numeric-props/exec.js

@@ -0,0 +1,10 @@
+function dec(target, name, descriptor){
+  assert(target);
+  assert.equal(name, 4);
+  assert.equal(typeof descriptor, "object");
+}
+
+const inst = {
+  @dec
+  4: 1
+};

packages/babel-plugin-proposal-decorators/test/fixtures/object-properties/return-descriptor/exec.js

@@ -0,0 +1,97 @@
+function dec(target, name, descriptor) {
+  assert(target);
+  assert.equal(typeof name, "string");
+  assert.equal(typeof descriptor, "object");
+
+  target.decoratedProps = (target.decoratedProps || []).concat([name]);
+
+  let initializer = descriptor.initializer;
+  return {
+    enumerable: name.indexOf('enum') !== -1,
+    configurable: name.indexOf('conf') !== -1,
+    writable: name.indexOf('write') !== -1,
+    initializer: function(...args){
+      return '__' + initializer.apply(this, args) + '__';
+    },
+  };
+}
+
+const inst = {
+  @dec
+  enumconfwrite: 1,
+
+  @dec
+  enumconf: 2,
+
+  @dec
+  enumwrite: 3,
+
+  @dec
+  enum: 4,
+
+  @dec
+  confwrite: 5,
+
+  @dec
+  conf: 6,
+
+  @dec
+  write: 7,
+
+  @dec
+  _: 8,
+};
+
+assert(inst.hasOwnProperty("decoratedProps"));
+assert.deepEqual(inst.decoratedProps, [
+  "enumconfwrite",
+  "enumconf",
+  "enumwrite",
+  "enum",
+  "confwrite",
+  "conf",
+  "write",
+  "_",
+]);
+
+const descs = Object.getOwnPropertyDescriptors(inst);
+
+assert(descs.enumconfwrite.enumerable);
+assert(descs.enumconfwrite.writable);
+assert(descs.enumconfwrite.configurable);
+assert.equal(inst.enumconfwrite, "__1__");
+
+assert(descs.enumconf.enumerable);
+assert.equal(descs.enumconf.writable, false);
+assert(descs.enumconf.configurable);
+assert.equal(inst.enumconf, "__2__");
+
+assert(descs.enumwrite.enumerable);
+assert(descs.enumwrite.writable);
+assert.equal(descs.enumwrite.configurable, false);
+assert.equal(inst.enumwrite, "__3__");
+
+assert(descs.enum.enumerable);
+assert.equal(descs.enum.writable, false);
+assert.equal(descs.enum.configurable, false);
+assert.equal(inst.enum, "__4__");
+
+assert.equal(descs.confwrite.enumerable, false);
+assert(descs.confwrite.writable);
+assert(descs.confwrite.configurable);
+assert.equal(inst.confwrite, "__5__");
+
+assert.equal(descs.conf.enumerable, false);
+assert.equal(descs.conf.writable, false);
+assert(descs.conf.configurable);
+assert.equal(inst.conf, "__6__");
+
+assert.equal(descs.write.enumerable, false);
+assert(descs.write.writable);
+assert.equal(descs.write.configurable, false);
+assert.equal(inst.write, "__7__");
+
+assert.equal(descs._.enumerable, false);
+assert.equal(descs._.writable, false);
+assert.equal(descs._.configurable, false);
+assert.equal(inst._, "__8__");

packages/babel-plugin-proposal-decorators/test/fixtures/object-properties/string-props/exec.js

@@ -0,0 +1,10 @@
+function dec(target, name, descriptor){
+  assert(target);
+  assert.equal(name, "str");
+  assert.equal(typeof descriptor, "object");
+}
+
+const inst = {
+  @dec
+  "str": 1
+};

packages/babel-plugin-proposal-decorators/test/fixtures/options.json

@@ -0,0 +1,4 @@
+{
+  "presets": ["es2015"],
+  "plugins": ["proposal-decorators", ["proposal-class-properties", {"loose": true}]]
+}

packages/babel-plugin-proposal-decorators/test/index.js

@@ -0,0 +1,3 @@
+import runner from "@babel/helper-plugin-test-runner";
+
+runner(__dirname);