diff --git a/packages/babel-core/src/config/validation/options.ts b/packages/babel-core/src/config/validation/options.ts index d79ea0fe1675..2c67705fbdb0 100644 --- a/packages/babel-core/src/config/validation/options.ts +++ b/packages/babel-core/src/config/validation/options.ts @@ -277,6 +277,7 @@ const knownAssumptions = [ "noIncompleteNsImportDetection", "noNewArrows", "objectRestNoSymbols", + "privateFieldsAsSymbols", "privateFieldsAsProperties", "pureGetters", "setClassMethods", diff --git a/packages/babel-helper-create-class-features-plugin/src/fields.ts b/packages/babel-helper-create-class-features-plugin/src/fields.ts index ea16321f898c..9754273b6c1c 100644 --- a/packages/babel-helper-create-class-features-plugin/src/fields.ts +++ b/packages/babel-helper-create-class-features-plugin/src/fields.ts @@ -58,18 +58,22 @@ export function buildPrivateNamesMap(props: PropPath[]) { export function buildPrivateNamesNodes( privateNamesMap: PrivateNamesMap, privateFieldsAsProperties: boolean, + privateFieldsAsSymbols: boolean, state: File, ) { const initNodes: t.Statement[] = []; for (const [name, value] of privateNamesMap) { - // When the privateFieldsAsProperties assumption is enabled, - // both static and instance fields are transpiled using a - // secret non-enumerable property. Hence, we also need to generate that - // key (using the classPrivateFieldLooseKey helper). - // In spec mode, only instance fields need a "private name" initializer - // because static fields are directly assigned to a variable in the - // buildPrivateStaticFieldInitSpec function. + // - When the privateFieldsAsProperties assumption is enabled, + // both static and instance fields are transpiled using a + // secret non-enumerable property. Hence, we also need to generate that + // key (using the classPrivateFieldLooseKey helper). + // - When the privateFieldsAsSymbols assumption is enabled, + // both static and instance fields are transpiled using a + // unique Symbol to define a non-enumerable property. + // - In spec mode, only instance fields need a "private name" initializer + // because static fields are directly assigned to a variable in the + // buildPrivateStaticFieldInitSpec function. const { static: isStatic, method: isMethod, getId, setId } = value; const isAccessor = getId || setId; const id = t.cloneNode(value.id); @@ -80,6 +84,8 @@ export function buildPrivateNamesNodes( init = t.callExpression(state.addHelper("classPrivateFieldLooseKey"), [ t.stringLiteral(name), ]); + } else if (privateFieldsAsSymbols) { + init = t.callExpression(t.identifier("Symbol"), [t.stringLiteral(name)]); } else if (!isStatic) { init = t.newExpression( t.identifier(!isMethod || isAccessor ? "WeakMap" : "WeakSet"), diff --git a/packages/babel-helper-create-class-features-plugin/src/index.ts b/packages/babel-helper-create-class-features-plugin/src/index.ts index b28fa0ea624a..979f95c8ac80 100644 --- a/packages/babel-helper-create-class-features-plugin/src/index.ts +++ b/packages/babel-helper-create-class-features-plugin/src/index.ts @@ -48,12 +48,23 @@ export function createClassFeaturePlugin({ inherits, }: Options): PluginObject { const setPublicClassFields = api.assumption("setPublicClassFields"); + const privateFieldsAsSymbols = api.assumption("privateFieldsAsSymbols"); const privateFieldsAsProperties = api.assumption("privateFieldsAsProperties"); const constantSuper = api.assumption("constantSuper"); const noDocumentAll = api.assumption("noDocumentAll"); + if (privateFieldsAsProperties && privateFieldsAsSymbols) { + throw new Error( + `Cannot enable both the "privateFieldsAsProperties" and ` + + `"privateFieldsAsSymbols" assumptions as the same time.`, + ); + } + const privateFieldsAsSymbolsOrProperties = + privateFieldsAsProperties || privateFieldsAsSymbols; + if (loose === true) { - const explicit = []; + type AssumptionName = Parameters[0]; + const explicit: `"${AssumptionName}"`[] = []; if (setPublicClassFields !== undefined) { explicit.push(`"setPublicClassFields"`); @@ -61,6 +72,9 @@ export function createClassFeaturePlugin({ if (privateFieldsAsProperties !== undefined) { explicit.push(`"privateFieldsAsProperties"`); } + if (privateFieldsAsSymbols !== undefined) { + explicit.push(`"privateFieldsAsSymbols"`); + } if (explicit.length !== 0) { console.warn( `[${name}]: You are using the "loose: true" option and you are` + @@ -71,7 +85,7 @@ export function createClassFeaturePlugin({ ` following top-level option:\n` + `\t"assumptions": {\n` + `\t\t"setPublicClassFields": true,\n` + - `\t\t"privateFieldsAsProperties": true\n` + + `\t\t"privateFieldsAsSymbols": true\n` + `\t}`, ); } @@ -191,6 +205,7 @@ export function createClassFeaturePlugin({ const privateNamesNodes = buildPrivateNamesNodes( privateNamesMap, privateFieldsAsProperties ?? loose, + privateFieldsAsSymbols ?? false, file, ); @@ -199,7 +214,8 @@ export function createClassFeaturePlugin({ path, privateNamesMap, { - privateFieldsAsProperties: privateFieldsAsProperties ?? loose, + privateFieldsAsProperties: + privateFieldsAsSymbolsOrProperties ?? loose, noDocumentAll, innerBinding, }, @@ -231,7 +247,7 @@ export function createClassFeaturePlugin({ privateNamesMap, file, setPublicClassFields ?? loose, - privateFieldsAsProperties ?? loose, + privateFieldsAsSymbolsOrProperties ?? loose, constantSuper ?? loose, innerBinding, )); @@ -246,7 +262,7 @@ export function createClassFeaturePlugin({ privateNamesMap, file, setPublicClassFields ?? loose, - privateFieldsAsProperties ?? loose, + privateFieldsAsSymbolsOrProperties ?? loose, constantSuper ?? loose, innerBinding, )); diff --git a/packages/babel-helper-create-class-features-plugin/test/fixtures/plugin-proposal-class-properties/both-privateFieldsAsProperties-and-privateFieldsAsSymbols/input.js b/packages/babel-helper-create-class-features-plugin/test/fixtures/plugin-proposal-class-properties/both-privateFieldsAsProperties-and-privateFieldsAsSymbols/input.js new file mode 100644 index 000000000000..092bc2b04126 --- /dev/null +++ b/packages/babel-helper-create-class-features-plugin/test/fixtures/plugin-proposal-class-properties/both-privateFieldsAsProperties-and-privateFieldsAsSymbols/input.js @@ -0,0 +1 @@ +; diff --git a/packages/babel-helper-create-class-features-plugin/test/fixtures/plugin-proposal-class-properties/both-privateFieldsAsProperties-and-privateFieldsAsSymbols/options.json b/packages/babel-helper-create-class-features-plugin/test/fixtures/plugin-proposal-class-properties/both-privateFieldsAsProperties-and-privateFieldsAsSymbols/options.json new file mode 100644 index 000000000000..7850be15b705 --- /dev/null +++ b/packages/babel-helper-create-class-features-plugin/test/fixtures/plugin-proposal-class-properties/both-privateFieldsAsProperties-and-privateFieldsAsSymbols/options.json @@ -0,0 +1,8 @@ +{ + "plugins": ["proposal-class-properties"], + "assumptions": { + "privateFieldsAsProperties": true, + "privateFieldsAsSymbols": true + }, + "throws": "Cannot enable both the \"privateFieldsAsProperties\" and \"privateFieldsAsSymbols\" assumptions as the same time." +} diff --git a/packages/babel-helper-create-class-features-plugin/test/fixtures/plugin-proposal-class-properties/warn-loose-and-assumptions/stderr.txt b/packages/babel-helper-create-class-features-plugin/test/fixtures/plugin-proposal-class-properties/warn-loose-and-assumptions/stderr.txt index 2d6c3d02acff..fdb9ce93e7c3 100644 --- a/packages/babel-helper-create-class-features-plugin/test/fixtures/plugin-proposal-class-properties/warn-loose-and-assumptions/stderr.txt +++ b/packages/babel-helper-create-class-features-plugin/test/fixtures/plugin-proposal-class-properties/warn-loose-and-assumptions/stderr.txt @@ -1,5 +1,5 @@ [proposal-class-properties]: You are using the "loose: true" option and you are explicitly setting a value for the "setPublicClassFields" assumption. The "loose" option can cause incompatibilities with the other class features plugins, so it's recommended that you replace it with the following top-level option: "assumptions": { "setPublicClassFields": true, - "privateFieldsAsProperties": true + "privateFieldsAsSymbols": true } diff --git a/packages/babel-plugin-proposal-class-properties/test/fixtures/assumption-setPublicClassFields/static-super-loose/stderr.txt b/packages/babel-plugin-proposal-class-properties/test/fixtures/assumption-setPublicClassFields/static-super-loose/stderr.txt index 2d6c3d02acff..fdb9ce93e7c3 100644 --- a/packages/babel-plugin-proposal-class-properties/test/fixtures/assumption-setPublicClassFields/static-super-loose/stderr.txt +++ b/packages/babel-plugin-proposal-class-properties/test/fixtures/assumption-setPublicClassFields/static-super-loose/stderr.txt @@ -1,5 +1,5 @@ [proposal-class-properties]: You are using the "loose: true" option and you are explicitly setting a value for the "setPublicClassFields" assumption. The "loose" option can cause incompatibilities with the other class features plugins, so it's recommended that you replace it with the following top-level option: "assumptions": { "setPublicClassFields": true, - "privateFieldsAsProperties": true + "privateFieldsAsSymbols": true } diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/basic/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/basic/exec.js new file mode 100644 index 000000000000..3cdb24863398 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/basic/exec.js @@ -0,0 +1,31 @@ +class Cl { + #privateField = "top secret string"; + + constructor() { + this.publicField = "not secret string"; + } + + get #privateFieldValue() { + return this.#privateField; + } + + set #privateFieldValue(newValue) { + this.#privateField = newValue; + } + + publicGetPrivateField() { + return this.#privateFieldValue; + } + + publicSetPrivateField(newValue) { + this.#privateFieldValue = newValue; + } +} + +const cl = new Cl(); + +expect(cl.publicGetPrivateField()).toEqual("top secret string"); + +cl.publicSetPrivateField("new secret string"); +expect(cl.publicGetPrivateField()).toEqual("new secret string"); + diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/basic/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/basic/input.js new file mode 100644 index 000000000000..53e77128c0bd --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/basic/input.js @@ -0,0 +1,23 @@ +class Cl { + #privateField = "top secret string"; + + constructor() { + this.publicField = "not secret string"; + } + + get #privateFieldValue() { + return this.#privateField; + } + + set #privateFieldValue(newValue) { + this.#privateField = newValue; + } + + publicGetPrivateField() { + return this.#privateFieldValue; + } + + publicSetPrivateField(newValue) { + this.#privateFieldValue = newValue; + } +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/basic/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/basic/output.js new file mode 100644 index 000000000000..4931f6d4c1b3 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/basic/output.js @@ -0,0 +1,27 @@ +var _privateField = /*#__PURE__*/Symbol("privateField"); +var _privateFieldValue = /*#__PURE__*/Symbol("privateFieldValue"); +class Cl { + constructor() { + Object.defineProperty(this, _privateFieldValue, { + get: _get_privateFieldValue, + set: _set_privateFieldValue + }); + Object.defineProperty(this, _privateField, { + writable: true, + value: "top secret string" + }); + this.publicField = "not secret string"; + } + publicGetPrivateField() { + return babelHelpers.classPrivateFieldLooseBase(this, _privateFieldValue)[_privateFieldValue]; + } + publicSetPrivateField(newValue) { + babelHelpers.classPrivateFieldLooseBase(this, _privateFieldValue)[_privateFieldValue] = newValue; + } +} +function _get_privateFieldValue() { + return babelHelpers.classPrivateFieldLooseBase(this, _privateField)[_privateField]; +} +function _set_privateFieldValue(newValue) { + babelHelpers.classPrivateFieldLooseBase(this, _privateField)[_privateField] = newValue; +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/get-only-setter/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/get-only-setter/exec.js new file mode 100644 index 000000000000..92e8197700c0 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/get-only-setter/exec.js @@ -0,0 +1,13 @@ +class Cl { + #privateField = 0; + + set #privateFieldValue(newValue) { + this.#privateField = newValue; + } + + constructor() { + expect(this.#privateFieldValue).toBeUndefined(); + } +} + +const cl = new Cl(); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/get-only-setter/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/get-only-setter/input.js new file mode 100644 index 000000000000..d676919b85eb --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/get-only-setter/input.js @@ -0,0 +1,11 @@ +class Cl { + #privateField = 0; + + set #privateFieldValue(newValue) { + this.#privateField = newValue; + } + + constructor() { + this.publicField = this.#privateFieldValue; + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/get-only-setter/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/get-only-setter/output.js new file mode 100644 index 000000000000..0c3155a02405 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/get-only-setter/output.js @@ -0,0 +1,18 @@ +var _privateField = /*#__PURE__*/Symbol("privateField"); +var _privateFieldValue = /*#__PURE__*/Symbol("privateFieldValue"); +class Cl { + constructor() { + Object.defineProperty(this, _privateFieldValue, { + get: void 0, + set: _set_privateFieldValue + }); + Object.defineProperty(this, _privateField, { + writable: true, + value: 0 + }); + this.publicField = babelHelpers.classPrivateFieldLooseBase(this, _privateFieldValue)[_privateFieldValue]; + } +} +function _set_privateFieldValue(newValue) { + babelHelpers.classPrivateFieldLooseBase(this, _privateField)[_privateField] = newValue; +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/helper/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/helper/exec.js new file mode 100644 index 000000000000..59d4b47896ae --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/helper/exec.js @@ -0,0 +1,11 @@ +let foo; +class Cl { + set #foo(v) { return 1 } + test() { + foo = this.#foo = 2; + } +} + +new Cl().test(); + +expect(foo).toBe(2); \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/options.json b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/options.json new file mode 100644 index 000000000000..1c536ad2aac0 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/options.json @@ -0,0 +1,6 @@ +{ + "plugins": ["proposal-private-methods", "proposal-class-properties"], + "assumptions": { + "privateFieldsAsSymbols": true + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/preserve-comments/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/preserve-comments/input.js new file mode 100644 index 000000000000..eda89ee587b0 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/preserve-comments/input.js @@ -0,0 +1,9 @@ +class C { + /* before get a */ + get #a() { return 42 }; + /* after get a */ + + /* before set a */ + set #a(v) {} + /* after set a */ +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/preserve-comments/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/preserve-comments/output.js new file mode 100644 index 000000000000..d97680770de2 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/preserve-comments/output.js @@ -0,0 +1,17 @@ +var _a = /*#__PURE__*/Symbol("a"); +class C { + constructor() { + /* before get a */ + Object.defineProperty(this, _a, { + get: _get_a, + set: _set_a + }); + } + /* after set a */ +} +function _get_a() { + return 42; +} +/* after get a */ +/* before set a */ +function _set_a(v) {} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/set-only-getter/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/set-only-getter/exec.js new file mode 100644 index 000000000000..e3878e3caa73 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/set-only-getter/exec.js @@ -0,0 +1,14 @@ +class Cl { + #privateField = 0; + + get #privateFieldValue() { + return this.#privateField; + } + + constructor() { + expect(() => this.#privateFieldValue = 1).toThrow(TypeError); + expect(() => ([this.#privateFieldValue] = [1])).toThrow(TypeError); + } +} + +const cl = new Cl(); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/set-only-getter/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/set-only-getter/input.js new file mode 100644 index 000000000000..b8a024c4f9e6 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/set-only-getter/input.js @@ -0,0 +1,12 @@ +class Cl { + #privateField = 0; + + get #privateFieldValue() { + return this.#privateField; + } + + constructor() { + this.#privateFieldValue = 1; + ([this.#privateFieldValue] = [1]); + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/set-only-getter/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/set-only-getter/output.js new file mode 100644 index 000000000000..891eb1626081 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/set-only-getter/output.js @@ -0,0 +1,19 @@ +var _privateField = /*#__PURE__*/Symbol("privateField"); +var _privateFieldValue = /*#__PURE__*/Symbol("privateFieldValue"); +class Cl { + constructor() { + Object.defineProperty(this, _privateFieldValue, { + get: _get_privateFieldValue, + set: void 0 + }); + Object.defineProperty(this, _privateField, { + writable: true, + value: 0 + }); + babelHelpers.classPrivateFieldLooseBase(this, _privateFieldValue)[_privateFieldValue] = 1; + [babelHelpers.classPrivateFieldLooseBase(this, _privateFieldValue)[_privateFieldValue]] = [1]; + } +} +function _get_privateFieldValue() { + return babelHelpers.classPrivateFieldLooseBase(this, _privateField)[_privateField]; +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/updates/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/updates/exec.js new file mode 100644 index 000000000000..2e0c58ef2785 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/updates/exec.js @@ -0,0 +1,50 @@ +class Cl { + #privateField = "top secret string"; + + constructor() { + this.publicField = "not secret string"; + } + + get #privateFieldValue() { + return this.#privateField; + } + + set #privateFieldValue(newValue) { + this.#privateField = newValue; + } + + publicGetPrivateField() { + return this.#privateFieldValue; + } + + publicSetPrivateField(newValue) { + this.#privateFieldValue = newValue; + } + + get publicFieldValue() { + return this.publicField; + } + + set publicFieldValue(newValue) { + this.publicField = newValue; + } + + testUpdates() { + this.#privateField = 0; + this.publicField = 0; + this.#privateFieldValue = this.#privateFieldValue++; + this.publicFieldValue = this.publicFieldValue++; + expect(this.#privateField).toEqual(this.publicField); + + ++this.#privateFieldValue; + ++this.publicFieldValue; + expect(this.#privateField).toEqual(this.publicField); + + this.#privateFieldValue += 1; + this.publicFieldValue += 1; + expect(this.#privateField).toEqual(this.publicField); + } +} + +const cl = new Cl(); +cl.testUpdates(); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/updates/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/updates/input.js new file mode 100644 index 000000000000..587f09e0aa93 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/updates/input.js @@ -0,0 +1,47 @@ +class Cl { + #privateField = "top secret string"; + + constructor() { + this.publicField = "not secret string"; + } + + get #privateFieldValue() { + return this.#privateField; + } + + set #privateFieldValue(newValue) { + this.#privateField = newValue; + } + + publicGetPrivateField() { + return this.#privateFieldValue; + } + + publicSetPrivateField(newValue) { + this.#privateFieldValue = newValue; + } + + get publicFieldValue() { + return this.publicField; + } + + set publicFieldValue(newValue) { + this.publicField = newValue; + } + + testUpdates() { + this.#privateField = 0; + this.publicField = 0; + this.#privateFieldValue = this.#privateFieldValue++; + this.publicFieldValue = this.publicFieldValue++; + + ++this.#privateFieldValue; + ++this.publicFieldValue; + + this.#privateFieldValue += 1; + this.publicFieldValue += 1; + + this.#privateFieldValue = -(this.#privateFieldValue ** this.#privateFieldValue); + this.publicFieldValue = -(this.publicFieldValue ** this.publicFieldValue); + } +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/updates/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/updates/output.js new file mode 100644 index 000000000000..41dcdd3e6307 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/accessors-privateFieldsAsSymbols/updates/output.js @@ -0,0 +1,45 @@ +var _privateField = /*#__PURE__*/Symbol("privateField"); +var _privateFieldValue = /*#__PURE__*/Symbol("privateFieldValue"); +class Cl { + constructor() { + Object.defineProperty(this, _privateFieldValue, { + get: _get_privateFieldValue, + set: _set_privateFieldValue + }); + Object.defineProperty(this, _privateField, { + writable: true, + value: "top secret string" + }); + this.publicField = "not secret string"; + } + publicGetPrivateField() { + return babelHelpers.classPrivateFieldLooseBase(this, _privateFieldValue)[_privateFieldValue]; + } + publicSetPrivateField(newValue) { + babelHelpers.classPrivateFieldLooseBase(this, _privateFieldValue)[_privateFieldValue] = newValue; + } + get publicFieldValue() { + return this.publicField; + } + set publicFieldValue(newValue) { + this.publicField = newValue; + } + testUpdates() { + babelHelpers.classPrivateFieldLooseBase(this, _privateField)[_privateField] = 0; + this.publicField = 0; + babelHelpers.classPrivateFieldLooseBase(this, _privateFieldValue)[_privateFieldValue] = babelHelpers.classPrivateFieldLooseBase(this, _privateFieldValue)[_privateFieldValue]++; + this.publicFieldValue = this.publicFieldValue++; + ++babelHelpers.classPrivateFieldLooseBase(this, _privateFieldValue)[_privateFieldValue]; + ++this.publicFieldValue; + babelHelpers.classPrivateFieldLooseBase(this, _privateFieldValue)[_privateFieldValue] += 1; + this.publicFieldValue += 1; + babelHelpers.classPrivateFieldLooseBase(this, _privateFieldValue)[_privateFieldValue] = -(babelHelpers.classPrivateFieldLooseBase(this, _privateFieldValue)[_privateFieldValue] ** babelHelpers.classPrivateFieldLooseBase(this, _privateFieldValue)[_privateFieldValue]); + this.publicFieldValue = -(this.publicFieldValue ** this.publicFieldValue); + } +} +function _get_privateFieldValue() { + return babelHelpers.classPrivateFieldLooseBase(this, _privateField)[_privateField]; +} +function _set_privateFieldValue(newValue) { + babelHelpers.classPrivateFieldLooseBase(this, _privateField)[_privateField] = newValue; +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/assignment/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/assignment/exec.js new file mode 100644 index 000000000000..4c1324aeeb62 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/assignment/exec.js @@ -0,0 +1,11 @@ +class Foo { + constructor() { + this.publicField = this.#privateMethod(); + } + + #privateMethod() { + return 42; + } + } + + expect((new Foo).publicField).toEqual(42); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/assignment/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/assignment/input.js new file mode 100644 index 000000000000..e55a8afdd3ad --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/assignment/input.js @@ -0,0 +1,9 @@ +class Foo { + constructor() { + this.publicField = this.#privateMethod(); + } + + #privateMethod() { + return 42; + } +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/assignment/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/assignment/output.js new file mode 100644 index 000000000000..93b11e408f68 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/assignment/output.js @@ -0,0 +1,12 @@ +var _privateMethod = /*#__PURE__*/Symbol("privateMethod"); +class Foo { + constructor() { + Object.defineProperty(this, _privateMethod, { + value: _privateMethod2 + }); + this.publicField = babelHelpers.classPrivateFieldLooseBase(this, _privateMethod)[_privateMethod](); + } +} +function _privateMethod2() { + return 42; +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/async/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/async/exec.js new file mode 100644 index 000000000000..168eb945dd14 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/async/exec.js @@ -0,0 +1,13 @@ +class Cl { + async #foo() { + return 2; + } + + test() { + return this.#foo(); + } +} + +return new Cl().test().then(val => { + expect(val).toBe(2); +}); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/async/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/async/input.js new file mode 100644 index 000000000000..aed36e25613f --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/async/input.js @@ -0,0 +1,9 @@ +class Cl { + async #foo() { + return 2; + } + + test() { + return this.#foo(); + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/async/options.json b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/async/options.json new file mode 100644 index 000000000000..5496a04a7e96 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/async/options.json @@ -0,0 +1,10 @@ +{ + "minNodeVersion": "8.0.0", + "plugins": ["proposal-private-methods", "proposal-class-properties"], + "assumptions": { + "privateFieldsAsProperties": true + }, + "parserOpts": { + "allowReturnOutsideFunction": true + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/async/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/async/output.js new file mode 100644 index 000000000000..258d2fc6846a --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/async/output.js @@ -0,0 +1,14 @@ +var _foo = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("foo"); +class Cl { + constructor() { + Object.defineProperty(this, _foo, { + value: _foo2 + }); + } + test() { + return babelHelpers.classPrivateFieldLooseBase(this, _foo)[_foo](); + } +} +async function _foo2() { + return 2; +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/before-fields/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/before-fields/exec.js new file mode 100644 index 000000000000..26caf2d02c1f --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/before-fields/exec.js @@ -0,0 +1,16 @@ +class Cl { + prop = this.#method(1); + + #priv = this.#method(2); + + #method(x) { + return x; + } + + getPriv() { + return this.#priv; + } +} + +expect(new Cl().prop).toBe(1); +expect(new Cl().getPriv()).toBe(2); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/before-fields/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/before-fields/input.js new file mode 100644 index 000000000000..2fcb7857468f --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/before-fields/input.js @@ -0,0 +1,13 @@ +class Cl { + prop = this.#method(1); + + #priv = this.#method(2); + + #method(x) { + return x; + } + + getPriv() { + return this.#priv; + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/before-fields/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/before-fields/output.js new file mode 100644 index 000000000000..a079499bf287 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/before-fields/output.js @@ -0,0 +1,20 @@ +var _priv = /*#__PURE__*/Symbol("priv"); +var _method = /*#__PURE__*/Symbol("method"); +class Cl { + constructor() { + Object.defineProperty(this, _method, { + value: _method2 + }); + babelHelpers.defineProperty(this, "prop", babelHelpers.classPrivateFieldLooseBase(this, _method)[_method](1)); + Object.defineProperty(this, _priv, { + writable: true, + value: babelHelpers.classPrivateFieldLooseBase(this, _method)[_method](2) + }); + } + getPriv() { + return babelHelpers.classPrivateFieldLooseBase(this, _priv)[_priv]; + } +} +function _method2(x) { + return x; +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/class-expression/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/class-expression/input.js new file mode 100644 index 000000000000..e180867063cc --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/class-expression/input.js @@ -0,0 +1,7 @@ +console.log(class A { + #foo() {} + + method() { + this.#foo(); + } +}); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/class-expression/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/class-expression/output.js new file mode 100644 index 000000000000..f68efea66cf3 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/class-expression/output.js @@ -0,0 +1,12 @@ +var _foo; +console.log((_foo = /*#__PURE__*/Symbol("foo"), class A { + constructor() { + Object.defineProperty(this, _foo, { + value: _foo2 + }); + } + method() { + babelHelpers.classPrivateFieldLooseBase(this, _foo)[_foo](); + } +})); +function _foo2() {} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/context/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/context/exec.js new file mode 100644 index 000000000000..6c18bf53c193 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/context/exec.js @@ -0,0 +1,41 @@ +class Foo { + constructor(status) { + this.status = status; + expect(() => this.#getStatus = null).toThrow(TypeError); + } + + #getStatus() { + return this.status; + } + + getCurrentStatus() { + return this.#getStatus(); + } + + setCurrentStatus(newStatus) { + this.status = newStatus; + } + + getFakeStatus(fakeStatus) { + const getStatus = this.#getStatus; + return function () { + return getStatus.call({ status: fakeStatus }); + }; + } + + getFakeStatusFunc() { + return { + status: 'fake-status', + getFakeStatus: this.#getStatus, + }; + } + } + + const f = new Foo('inactive'); + expect(f.getCurrentStatus()).toBe('inactive'); + + f.setCurrentStatus('new-status'); + expect(f.getCurrentStatus()).toBe('new-status'); + + expect(f.getFakeStatus('fake')()).toBe('fake'); + expect(f.getFakeStatusFunc().getFakeStatus()).toBe('fake-status'); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/context/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/context/input.js new file mode 100644 index 000000000000..67a8ab68a682 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/context/input.js @@ -0,0 +1,31 @@ +class Foo { + constructor(status) { + this.status = status; + } + + #getStatus() { + return this.status; + } + + getCurrentStatus() { + return this.#getStatus(); + } + + setCurrentStatus(newStatus) { + this.status = newStatus; + } + + getFakeStatus(fakeStatus) { + const fakeGetStatus = this.#getStatus; + return function() { + return fakeGetStatus.call({ status: fakeStatus }); + }; + } + + getFakeStatusFunc() { + return { + status: 'fake-status', + getFakeStatus: this.#getStatus, + }; + } +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/context/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/context/output.js new file mode 100644 index 000000000000..7da6cd2d9caf --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/context/output.js @@ -0,0 +1,32 @@ +var _getStatus = /*#__PURE__*/Symbol("getStatus"); +class Foo { + constructor(status) { + Object.defineProperty(this, _getStatus, { + value: _getStatus2 + }); + this.status = status; + } + getCurrentStatus() { + return babelHelpers.classPrivateFieldLooseBase(this, _getStatus)[_getStatus](); + } + setCurrentStatus(newStatus) { + this.status = newStatus; + } + getFakeStatus(fakeStatus) { + const fakeGetStatus = babelHelpers.classPrivateFieldLooseBase(this, _getStatus)[_getStatus]; + return function () { + return fakeGetStatus.call({ + status: fakeStatus + }); + }; + } + getFakeStatusFunc() { + return { + status: 'fake-status', + getFakeStatus: babelHelpers.classPrivateFieldLooseBase(this, _getStatus)[_getStatus] + }; + } +} +function _getStatus2() { + return this.status; +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/exfiltrated/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/exfiltrated/exec.js new file mode 100644 index 000000000000..659a3e891085 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/exfiltrated/exec.js @@ -0,0 +1,15 @@ +let exfiltrated; +class Foo { + #privateMethod() {} + + constructor() { + if (exfiltrated === undefined) { + exfiltrated = this.#privateMethod; + } + expect(exfiltrated).toStrictEqual(this.#privateMethod); + } +} + +new Foo(); +// check for private method function object equality +new Foo(); \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/exfiltrated/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/exfiltrated/input.js new file mode 100644 index 000000000000..91bf8510d814 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/exfiltrated/input.js @@ -0,0 +1,10 @@ +let exfiltrated; +class Foo { + #privateMethod() {} + + constructor() { + if (exfiltrated === undefined) { + exfiltrated = this.#privateMethod; + } + } +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/exfiltrated/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/exfiltrated/output.js new file mode 100644 index 000000000000..89ce292d1a35 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/exfiltrated/output.js @@ -0,0 +1,13 @@ +let exfiltrated; +var _privateMethod = /*#__PURE__*/Symbol("privateMethod"); +class Foo { + constructor() { + Object.defineProperty(this, _privateMethod, { + value: _privateMethod2 + }); + if (exfiltrated === undefined) { + exfiltrated = babelHelpers.classPrivateFieldLooseBase(this, _privateMethod)[_privateMethod]; + } + } +} +function _privateMethod2() {} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/generator/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/generator/exec.js new file mode 100644 index 000000000000..472eadeabff6 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/generator/exec.js @@ -0,0 +1,14 @@ +class Cl { + *#foo() { + yield 2; + return 3; + } + + test() { + return this.#foo(); + } +} + +const val = new Cl().test(); +expect(val.next()).toEqual({ value: 2, done: false }); +expect(val.next()).toEqual({ value: 3, done: true }); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/generator/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/generator/input.js new file mode 100644 index 000000000000..39aace6dc402 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/generator/input.js @@ -0,0 +1,10 @@ +class Cl { + *#foo() { + yield 2; + return 3; + } + + test() { + return this.#foo(); + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/generator/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/generator/output.js new file mode 100644 index 000000000000..df5d0c804fe1 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/generator/output.js @@ -0,0 +1,15 @@ +var _foo = /*#__PURE__*/Symbol("foo"); +class Cl { + constructor() { + Object.defineProperty(this, _foo, { + value: _foo2 + }); + } + test() { + return babelHelpers.classPrivateFieldLooseBase(this, _foo)[_foo](); + } +} +function* _foo2() { + yield 2; + return 3; +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/options.json b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/options.json new file mode 100644 index 000000000000..1c536ad2aac0 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/options.json @@ -0,0 +1,6 @@ +{ + "plugins": ["proposal-private-methods", "proposal-class-properties"], + "assumptions": { + "privateFieldsAsSymbols": true + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/super/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/super/exec.js new file mode 100644 index 000000000000..63d8fe8cdfe3 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/super/exec.js @@ -0,0 +1,21 @@ +class Base { + superMethod() { + return 'good'; + } +} + +class Sub extends Base { + superMethod() { + return 'bad'; + } + + #privateMethod() { + return super.superMethod(); + } + + publicMethod() { + return this.#privateMethod(); + } +} + +expect((new Sub()).publicMethod()).toEqual('good'); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/super/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/super/input.js new file mode 100644 index 000000000000..d85e01133ac1 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/super/input.js @@ -0,0 +1,19 @@ +class Base { + superMethod() { + return 'good'; + } +} + +class Sub extends Base { + superMethod() { + return 'bad'; + } + + #privateMethod() { + return super.superMethod(); + } + + publicMethod() { + return this.#privateMethod(); + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/super/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/super/output.js new file mode 100644 index 000000000000..be536e6f873c --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-method-privateFieldsAsSymbols/super/output.js @@ -0,0 +1,23 @@ +class Base { + superMethod() { + return 'good'; + } +} +var _privateMethod = /*#__PURE__*/Symbol("privateMethod"); +class Sub extends Base { + constructor(...args) { + super(...args); + Object.defineProperty(this, _privateMethod, { + value: _privateMethod2 + }); + } + superMethod() { + return 'bad'; + } + publicMethod() { + return babelHelpers.classPrivateFieldLooseBase(this, _privateMethod)[_privateMethod](); + } +} +function _privateMethod2() { + return babelHelpers.get(babelHelpers.getPrototypeOf(Sub.prototype), "superMethod", this).call(this); +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/async/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/async/input.js new file mode 100644 index 000000000000..99125b6f24c4 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/async/input.js @@ -0,0 +1,13 @@ +class Cl { + static async #privateStaticMethod() { + return 2; + } + + test() { + return Cl.#privateStaticMethod(); + } +} + +return new Cl().test().then(val => { + expect(val).toBe(2); +}); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/async/options.json b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/async/options.json new file mode 100644 index 000000000000..5496a04a7e96 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/async/options.json @@ -0,0 +1,10 @@ +{ + "minNodeVersion": "8.0.0", + "plugins": ["proposal-private-methods", "proposal-class-properties"], + "assumptions": { + "privateFieldsAsProperties": true + }, + "parserOpts": { + "allowReturnOutsideFunction": true + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/async/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/async/output.js new file mode 100644 index 000000000000..79468d79ce74 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/async/output.js @@ -0,0 +1,15 @@ +var _privateStaticMethod = /*#__PURE__*/babelHelpers.classPrivateFieldLooseKey("privateStaticMethod"); +class Cl { + test() { + return babelHelpers.classPrivateFieldLooseBase(Cl, _privateStaticMethod)[_privateStaticMethod](); + } +} +async function _privateStaticMethod2() { + return 2; +} +Object.defineProperty(Cl, _privateStaticMethod, { + value: _privateStaticMethod2 +}); +return new Cl().test().then(val => { + expect(val).toBe(2); +}); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/basic/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/basic/exec.js new file mode 100644 index 000000000000..d5577057caa9 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/basic/exec.js @@ -0,0 +1,33 @@ +const privateStaticValue = 1017; + +class Cl { + static staticMethod2() { + return Cl.#privateStaticMethod(); + } + + static #privateStaticMethod() { + return privateStaticValue; + } + + static staticMethod() { + return Cl.#privateStaticMethod(); + } + + static privateStaticMethod() { + return Cl.#privateStaticMethod(); + } + + publicMethod() { + return Cl.#privateStaticMethod(); + } + + constructor() { + this.instanceField = Cl.#privateStaticMethod(); + } +} + +expect((new Cl).publicMethod()).toEqual(privateStaticValue); +// expect((new Cl).instanceField).toEqual(privateStaticValue); +// expect(Cl.privateStaticMethod()).toEqual(privateStaticValue); +// expect(Cl.staticMethod()).toEqual(privateStaticValue); +// expect(Cl.staticMethod2()).toEqual(privateStaticValue); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/basic/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/basic/input.js new file mode 100644 index 000000000000..ad0ee3d44814 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/basic/input.js @@ -0,0 +1,25 @@ +class Cl { + static staticMethod2() { + return Cl.#privateStaticMethod(); + } + + static #privateStaticMethod() { + return 1017; + } + + static staticMethod() { + return Cl.#privateStaticMethod(); + } + + static privateStaticMethod() { + return Cl.#privateStaticMethod(); + } + + publicMethod() { + return Cl.#privateStaticMethod(); + } + + constructor() { + this.instanceField = Cl.#privateStaticMethod(); + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/basic/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/basic/output.js new file mode 100644 index 000000000000..a4e5f4de0e29 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/basic/output.js @@ -0,0 +1,24 @@ +var _privateStaticMethod = /*#__PURE__*/Symbol("privateStaticMethod"); +class Cl { + static staticMethod2() { + return babelHelpers.classPrivateFieldLooseBase(Cl, _privateStaticMethod)[_privateStaticMethod](); + } + static staticMethod() { + return babelHelpers.classPrivateFieldLooseBase(Cl, _privateStaticMethod)[_privateStaticMethod](); + } + static privateStaticMethod() { + return babelHelpers.classPrivateFieldLooseBase(Cl, _privateStaticMethod)[_privateStaticMethod](); + } + publicMethod() { + return babelHelpers.classPrivateFieldLooseBase(Cl, _privateStaticMethod)[_privateStaticMethod](); + } + constructor() { + this.instanceField = babelHelpers.classPrivateFieldLooseBase(Cl, _privateStaticMethod)[_privateStaticMethod](); + } +} +function _privateStaticMethod2() { + return 1017; +} +Object.defineProperty(Cl, _privateStaticMethod, { + value: _privateStaticMethod2 +}); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/class-check/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/class-check/exec.js new file mode 100644 index 000000000000..940b62801e26 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/class-check/exec.js @@ -0,0 +1,12 @@ +class Cl { + static #privateStaticMethod() { + return 1017; + } + + publicMethod(checked) { + return checked.#privateStaticMethod(); + } +} + +const cl = new Cl(); +expect(cl.publicMethod(Cl)).toBe(1017); \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/class-check/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/class-check/input.js new file mode 100644 index 000000000000..fd8c6c331e4e --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/class-check/input.js @@ -0,0 +1,7 @@ +class Cl { + static #privateStaticMethod() { } + + publicMethod(checked) { + return checked.#privateStaticMethod(); + } +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/class-check/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/class-check/output.js new file mode 100644 index 000000000000..63e3eef9c99a --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/class-check/output.js @@ -0,0 +1,10 @@ +var _privateStaticMethod = /*#__PURE__*/Symbol("privateStaticMethod"); +class Cl { + publicMethod(checked) { + return babelHelpers.classPrivateFieldLooseBase(checked, _privateStaticMethod)[_privateStaticMethod](); + } +} +function _privateStaticMethod2() {} +Object.defineProperty(Cl, _privateStaticMethod, { + value: _privateStaticMethod2 +}); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/class-expression/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/class-expression/input.js new file mode 100644 index 000000000000..1106a11b73ad --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/class-expression/input.js @@ -0,0 +1,7 @@ +console.log(class A { + static #foo() {} + + method() { + this.#foo(); + } +}); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/class-expression/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/class-expression/output.js new file mode 100644 index 000000000000..e23ee98c50f4 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/class-expression/output.js @@ -0,0 +1,9 @@ +var _class, _foo; +console.log((_foo = /*#__PURE__*/Symbol("foo"), (_class = class A { + method() { + babelHelpers.classPrivateFieldLooseBase(this, _foo)[_foo](); + } +}, Object.defineProperty(_class, _foo, { + value: _foo2 +}), _class))); +function _foo2() {} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/exfiltrated/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/exfiltrated/exec.js new file mode 100644 index 000000000000..14a7b5edd830 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/exfiltrated/exec.js @@ -0,0 +1,20 @@ +let exfiltrated; + +class Cl { + static #privateStaticMethod() { + return 1017; + } + + constructor() { + if (exfiltrated === undefined) { + exfiltrated = Cl.#privateStaticMethod; + } + expect(exfiltrated).toStrictEqual(Cl.#privateStaticMethod); + } +} + +new Cl(); +// check for private method function object equality +new Cl(); + +expect(exfiltrated()).toEqual(1017); \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/exfiltrated/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/exfiltrated/input.js new file mode 100644 index 000000000000..fdc78e57981a --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/exfiltrated/input.js @@ -0,0 +1,13 @@ +let exfiltrated; + +class Cl { + static #privateStaticMethod() { + return 1017; + } + + constructor() { + if (exfiltrated === undefined) { + exfiltrated = Cl.#privateStaticMethod; + } + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/exfiltrated/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/exfiltrated/output.js new file mode 100644 index 000000000000..308f92670e6d --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/exfiltrated/output.js @@ -0,0 +1,15 @@ +let exfiltrated; +var _privateStaticMethod = /*#__PURE__*/Symbol("privateStaticMethod"); +class Cl { + constructor() { + if (exfiltrated === undefined) { + exfiltrated = babelHelpers.classPrivateFieldLooseBase(Cl, _privateStaticMethod)[_privateStaticMethod]; + } + } +} +function _privateStaticMethod2() { + return 1017; +} +Object.defineProperty(Cl, _privateStaticMethod, { + value: _privateStaticMethod2 +}); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/generator/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/generator/exec.js new file mode 100644 index 000000000000..97a6a708fc63 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/generator/exec.js @@ -0,0 +1,14 @@ +class Cl { + static *#foo() { + yield 2; + return 3; + } + + test() { + return Cl.#foo(); + } +} + +const val = new Cl().test(); +expect(val.next()).toEqual({ value: 2, done: false }); +expect(val.next()).toEqual({ value: 3, done: true }); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/generator/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/generator/input.js new file mode 100644 index 000000000000..2b8727d64cfa --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/generator/input.js @@ -0,0 +1,10 @@ +class Cl { + static *#foo() { + yield 2; + return 3; + } + + test() { + return Cl.#foo(); + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/generator/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/generator/output.js new file mode 100644 index 000000000000..abbc5b14f341 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/generator/output.js @@ -0,0 +1,13 @@ +var _foo = /*#__PURE__*/Symbol("foo"); +class Cl { + test() { + return babelHelpers.classPrivateFieldLooseBase(Cl, _foo)[_foo](); + } +} +function* _foo2() { + yield 2; + return 3; +} +Object.defineProperty(Cl, _foo, { + value: _foo2 +}); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/options.json b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/options.json new file mode 100644 index 000000000000..1c536ad2aac0 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/options.json @@ -0,0 +1,6 @@ +{ + "plugins": ["proposal-private-methods", "proposal-class-properties"], + "assumptions": { + "privateFieldsAsSymbols": true + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/reassignment/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/reassignment/exec.js new file mode 100644 index 000000000000..d55af8ba71d7 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/reassignment/exec.js @@ -0,0 +1,9 @@ +class Cl { + static #privateStaticMethod() { } + + constructor() { + expect(() => Cl.#privateStaticMethod = null).toThrow(TypeError); + } +} + +new Cl(); \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/reassignment/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/reassignment/input.js new file mode 100644 index 000000000000..865ddea4ccf1 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/reassignment/input.js @@ -0,0 +1,9 @@ +class Cl { + static #privateStaticMethod() { } + + constructor() { + Cl.#privateStaticMethod = null; + } +} + +new Cl(); \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/reassignment/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/reassignment/output.js new file mode 100644 index 000000000000..cffb5ab5b1ac --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/reassignment/output.js @@ -0,0 +1,11 @@ +var _privateStaticMethod = /*#__PURE__*/Symbol("privateStaticMethod"); +class Cl { + constructor() { + babelHelpers.classPrivateFieldLooseBase(Cl, _privateStaticMethod)[_privateStaticMethod] = null; + } +} +function _privateStaticMethod2() {} +Object.defineProperty(Cl, _privateStaticMethod, { + value: _privateStaticMethod2 +}); +new Cl(); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/scopable/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/scopable/exec.js new file mode 100644 index 000000000000..f94e5c495f9a --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/scopable/exec.js @@ -0,0 +1,17 @@ +class Cl { + static #privateMethodA() { + const i = 40; + return i; + } + + static #privateMethodB() { + const i = 2; + return i; + } + + publicMethod() { + return Cl.#privateMethodA() + Cl.#privateMethodB(); + } +} + +expect((new Cl).publicMethod()).toEqual(42); \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/super/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/super/exec.js new file mode 100644 index 000000000000..1d6f0c63559a --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/super/exec.js @@ -0,0 +1,21 @@ +class Base { + static basePublicStaticMethod() { + return 'good'; + } +} + +class Sub extends Base { + static basePublicStaticMethod() { + return 'bad'; + } + + static #subStaticPrivateMethod() { + return super.basePublicStaticMethod(); + } + + static check() { + return Sub.#subStaticPrivateMethod(); + } +} + +expect(Sub.check()).toEqual('good'); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/super/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/super/input.js new file mode 100644 index 000000000000..e5fb0ecd5eec --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/super/input.js @@ -0,0 +1,19 @@ +class Base { + static basePublicStaticMethod() { + return 'good'; + } +} + +class Sub extends Base { + static basePublicStaticMethod() { + return 'bad'; + } + + static #subStaticPrivateMethod() { + return super.basePublicStaticMethod(); + } + + static check() { + Sub.#subStaticPrivateMethod(); + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/super/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/super/output.js new file mode 100644 index 000000000000..1e2458cf763c --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/super/output.js @@ -0,0 +1,20 @@ +class Base { + static basePublicStaticMethod() { + return 'good'; + } +} +var _subStaticPrivateMethod = /*#__PURE__*/Symbol("subStaticPrivateMethod"); +class Sub extends Base { + static basePublicStaticMethod() { + return 'bad'; + } + static check() { + babelHelpers.classPrivateFieldLooseBase(Sub, _subStaticPrivateMethod)[_subStaticPrivateMethod](); + } +} +function _subStaticPrivateMethod2() { + return babelHelpers.get(babelHelpers.getPrototypeOf(Sub), "basePublicStaticMethod", this).call(this); +} +Object.defineProperty(Sub, _subStaticPrivateMethod, { + value: _subStaticPrivateMethod2 +}); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/this/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/this/exec.js new file mode 100644 index 000000000000..3262c36845be --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/this/exec.js @@ -0,0 +1,18 @@ +class A { + static get a() { return 1 } +} + +class B extends A { + static get b() { return 2 } + + static #getA() { return super.a } + static #getB() { return this.b } + + static extract() { + return [this.#getA, this.#getB]; + } +} + +const [getA, getB] = B.extract(); +expect(getA.call({ a: 3 })).toBe(1); +expect(getB.call({ b: 4 })).toBe(4); \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/this/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/this/input.js new file mode 100644 index 000000000000..3c8639776d62 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/this/input.js @@ -0,0 +1,16 @@ +class A { + static get a() { return 1 } +} + +class B extends A { + static get b() { return 2 } + + static #getA() { return super.a } + static #getB() { return this.b } + + static extract() { + return [this.#getA, this.#getB]; + } +} + +const [getA, getB] = B.extract(); \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/this/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/this/output.js new file mode 100644 index 000000000000..8662fbab887b --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/private-static-method-privateFieldsAsSymbols/this/output.js @@ -0,0 +1,28 @@ +class A { + static get a() { + return 1; + } +} +var _getA = /*#__PURE__*/Symbol("getA"); +var _getB = /*#__PURE__*/Symbol("getB"); +class B extends A { + static get b() { + return 2; + } + static extract() { + return [babelHelpers.classPrivateFieldLooseBase(this, _getA)[_getA], babelHelpers.classPrivateFieldLooseBase(this, _getB)[_getB]]; + } +} +function _getA2() { + return babelHelpers.get(babelHelpers.getPrototypeOf(B), "a", this); +} +function _getB2() { + return this.b; +} +Object.defineProperty(B, _getB, { + value: _getB2 +}); +Object.defineProperty(B, _getA, { + value: _getA2 +}); +const [getA, getB] = B.extract(); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/access-in-static-field-initializer/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/access-in-static-field-initializer/exec.js new file mode 100644 index 000000000000..b5c8dc3918df --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/access-in-static-field-initializer/exec.js @@ -0,0 +1,35 @@ +expect((() => { + let r; + class C { + static #_ = new C; + static get #p() { return 0 }; + constructor() { + r = C.#p; + } + } + return r; +})()).toBe(0); + +expect((() => { + let r; + class C { + static #_ = new C; + static set #p(v) { r = v; }; + constructor() { + C.#p = 0; + } + } + return r; +})()).toBe(0); + +expect((() => { + let r; + class C { + static #_ = new C; + static set #p(v) { r = v; }; + constructor() { + for (C.#p of [0]); + } + } + return r; +})()).toBe(0); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/basic/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/basic/exec.js new file mode 100644 index 000000000000..791a59034af9 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/basic/exec.js @@ -0,0 +1,23 @@ +class Cl { + static #PRIVATE_STATIC_FIELD = "top secret string"; + + static get #privateStaticFieldValue() { + return Cl.#PRIVATE_STATIC_FIELD; + } + + static set #privateStaticFieldValue(newValue) { + Cl.#PRIVATE_STATIC_FIELD = `Updated: ${newValue}`; + } + + static getValue() { + return Cl.#privateStaticFieldValue; + } + + static setValue() { + Cl.#privateStaticFieldValue = "dank"; + } +} + +expect(Cl.getValue()).toEqual("top secret string"); +Cl.setValue(); +expect(Cl.getValue()).toEqual("Updated: dank"); \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/basic/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/basic/input.js new file mode 100644 index 000000000000..c79cdbe5ff0e --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/basic/input.js @@ -0,0 +1,19 @@ +class Cl { + static #PRIVATE_STATIC_FIELD = "top secret string"; + + static get #privateStaticFieldValue() { + return Cl.#PRIVATE_STATIC_FIELD; + } + + static set #privateStaticFieldValue(newValue) { + Cl.#PRIVATE_STATIC_FIELD = `Updated: ${newValue}`; + } + + static getValue() { + return Cl.#privateStaticFieldValue; + } + + static setValue() { + Cl.#privateStaticFieldValue = "dank"; + } +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/basic/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/basic/output.js new file mode 100644 index 000000000000..65a65d2d92ca --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/basic/output.js @@ -0,0 +1,24 @@ +var _PRIVATE_STATIC_FIELD = /*#__PURE__*/Symbol("PRIVATE_STATIC_FIELD"); +var _privateStaticFieldValue = /*#__PURE__*/Symbol("privateStaticFieldValue"); +class Cl { + static getValue() { + return babelHelpers.classPrivateFieldLooseBase(Cl, _privateStaticFieldValue)[_privateStaticFieldValue]; + } + static setValue() { + babelHelpers.classPrivateFieldLooseBase(Cl, _privateStaticFieldValue)[_privateStaticFieldValue] = "dank"; + } +} +function _get_privateStaticFieldValue() { + return babelHelpers.classPrivateFieldLooseBase(Cl, _PRIVATE_STATIC_FIELD)[_PRIVATE_STATIC_FIELD]; +} +function _set_privateStaticFieldValue(newValue) { + babelHelpers.classPrivateFieldLooseBase(Cl, _PRIVATE_STATIC_FIELD)[_PRIVATE_STATIC_FIELD] = `Updated: ${newValue}`; +} +Object.defineProperty(Cl, _privateStaticFieldValue, { + get: _get_privateStaticFieldValue, + set: _set_privateStaticFieldValue +}); +Object.defineProperty(Cl, _PRIVATE_STATIC_FIELD, { + writable: true, + value: "top secret string" +}); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/destructure-set/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/destructure-set/exec.js new file mode 100644 index 000000000000..a54bafb72aef --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/destructure-set/exec.js @@ -0,0 +1,10 @@ +class C { + static set #p(v) { C.#q = v } + static #q; + constructor() { + ([C.#p] = [0]); + expect(C.#q).toBe(0); + } +} + +new C; diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/destructure-set/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/destructure-set/input.js new file mode 100644 index 000000000000..e6919dccdc7e --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/destructure-set/input.js @@ -0,0 +1,9 @@ +class C { + static set #p(v) { C.#q = v } + static #q; + constructor() { + ([C.#p] = [0]); + } +} + +new C; diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/destructure-set/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/destructure-set/output.js new file mode 100644 index 000000000000..4418c9d54627 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/destructure-set/output.js @@ -0,0 +1,19 @@ +var _p = /*#__PURE__*/Symbol("p"); +var _q = /*#__PURE__*/Symbol("q"); +class C { + constructor() { + [babelHelpers.classPrivateFieldLooseBase(C, _p)[_p]] = [0]; + } +} +function _set_p(v) { + babelHelpers.classPrivateFieldLooseBase(C, _q)[_q] = v; +} +Object.defineProperty(C, _p, { + get: void 0, + set: _set_p +}); +Object.defineProperty(C, _q, { + writable: true, + value: void 0 +}); +new C(); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/get-only-setter/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/get-only-setter/exec.js new file mode 100644 index 000000000000..0c14f25c0938 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/get-only-setter/exec.js @@ -0,0 +1,13 @@ +class Cl { + static #PRIVATE_STATIC_FIELD = 0; + + static set #privateStaticFieldValue(newValue) { + Cl.#PRIVATE_STATIC_FIELD = newValue; + } + + static getPrivateStaticFieldValue() { + return Cl.#privateStaticFieldValue; + } +} + +expect(Cl.getPrivateStaticFieldValue()).toBeUndefined(); \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/get-only-setter/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/get-only-setter/input.js new file mode 100644 index 000000000000..ab8771074ec7 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/get-only-setter/input.js @@ -0,0 +1,11 @@ +class Cl { + static #PRIVATE_STATIC_FIELD = 0; + + static set #privateStaticFieldValue(newValue) { + Cl.#PRIVATE_STATIC_FIELD = newValue; + } + + static getPrivateStaticFieldValue() { + return Cl.#privateStaticFieldValue; + } +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/get-only-setter/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/get-only-setter/output.js new file mode 100644 index 000000000000..160942f103cd --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/get-only-setter/output.js @@ -0,0 +1,18 @@ +var _PRIVATE_STATIC_FIELD = /*#__PURE__*/Symbol("PRIVATE_STATIC_FIELD"); +var _privateStaticFieldValue = /*#__PURE__*/Symbol("privateStaticFieldValue"); +class Cl { + static getPrivateStaticFieldValue() { + return babelHelpers.classPrivateFieldLooseBase(Cl, _privateStaticFieldValue)[_privateStaticFieldValue]; + } +} +function _set_privateStaticFieldValue(newValue) { + babelHelpers.classPrivateFieldLooseBase(Cl, _PRIVATE_STATIC_FIELD)[_PRIVATE_STATIC_FIELD] = newValue; +} +Object.defineProperty(Cl, _privateStaticFieldValue, { + get: void 0, + set: _set_privateStaticFieldValue +}); +Object.defineProperty(Cl, _PRIVATE_STATIC_FIELD, { + writable: true, + value: 0 +}); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/options.json b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/options.json new file mode 100644 index 000000000000..1c536ad2aac0 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/options.json @@ -0,0 +1,6 @@ +{ + "plugins": ["proposal-private-methods", "proposal-class-properties"], + "assumptions": { + "privateFieldsAsSymbols": true + } +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/preserve-comments/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/preserve-comments/input.js new file mode 100644 index 000000000000..89d2b3bedb64 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/preserve-comments/input.js @@ -0,0 +1,9 @@ +class C { + /* before get a */ + static get #a() { return 42 }; + /* after get a */ + + /* before set a */ + static set #a(v) {} + /* after set a */ +} diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/preserve-comments/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/preserve-comments/output.js new file mode 100644 index 000000000000..29c121364955 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/preserve-comments/output.js @@ -0,0 +1,13 @@ +var _a = /*#__PURE__*/Symbol("a"); +class C {} +/* before get a */ +function _get_a() { + return 42; +} +/* after get a */ +/* before set a */ +function _set_a(v) {} +Object.defineProperty(C, _a, { + get: _get_a, + set: _set_a +}); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/set-only-getter/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/set-only-getter/exec.js new file mode 100644 index 000000000000..161aa995a447 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/set-only-getter/exec.js @@ -0,0 +1,14 @@ +class Cl { + static #privateField = 0; + + static get #privateFieldValue() { + return this.#privateField; + } + + constructor() { + expect(() => Cl.#privateFieldValue = 1).toThrow(TypeError); + expect(() => ([Cl.#privateFieldValue] = [1])).toThrow(TypeError); + } +} + +const cl = new Cl(); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/set-only-getter/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/set-only-getter/input.js new file mode 100644 index 000000000000..041681e06600 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/set-only-getter/input.js @@ -0,0 +1,15 @@ +class Cl { + static #privateField = 0; + + static get #privateFieldValue() { + return this.#privateField; + } + + constructor() { + Cl.#privateFieldValue = 1; + ([Cl.#privateFieldValue] = [1]); + } +} + +const cl = new Cl(); + diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/set-only-getter/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/set-only-getter/output.js new file mode 100644 index 000000000000..3a43b9448731 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/set-only-getter/output.js @@ -0,0 +1,20 @@ +var _privateField = /*#__PURE__*/Symbol("privateField"); +var _privateFieldValue = /*#__PURE__*/Symbol("privateFieldValue"); +class Cl { + constructor() { + babelHelpers.classPrivateFieldLooseBase(Cl, _privateFieldValue)[_privateFieldValue] = 1; + [babelHelpers.classPrivateFieldLooseBase(Cl, _privateFieldValue)[_privateFieldValue]] = [1]; + } +} +function _get_privateFieldValue() { + return babelHelpers.classPrivateFieldLooseBase(this, _privateField)[_privateField]; +} +Object.defineProperty(Cl, _privateFieldValue, { + get: _get_privateFieldValue, + set: void 0 +}); +Object.defineProperty(Cl, _privateField, { + writable: true, + value: 0 +}); +const cl = new Cl(); diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/updates/exec.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/updates/exec.js new file mode 100644 index 000000000000..05f70aecceec --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/updates/exec.js @@ -0,0 +1,46 @@ +class Cl { + static #privateField = "top secret string"; + static publicField = "not secret string"; + + static get #privateFieldValue() { + return Cl.#privateField; + } + + static set #privateFieldValue(newValue) { + Cl.#privateField = newValue; + } + + static publicGetPrivateField() { + return Cl.#privateFieldValue; + } + + static publicSetPrivateField(newValue) { + Cl.#privateFieldValue = newValue; + } + + static get publicFieldValue() { + return Cl.publicField; + } + + static set publicFieldValue(newValue) { + Cl.publicField = newValue; + } + + static testUpdates() { + Cl.#privateField = 0; + Cl.publicField = 0; + Cl.#privateFieldValue = Cl.#privateFieldValue++; + Cl.publicFieldValue = Cl.publicFieldValue++; + expect(Cl.#privateField).toEqual(Cl.publicField); + + ++Cl.#privateFieldValue; + ++Cl.publicFieldValue; + expect(Cl.#privateField).toEqual(Cl.publicField); + + Cl.#privateFieldValue += 1; + Cl.publicFieldValue += 1; + expect(Cl.#privateField).toEqual(Cl.publicField); + } +} + +Cl.testUpdates(); \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/updates/input.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/updates/input.js new file mode 100644 index 000000000000..33c7b39d9cb4 --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/updates/input.js @@ -0,0 +1,44 @@ +class Cl { + static #privateField = "top secret string"; + static publicField = "not secret string"; + + static get #privateFieldValue() { + return Cl.#privateField; + } + + static set #privateFieldValue(newValue) { + Cl.#privateField = newValue; + } + + static publicGetPrivateField() { + return Cl.#privateFieldValue; + } + + static publicSetPrivateField(newValue) { + Cl.#privateFieldValue = newValue; + } + + static get publicFieldValue() { + return Cl.publicField; + } + + static set publicFieldValue(newValue) { + Cl.publicField = newValue; + } + + static testUpdates() { + Cl.#privateField = 0; + Cl.publicField = 0; + Cl.#privateFieldValue = Cl.#privateFieldValue++; + Cl.publicFieldValue = Cl.publicFieldValue++; + + ++Cl.#privateFieldValue; + ++Cl.publicFieldValue; + + Cl.#privateFieldValue += 1; + Cl.publicFieldValue += 1; + + Cl.#privateFieldValue = -(Cl.#privateFieldValue ** Cl.#privateFieldValue); + Cl.publicFieldValue = -(Cl.publicFieldValue ** Cl.publicFieldValue); + } +} \ No newline at end of file diff --git a/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/updates/output.js b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/updates/output.js new file mode 100644 index 000000000000..6d93f7fae6ba --- /dev/null +++ b/packages/babel-plugin-proposal-private-methods/test/fixtures/static-accessors-privateFieldsAsSymbols/updates/output.js @@ -0,0 +1,43 @@ +var _privateField = /*#__PURE__*/Symbol("privateField"); +var _privateFieldValue = /*#__PURE__*/Symbol("privateFieldValue"); +class Cl { + static publicGetPrivateField() { + return babelHelpers.classPrivateFieldLooseBase(Cl, _privateFieldValue)[_privateFieldValue]; + } + static publicSetPrivateField(newValue) { + babelHelpers.classPrivateFieldLooseBase(Cl, _privateFieldValue)[_privateFieldValue] = newValue; + } + static get publicFieldValue() { + return Cl.publicField; + } + static set publicFieldValue(newValue) { + Cl.publicField = newValue; + } + static testUpdates() { + babelHelpers.classPrivateFieldLooseBase(Cl, _privateField)[_privateField] = 0; + Cl.publicField = 0; + babelHelpers.classPrivateFieldLooseBase(Cl, _privateFieldValue)[_privateFieldValue] = babelHelpers.classPrivateFieldLooseBase(Cl, _privateFieldValue)[_privateFieldValue]++; + Cl.publicFieldValue = Cl.publicFieldValue++; + ++babelHelpers.classPrivateFieldLooseBase(Cl, _privateFieldValue)[_privateFieldValue]; + ++Cl.publicFieldValue; + babelHelpers.classPrivateFieldLooseBase(Cl, _privateFieldValue)[_privateFieldValue] += 1; + Cl.publicFieldValue += 1; + babelHelpers.classPrivateFieldLooseBase(Cl, _privateFieldValue)[_privateFieldValue] = -(babelHelpers.classPrivateFieldLooseBase(Cl, _privateFieldValue)[_privateFieldValue] ** babelHelpers.classPrivateFieldLooseBase(Cl, _privateFieldValue)[_privateFieldValue]); + Cl.publicFieldValue = -(Cl.publicFieldValue ** Cl.publicFieldValue); + } +} +function _get_privateFieldValue() { + return babelHelpers.classPrivateFieldLooseBase(Cl, _privateField)[_privateField]; +} +function _set_privateFieldValue(newValue) { + babelHelpers.classPrivateFieldLooseBase(Cl, _privateField)[_privateField] = newValue; +} +Object.defineProperty(Cl, _privateFieldValue, { + get: _get_privateFieldValue, + set: _set_privateFieldValue +}); +Object.defineProperty(Cl, _privateField, { + writable: true, + value: "top secret string" +}); +babelHelpers.defineProperty(Cl, "publicField", "not secret string"); diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/accessor/input.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/accessor/input.js new file mode 100644 index 000000000000..c0e9000615fd --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/accessor/input.js @@ -0,0 +1,7 @@ +class Foo { + get #foo() {} + + test(other) { + return #foo in other; + } +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/accessor/output.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/accessor/output.js new file mode 100644 index 000000000000..e4f55eb71d9b --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/accessor/output.js @@ -0,0 +1,13 @@ +var _foo = /*#__PURE__*/Symbol("foo"); +class Foo { + constructor() { + Object.defineProperty(this, _foo, { + get: _get_foo, + set: void 0 + }); + } + test(other) { + return Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(other), _foo); + } +} +function _get_foo() {} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/compiled-classes/input.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/compiled-classes/input.js new file mode 100644 index 000000000000..23c266018025 --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/compiled-classes/input.js @@ -0,0 +1,12 @@ +class Foo { + static #foo = "foo"; + #bar = "bar"; + + static test() { + return #foo in Foo; + } + + test() { + return #bar in this; + } +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/compiled-classes/options.json b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/compiled-classes/options.json new file mode 100644 index 000000000000..83069bfb945c --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/compiled-classes/options.json @@ -0,0 +1,8 @@ +{ + "plugins": [ + "proposal-private-property-in-object", + "proposal-class-properties", + "proposal-private-methods", + "transform-classes" + ] +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/compiled-classes/output.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/compiled-classes/output.js new file mode 100644 index 000000000000..2b401954b1ca --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/compiled-classes/output.js @@ -0,0 +1,29 @@ +var _foo = /*#__PURE__*/Symbol("foo"); +var _bar = /*#__PURE__*/Symbol("bar"); +let Foo = /*#__PURE__*/function () { + "use strict"; + + function Foo() { + babelHelpers.classCallCheck(this, Foo); + Object.defineProperty(this, _bar, { + writable: true, + value: "bar" + }); + } + babelHelpers.createClass(Foo, [{ + key: "test", + value: function test() { + return Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(this), _bar); + } + }], [{ + key: "test", + value: function test() { + return Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(Foo), _foo); + } + }]); + return Foo; +}(); +Object.defineProperty(Foo, _foo, { + writable: true, + value: "foo" +}); diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/field/input.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/field/input.js new file mode 100644 index 000000000000..a682a1a15c5b --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/field/input.js @@ -0,0 +1,7 @@ +class Foo { + #foo = 1; + + test(other) { + return #foo in other; + } +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/field/output.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/field/output.js new file mode 100644 index 000000000000..4104428b0746 --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/field/output.js @@ -0,0 +1,12 @@ +var _foo = /*#__PURE__*/Symbol("foo"); +class Foo { + constructor() { + Object.defineProperty(this, _foo, { + writable: true, + value: 1 + }); + } + test(other) { + return Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(other), _foo); + } +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/method/input.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/method/input.js new file mode 100644 index 000000000000..365843c59708 --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/method/input.js @@ -0,0 +1,7 @@ +class Foo { + #foo() {} + + test(other) { + return #foo in other; + } +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/method/output.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/method/output.js new file mode 100644 index 000000000000..f523fa5db964 --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/method/output.js @@ -0,0 +1,12 @@ +var _foo = /*#__PURE__*/Symbol("foo"); +class Foo { + constructor() { + Object.defineProperty(this, _foo, { + value: _foo2 + }); + } + test(other) { + return Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(other), _foo); + } +} +function _foo2() {} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class-other-redeclared/input.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class-other-redeclared/input.js new file mode 100644 index 000000000000..a084dd06afd6 --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class-other-redeclared/input.js @@ -0,0 +1,18 @@ +class Foo { + #foo = 1; + #bar = 1; + + test() { + class Nested { + #bar = 2; + + test() { + #foo in this; + #bar in this; + } + } + + #foo in this; + #bar in this; + } +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class-other-redeclared/output.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class-other-redeclared/output.js new file mode 100644 index 000000000000..2b74517f77b4 --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class-other-redeclared/output.js @@ -0,0 +1,31 @@ +var _foo = /*#__PURE__*/Symbol("foo"); +var _bar = /*#__PURE__*/Symbol("bar"); +class Foo { + constructor() { + Object.defineProperty(this, _foo, { + writable: true, + value: 1 + }); + Object.defineProperty(this, _bar, { + writable: true, + value: 1 + }); + } + test() { + var _bar2 = /*#__PURE__*/Symbol("bar"); + class Nested { + constructor() { + Object.defineProperty(this, _bar2, { + writable: true, + value: 2 + }); + } + test() { + Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(this), _foo); + Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(this), _bar2); + } + } + Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(this), _foo); + Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(this), _bar); + } +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class-redeclared/input.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class-redeclared/input.js new file mode 100644 index 000000000000..2258be35c5fd --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class-redeclared/input.js @@ -0,0 +1,15 @@ +class Foo { + #foo = 1; + + test() { + class Nested { + #foo = 2; + + test() { + #foo in this; + } + } + + #foo in this; + } +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class-redeclared/output.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class-redeclared/output.js new file mode 100644 index 000000000000..21f60c5140da --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class-redeclared/output.js @@ -0,0 +1,24 @@ +var _foo = /*#__PURE__*/Symbol("foo"); +class Foo { + constructor() { + Object.defineProperty(this, _foo, { + writable: true, + value: 1 + }); + } + test() { + var _foo2 = /*#__PURE__*/Symbol("foo"); + class Nested { + constructor() { + Object.defineProperty(this, _foo2, { + writable: true, + value: 2 + }); + } + test() { + Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(this), _foo2); + } + } + Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(this), _foo); + } +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class/input.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class/input.js new file mode 100644 index 000000000000..e17e438b314d --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class/input.js @@ -0,0 +1,13 @@ +class Foo { + #foo = 1; + + test() { + class Nested { + test() { + #foo in this; + } + } + + #foo in this; + } +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class/output.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class/output.js new file mode 100644 index 000000000000..ba7cae8d6b0a --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/nested-class/output.js @@ -0,0 +1,17 @@ +var _foo = /*#__PURE__*/Symbol("foo"); +class Foo { + constructor() { + Object.defineProperty(this, _foo, { + writable: true, + value: 1 + }); + } + test() { + class Nested { + test() { + Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(this), _foo); + } + } + Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(this), _foo); + } +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/options.json b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/options.json new file mode 100644 index 000000000000..5dc99c1e246e --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/options.json @@ -0,0 +1,10 @@ +{ + "plugins": [ + "proposal-private-property-in-object", + "proposal-private-methods", + "proposal-class-properties" + ], + "assumptions": { + "privateFieldsAsSymbols": true + } +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/rhs-not-object/exec.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/rhs-not-object/exec.js new file mode 100644 index 000000000000..d27c86671973 --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/rhs-not-object/exec.js @@ -0,0 +1,31 @@ +expect(() => class { static #p = #p in 0 }).toThrow(`right-hand side of 'in' should be an object, got number`); +expect(() => class { static #p = #p in "" }).toThrow(`right-hand side of 'in' should be an object, got string`); +expect(() => class { static #p = #p in true }).toThrow(`right-hand side of 'in' should be an object, got boolean`); +expect(() => class { static #p = #p in void 0 }).toThrow(`right-hand side of 'in' should be an object, got undefined`); +expect(() => class { static #p = #p in null }).toThrow(`right-hand side of 'in' should be an object, got null`); +expect(() => class { static #p = #p in Symbol.iterator }).toThrow(`right-hand side of 'in' should be an object, got symbol`); +expect(() => class { static #p = #p in 0n }).toThrow(`right-hand side of 'in' should be an object, got bigint`); + +expect(() => class { static #p() {}; static q = #p in 0 }).toThrow(`right-hand side of 'in' should be an object, got number`); +expect(() => class { static #p() {}; static q = #p in "" }).toThrow(`right-hand side of 'in' should be an object, got string`); +expect(() => class { static #p() {}; static q = #p in true }).toThrow(`right-hand side of 'in' should be an object, got boolean`); +expect(() => class { static #p() {}; static q = #p in void 0 }).toThrow(`right-hand side of 'in' should be an object, got undefined`); +expect(() => class { static #p() {}; static q = #p in null }).toThrow(`right-hand side of 'in' should be an object, got null`); +expect(() => class { static #p() {}; static q = #p in Symbol.iterator }).toThrow(`right-hand side of 'in' should be an object, got symbol`); +expect(() => class { static #p() {}; static q = #p in 0n }).toThrow(`right-hand side of 'in' should be an object, got bigint`); + +expect(() => new class { #p = #p in 0 }).toThrow(`right-hand side of 'in' should be an object, got number`); +expect(() => new class { #p = #p in "" }).toThrow(`right-hand side of 'in' should be an object, got string`); +expect(() => new class { #p = #p in true }).toThrow(`right-hand side of 'in' should be an object, got boolean`); +expect(() => new class { #p = #p in void 0 }).toThrow(`right-hand side of 'in' should be an object, got undefined`); +expect(() => new class { #p = #p in null }).toThrow(`right-hand side of 'in' should be an object, got null`); +expect(() => new class { #p = #p in Symbol.iterator }).toThrow(`right-hand side of 'in' should be an object, got symbol`); +expect(() => new class { #p = #p in 0n }).toThrow(`right-hand side of 'in' should be an object, got bigint`); + +expect(() => new class { #p() {}; q = #p in 0 }).toThrow(`right-hand side of 'in' should be an object, got number`); +expect(() => new class { #p() {}; q = #p in "" }).toThrow(`right-hand side of 'in' should be an object, got string`); +expect(() => new class { #p() {}; q = #p in true }).toThrow(`right-hand side of 'in' should be an object, got boolean`); +expect(() => new class { #p() {}; q = #p in void 0 }).toThrow(`right-hand side of 'in' should be an object, got undefined`); +expect(() => new class { #p() {}; q = #p in null }).toThrow(`right-hand side of 'in' should be an object, got null`); +expect(() => new class { #p() {}; q = #p in Symbol.iterator }).toThrow(`right-hand side of 'in' should be an object, got symbol`); +expect(() => new class { #p() {}; q = #p in 0n }).toThrow(`right-hand side of 'in' should be an object, got bigint`); diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/rhs-not-object/options.json b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/rhs-not-object/options.json new file mode 100644 index 000000000000..22b476c4bb57 --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/rhs-not-object/options.json @@ -0,0 +1,3 @@ +{ + "minNodeVersion": "12.0.0" +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-accessor/input.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-accessor/input.js new file mode 100644 index 000000000000..e74333f2055f --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-accessor/input.js @@ -0,0 +1,7 @@ +class Foo { + static get #foo() {} + + test(other) { + return #foo in other; + } +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-accessor/output.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-accessor/output.js new file mode 100644 index 000000000000..9822dfc626c3 --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-accessor/output.js @@ -0,0 +1,11 @@ +var _foo = /*#__PURE__*/Symbol("foo"); +class Foo { + test(other) { + return Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(other), _foo); + } +} +function _get_foo() {} +Object.defineProperty(Foo, _foo, { + get: _get_foo, + set: void 0 +}); diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-field/input.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-field/input.js new file mode 100644 index 000000000000..a4f771844fe9 --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-field/input.js @@ -0,0 +1,7 @@ +class Foo { + static #foo = 1; + + test(other) { + return #foo in other; + } +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-field/output.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-field/output.js new file mode 100644 index 000000000000..848efc620173 --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-field/output.js @@ -0,0 +1,10 @@ +var _foo = /*#__PURE__*/Symbol("foo"); +class Foo { + test(other) { + return Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(other), _foo); + } +} +Object.defineProperty(Foo, _foo, { + writable: true, + value: 1 +}); diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-method/input.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-method/input.js new file mode 100644 index 000000000000..9fffe7a01622 --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-method/input.js @@ -0,0 +1,7 @@ +class Foo { + static #foo() {} + + test(other) { + return #foo in other; + } +} diff --git a/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-method/output.js b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-method/output.js new file mode 100644 index 000000000000..46d5b91b91d2 --- /dev/null +++ b/packages/babel-plugin-proposal-private-property-in-object/test/fixtures/assumption-privateFieldsAsSymbols/static-method/output.js @@ -0,0 +1,10 @@ +var _foo = /*#__PURE__*/Symbol("foo"); +class Foo { + test(other) { + return Object.prototype.hasOwnProperty.call(babelHelpers.checkInRHS(other), _foo); + } +} +function _foo2() {} +Object.defineProperty(Foo, _foo, { + value: _foo2 +});