Get set helpers (#7687)

* Improve get/set helper

* fixtures

* Edge cases

* Add loose edge cases

* Spec compliant

* Add issue case

* Even more edge cases!

* Final updates

* Fix name

* Use Reflect.{get, set} when available

* Avoid block scoping in loose

* Remove semicolon

* Do not redefine a non-enumerable

* Get strictness from call site, not helpers

* Add called assertions

* Classes are always strict

* Update test fixture

packages/babel-helper-replace-supers/src/index.js

@@ -142,7 +142,7 @@ export default class ReplaceSupers {
    * @example
    *
    *   _set(CLASS.prototype.__proto__ || Object.getPrototypeOf(CLASS.prototype), "METHOD", "VALUE",
-   *     this)
+   *     this, isStrict)
    *
    */
 
@@ -150,12 +150,14 @@ export default class ReplaceSupers {
     property: Object,
     value: Object,
     isComputed: boolean,
+    isStrict: boolean,
   ): Object {
     return t.callExpression(this.file.addHelper("set"), [
       getPrototypeOfExpression(this.getObjectRef(), this.isStatic, this.file),
       isComputed ? property : t.stringLiteral(property.name),
       value,
       t.thisExpression(),
+      t.booleanLiteral(isStrict),
     ]);
   }
 
@@ -225,14 +227,37 @@ export default class ReplaceSupers {
 
   specHandleAssignmentExpression(ref, path, node) {
     if (node.operator === "=") {
-      // super.name = "val"; -> _set(Object.getPrototypeOf(objectRef.prototype), "name", this);
+      const strictParent = path.findParent(path => {
+        if (path.isClassBody()) {
+          return true;
+        }
+
+        if (path.isProgram() && path.node.sourceType === "module") {
+          return true;
+        }
+
+        if (!path.isProgram() && !path.isBlockStatement()) {
+          return false;
+        }
+
+        return path.node.directives.some(
+          directive => directive.value.value === "use strict",
+        );
+      });
+
+      // super.name = "val"
+      // to
+      // _set(Object.getPrototypeOf(objectRef.prototype), "name", this, isStrict);
       return this.setSuperProperty(
         node.left.property,
         node.right,
         node.left.computed,
+        !!strictParent,
       );
     } else {
-      // super.age += 2; -> let _ref = super.age; super.age = _ref + 2;
+      // super.age += 2
+      // to
+      // let _ref = super.age; super.age = _ref + 2;
       ref = ref || path.scope.generateUidIdentifier("ref");
       return [
         t.variableDeclaration("var", [

packages/babel-helpers/src/helpers.js

@@ -390,36 +390,6 @@ helpers.objectSpread = () => template.program.ast`
   }
 `;
 
-helpers.get = () => template.program.ast`
-  import getPrototypeOf from "getPrototypeOf";
-
-  export default function _get(object, property, receiver) {
-    if (object === null) object = Function.prototype;
-
-    var desc = Object.getOwnPropertyDescriptor(object, property);
-
-    if (desc === undefined) {
-      var parent = getPrototypeOf(object);
-
-      if (parent === null) {
-        return undefined;
-      } else {
-        return _get(parent, property, receiver);
-      }
-    } else if ("value" in desc) {
-      return desc.value;
-    } else {
-      var getter = desc.get;
-
-      if (getter === undefined) {
-        return undefined;
-      }
-
-      return getter.call(receiver);
-    }
-  }
-`;
-
 helpers.inherits = () => template.program.ast`
   import setPrototypeOf from "setPrototypeOf";
 
@@ -470,7 +440,7 @@ helpers.construct = () => template.program.ast`
   import setPrototypeOf from "setPrototypeOf";
 
   export default function _construct(Parent, args, Class) {
-    if (typeof Reflect === "object" && Reflect.construct) {
+    if (typeof Reflect !== "undefined" && Reflect.construct) {
       _construct = Reflect.construct;
     } else {
       _construct = function _construct(Parent, args, Class) {
@@ -633,26 +603,96 @@ helpers.possibleConstructorReturn = () => template.program.ast`
   }
 `;
 
-helpers.set = () => template.program.ast`
+helpers.superPropBase = () => template.program.ast`
   import getPrototypeOf from "getPrototypeOf";
 
-  export default function _set(object, property, value, receiver) {
+  export default function _superPropBase(object, property) {
-    var desc = Object.getOwnPropertyDescriptor(object, property);
+    // Yes, this throws if object is null to being with, that's on purpose.
-
+    while (!Object.prototype.hasOwnProperty.call(object, property)) {
-    if (desc === undefined) {
+      object = getPrototypeOf(object);
-      var parent = getPrototypeOf(object);
+      if (object === null) break;
-
-      if (parent !== null) {
-        _set(parent, property, value, receiver);
     }
-    } else if ("value" in desc && desc.writable) {
+    return object;
-      desc.value = value;
+  }
+`;
+
+helpers.get = () => template.program.ast`
+  import getPrototypeOf from "getPrototypeOf";
+  import superPropBase from "superPropBase";
+
+  export default function _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+      _get = Reflect.get;
     } else {
-      var setter = desc.set;
+      _get = function _get(target, property, receiver) {
+        var base = superPropBase(target, property);
 
-      if (setter !== undefined) {
+        if (!base) return;
-        setter.call(receiver, value);
+
+        var desc = Object.getOwnPropertyDescriptor(base, property);
+        if (desc.get) {
+          return desc.get.call(receiver);
         }
+
+        return desc.value;
+      };
+    }
+    return _get(target, property, receiver || target);
+  }
+`;
+
+helpers.set = () => template.program.ast`
+  import getPrototypeOf from "getPrototypeOf";
+  import superPropBase from "superPropBase";
+  import defineProperty from "defineProperty";
+
+  function set(target, property, value, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.set) {
+      set = Reflect.set;
+    } else {
+      set = function set(target, property, value, receiver) {
+        var base = superPropBase(target, property);
+        var desc;
+
+        if (base) {
+          desc = Object.getOwnPropertyDescriptor(base, property);
+          if (desc.set) {
+            desc.set.call(receiver, value);
+            return true;
+          } else if (!desc.writable) {
+            // Both getter and non-writable fall into this.
+            return false;
+          }
+        }
+
+        // Without a super that defines the property, spec boils down to
+        // "define on receiver" for some reason.
+        desc = Object.getOwnPropertyDescriptor(receiver, property);
+        if (desc) {
+          if (!desc.writable) {
+            // Setter, getter, and non-writable fall into this.
+            return false;
+          }
+
+          desc.value = value;
+          Object.defineProperty(receiver, property, desc);
+        } else {
+          // Avoid setters that may be defined on Sub's prototype, but not on
+          // the instance.
+          defineProperty(receiver, property, value);
+        }
+
+        return true;
+      };
+    }
+
+    return set(target, property, value, receiver);
+  }
+
+  export default function _set(target, property, value, receiver, isStrict) {
+    const s = set(target, property, value, receiver || target);
+    if (!s && isStrict) {
+      throw new Error('failed to set property');
     }
 
     return value;

packages/babel-plugin-proposal-class-properties/test/fixtures/regression/6154/output.js

@@ -10,7 +10,9 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func
 
 function _classCallCheck(instance, Constructor) { if (!_instanceof(instance, Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-function _get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = _getPrototypeOf(object); if (parent === null) { return undefined; } else { return _get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 
 function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
 

packages/babel-plugin-transform-classes/test/fixtures/extend-builtins/loose/output.js

@@ -2,7 +2,7 @@ function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.crea
 
 function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() {} Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, _setPrototypeOf(function Super() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); }, Class)); }; return _wrapNativeSuper(Class); }
 
-function _construct(Parent, args, Class) { if (typeof Reflect === "object" && Reflect.construct) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Parent.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+function _construct(Parent, args, Class) { if (typeof Reflect !== "undefined" && Reflect.construct) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Parent.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 

packages/babel-plugin-transform-classes/test/fixtures/extend-builtins/spec/output.js

@@ -8,7 +8,7 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 
 function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() {} Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, _setPrototypeOf(function Super() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); }, Class)); }; return _wrapNativeSuper(Class); }
 
-function _construct(Parent, args, Class) { if (typeof Reflect === "object" && Reflect.construct) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Parent.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+function _construct(Parent, args, Class) { if (typeof Reflect !== "undefined" && Reflect.construct) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Parent.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-data-defined-on-parent/exec.js

@@ -0,0 +1,23 @@
+"use strict";
+class Base {
+}
+Object.defineProperty(Base.prototype, 'test', {
+  value: 1,
+  writable: true,
+  configurable: true,
+});
+
+class Obj extends Base {
+  get() {
+    return super.test;
+  }
+}
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+});
+
+const obj = new Obj();
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), 1);

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-data-defined-on-parent/input.js

@@ -0,0 +1,15 @@
+"use strict";
+class Base {
+}
+Base.prototype.test = 1;
+
+class Obj extends Base {
+  get() {
+    return super.test;
+  }
+}
+Obj.prototype.test = 2;
+
+const obj = new Obj();
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), 1);

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-data-defined-on-parent/output.js

@@ -0,0 +1,53 @@
+"use strict";
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+let Base = function Base() {
+  _classCallCheck(this, Base);
+};
+
+Base.prototype.test = 1;
+
+let Obj =
+/*#__PURE__*/
+function (_Base) {
+  _inherits(Obj, _Base);
+
+  function Obj() {
+    _classCallCheck(this, Obj);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(Obj).apply(this, arguments));
+  }
+
+  _createClass(Obj, [{
+    key: "get",
+    value: function get() {
+      return _get(_getPrototypeOf(Obj.prototype), "test", this);
+    }
+  }]);
+
+  return Obj;
+}(Base);
+
+Obj.prototype.test = 2;
+const obj = new Obj();
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), 1);

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-getter-defined-on-parent/exec.js

@@ -0,0 +1,22 @@
+"use strict";
+class Base {
+  get test() {
+    assert.equal(this, obj);
+    return 1;
+  }
+}
+
+class Obj extends Base {
+  get() {
+    return super.test;
+  }
+}
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+});
+
+const obj = new Obj();
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), 1);

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-getter-defined-on-parent/input.js

@@ -0,0 +1,22 @@
+"use strict";
+class Base {
+  get test() {
+    assert.equal(this, obj);
+    return 1;
+  }
+}
+
+class Obj extends Base {
+  get() {
+    return super.test;
+  }
+}
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+});
+
+const obj = new Obj();
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), 1);

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-getter-defined-on-parent/output.js

@@ -0,0 +1,69 @@
+"use strict";
+
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+let Base =
+/*#__PURE__*/
+function () {
+  function Base() {
+    _classCallCheck(this, Base);
+  }
+
+  _createClass(Base, [{
+    key: "test",
+    get: function () {
+      assert.equal(this, obj);
+      return 1;
+    }
+  }]);
+
+  return Base;
+}();
+
+let Obj =
+/*#__PURE__*/
+function (_Base) {
+  _inherits(Obj, _Base);
+
+  function Obj() {
+    _classCallCheck(this, Obj);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(Obj).apply(this, arguments));
+  }
+
+  _createClass(Obj, [{
+    key: "get",
+    value: function get() {
+      return _get(_getPrototypeOf(Obj.prototype), "test", this);
+    }
+  }]);
+
+  return Obj;
+}(Base);
+
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true
+});
+const obj = new Obj();
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), 1);

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-not-defined-on-parent/exec.js

@@ -0,0 +1,18 @@
+"use strict";
+class Base {
+}
+
+class Obj extends Base {
+  get() {
+    return super.test;
+  }
+}
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+});
+
+const obj = new Obj();
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), undefined);

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-not-defined-on-parent/input.js

@@ -0,0 +1,18 @@
+"use strict";
+class Base {
+}
+
+class Obj extends Base {
+  get() {
+    return super.test;
+  }
+}
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+});
+
+const obj = new Obj();
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), undefined);

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-not-defined-on-parent/output.js

@@ -0,0 +1,55 @@
+"use strict";
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+let Base = function Base() {
+  _classCallCheck(this, Base);
+};
+
+let Obj =
+/*#__PURE__*/
+function (_Base) {
+  _inherits(Obj, _Base);
+
+  function Obj() {
+    _classCallCheck(this, Obj);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(Obj).apply(this, arguments));
+  }
+
+  _createClass(Obj, [{
+    key: "get",
+    value: function get() {
+      return _get(_getPrototypeOf(Obj.prototype), "test", this);
+    }
+  }]);
+
+  return Obj;
+}(Base);
+
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true
+});
+const obj = new Obj();
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), undefined);

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-setter-defined-on-parent/exec.js

@@ -0,0 +1,21 @@
+"use strict";
+class Base {
+  set test(v) {
+    throw new Error("not called");
+  }
+}
+
+class Obj extends Base {
+  get() {
+    return super.test;
+  }
+}
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+});
+
+const obj = new Obj();
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), undefined);

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-setter-defined-on-parent/input.js

@@ -0,0 +1,21 @@
+"use strict";
+class Base {
+  set test(v) {
+    throw new Error("not called");
+  }
+}
+
+class Obj extends Base {
+  get() {
+    return super.test;
+  }
+}
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+});
+
+const obj = new Obj();
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), undefined);

packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-setter-defined-on-parent/output.js

@@ -0,0 +1,68 @@
+"use strict";
+
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+let Base =
+/*#__PURE__*/
+function () {
+  function Base() {
+    _classCallCheck(this, Base);
+  }
+
+  _createClass(Base, [{
+    key: "test",
+    set: function (v) {
+      throw new Error("not called");
+    }
+  }]);
+
+  return Base;
+}();
+
+let Obj =
+/*#__PURE__*/
+function (_Base) {
+  _inherits(Obj, _Base);
+
+  function Obj() {
+    _classCallCheck(this, Obj);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(Obj).apply(this, arguments));
+  }
+
+  _createClass(Obj, [{
+    key: "get",
+    value: function get() {
+      return _get(_getPrototypeOf(Obj.prototype), "test", this);
+    }
+  }]);
+
+  return Obj;
+}(Base);
+
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true
+});
+const obj = new Obj();
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), undefined);

packages/babel-plugin-transform-classes/test/fixtures/get-set/options.json

@@ -0,0 +1,3 @@
+{
+  "plugins": ["transform-classes"]
+}

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-data-defined-on-parent/exec.js

@@ -0,0 +1,25 @@
+"use strict";
+class Base  {
+}
+Object.defineProperty(Base.prototype, 'test', {
+  value: 1,
+  writable: true,
+  configurable: true,
+});
+
+class Obj extends Base {
+  set() {
+    return super.test = 3;
+  }
+}
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+});
+
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(Base.prototype.test, 1);
+assert.equal(Obj.prototype.test, 2);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-data-defined-on-parent/input.js

@@ -0,0 +1,25 @@
+"use strict";
+class Base  {
+}
+Object.defineProperty(Base.prototype, 'test', {
+  value: 1,
+  writable: true,
+  configurable: true,
+});
+
+class Obj extends Base {
+  set() {
+    return super.test = 3;
+  }
+}
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+});
+
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(Base.prototype.test, 1);
+assert.equal(Obj.prototype.test, 2);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-data-defined-on-parent/output.js

@@ -0,0 +1,67 @@
+"use strict";
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+let Base = function Base() {
+  _classCallCheck(this, Base);
+};
+
+Object.defineProperty(Base.prototype, 'test', {
+  value: 1,
+  writable: true,
+  configurable: true
+});
+
+let Obj =
+/*#__PURE__*/
+function (_Base) {
+  _inherits(Obj, _Base);
+
+  function Obj() {
+    _classCallCheck(this, Obj);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(Obj).apply(this, arguments));
+  }
+
+  _createClass(Obj, [{
+    key: "set",
+    value: function set() {
+      return _set(_getPrototypeOf(Obj.prototype), "test", 3, this, true);
+    }
+  }]);
+
+  return Obj;
+}(Base);
+
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true
+});
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(Base.prototype.test, 1);
+assert.equal(Obj.prototype.test, 2);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-getter-defined-on-parent/exec.js

@@ -0,0 +1,28 @@
+"use strict";
+let called = false;
+class Base {
+  get test() {
+    called = true;
+    return 1;
+  }
+};
+
+class Obj extends Base {
+  set() {
+    return super.test = 3;
+  }
+}
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+});
+
+const obj = new Obj();
+assert.throws(() => {
+  obj.set();
+});
+assert.equal(called, false);
+assert.equal(Base.prototype.test, 1);
+assert.equal(Obj.prototype.test, 2);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-getter-defined-on-parent/input.js

@@ -0,0 +1,27 @@
+"use strict";
+class Base {
+  get test() {
+    return 1;
+  }
+};
+
+class Obj extends Base {
+  set() {
+    return super.test = 3;
+  }
+}
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+});
+
+const obj = new Obj();
+assert.throws(() => {
+  // this requires helpers to be in file (not external), so they
+  // are in "strict" mode code.
+  obj.set();
+});
+assert.equal(Base.prototype.test, 1);
+assert.equal(Obj.prototype.test, 2);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-getter-defined-on-parent/output.js

@@ -0,0 +1,80 @@
+"use strict";
+
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+let Base =
+/*#__PURE__*/
+function () {
+  function Base() {
+    _classCallCheck(this, Base);
+  }
+
+  _createClass(Base, [{
+    key: "test",
+    get: function () {
+      return 1;
+    }
+  }]);
+
+  return Base;
+}();
+
+;
+
+let Obj =
+/*#__PURE__*/
+function (_Base) {
+  _inherits(Obj, _Base);
+
+  function Obj() {
+    _classCallCheck(this, Obj);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(Obj).apply(this, arguments));
+  }
+
+  _createClass(Obj, [{
+    key: "set",
+    value: function set() {
+      return _set(_getPrototypeOf(Obj.prototype), "test", 3, this, true);
+    }
+  }]);
+
+  return Obj;
+}(Base);
+
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true
+});
+const obj = new Obj();
+assert.throws(() => {
+  // this requires helpers to be in file (not external), so they
+  // are in "strict" mode code.
+  obj.set();
+});
+assert.equal(Base.prototype.test, 1);
+assert.equal(Obj.prototype.test, 2);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/exec.js

@@ -0,0 +1,20 @@
+"use strict";
+class Base {
+}
+
+class Obj extends Base {
+  set() {
+    return super.test = 3;
+  }
+}
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+});
+
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(Base.prototype.test, undefined);
+assert.equal(Obj.prototype.test, 2);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/input.js

@@ -0,0 +1,20 @@
+"use strict";
+class Base {
+}
+
+class Obj extends Base {
+  set() {
+    return super.test = 3;
+  }
+}
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+});
+
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(Base.prototype.test, undefined);
+assert.equal(Obj.prototype.test, 2);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/output.js

@@ -0,0 +1,61 @@
+"use strict";
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+let Base = function Base() {
+  _classCallCheck(this, Base);
+};
+
+let Obj =
+/*#__PURE__*/
+function (_Base) {
+  _inherits(Obj, _Base);
+
+  function Obj() {
+    _classCallCheck(this, Obj);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(Obj).apply(this, arguments));
+  }
+
+  _createClass(Obj, [{
+    key: "set",
+    value: function set() {
+      return _set(_getPrototypeOf(Obj.prototype), "test", 3, this, true);
+    }
+  }]);
+
+  return Obj;
+}(Base);
+
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true
+});
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(Base.prototype.test, undefined);
+assert.equal(Obj.prototype.test, 2);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/exec.js

@@ -0,0 +1,21 @@
+"use strict";
+class Base {
+}
+
+let called = false;
+class Obj extends Base {
+  get test() {
+    called = true;
+  }
+
+  set() {
+    return super.test = 3;
+  }
+}
+
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(called, false);
+assert.equal(Base.prototype.test, undefined);
+assert.equal(Obj.prototype.test, undefined);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/input.js

@@ -0,0 +1,17 @@
+"use strict";
+class Base {
+}
+
+class Obj extends Base {
+  get test() { }
+
+  set() {
+    return super.test = 3;
+  }
+}
+
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(Base.prototype.test, undefined);
+assert.equal(Obj.prototype.test, undefined);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/output.js

@@ -0,0 +1,59 @@
+"use strict";
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+let Base = function Base() {
+  _classCallCheck(this, Base);
+};
+
+let Obj =
+/*#__PURE__*/
+function (_Base) {
+  _inherits(Obj, _Base);
+
+  function Obj() {
+    _classCallCheck(this, Obj);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(Obj).apply(this, arguments));
+  }
+
+  _createClass(Obj, [{
+    key: "set",
+    value: function set() {
+      return _set(_getPrototypeOf(Obj.prototype), "test", 3, this, true);
+    }
+  }, {
+    key: "test",
+    get: function () {}
+  }]);
+
+  return Obj;
+}(Base);
+
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(Base.prototype.test, undefined);
+assert.equal(Obj.prototype.test, undefined);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/exec.js

@@ -0,0 +1,15 @@
+"use strict";
+class Base {
+}
+
+class Obj extends Base {
+  set() {
+    return super.test = 3;
+  }
+}
+
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(Base.prototype.test, undefined);
+assert.equal(Obj.prototype.test, undefined);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/input.js

@@ -0,0 +1,15 @@
+"use strict";
+class Base {
+}
+
+class Obj extends Base {
+  set() {
+    return super.test = 3;
+  }
+}
+
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(Base.prototype.test, undefined);
+assert.equal(Obj.prototype.test, undefined);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/output.js

@@ -0,0 +1,56 @@
+"use strict";
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+let Base = function Base() {
+  _classCallCheck(this, Base);
+};
+
+let Obj =
+/*#__PURE__*/
+function (_Base) {
+  _inherits(Obj, _Base);
+
+  function Obj() {
+    _classCallCheck(this, Obj);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(Obj).apply(this, arguments));
+  }
+
+  _createClass(Obj, [{
+    key: "set",
+    value: function set() {
+      return _set(_getPrototypeOf(Obj.prototype), "test", 3, this, true);
+    }
+  }]);
+
+  return Obj;
+}(Base);
+
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(Base.prototype.test, undefined);
+assert.equal(Obj.prototype.test, undefined);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/exec.js

@@ -0,0 +1,21 @@
+"use strict";
+class Base {
+}
+
+let value = 2;
+class Obj extends Base {
+  set test(v) {
+    value = v;
+  }
+
+  set() {
+    return super.test = 3;
+  }
+}
+
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(Base.prototype.test, undefined);
+assert.equal(Obj.prototype.test, undefined);
+assert.equal(value, 2);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/input.js

@@ -0,0 +1,22 @@
+"use strict";
+class Base {
+}
+
+let value = 2;
+class Obj extends Base {
+  set test(v) {
+    assert.equal(this, obj);
+    value = v;
+  }
+
+  set() {
+    return super.test = 3;
+  }
+}
+
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(Base.prototype.test, undefined);
+assert.equal(Obj.prototype.test, undefined);
+assert.equal(value, 2);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/output.js

@@ -0,0 +1,65 @@
+"use strict";
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+let Base = function Base() {
+  _classCallCheck(this, Base);
+};
+
+let value = 2;
+
+let Obj =
+/*#__PURE__*/
+function (_Base) {
+  _inherits(Obj, _Base);
+
+  function Obj() {
+    _classCallCheck(this, Obj);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(Obj).apply(this, arguments));
+  }
+
+  _createClass(Obj, [{
+    key: "set",
+    value: function set() {
+      return _set(_getPrototypeOf(Obj.prototype), "test", 3, this, true);
+    }
+  }, {
+    key: "test",
+    set: function (v) {
+      assert.equal(this, obj);
+      value = v;
+    }
+  }]);
+
+  return Obj;
+}(Base);
+
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(Base.prototype.test, undefined);
+assert.equal(Obj.prototype.test, undefined);
+assert.equal(value, 2);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-setter-defined-on-parent/exec.js

@@ -0,0 +1,25 @@
+"use strict";
+let value = 1;
+class Base {
+  set test(v) {
+    value = v;
+  }
+}
+
+class Obj extends Base {
+  set() {
+    return super.test = 3;
+  }
+}
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+});
+
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(value, 3);
+assert.equal(Base.prototype.test, undefined);
+assert.equal(Obj.prototype.test, 2);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-setter-defined-on-parent/input.js

@@ -0,0 +1,25 @@
+"use strict";
+let value = 1;
+class Base {
+  set test(v) {
+    value = v;
+  }
+}
+
+class Obj extends Base {
+  set() {
+    return super.test = 3;
+  }
+}
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+});
+
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(value, 3);
+assert.equal(Base.prototype.test, undefined);
+assert.equal(Obj.prototype.test, 2);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-setter-defined-on-parent/output.js

@@ -0,0 +1,77 @@
+"use strict";
+
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+let value = 1;
+
+let Base =
+/*#__PURE__*/
+function () {
+  function Base() {
+    _classCallCheck(this, Base);
+  }
+
+  _createClass(Base, [{
+    key: "test",
+    set: function (v) {
+      value = v;
+    }
+  }]);
+
+  return Base;
+}();
+
+let Obj =
+/*#__PURE__*/
+function (_Base) {
+  _inherits(Obj, _Base);
+
+  function Obj() {
+    _classCallCheck(this, Obj);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(Obj).apply(this, arguments));
+  }
+
+  _createClass(Obj, [{
+    key: "set",
+    value: function set() {
+      return _set(_getPrototypeOf(Obj.prototype), "test", 3, this, true);
+    }
+  }]);
+
+  return Obj;
+}(Base);
+
+Object.defineProperty(Obj.prototype, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true
+});
+const obj = new Obj();
+assert.equal(obj.set(), 3);
+assert.equal(value, 3);
+assert.equal(Base.prototype.test, undefined);
+assert.equal(Obj.prototype.test, 2);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-classes/test/fixtures/regression/5769/exec.js

@@ -0,0 +1,22 @@
+class Point {
+  getX() {
+    assert.equal(this.x, 3); // C
+  }
+}
+
+class ColorPoint extends Point {
+  constructor() {
+    super();
+    this.x = 2;
+    super.x = 3;
+    assert.equal(this.x, 3)   // A
+    assert.equal(super.x, undefined)  // B
+  }
+
+  m() {
+    this.getX()
+  }
+}
+
+const cp = new ColorPoint();
+cp.m();

packages/babel-plugin-transform-classes/test/fixtures/regression/5769/input.js

@@ -0,0 +1,22 @@
+class Point {
+  getX() {
+    assert.equal(this.x, 3); // C
+  }
+}
+
+class ColorPoint extends Point {
+  constructor() {
+    super();
+    this.x = 2;
+    super.x = 3;
+    assert.equal(this.x, 3)   // A
+    assert.equal(super.x, undefined)  // B
+  }
+
+  m() {
+    this.getX()
+  }
+}
+
+const cp = new ColorPoint();
+cp.m();

packages/babel-plugin-transform-classes/test/fixtures/regression/5769/output.js

@@ -0,0 +1,46 @@
+var Point =
+/*#__PURE__*/
+function () {
+  function Point() {
+    babelHelpers.classCallCheck(this, Point);
+  }
+
+  babelHelpers.createClass(Point, [{
+    key: "getX",
+    value: function getX() {
+      assert.equal(this.x, 3); // C
+    }
+  }]);
+  return Point;
+}();
+
+var ColorPoint =
+/*#__PURE__*/
+function (_Point) {
+  babelHelpers.inherits(ColorPoint, _Point);
+
+  function ColorPoint() {
+    var _this;
+
+    babelHelpers.classCallCheck(this, ColorPoint);
+    _this = babelHelpers.possibleConstructorReturn(this, babelHelpers.getPrototypeOf(ColorPoint).call(this));
+    _this.x = 2;
+    babelHelpers.set(babelHelpers.getPrototypeOf(ColorPoint.prototype), "x", 3, _this, true);
+    assert.equal(_this.x, 3); // A
+
+    assert.equal(babelHelpers.get(babelHelpers.getPrototypeOf(ColorPoint.prototype), "x", babelHelpers.assertThisInitialized(_this)), undefined); // B
+
+    return _this;
+  }
+
+  babelHelpers.createClass(ColorPoint, [{
+    key: "m",
+    value: function m() {
+      this.getX();
+    }
+  }]);
+  return ColorPoint;
+}(Point);
+
+var cp = new ColorPoint();
+cp.m();

packages/babel-plugin-transform-classes/test/fixtures/spec/super-reference-before-bare-super-inline/output.js

@@ -6,7 +6,9 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-function _get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = _getPrototypeOf(object); if (parent === null) { return undefined; } else { return _get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 
 function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
 

packages/babel-plugin-transform-classes/test/fixtures/spec/super-reference-before-bare-super/output.js

@@ -6,7 +6,9 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-function _get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = _getPrototypeOf(object); if (parent === null) { return undefined; } else { return _get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 
 function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
 

packages/babel-plugin-transform-exponentiation-operator/test/fixtures/regression/4349/output.js

@@ -1,8 +1,14 @@
 var _obj;
 
-function _set(object, property, value, receiver) { var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = _getPrototypeOf(object); if (parent !== null) { _set(parent, property, value, receiver); } } else if ("value" in desc && desc.writable) { desc.value = value; } else { var setter = desc.set; if (setter !== undefined) { setter.call(receiver, value); } } return value; }
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
 
-function _get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = _getPrototypeOf(object); if (parent === null) { return undefined; } else { return _get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 
 function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
 
@@ -10,7 +16,7 @@ foo = _obj = {
   bar() {
     var _ref;
 
-    return _ref = _get(_getPrototypeOf(_obj), "baz", this), _set(_getPrototypeOf(_obj), "baz", Math.pow(_ref, 12), this);
+    return _ref = _get(_getPrototypeOf(_obj), "baz", this), _set(_getPrototypeOf(_obj), "baz", Math.pow(_ref, 12), this, false);
   }
 
 };

packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-data-defined-on-parent/exec.js

@@ -0,0 +1,16 @@
+"use strict";
+const Base = {
+  test: 1,
+};
+
+const obj = {
+  test: 2,
+
+  get() {
+    return super.test;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), 1);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-data-defined-on-parent/input.js

@@ -0,0 +1,16 @@
+"use strict";
+const Base = {
+  test: 1,
+};
+
+const obj = {
+  test: 2,
+
+  get() {
+    return super.test;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), 1);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-data-defined-on-parent/output.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _obj;
+
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+const Base = {
+  test: 1
+};
+const obj = _obj = {
+  test: 2,
+
+  get() {
+    return _get(_getPrototypeOf(_obj), "test", this);
+  }
+
+};
+Object.setPrototypeOf(obj, Base);
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), 1);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-getter-defined-on-parent/exec.js

@@ -0,0 +1,19 @@
+"use strict";
+const Base = {
+  get test() {
+    assert.equal(this, obj);
+    return 1;
+  }
+};
+
+const obj = {
+  test: 2,
+
+  get() {
+    return super.test;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), 1);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-getter-defined-on-parent/input.js

@@ -0,0 +1,19 @@
+"use strict";
+const Base = {
+  get test() {
+    assert.equal(this, obj);
+    return 1;
+  }
+};
+
+const obj = {
+  test: 2,
+
+  get() {
+    return super.test;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), 1);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-getter-defined-on-parent/output.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _obj;
+
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+const Base = {
+  get test() {
+    assert.equal(this, obj);
+    return 1;
+  }
+
+};
+const obj = _obj = {
+  test: 2,
+
+  get() {
+    return _get(_getPrototypeOf(_obj), "test", this);
+  }
+
+};
+Object.setPrototypeOf(obj, Base);
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), 1);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-not-defined-on-parent/exec.js

@@ -0,0 +1,15 @@
+"use strict";
+const Base = {
+};
+
+const obj = {
+  test: 2,
+
+  get() {
+    return super.test;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), undefined);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-not-defined-on-parent/input.js

@@ -0,0 +1,15 @@
+"use strict";
+const Base = {
+};
+
+const obj = {
+  test: 2,
+
+  get() {
+    return super.test;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), undefined);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-not-defined-on-parent/output.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _obj;
+
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+const Base = {};
+const obj = _obj = {
+  test: 2,
+
+  get() {
+    return _get(_getPrototypeOf(_obj), "test", this);
+  }
+
+};
+Object.setPrototypeOf(obj, Base);
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), undefined);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-setter-defined-on-parent/exec.js

@@ -0,0 +1,18 @@
+"use strict";
+const Base = {
+  set test(v) {
+    throw new Error("not called");
+  }
+};
+
+const obj = {
+  test: 2,
+
+  get() {
+    return super.test;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), undefined);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-setter-defined-on-parent/input.js

@@ -0,0 +1,18 @@
+"use strict";
+const Base = {
+  set test(v) {
+    throw new Error("not called");
+  }
+};
+
+const obj = {
+  test: 2,
+
+  get() {
+    return super.test;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), undefined);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-setter-defined-on-parent/output.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _obj;
+
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+const Base = {
+  set test(v) {
+    throw new Error("not called");
+  }
+
+};
+const obj = _obj = {
+  test: 2,
+
+  get() {
+    return _get(_getPrototypeOf(_obj), "test", this);
+  }
+
+};
+Object.setPrototypeOf(obj, Base);
+assert.equal(obj.test, 2);
+assert.equal(obj.get(), undefined);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/options.json

@@ -0,0 +1,4 @@
+{
+  "minNodeVersion": "6.0.0",
+  "plugins": ["transform-object-super"]
+}

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-defined-on-parent/exec.js

@@ -0,0 +1,17 @@
+"use strict";
+const Base = {
+  test: 1,
+};
+
+const obj = {
+  test: 2,
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, 1);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-defined-on-parent/input.js

@@ -0,0 +1,17 @@
+"use strict";
+const Base = {
+  test: 1,
+};
+
+const obj = {
+  test: 2,
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, 3);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-defined-on-parent/output.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _obj;
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+const Base = {
+  test: 1
+};
+const obj = _obj = {
+  test: 2,
+
+  set() {
+    return _set(_getPrototypeOf(_obj), "test", 3, this, true);
+  }
+
+};
+Object.setPrototypeOf(obj, Base);
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, 3);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-non-configurable-defined-on-parent/exec.js

@@ -0,0 +1,21 @@
+"use strict";
+const Base = {
+};
+Object.defineProperty(Base, 'test', {
+  value: 1,
+  writable: true,
+  configurable: false,
+});
+
+const obj = {
+  test: 2,
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, 1);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-non-writable-defined-on-parent-loose/exec.js

@@ -0,0 +1,20 @@
+var Base = {
+};
+Object.defineProperty(Base, 'test', {
+  value: 1,
+  writable: false,
+  configurable: true,
+});
+
+var obj = {
+  test: 2,
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, 1);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-non-writable-defined-on-parent/exec.js

@@ -0,0 +1,23 @@
+"use strict";
+const Base = {
+};
+Object.defineProperty(Base, 'test', {
+  value: 1,
+  writable: false,
+  configurable: true,
+});
+
+const obj = {
+  test: 2,
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.throws(() => {
+  obj.set();
+});
+assert.equal(Base.test, 1);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-getter-defined-on-parent/exec.js

@@ -0,0 +1,24 @@
+"use strict";
+let called = false;
+const Base = {
+  get test() {
+    called = true;
+    return 1;
+  }
+};
+
+const obj = {
+  test: 2,
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.throws(() => {
+  obj.set();
+});
+assert.equal(called, false);
+assert.equal(Base.test, 1);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-getter-defined-on-parent/input.js

@@ -0,0 +1,23 @@
+"use strict";
+const Base = {
+  get test() {
+    return 1;
+  }
+};
+
+const obj = {
+  test: 2,
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.throws(() => {
+  // this requires helpers to be in file (not external), so they
+  // are in "strict" mode code.
+  obj.set();
+});
+assert.equal(Base.test, 1);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-getter-defined-on-parent/output.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _obj;
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+const Base = {
+  get test() {
+    return 1;
+  }
+
+};
+const obj = _obj = {
+  test: 2,
+
+  set() {
+    return _set(_getPrototypeOf(_obj), "test", 3, this, true);
+  }
+
+};
+Object.setPrototypeOf(obj, Base);
+assert.throws(() => {
+  // this requires helpers to be in file (not external), so they
+  // are in "strict" mode code.
+  obj.set();
+});
+assert.equal(Base.test, 1);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-configurable-on-obj/exec.js

@@ -0,0 +1,25 @@
+"use strict";
+const Base = {
+};
+
+const obj = {
+  set() {
+    return super.test = 3;
+  },
+};
+Object.defineProperty(obj, 'test', {
+  value: 2,
+  writable: true,
+  configurable: false,
+  enumerable: true,
+});
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 3);
+
+const desc = Object.getOwnPropertyDescriptor(obj, 'test');
+assert.equal(desc.configurable, false);
+assert.equal(desc.writable, true);
+assert.equal(desc.enumerable, true);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-configurable-on-obj/input.js

@@ -0,0 +1,25 @@
+"use strict";
+const Base = {
+};
+
+const obj = {
+  set() {
+    return super.test = 3;
+  },
+};
+Object.defineProperty(obj, 'test', {
+  value: 2,
+  writable: true,
+  configurable: false,
+  enumerable: true,
+});
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 3);
+
+const desc = Object.getOwnPropertyDescriptor(obj, 'test');
+assert.equal(desc.configurable, false);
+assert.equal(desc.writable, true);
+assert.equal(desc.enumerable, true);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-configurable-on-obj/output.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _obj;
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+const Base = {};
+const obj = _obj = {
+  set() {
+    return _set(_getPrototypeOf(_obj), "test", 3, this, true);
+  }
+
+};
+Object.defineProperty(obj, 'test', {
+  value: 2,
+  writable: true,
+  configurable: false,
+  enumerable: true
+});
+Object.setPrototypeOf(obj, Base);
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 3);
+const desc = Object.getOwnPropertyDescriptor(obj, 'test');
+assert.equal(desc.configurable, false);
+assert.equal(desc.writable, true);
+assert.equal(desc.enumerable, true);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-enumerable-on-obj/exec.js

@@ -0,0 +1,25 @@
+"use strict";
+const Base = {
+};
+
+const obj = {
+  set() {
+    return super.test = 3;
+  },
+};
+Object.defineProperty(obj, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+  enumerable: false,
+});
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 3);
+
+const desc = Object.getOwnPropertyDescriptor(obj, 'test');
+assert.equal(desc.configurable, true);
+assert.equal(desc.writable, true);
+assert.equal(desc.enumerable, false);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-enumerable-on-obj/input.js

@@ -0,0 +1,25 @@
+"use strict";
+const Base = {
+};
+
+const obj = {
+  set() {
+    return super.test = 3;
+  },
+};
+Object.defineProperty(obj, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+  enumerable: false,
+});
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 3);
+
+const desc = Object.getOwnPropertyDescriptor(obj, 'test');
+assert.equal(desc.configurable, true);
+assert.equal(desc.writable, true);
+assert.equal(desc.enumerable, false);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-enumerable-on-obj/output.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _obj;
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+const Base = {};
+const obj = _obj = {
+  set() {
+    return _set(_getPrototypeOf(_obj), "test", 3, this, true);
+  }
+
+};
+Object.defineProperty(obj, 'test', {
+  value: 2,
+  writable: true,
+  configurable: true,
+  enumerable: false
+});
+Object.setPrototypeOf(obj, Base);
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 3);
+const desc = Object.getOwnPropertyDescriptor(obj, 'test');
+assert.equal(desc.configurable, true);
+assert.equal(desc.writable, true);
+assert.equal(desc.enumerable, false);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-writable-on-obj-loose/exec.js

@@ -0,0 +1,24 @@
+var Base = {
+};
+
+var obj = {
+  set() {
+    return super.test = 3;
+  },
+};
+Object.defineProperty(obj, 'test', {
+  value: 2,
+  writable: false,
+  configurable: true,
+  enumerable: true,
+});
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 2);
+
+const desc = Object.getOwnPropertyDescriptor(obj, 'test');
+assert.equal(desc.configurable, true);
+assert.equal(desc.writable, false);
+assert.equal(desc.enumerable, true);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-writable-on-obj/exec.js

@@ -0,0 +1,27 @@
+"use strict";
+const Base = {
+};
+
+const obj = {
+  set() {
+    return super.test = 3;
+  },
+};
+Object.defineProperty(obj, 'test', {
+  value: 2,
+  writable: false,
+  configurable: true,
+  enumerable: true,
+});
+Object.setPrototypeOf(obj, Base);
+
+assert.throws(() => {
+  obj.set();
+});
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 2);
+
+const desc = Object.getOwnPropertyDescriptor(obj, 'test');
+assert.equal(desc.configurable, true);
+assert.equal(desc.writable, false);
+assert.equal(desc.enumerable, true);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-writable-on-obj/input.js

@@ -0,0 +1,27 @@
+"use strict";
+const Base = {
+};
+
+const obj = {
+  set() {
+    return super.test = 3;
+  },
+};
+Object.defineProperty(obj, 'test', {
+  value: 2,
+  writable: false,
+  configurable: true,
+  enumerable: true,
+});
+Object.setPrototypeOf(obj, Base);
+
+assert.throws(() => {
+  obj.set();
+});
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 2);
+
+const desc = Object.getOwnPropertyDescriptor(obj, 'test');
+assert.equal(desc.configurable, true);
+assert.equal(desc.writable, false);
+assert.equal(desc.enumerable, true);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-writable-on-obj/output.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _obj;
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+const Base = {};
+const obj = _obj = {
+  set() {
+    return _set(_getPrototypeOf(_obj), "test", 3, this, true);
+  }
+
+};
+Object.defineProperty(obj, 'test', {
+  value: 2,
+  writable: false,
+  configurable: true,
+  enumerable: true
+});
+Object.setPrototypeOf(obj, Base);
+assert.throws(() => {
+  obj.set();
+});
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 2);
+const desc = Object.getOwnPropertyDescriptor(obj, 'test');
+assert.equal(desc.configurable, true);
+assert.equal(desc.writable, false);
+assert.equal(desc.enumerable, true);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/exec.js

@@ -0,0 +1,16 @@
+"use strict";
+const Base = {
+};
+
+const obj = {
+  test: 2,
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/input.js

@@ -0,0 +1,16 @@
+"use strict";
+const Base = {
+};
+
+const obj = {
+  test: 2,
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/output.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _obj;
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+const Base = {};
+const obj = _obj = {
+  test: 2,
+
+  set() {
+    return _set(_getPrototypeOf(_obj), "test", 3, this, true);
+  }
+
+};
+Object.setPrototypeOf(obj, Base);
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj-loose/exec.js

@@ -0,0 +1,19 @@
+var Base = {
+};
+
+var called = false;
+var obj = {
+  get test() {
+    called = true;
+  },
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(called, false);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, undefined);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/exec.js

@@ -0,0 +1,22 @@
+"use strict";
+const Base = {
+};
+
+let called = false;
+const obj = {
+  get test() {
+    called = true;
+  },
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.throws(() => {
+  obj.set();
+});
+assert.equal(called, false);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, undefined);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/input.js

@@ -0,0 +1,20 @@
+"use strict";
+const Base = {
+};
+
+const obj = {
+  get test() { },
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.throws(() => {
+  // this requires helpers to be in file (not external), so they
+  // are in "strict" mode code.
+  obj.set();
+});
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, undefined);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/output.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _obj;
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+const Base = {};
+const obj = _obj = {
+  get test() {},
+
+  set() {
+    return _set(_getPrototypeOf(_obj), "test", 3, this, true);
+  }
+
+};
+Object.setPrototypeOf(obj, Base);
+assert.throws(() => {
+  // this requires helpers to be in file (not external), so they
+  // are in "strict" mode code.
+  obj.set();
+});
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, undefined);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/exec.js

@@ -0,0 +1,14 @@
+"use strict";
+const Base = {
+};
+
+const obj = {
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/input.js

@@ -0,0 +1,14 @@
+"use strict";
+const Base = {
+};
+
+const obj = {
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/output.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _obj;
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+const Base = {};
+const obj = _obj = {
+  set() {
+    return _set(_getPrototypeOf(_obj), "test", 3, this, true);
+  }
+
+};
+Object.setPrototypeOf(obj, Base);
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 3);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj-loose/exec.js

@@ -0,0 +1,19 @@
+var Base = {
+};
+
+var value = 2;
+var obj = {
+  set test(v) {
+    value = v;
+  },
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(value, 2);
+assert.equal(obj.test, undefined);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/exec.js

@@ -0,0 +1,22 @@
+"use strict";
+const Base = {
+};
+
+let value = 2;
+const obj = {
+  set test(v) {
+    value = v;
+  },
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.throws(() => {
+  obj.set();
+});
+assert.equal(value, 2);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, undefined);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/input.js

@@ -0,0 +1,21 @@
+"use strict";
+const Base = {
+};
+
+let value = 2;
+const obj = {
+  set test(v) {
+    assert.equal(this, obj);
+    value = v;
+  },
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(value, 3);
+assert.equal(obj.test, undefined);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/output.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _obj;
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+const Base = {};
+let value = 2;
+const obj = _obj = {
+  set test(v) {
+    assert.equal(this, obj);
+    value = v;
+  },
+
+  set() {
+    return _set(_getPrototypeOf(_obj), "test", 3, this, true);
+  }
+
+};
+Object.setPrototypeOf(obj, Base);
+assert.equal(obj.set(), 3);
+assert.equal(Base.test, undefined);
+assert.equal(value, 3);
+assert.equal(obj.test, undefined);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-setter-defined-on-parent/exec.js

@@ -0,0 +1,21 @@
+"use strict";
+let value = 1;
+const Base = {
+  set test(v) {
+    value = v;
+  }
+};
+
+const obj = {
+  test: 2,
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(value, 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-setter-defined-on-parent/input.js

@@ -0,0 +1,21 @@
+"use strict";
+let value = 1;
+const Base = {
+  set test(v) {
+    value = v;
+  }
+};
+
+const obj = {
+  test: 2,
+
+  set() {
+    return super.test = 3;
+  },
+};
+Object.setPrototypeOf(obj, Base);
+
+assert.equal(obj.set(), 3);
+assert.equal(value, 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-setter-defined-on-parent/output.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _obj;
+
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
+
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
+
+let value = 1;
+const Base = {
+  set test(v) {
+    value = v;
+  }
+
+};
+const obj = _obj = {
+  test: 2,
+
+  set() {
+    return _set(_getPrototypeOf(_obj), "test", 3, this, true);
+  }
+
+};
+Object.setPrototypeOf(obj, Base);
+assert.equal(obj.set(), 3);
+assert.equal(value, 3);
+assert.equal(Base.test, undefined);
+assert.equal(obj.test, 2);

packages/babel-plugin-transform-object-super/test/fixtures/object-super/super-exponentiation/output.js

@@ -1,8 +1,14 @@
 var _obj;
 
-function _set(object, property, value, receiver) { var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = _getPrototypeOf(object); if (parent !== null) { _set(parent, property, value, receiver); } } else if ("value" in desc && desc.writable) { desc.value = value; } else { var setter = desc.set; if (setter !== undefined) { setter.call(receiver, value); } } return value; }
+function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = _superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { return false; } } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { _defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); }
 
-function _get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = _getPrototypeOf(object); if (parent === null) { return undefined; } else { return _get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }
+function _set(target, property, value, receiver, isStrict) { const s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 
 function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }
 
@@ -10,6 +16,6 @@ foo = _obj = {
   bar: function () {
     var _ref;
 
-    return _ref = _get(_getPrototypeOf(_obj), "baz", this), _set(_getPrototypeOf(_obj), "baz", _ref ** 12, this);
+    return _ref = _get(_getPrototypeOf(_obj), "baz", this), _set(_getPrototypeOf(_obj), "baz", _ref ** 12, this, false);
   }
 };

packages/babel-preset-env/test/fixtures/plugins-integration/issue-7527/output.js

@@ -12,7 +12,7 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 
 function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() {} Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, _setPrototypeOf(function Super() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); }, Class)); }; return _wrapNativeSuper(Class); }
 
-function _construct(Parent, args, Class) { if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === "object" && Reflect.construct) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Parent.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+function _construct(Parent, args, Class) { if (typeof Reflect !== "undefined" && Reflect.construct) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Parent.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }