diff --git a/packages/babel-helper-replace-supers/src/index.js b/packages/babel-helper-replace-supers/src/index.js index 22bfce95a3..6a96b6d859 100644 --- a/packages/babel-helper-replace-supers/src/index.js +++ b/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", [ diff --git a/packages/babel-helpers/src/helpers.js b/packages/babel-helpers/src/helpers.js index f6f5810b7e..c430819ba4 100644 --- a/packages/babel-helpers/src/helpers.js +++ b/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) { - var desc = Object.getOwnPropertyDescriptor(object, property); + export default function _superPropBase(object, property) { + // Yes, this throws if object is null to being with, that's on purpose. + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = getPrototypeOf(object); + if (object === null) break; + } + return object; + } +`; - if (desc === undefined) { - var parent = getPrototypeOf(object); +helpers.get = () => template.program.ast` + import getPrototypeOf from "getPrototypeOf"; + import superPropBase from "superPropBase"; - if (parent !== null) { - _set(parent, property, value, receiver); - } - } else if ("value" in desc && desc.writable) { - desc.value = value; + 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) { - setter.call(receiver, value); - } + 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); + } +`; + +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; diff --git a/packages/babel-plugin-proposal-class-properties/test/fixtures/regression/6154/output.js b/packages/babel-plugin-proposal-class-properties/test/fixtures/regression/6154/output.js index 7cb8f5de65..448afa8d78 100644 --- a/packages/babel-plugin-proposal-class-properties/test/fixtures/regression/6154/output.js +++ b/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); } diff --git a/packages/babel-plugin-transform-classes/test/fixtures/extend-builtins/loose/output.js b/packages/babel-plugin-transform-classes/test/fixtures/extend-builtins/loose/output.js index b4cb5c179a..a9d4fc23b0 100644 --- a/packages/babel-plugin-transform-classes/test/fixtures/extend-builtins/loose/output.js +++ b/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); } diff --git a/packages/babel-plugin-transform-classes/test/fixtures/extend-builtins/spec/output.js b/packages/babel-plugin-transform-classes/test/fixtures/extend-builtins/spec/output.js index 708a9c4b80..4fb20362a4 100644 --- a/packages/babel-plugin-transform-classes/test/fixtures/extend-builtins/spec/output.js +++ b/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); } diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-data-defined-on-parent/exec.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-data-defined-on-parent/exec.js new file mode 100644 index 0000000000..7449b0aa90 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-data-defined-on-parent/input.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-data-defined-on-parent/input.js new file mode 100644 index 0000000000..c8bd42f157 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-data-defined-on-parent/output.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-data-defined-on-parent/output.js new file mode 100644 index 0000000000..ee9b5419da --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-getter-defined-on-parent/exec.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-getter-defined-on-parent/exec.js new file mode 100644 index 0000000000..78335607a8 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-getter-defined-on-parent/input.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-getter-defined-on-parent/input.js new file mode 100644 index 0000000000..78335607a8 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-getter-defined-on-parent/output.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-getter-defined-on-parent/output.js new file mode 100644 index 0000000000..f643c30c55 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-not-defined-on-parent/exec.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-not-defined-on-parent/exec.js new file mode 100644 index 0000000000..ad8535bcf5 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-not-defined-on-parent/input.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-not-defined-on-parent/input.js new file mode 100644 index 0000000000..ad8535bcf5 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-not-defined-on-parent/output.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-not-defined-on-parent/output.js new file mode 100644 index 0000000000..c9d5f68271 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-setter-defined-on-parent/exec.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-setter-defined-on-parent/exec.js new file mode 100644 index 0000000000..949bd5d3a1 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-setter-defined-on-parent/input.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-setter-defined-on-parent/input.js new file mode 100644 index 0000000000..949bd5d3a1 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-setter-defined-on-parent/output.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/get-semantics-setter-defined-on-parent/output.js new file mode 100644 index 0000000000..21c8294157 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/options.json b/packages/babel-plugin-transform-classes/test/fixtures/get-set/options.json new file mode 100644 index 0000000000..7e50eb3348 --- /dev/null +++ b/packages/babel-plugin-transform-classes/test/fixtures/get-set/options.json @@ -0,0 +1,3 @@ +{ + "plugins": ["transform-classes"] +} diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-data-defined-on-parent/exec.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-data-defined-on-parent/exec.js new file mode 100644 index 0000000000..27ffb6e936 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-data-defined-on-parent/input.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-data-defined-on-parent/input.js new file mode 100644 index 0000000000..27ffb6e936 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-data-defined-on-parent/output.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-data-defined-on-parent/output.js new file mode 100644 index 0000000000..2774c53748 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-getter-defined-on-parent/exec.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-getter-defined-on-parent/exec.js new file mode 100644 index 0000000000..3529d7b593 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-getter-defined-on-parent/input.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-getter-defined-on-parent/input.js new file mode 100644 index 0000000000..7952ae5bf5 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-getter-defined-on-parent/output.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-getter-defined-on-parent/output.js new file mode 100644 index 0000000000..974e8a2aff --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/exec.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/exec.js new file mode 100644 index 0000000000..ef14864502 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/input.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/input.js new file mode 100644 index 0000000000..ef14864502 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/output.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/output.js new file mode 100644 index 0000000000..5fb61861f3 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/exec.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/exec.js new file mode 100644 index 0000000000..f1620fec3e --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/input.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/input.js new file mode 100644 index 0000000000..38111c8642 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/output.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/output.js new file mode 100644 index 0000000000..969ef7af06 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/exec.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/exec.js new file mode 100644 index 0000000000..3a8f4fbdf6 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/input.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/input.js new file mode 100644 index 0000000000..3a8f4fbdf6 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/output.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/output.js new file mode 100644 index 0000000000..699acb30d8 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/exec.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/exec.js new file mode 100644 index 0000000000..16e65031fb --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/input.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/input.js new file mode 100644 index 0000000000..4185c0bb0f --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/output.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/output.js new file mode 100644 index 0000000000..aaf810f5d9 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-setter-defined-on-parent/exec.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-setter-defined-on-parent/exec.js new file mode 100644 index 0000000000..97a36a3b9e --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-setter-defined-on-parent/input.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-setter-defined-on-parent/input.js new file mode 100644 index 0000000000..97a36a3b9e --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-setter-defined-on-parent/output.js b/packages/babel-plugin-transform-classes/test/fixtures/get-set/set-semantics-setter-defined-on-parent/output.js new file mode 100644 index 0000000000..4bb99004e1 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/regression/5769/exec.js b/packages/babel-plugin-transform-classes/test/fixtures/regression/5769/exec.js new file mode 100644 index 0000000000..696f6b86e8 --- /dev/null +++ b/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(); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/regression/5769/input.js b/packages/babel-plugin-transform-classes/test/fixtures/regression/5769/input.js new file mode 100644 index 0000000000..696f6b86e8 --- /dev/null +++ b/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(); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/regression/5769/output.js b/packages/babel-plugin-transform-classes/test/fixtures/regression/5769/output.js new file mode 100644 index 0000000000..1c2c78976c --- /dev/null +++ b/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(); diff --git a/packages/babel-plugin-transform-classes/test/fixtures/spec/super-reference-before-bare-super-inline/output.js b/packages/babel-plugin-transform-classes/test/fixtures/spec/super-reference-before-bare-super-inline/output.js index bd488d16ac..cebbb9ac21 100644 --- a/packages/babel-plugin-transform-classes/test/fixtures/spec/super-reference-before-bare-super-inline/output.js +++ b/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); } diff --git a/packages/babel-plugin-transform-classes/test/fixtures/spec/super-reference-before-bare-super/output.js b/packages/babel-plugin-transform-classes/test/fixtures/spec/super-reference-before-bare-super/output.js index 9298b53093..c081bc737e 100644 --- a/packages/babel-plugin-transform-classes/test/fixtures/spec/super-reference-before-bare-super/output.js +++ b/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); } diff --git a/packages/babel-plugin-transform-exponentiation-operator/test/fixtures/regression/4349/output.js b/packages/babel-plugin-transform-exponentiation-operator/test/fixtures/regression/4349/output.js index 232a78272c..d573f7bbe9 100644 --- a/packages/babel-plugin-transform-exponentiation-operator/test/fixtures/regression/4349/output.js +++ b/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); } }; diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-data-defined-on-parent/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-data-defined-on-parent/exec.js new file mode 100644 index 0000000000..6ad23f339b --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-data-defined-on-parent/input.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-data-defined-on-parent/input.js new file mode 100644 index 0000000000..6ad23f339b --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-data-defined-on-parent/output.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-data-defined-on-parent/output.js new file mode 100644 index 0000000000..52b278725a --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-getter-defined-on-parent/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-getter-defined-on-parent/exec.js new file mode 100644 index 0000000000..fc0ff00c3f --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-getter-defined-on-parent/input.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-getter-defined-on-parent/input.js new file mode 100644 index 0000000000..fc0ff00c3f --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-getter-defined-on-parent/output.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-getter-defined-on-parent/output.js new file mode 100644 index 0000000000..deb7546f32 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-not-defined-on-parent/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-not-defined-on-parent/exec.js new file mode 100644 index 0000000000..9b74c3d981 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-not-defined-on-parent/input.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-not-defined-on-parent/input.js new file mode 100644 index 0000000000..9b74c3d981 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-not-defined-on-parent/output.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-not-defined-on-parent/output.js new file mode 100644 index 0000000000..15c554bc68 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-setter-defined-on-parent/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-setter-defined-on-parent/exec.js new file mode 100644 index 0000000000..7a2968c477 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-setter-defined-on-parent/input.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-setter-defined-on-parent/input.js new file mode 100644 index 0000000000..7a2968c477 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-setter-defined-on-parent/output.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/get-semantics-setter-defined-on-parent/output.js new file mode 100644 index 0000000000..ff5658433f --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/options.json b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/options.json new file mode 100644 index 0000000000..dc660e0bf4 --- /dev/null +++ b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/options.json @@ -0,0 +1,4 @@ +{ + "minNodeVersion": "6.0.0", + "plugins": ["transform-object-super"] +} diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-defined-on-parent/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-defined-on-parent/exec.js new file mode 100644 index 0000000000..a487a7dfe6 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-defined-on-parent/input.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-defined-on-parent/input.js new file mode 100644 index 0000000000..38c5048b00 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-defined-on-parent/output.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-defined-on-parent/output.js new file mode 100644 index 0000000000..5854ebf94a --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-non-configurable-defined-on-parent/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-non-configurable-defined-on-parent/exec.js new file mode 100644 index 0000000000..a54326fe37 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-non-writable-defined-on-parent-loose/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-non-writable-defined-on-parent-loose/exec.js new file mode 100644 index 0000000000..50bfe45e48 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-non-writable-defined-on-parent/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-data-non-writable-defined-on-parent/exec.js new file mode 100644 index 0000000000..bcb739a2dc --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-getter-defined-on-parent/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-getter-defined-on-parent/exec.js new file mode 100644 index 0000000000..f56bd917af --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-getter-defined-on-parent/input.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-getter-defined-on-parent/input.js new file mode 100644 index 0000000000..9bdb1d3774 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-getter-defined-on-parent/output.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-getter-defined-on-parent/output.js new file mode 100644 index 0000000000..d62df684e2 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-configurable-on-obj/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-configurable-on-obj/exec.js new file mode 100644 index 0000000000..910e985d0e --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-configurable-on-obj/input.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-configurable-on-obj/input.js new file mode 100644 index 0000000000..910e985d0e --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-configurable-on-obj/output.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-configurable-on-obj/output.js new file mode 100644 index 0000000000..3f5ef86ac9 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-enumerable-on-obj/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-enumerable-on-obj/exec.js new file mode 100644 index 0000000000..0e66ea140b --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-enumerable-on-obj/input.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-enumerable-on-obj/input.js new file mode 100644 index 0000000000..0e66ea140b --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-enumerable-on-obj/output.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-enumerable-on-obj/output.js new file mode 100644 index 0000000000..7a7c4ea6ee --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-writable-on-obj-loose/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-writable-on-obj-loose/exec.js new file mode 100644 index 0000000000..854d2e3479 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-writable-on-obj/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-writable-on-obj/exec.js new file mode 100644 index 0000000000..85e376bcfe --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-writable-on-obj/input.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-writable-on-obj/input.js new file mode 100644 index 0000000000..85e376bcfe --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-writable-on-obj/output.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-non-writable-on-obj/output.js new file mode 100644 index 0000000000..24636b29a5 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/exec.js new file mode 100644 index 0000000000..58cc8e0848 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/input.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/input.js new file mode 100644 index 0000000000..58cc8e0848 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/output.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-data-on-obj/output.js new file mode 100644 index 0000000000..e5c3e84ddb --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj-loose/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj-loose/exec.js new file mode 100644 index 0000000000..c7adbe833e --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/exec.js new file mode 100644 index 0000000000..b0d9805ea9 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/input.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/input.js new file mode 100644 index 0000000000..84ee7a2f66 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/output.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-getter-on-obj/output.js new file mode 100644 index 0000000000..1245437b24 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/exec.js new file mode 100644 index 0000000000..6946ee817e --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/input.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/input.js new file mode 100644 index 0000000000..6946ee817e --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/output.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-not-on-obj/output.js new file mode 100644 index 0000000000..35503bb3ec --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj-loose/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj-loose/exec.js new file mode 100644 index 0000000000..eb4b815197 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/exec.js new file mode 100644 index 0000000000..8f0e4ae727 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/input.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/input.js new file mode 100644 index 0000000000..fd0dbaedfa --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/output.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-not-defined-on-parent-setter-on-obj/output.js new file mode 100644 index 0000000000..91abe82b50 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-setter-defined-on-parent/exec.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-setter-defined-on-parent/exec.js new file mode 100644 index 0000000000..515bc6e9e2 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-setter-defined-on-parent/input.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-setter-defined-on-parent/input.js new file mode 100644 index 0000000000..515bc6e9e2 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-setter-defined-on-parent/output.js b/packages/babel-plugin-transform-object-super/test/fixtures/get-set/set-semantics-setter-defined-on-parent/output.js new file mode 100644 index 0000000000..4439094e78 --- /dev/null +++ b/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); diff --git a/packages/babel-plugin-transform-object-super/test/fixtures/object-super/super-exponentiation/output.js b/packages/babel-plugin-transform-object-super/test/fixtures/object-super/super-exponentiation/output.js index 3d37af8bdf..d5ae0060ee 100644 --- a/packages/babel-plugin-transform-object-super/test/fixtures/object-super/super-exponentiation/output.js +++ b/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); } }; diff --git a/packages/babel-preset-env/test/fixtures/plugins-integration/issue-7527/output.js b/packages/babel-preset-env/test/fixtures/plugins-integration/issue-7527/output.js index 7ef653ee76..d67a00efd3 100644 --- a/packages/babel-preset-env/test/fixtures/plugins-integration/issue-7527/output.js +++ b/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); }