From 3280e433f7edaab6dd5e059718cc321b8cc1fb15 Mon Sep 17 00:00:00 2001 From: Max Heiber Date: Sat, 23 Mar 2019 22:18:25 +0000 Subject: [PATCH 1/2] Transform private-named instance methods Transform private-named instance methods Signed-off-by: Max Heiber --- src/compiler/transformers/classProperties.ts | 220 ++++++++++++++---- ...ssConstructorParametersCommentPlacement.js | 29 +++ ...structorParametersCommentPlacement.symbols | 18 ++ ...onstructorParametersCommentPlacement.types | 22 ++ .../privateNameConstructorReserved.js | 4 +- .../reference/privateNameDeclaration.js | 6 +- .../reference/privateNameDuplicateField.js | 8 +- tests/baselines/reference/privateNameField.js | 8 +- .../reference/privateNameFieldAccess.js | 8 +- .../reference/privateNameFieldAssignment.js | 58 ++--- .../privateNameFieldCallExpression.js | 10 +- .../reference/privateNameFieldDeclaration.js | 15 ++ .../privateNameFieldDeclaration.symbols | 8 + .../privateNameFieldDeclaration.types | 8 + .../privateNameFieldDestructuredBinding.js | 10 +- .../reference/privateNameFieldInitializer.js | 8 +- .../privateNameFieldUnaryMutation.js | 22 +- .../reference/privateNameInObjectLiteral-2.js | 5 +- .../privateNameNestedClassNameConflict.js | 12 +- ...teNameNotAccessibleOutsideDefiningClass.js | 6 +- .../privateNameSneakyRuntimeException.js | 8 +- .../reference/privateNamedMemberOrder.js | 24 ++ .../reference/privateNamedMemberOrder.symbols | 19 ++ .../reference/privateNamedMemberOrder.types | 20 ++ .../baselines/reference/privateNamedMethod.js | 51 ++++ .../reference/privateNamedMethod.symbols | 65 ++++++ .../reference/privateNamedMethod.types | 82 +++++++ .../reference/privateNamedMethodOrder.js | 29 +++ .../reference/privateNamedMethodOrder.symbols | 33 +++ .../reference/privateNamedMethodOrder.types | 37 +++ .../reference/privateNamesAndDecorators.js | 8 +- .../reference/privateNamesAndFields.js | 14 +- .../privateNamesAndGenericClasses-2.js | 23 +- .../reference/privateNamesAndIndexedAccess.js | 8 +- .../reference/privateNamesAndMethods.js | 32 +-- .../reference/privateNamesAndStaticFields.js | 10 +- .../reference/privateNamesAndStaticMethods.js | 14 +- .../reference/privateNamesAndkeyof.js | 6 +- .../reference/privateNamesInGenericClasses.js | 12 +- .../reference/privateNamesInNestedClasses.js | 20 +- .../privateNamesNoAccessibilityModifiers.js | 12 +- .../privateNamesNoConflictWhenInheriting.js | 10 +- .../reference/privateNamesNoDelete.js | 8 +- .../privateNamesNotAllowedAsParameters.js | 6 +- .../baselines/reference/privateNamesUnique.js | 10 +- ...ssConstructorParametersCommentPlacement.ts | 8 + .../privateNameFieldDeclaration.ts | 3 + .../privateNames/privateNamedMemberOrder.ts | 7 + .../privateNames/privateNamedMethod.ts | 24 ++ .../privateNames/privateNamedMethodOrder.ts | 14 ++ 50 files changed, 870 insertions(+), 232 deletions(-) create mode 100644 tests/baselines/reference/classConstructorParametersCommentPlacement.js create mode 100644 tests/baselines/reference/classConstructorParametersCommentPlacement.symbols create mode 100644 tests/baselines/reference/classConstructorParametersCommentPlacement.types create mode 100644 tests/baselines/reference/privateNameFieldDeclaration.js create mode 100644 tests/baselines/reference/privateNameFieldDeclaration.symbols create mode 100644 tests/baselines/reference/privateNameFieldDeclaration.types create mode 100644 tests/baselines/reference/privateNamedMemberOrder.js create mode 100644 tests/baselines/reference/privateNamedMemberOrder.symbols create mode 100644 tests/baselines/reference/privateNamedMemberOrder.types create mode 100644 tests/baselines/reference/privateNamedMethod.js create mode 100644 tests/baselines/reference/privateNamedMethod.symbols create mode 100644 tests/baselines/reference/privateNamedMethod.types create mode 100644 tests/baselines/reference/privateNamedMethodOrder.js create mode 100644 tests/baselines/reference/privateNamedMethodOrder.symbols create mode 100644 tests/baselines/reference/privateNamedMethodOrder.types create mode 100644 tests/cases/conformance/classes/constructorDeclarations/classConstructorParametersCommentPlacement.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNameFieldDeclaration.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamedMemberOrder.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamedMethod.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamedMethodOrder.ts diff --git a/src/compiler/transformers/classProperties.ts b/src/compiler/transformers/classProperties.ts index 07498d85b989a..01bb21fe1b7a2 100644 --- a/src/compiler/transformers/classProperties.ts +++ b/src/compiler/transformers/classProperties.ts @@ -9,20 +9,26 @@ namespace ts { } const enum PrivateNamePlacement { - InstanceField + InstanceField, + InstanceMethod } - type PrivateNameInfo = PrivateNamedInstanceField; - interface PrivateNamedInstanceField { placement: PrivateNamePlacement.InstanceField; - weakMapName: Identifier; + accumulator: Identifier; + } + + interface PrivateNamedInstanceMethod { + placement: PrivateNamePlacement.InstanceMethod; + accumulator: Identifier; + origFunc: MethodDeclaration; + funcName: Identifier; } /** * A mapping of private names to information needed for transformation. */ - type PrivateNameEnvironment = UnderscoreEscapedMap; + type PrivateNameEnvironment = UnderscoreEscapedMap; /** * Transforms ECMAScript Class Syntax. @@ -92,6 +98,10 @@ namespace ts { return visitCallExpression(node as CallExpression); case SyntaxKind.BinaryExpression: return visitBinaryExpression(node as BinaryExpression); + case SyntaxKind.MethodDeclaration: + if (isPrivateName((node as MethodDeclaration).name)) { + return []; + } } return visitEachChild(node, visitor, context); } @@ -177,12 +187,26 @@ namespace ts { createClassPrivateFieldGetHelper( context, visitNode(node.expression, visitor, isExpression), - privateNameInfo.weakMapName + privateNameInfo.accumulator + ), + node + ), + node + ); + case PrivateNamePlacement.InstanceMethod: + return setOriginalNode( + setTextRange( + createClassPrivateNamedMethodGetHelper( + context, + privateNameInfo.accumulator, + privateNameInfo.funcName ), node ), node ); + default: + Debug.assertNever(privateNameInfo, "Unexpected private name placement"); } } } @@ -258,7 +282,6 @@ namespace ts { return visitEachChild(node, visitor, context); } - function visitCallExpression(node: CallExpression) { if (isPrivateNamedPropertyAccessExpression(node.expression)) { // Transform call expressions of private names to properly bind the `this` parameter. @@ -273,6 +296,30 @@ namespace ts { ); receiver = generatedName; } + const privateNameEntry = privateNameEnvironmentStack.length + ? last(privateNameEnvironmentStack).get(node.expression.name.escapedText) + : undefined; + if (privateNameEntry && privateNameEntry.placement === PrivateNamePlacement.InstanceMethod) { + return setOriginalNode( + setTextRange( + createCall( + createPropertyAccess( + createClassPrivateNamedMethodGetHelper( + context, + privateNameEntry.accumulator, + privateNameEntry.funcName + ), + "call" + ), + /* typeArguments */ undefined, + // node.arguments + concatenate([createThis()], node.arguments) + ), + /* location */ node + ), + node + ); + } return visitNode( updateCall( node, @@ -332,12 +379,12 @@ namespace ts { createClassPrivateFieldSetHelper( context, setReceiver, - privateNameInfo.weakMapName, + privateNameInfo.accumulator, createBinary( createClassPrivateFieldGetHelper( context, getReceiver, - privateNameInfo.weakMapName + privateNameInfo.accumulator ), getOperatorForCompoundAssignment(node.operatorToken.kind), visitNode(node.right, visitor) @@ -351,7 +398,7 @@ namespace ts { createClassPrivateFieldSetHelper( context, node.left.expression, - privateNameInfo.weakMapName, + privateNameInfo.accumulator, visitNode(node.right, visitor) ), node @@ -394,7 +441,7 @@ namespace ts { // Write any pending expressions from elided or moved computed property names if (some(pendingExpressions)) { - statements.push(createExpressionStatement(inlineExpressions(pendingExpressions!))); + statements.push(createExpressionStatement(inlineExpressions(pendingExpressions))); } // Emit static property assignment. Because classDeclaration is lexically evaluated, @@ -475,16 +522,31 @@ namespace ts { return classExpression; } + function transformClassMembers(node: ClassDeclaration | ClassExpression, isDerivedClass: boolean) { // Declare private names. - node.members.forEach(member => { - if (isPrivateNamedPropertyDeclaration(member)) { - addPrivateNameToEnvironment(member.name); + const privateNamedMembers = node.members + .filter(element => isNamedDeclaration(element) && isPrivateName(element.name)); + privateNamedMembers.forEach(addPrivateName); + + pendingExpressions = pendingExpressions || []; + last(privateNameEnvironmentStack).forEach(entry => { + switch (entry.placement) { + case PrivateNamePlacement.InstanceField: + break; + case PrivateNamePlacement.InstanceMethod: + const func = privateNamedMethodToFunction(entry.origFunc, entry.funcName); + (pendingExpressions = pendingExpressions || []).push(createAssignment( + entry.funcName, + func + )); + break; + default: + Debug.assertNever(entry, "unexpected private name placement"); } }); - const members: ClassElement[] = []; - const constructor = transformConstructor(node, isDerivedClass); + const constructor = transformConstructor(node, isDerivedClass, !!privateNamedMembers.length); if (constructor) { members.push(constructor); } @@ -492,17 +554,15 @@ namespace ts { return setTextRange(createNodeArray(members), /*location*/ node.members); } - function transformConstructor(node: ClassDeclaration | ClassExpression, isDerivedClass: boolean) { + function transformConstructor(node: ClassDeclaration | ClassExpression, isDerivedClass: boolean, declaresPrivateNames: boolean) { const constructor = visitNode(getFirstConstructorWithBody(node), visitor, isConstructorDeclaration); - const containsPropertyInitializerOrPrivateName = forEach( - node.members, - member => isInitializedProperty(member) || isPrivateNamedPropertyDeclaration(member) - ); - if (!containsPropertyInitializerOrPrivateName) { - return constructor; + const containsPropertyInitializer = forEach(node.members, isInitializedProperty); + let body = constructor ? constructor.body : undefined; + let parameters = constructor ? constructor.parameters : undefined; + if (containsPropertyInitializer || declaresPrivateNames) { + parameters = visitParameterList(constructor ? constructor.parameters : undefined, visitor, context); + body = transformConstructorBody(node, constructor, isDerivedClass, declaresPrivateNames); } - const parameters = visitParameterList(constructor ? constructor.parameters : undefined, visitor, context); - const body = transformConstructorBody(node, constructor, isDerivedClass); if (!body) { return undefined; } @@ -512,7 +572,7 @@ namespace ts { createConstructor( /*decorators*/ undefined, /*modifiers*/ undefined, - parameters, + parameters || [], body ), constructor || node @@ -522,20 +582,25 @@ namespace ts { ); } - function transformConstructorBody(node: ClassDeclaration | ClassExpression, constructor: ConstructorDeclaration | undefined, isDerivedClass: boolean) { - const properties = node.members.filter( - (node): node is PropertyDeclaration => isPropertyDeclaration(node) && !hasStaticModifier(node) - ); + function transformConstructorBody( + node: ClassDeclaration | ClassExpression, + constructor: ConstructorDeclaration | undefined, + isDerivedClass: boolean, + classDeclaresPrivateNames: boolean, + ) { + const properties = filter(node.members, (node): node is PropertyDeclaration => isPropertyDeclaration(node) && !hasStaticModifier(node)); - // Only generate synthetic constructor when there are property initializers to move. - if (!constructor && !some(properties)) { + // Only generate synthetic constructor when there are property or private name declarations to move + if (!constructor && !some(properties) && !classDeclaresPrivateNames) { return visitFunctionBody(/*node*/ undefined, visitor, context); } + let statements: Statement[] = []; + + // was suspended to provide a scope for parameter properties and/or private names resumeLexicalEnvironment(); let indexOfFirstStatement = 0; - let statements: Statement[] = []; if (!constructor && isDerivedClass) { // Add a synthetic `super` call: @@ -557,6 +622,27 @@ namespace ts { indexOfFirstStatement = addPrologueDirectivesAndInitialSuperCall(constructor, statements, visitor); } + if (classDeclaresPrivateNames) { + last(privateNameEnvironmentStack).forEach(({ placement, accumulator }) => { + switch (placement) { + case PrivateNamePlacement.InstanceField: + // handled in addInitializedPropertyStatements + break; + case PrivateNamePlacement.InstanceMethod: + statements.push( + createExpressionStatement( + createCall( + createPropertyAccess(accumulator, "add"), + /* typeArguments */ undefined, + [createThis()] + ) + ) + ); + break; + } + }); + } + // Add the property initializers. Transforms this: // // public x = 1; @@ -652,7 +738,7 @@ namespace ts { return createPrivateInstanceFieldInitializer( receiver, initializer, - privateNameInfo.weakMapName + privateNameInfo.accumulator ); } } @@ -761,18 +847,54 @@ namespace ts { privateNameEnvironmentStack.pop(); } - function addPrivateNameToEnvironment(name: PrivateName) { + function privateNamedMethodToFunction (declaration: MethodDeclaration, funcName: Identifier): FunctionExpression { + const params = declaration.parameters; + const body = visitEachChild(declaration.body, visitor, context) || createBlock([], /* multiLine */ true); + const func = createFunctionExpression( + /* modifiers */ undefined, + /* asteriskToken */ undefined, + funcName, + /* typeParameters*/ undefined, + params, + /* type */ undefined, + body); + return func; + } + + function addPrivateName(element: ClassElement & { name: PrivateName }) { const env = last(privateNameEnvironmentStack); - const text = getTextOfPropertyName(name) as string; - const weakMapName = createOptimisticUniqueName("_" + text.substring(1)); - weakMapName.autoGenerateFlags |= GeneratedIdentifierFlags.ReservedInNestedScopes; - hoistVariableDeclaration(weakMapName); - env.set(name.escapedText, { placement: PrivateNamePlacement.InstanceField, weakMapName }); - (pendingExpressions || (pendingExpressions = [])).push( + const text = getTextOfPropertyName(element.name) as string; + const { escapedText } = element.name; + + let identifierName: string; + let accumulator: Identifier; + if (hasModifier(element, ModifierFlags.Static)) { + // statics not supported yet + return; + } + if (isPropertyDeclaration(element)) { + identifierName = "WeakMap"; + accumulator = createUniqueName(`_${text.slice(1)}WeakMap`); + env.set(escapedText, { placement: PrivateNamePlacement.InstanceField, accumulator }); + } + else if (isMethodDeclaration(element)) { + identifierName = "WeakSet"; + accumulator = createUniqueName(`_${text.slice(1)}WeakSet`); + const escapedText = element.name.escapedText; + const escapedTextNoHash = `_${`${escapedText}`.slice(1)}`; + const funcName: Identifier = createUniqueName(escapedTextNoHash); + env.set(escapedText, { placement: PrivateNamePlacement.InstanceMethod, accumulator, funcName, origFunc: element }); + hoistVariableDeclaration(funcName); // todo: hoist in lexical, not func scope + } + else { + return; + } + hoistVariableDeclaration(accumulator); + (pendingExpressions = pendingExpressions || []).push( createAssignment( - weakMapName, + accumulator, createNew( - createIdentifier("WeakMap"), + createIdentifier(identifierName), /*typeArguments*/ undefined, [] ) @@ -897,4 +1019,16 @@ namespace ts { context.requestEmitHelper(classPrivateFieldSetHelper); return createCall(getHelperName("_classPrivateFieldSet"), /* typeArguments */ undefined, [receiver, privateField, value]); } + + const classPrivateNamedMethodGet: EmitHelper = { + name: "typescript:classPrivateNamedMethodGet", + scoped: false, + text: `function _classPrivateNamedMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }` + }; + + function createClassPrivateNamedMethodGetHelper(context: TransformationContext, weakSet: Identifier, name: Identifier) { + context.requestEmitHelper(classPrivateNamedMethodGet); + return createCall(getHelperName("_classPrivateNamedMethodGet"), /* typeArguments */ undefined, + [ createThis(), weakSet, name ]); + } } diff --git a/tests/baselines/reference/classConstructorParametersCommentPlacement.js b/tests/baselines/reference/classConstructorParametersCommentPlacement.js new file mode 100644 index 0000000000000..4984368683af3 --- /dev/null +++ b/tests/baselines/reference/classConstructorParametersCommentPlacement.js @@ -0,0 +1,29 @@ +//// [classConstructorParametersCommentPlacement.ts] +// some comment +class A { + #a = "private hello"; + #b = "another private name"; + a = "public property"; + constructor(private b = "something") { } +} + + +//// [classConstructorParametersCommentPlacement.js] +var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; +var _aWeakMap_1, _bWeakMap_1; +// some comment +var A = /** @class */ (function () { + function A(b) { + if (b === void 0) { b = "something"; } + // some comment + _aWeakMap_1.set(this, void 0); + // some comment + _bWeakMap_1.set(this, void 0); + this.b = b; + _classPrivateFieldSet(this, _aWeakMap_1, "private hello"); + _classPrivateFieldSet(this, _bWeakMap_1, "another private name"); + this.a = "public property"; + } + return A; +}()); +_aWeakMap_1 = new WeakMap(), _bWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/classConstructorParametersCommentPlacement.symbols b/tests/baselines/reference/classConstructorParametersCommentPlacement.symbols new file mode 100644 index 0000000000000..110e1571bef80 --- /dev/null +++ b/tests/baselines/reference/classConstructorParametersCommentPlacement.symbols @@ -0,0 +1,18 @@ +=== tests/cases/conformance/classes/constructorDeclarations/classConstructorParametersCommentPlacement.ts === +// some comment +class A { +>A : Symbol(A, Decl(classConstructorParametersCommentPlacement.ts, 0, 0)) + + #a = "private hello"; +>#a : Symbol(A.#a, Decl(classConstructorParametersCommentPlacement.ts, 1, 9)) + + #b = "another private name"; +>#b : Symbol(A.#b, Decl(classConstructorParametersCommentPlacement.ts, 2, 25)) + + a = "public property"; +>a : Symbol(A.a, Decl(classConstructorParametersCommentPlacement.ts, 3, 32)) + + constructor(private b = "something") { } +>b : Symbol(A.b, Decl(classConstructorParametersCommentPlacement.ts, 5, 16)) +} + diff --git a/tests/baselines/reference/classConstructorParametersCommentPlacement.types b/tests/baselines/reference/classConstructorParametersCommentPlacement.types new file mode 100644 index 0000000000000..f5b0cf9c9c244 --- /dev/null +++ b/tests/baselines/reference/classConstructorParametersCommentPlacement.types @@ -0,0 +1,22 @@ +=== tests/cases/conformance/classes/constructorDeclarations/classConstructorParametersCommentPlacement.ts === +// some comment +class A { +>A : A + + #a = "private hello"; +>#a : string +>"private hello" : "private hello" + + #b = "another private name"; +>#b : string +>"another private name" : "another private name" + + a = "public property"; +>a : string +>"public property" : "public property" + + constructor(private b = "something") { } +>b : string +>"something" : "something" +} + diff --git a/tests/baselines/reference/privateNameConstructorReserved.js b/tests/baselines/reference/privateNameConstructorReserved.js index 61585bd4eb127..034dfa49195d9 100644 --- a/tests/baselines/reference/privateNameConstructorReserved.js +++ b/tests/baselines/reference/privateNameConstructorReserved.js @@ -8,9 +8,11 @@ class A { //// [privateNameConstructorReserved.js] // @target es6 +var _constructor_1, _constructorWeakSet_1; var A = /** @class */ (function () { function A() { + _constructorWeakSet_1.add(this); } - A.prototype.#constructor = function () { }; // Error: `#constructor` is a reserved word. return A; }()); +_constructorWeakSet_1 = new WeakSet(), _constructor_1 = function _constructor_1() { }; diff --git a/tests/baselines/reference/privateNameDeclaration.js b/tests/baselines/reference/privateNameDeclaration.js index ee7ec86c7b612..9f9a06ba1fe1c 100644 --- a/tests/baselines/reference/privateNameDeclaration.js +++ b/tests/baselines/reference/privateNameDeclaration.js @@ -5,11 +5,11 @@ class A { //// [privateNameDeclaration.js] -var _name; +var _nameWeakMap_1; var A = /** @class */ (function () { function A() { - _name.set(this, void 0); + _nameWeakMap_1.set(this, void 0); } return A; }()); -_name = new WeakMap(); +_nameWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameDuplicateField.js b/tests/baselines/reference/privateNameDuplicateField.js index 6ece4be8f032a..00b49deece99d 100644 --- a/tests/baselines/reference/privateNameDuplicateField.js +++ b/tests/baselines/reference/privateNameDuplicateField.js @@ -9,13 +9,13 @@ class A { //// [privateNameDuplicateField.js] // @target es6 -var _foo, _foo_1; +var _fooWeakMap_1, _fooWeakMap_2; "use strict"; var A = /** @class */ (function () { function A() { - _foo_1.set(this, "foo"); - _foo_1.set(this, "foo"); + _fooWeakMap_2.set(this, "foo"); + _fooWeakMap_2.set(this, "foo"); } return A; }()); -_foo = new WeakMap(), _foo_1 = new WeakMap(); +_fooWeakMap_1 = new WeakMap(), _fooWeakMap_2 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameField.js b/tests/baselines/reference/privateNameField.js index 57446748cb668..d8a3ebed47af7 100644 --- a/tests/baselines/reference/privateNameField.js +++ b/tests/baselines/reference/privateNameField.js @@ -11,13 +11,13 @@ class A { //// [privateNameField.js] // @target es6 var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; -var _name; +var _nameWeakMap_1; "use strict"; var A = /** @class */ (function () { function A(name) { - _name.set(this, void 0); - _classPrivateFieldSet(this, _name, name); + _nameWeakMap_1.set(this, void 0); + _classPrivateFieldSet(this, _nameWeakMap_1, name); } return A; }()); -_name = new WeakMap(); +_nameWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameFieldAccess.js b/tests/baselines/reference/privateNameFieldAccess.js index 2f64fc96515fa..f9a6a0b0dd78d 100644 --- a/tests/baselines/reference/privateNameFieldAccess.js +++ b/tests/baselines/reference/privateNameFieldAccess.js @@ -9,12 +9,12 @@ class A { //// [privateNameFieldAccess.js] var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; -var _myField; +var _myFieldWeakMap_1; var A = /** @class */ (function () { function A() { - _myField.set(this, "hello world"); - console.log(_classPrivateFieldGet(this, _myField)); + _myFieldWeakMap_1.set(this, "hello world"); + console.log(_classPrivateFieldGet(this, _myFieldWeakMap_1)); } return A; }()); -_myField = new WeakMap(); +_myFieldWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameFieldAssignment.js b/tests/baselines/reference/privateNameFieldAssignment.js index 34040558f1f42..4dad664c83109 100644 --- a/tests/baselines/reference/privateNameFieldAssignment.js +++ b/tests/baselines/reference/privateNameFieldAssignment.js @@ -38,41 +38,41 @@ class A { //// [privateNameFieldAssignment.js] var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; -var _field; +var _fieldWeakMap_1; var A = /** @class */ (function () { function A() { - _field.set(this, 0); + _fieldWeakMap_1.set(this, 0); var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m; - _classPrivateFieldSet(this, _field, 1); - _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) + 2); - _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) - 3); - _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) / 4); - _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) * 5); - _classPrivateFieldSet(this, _field, Math.pow(_classPrivateFieldGet(this, _field), 6)); - _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) % 7); - _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) << 8); - _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) >> 9); - _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) >>> 10); - _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) & 11); - _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) | 12); - _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) ^ 13); - _classPrivateFieldSet(A.getInstance(), _field, 1); - _classPrivateFieldSet(_a = A.getInstance(), _field, _classPrivateFieldGet(_a, _field) + 2); - _classPrivateFieldSet(_b = A.getInstance(), _field, _classPrivateFieldGet(_b, _field) - 3); - _classPrivateFieldSet(_c = A.getInstance(), _field, _classPrivateFieldGet(_c, _field) / 4); - _classPrivateFieldSet(_d = A.getInstance(), _field, _classPrivateFieldGet(_d, _field) * 5); - _classPrivateFieldSet(_e = A.getInstance(), _field, Math.pow(_classPrivateFieldGet(_e, _field), 6)); - _classPrivateFieldSet(_f = A.getInstance(), _field, _classPrivateFieldGet(_f, _field) % 7); - _classPrivateFieldSet(_g = A.getInstance(), _field, _classPrivateFieldGet(_g, _field) << 8); - _classPrivateFieldSet(_h = A.getInstance(), _field, _classPrivateFieldGet(_h, _field) >> 9); - _classPrivateFieldSet(_j = A.getInstance(), _field, _classPrivateFieldGet(_j, _field) >>> 10); - _classPrivateFieldSet(_k = A.getInstance(), _field, _classPrivateFieldGet(_k, _field) & 11); - _classPrivateFieldSet(_l = A.getInstance(), _field, _classPrivateFieldGet(_l, _field) | 12); - _classPrivateFieldSet(_m = A.getInstance(), _field, _classPrivateFieldGet(_m, _field) ^ 13); + _classPrivateFieldSet(this, _fieldWeakMap_1, 1); + _classPrivateFieldSet(this, _fieldWeakMap_1, _classPrivateFieldGet(this, _fieldWeakMap_1) + 2); + _classPrivateFieldSet(this, _fieldWeakMap_1, _classPrivateFieldGet(this, _fieldWeakMap_1) - 3); + _classPrivateFieldSet(this, _fieldWeakMap_1, _classPrivateFieldGet(this, _fieldWeakMap_1) / 4); + _classPrivateFieldSet(this, _fieldWeakMap_1, _classPrivateFieldGet(this, _fieldWeakMap_1) * 5); + _classPrivateFieldSet(this, _fieldWeakMap_1, Math.pow(_classPrivateFieldGet(this, _fieldWeakMap_1), 6)); + _classPrivateFieldSet(this, _fieldWeakMap_1, _classPrivateFieldGet(this, _fieldWeakMap_1) % 7); + _classPrivateFieldSet(this, _fieldWeakMap_1, _classPrivateFieldGet(this, _fieldWeakMap_1) << 8); + _classPrivateFieldSet(this, _fieldWeakMap_1, _classPrivateFieldGet(this, _fieldWeakMap_1) >> 9); + _classPrivateFieldSet(this, _fieldWeakMap_1, _classPrivateFieldGet(this, _fieldWeakMap_1) >>> 10); + _classPrivateFieldSet(this, _fieldWeakMap_1, _classPrivateFieldGet(this, _fieldWeakMap_1) & 11); + _classPrivateFieldSet(this, _fieldWeakMap_1, _classPrivateFieldGet(this, _fieldWeakMap_1) | 12); + _classPrivateFieldSet(this, _fieldWeakMap_1, _classPrivateFieldGet(this, _fieldWeakMap_1) ^ 13); + _classPrivateFieldSet(A.getInstance(), _fieldWeakMap_1, 1); + _classPrivateFieldSet(_a = A.getInstance(), _fieldWeakMap_1, _classPrivateFieldGet(_a, _fieldWeakMap_1) + 2); + _classPrivateFieldSet(_b = A.getInstance(), _fieldWeakMap_1, _classPrivateFieldGet(_b, _fieldWeakMap_1) - 3); + _classPrivateFieldSet(_c = A.getInstance(), _fieldWeakMap_1, _classPrivateFieldGet(_c, _fieldWeakMap_1) / 4); + _classPrivateFieldSet(_d = A.getInstance(), _fieldWeakMap_1, _classPrivateFieldGet(_d, _fieldWeakMap_1) * 5); + _classPrivateFieldSet(_e = A.getInstance(), _fieldWeakMap_1, Math.pow(_classPrivateFieldGet(_e, _fieldWeakMap_1), 6)); + _classPrivateFieldSet(_f = A.getInstance(), _fieldWeakMap_1, _classPrivateFieldGet(_f, _fieldWeakMap_1) % 7); + _classPrivateFieldSet(_g = A.getInstance(), _fieldWeakMap_1, _classPrivateFieldGet(_g, _fieldWeakMap_1) << 8); + _classPrivateFieldSet(_h = A.getInstance(), _fieldWeakMap_1, _classPrivateFieldGet(_h, _fieldWeakMap_1) >> 9); + _classPrivateFieldSet(_j = A.getInstance(), _fieldWeakMap_1, _classPrivateFieldGet(_j, _fieldWeakMap_1) >>> 10); + _classPrivateFieldSet(_k = A.getInstance(), _fieldWeakMap_1, _classPrivateFieldGet(_k, _fieldWeakMap_1) & 11); + _classPrivateFieldSet(_l = A.getInstance(), _fieldWeakMap_1, _classPrivateFieldGet(_l, _fieldWeakMap_1) | 12); + _classPrivateFieldSet(_m = A.getInstance(), _fieldWeakMap_1, _classPrivateFieldGet(_m, _fieldWeakMap_1) ^ 13); } A.getInstance = function () { return new A(); }; return A; }()); -_field = new WeakMap(); +_fieldWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameFieldCallExpression.js b/tests/baselines/reference/privateNameFieldCallExpression.js index b1b1260faee53..ec548bc95a422 100644 --- a/tests/baselines/reference/privateNameFieldCallExpression.js +++ b/tests/baselines/reference/privateNameFieldCallExpression.js @@ -12,18 +12,18 @@ class A { //// [privateNameFieldCallExpression.js] var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; -var _fieldFunc; +var _fieldFuncWeakMap_1; var A = /** @class */ (function () { function A() { var _this = this; - _fieldFunc.set(this, function () { return _this.x = 10; }); + _fieldFuncWeakMap_1.set(this, function () { return _this.x = 10; }); this.x = 1; } A.prototype.test = function () { - _classPrivateFieldGet(this, _fieldFunc).call(this); - var func = _classPrivateFieldGet(this, _fieldFunc); + _classPrivateFieldGet(this, _fieldFuncWeakMap_1).call(this); + var func = _classPrivateFieldGet(this, _fieldFuncWeakMap_1); func(); }; return A; }()); -_fieldFunc = new WeakMap(); +_fieldFuncWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameFieldDeclaration.js b/tests/baselines/reference/privateNameFieldDeclaration.js new file mode 100644 index 0000000000000..1b362003ba7b8 --- /dev/null +++ b/tests/baselines/reference/privateNameFieldDeclaration.js @@ -0,0 +1,15 @@ +//// [privateNameFieldDeclaration.ts] +class A { + #name: string; +} + + +//// [privateNameFieldDeclaration.js] +var _nameWeakMap_1; +var A = /** @class */ (function () { + function A() { + _nameWeakMap_1.set(this, void 0); + } + return A; +}()); +_nameWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameFieldDeclaration.symbols b/tests/baselines/reference/privateNameFieldDeclaration.symbols new file mode 100644 index 0000000000000..32a40fa42b89a --- /dev/null +++ b/tests/baselines/reference/privateNameFieldDeclaration.symbols @@ -0,0 +1,8 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameFieldDeclaration.ts === +class A { +>A : Symbol(A, Decl(privateNameFieldDeclaration.ts, 0, 0)) + + #name: string; +>#name : Symbol(A.#name, Decl(privateNameFieldDeclaration.ts, 0, 9)) +} + diff --git a/tests/baselines/reference/privateNameFieldDeclaration.types b/tests/baselines/reference/privateNameFieldDeclaration.types new file mode 100644 index 0000000000000..ce6312a793ea6 --- /dev/null +++ b/tests/baselines/reference/privateNameFieldDeclaration.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameFieldDeclaration.ts === +class A { +>A : A + + #name: string; +>#name : string +} + diff --git a/tests/baselines/reference/privateNameFieldDestructuredBinding.js b/tests/baselines/reference/privateNameFieldDestructuredBinding.js index dadf60bab9d08..c17ab70b39fd2 100644 --- a/tests/baselines/reference/privateNameFieldDestructuredBinding.js +++ b/tests/baselines/reference/privateNameFieldDestructuredBinding.js @@ -17,14 +17,14 @@ class A { //// [privateNameFieldDestructuredBinding.js] var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; -var _field; +var _fieldWeakMap_1; var A = /** @class */ (function () { function A() { var _a, _b; - _field.set(this, 1); + _fieldWeakMap_1.set(this, 1); var y; - (_a = this.testObject(), { set value(x) { _classPrivateFieldSet(this, _field, x); } }.value = _a.x, y = _a.y); - (_b = this.testArray(), { set value(x) { _classPrivateFieldSet(this, _field, x); } }.value = _b[0], y = _b[1]); + (_a = this.testObject(), { set value(x) { _classPrivateFieldSet(this, _fieldWeakMap_1, x); } }.value = _a.x, y = _a.y); + (_b = this.testArray(), { set value(x) { _classPrivateFieldSet(this, _fieldWeakMap_1, x); } }.value = _b[0], y = _b[1]); } A.prototype.testObject = function () { return { x: 10, y: 6 }; @@ -34,4 +34,4 @@ var A = /** @class */ (function () { }; return A; }()); -_field = new WeakMap(); +_fieldWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameFieldInitializer.js b/tests/baselines/reference/privateNameFieldInitializer.js index 8f40b98bb096e..d3162f7fbfb2a 100644 --- a/tests/baselines/reference/privateNameFieldInitializer.js +++ b/tests/baselines/reference/privateNameFieldInitializer.js @@ -6,12 +6,12 @@ class A { //// [privateNameFieldInitializer.js] -var _field, _uninitialized; +var _fieldWeakMap_1, _uninitializedWeakMap_1; var A = /** @class */ (function () { function A() { - _field.set(this, 10); - _uninitialized.set(this, void 0); + _fieldWeakMap_1.set(this, 10); + _uninitializedWeakMap_1.set(this, void 0); } return A; }()); -_field = new WeakMap(), _uninitialized = new WeakMap(); +_fieldWeakMap_1 = new WeakMap(), _uninitializedWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameFieldUnaryMutation.js b/tests/baselines/reference/privateNameFieldUnaryMutation.js index e3fb0956b41dd..2c96670c12922 100644 --- a/tests/baselines/reference/privateNameFieldUnaryMutation.js +++ b/tests/baselines/reference/privateNameFieldUnaryMutation.js @@ -20,24 +20,24 @@ class C { //// [privateNameFieldUnaryMutation.js] var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; -var _test; +var _testWeakMap_1; var C = /** @class */ (function () { function C() { - _test.set(this, 24); + _testWeakMap_1.set(this, 24); var _a, _b; - _a = _classPrivateFieldGet(this, _test), _classPrivateFieldSet(this, _test, _a + 1), _a; - _b = _classPrivateFieldGet(this, _test), _classPrivateFieldSet(this, _test, _b - 1), _b; - _classPrivateFieldSet(this, _test, _classPrivateFieldGet(this, _test) + 1); - _classPrivateFieldSet(this, _test, _classPrivateFieldGet(this, _test) - 1); + _a = _classPrivateFieldGet(this, _testWeakMap_1), _classPrivateFieldSet(this, _testWeakMap_1, _a + 1), _a; + _b = _classPrivateFieldGet(this, _testWeakMap_1), _classPrivateFieldSet(this, _testWeakMap_1, _b - 1), _b; + _classPrivateFieldSet(this, _testWeakMap_1, _classPrivateFieldGet(this, _testWeakMap_1) + 1); + _classPrivateFieldSet(this, _testWeakMap_1, _classPrivateFieldGet(this, _testWeakMap_1) - 1); } C.prototype.test = function () { var _a, _b, _c, _d, _e, _f; - _a = this.getInstance(), _b = _classPrivateFieldGet(_a, _test), _classPrivateFieldSet(_a, _test, _b + 1), _b; - _c = this.getInstance(), _d = _classPrivateFieldGet(_c, _test), _classPrivateFieldSet(_c, _test, _d - 1), _d; - _classPrivateFieldSet(_e = this.getInstance(), _test, _classPrivateFieldGet(_e, _test) + 1); - _classPrivateFieldSet(_f = this.getInstance(), _test, _classPrivateFieldGet(_f, _test) - 1); + _a = this.getInstance(), _b = _classPrivateFieldGet(_a, _testWeakMap_1), _classPrivateFieldSet(_a, _testWeakMap_1, _b + 1), _b; + _c = this.getInstance(), _d = _classPrivateFieldGet(_c, _testWeakMap_1), _classPrivateFieldSet(_c, _testWeakMap_1, _d - 1), _d; + _classPrivateFieldSet(_e = this.getInstance(), _testWeakMap_1, _classPrivateFieldGet(_e, _testWeakMap_1) + 1); + _classPrivateFieldSet(_f = this.getInstance(), _testWeakMap_1, _classPrivateFieldGet(_f, _testWeakMap_1) - 1); }; C.prototype.getInstance = function () { return new C(); }; return C; }()); -_test = new WeakMap(); +_testWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameInObjectLiteral-2.js b/tests/baselines/reference/privateNameInObjectLiteral-2.js index 6bb2c99d4c169..2af0689754d9d 100644 --- a/tests/baselines/reference/privateNameInObjectLiteral-2.js +++ b/tests/baselines/reference/privateNameInObjectLiteral-2.js @@ -7,7 +7,4 @@ const obj = { //// [privateNameInObjectLiteral-2.js] -var obj = { - #foo: function () { - } -}; +var obj = {}; diff --git a/tests/baselines/reference/privateNameNestedClassNameConflict.js b/tests/baselines/reference/privateNameNestedClassNameConflict.js index d8e0e240a7a6b..d3c26b03666cb 100644 --- a/tests/baselines/reference/privateNameNestedClassNameConflict.js +++ b/tests/baselines/reference/privateNameNestedClassNameConflict.js @@ -10,19 +10,19 @@ class A { //// [privateNameNestedClassNameConflict.js] -var _foo; +var _fooWeakMap_1; var A = /** @class */ (function () { function A() { - _foo.set(this, void 0); - var _foo_1; + _fooWeakMap_1.set(this, void 0); + var _fooWeakMap_2; var A = /** @class */ (function () { function A() { - _foo_1.set(this, void 0); + _fooWeakMap_2.set(this, void 0); } return A; }()); - _foo_1 = new WeakMap(); + _fooWeakMap_2 = new WeakMap(); } return A; }()); -_foo = new WeakMap(); +_fooWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.js b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.js index 655f3c7c55d37..098f116052536 100644 --- a/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.js +++ b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.js @@ -10,13 +10,13 @@ new A().#foo = 4; // Error //// [privateNameNotAccessibleOutsideDefiningClass.js] // @target es6 -var _foo; +var _fooWeakMap_1; "use strict"; var A = /** @class */ (function () { function A() { - _foo.set(this, 3); + _fooWeakMap_1.set(this, 3); } return A; }()); -_foo = new WeakMap(); +_fooWeakMap_1 = new WeakMap(); new A().#foo = 4; // Error diff --git a/tests/baselines/reference/privateNameSneakyRuntimeException.js b/tests/baselines/reference/privateNameSneakyRuntimeException.js index e437f4da29fb5..ae9bc9d07d4d4 100644 --- a/tests/baselines/reference/privateNameSneakyRuntimeException.js +++ b/tests/baselines/reference/privateNameSneakyRuntimeException.js @@ -22,17 +22,17 @@ console.log(a.equals(b)); // OK at compile time but will be a runtime error var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; function createClass() { - var _foo, _a; + var _fooWeakMap_1, _a; return _a = /** @class */ (function () { function class_1() { - _foo.set(this, 3); + _fooWeakMap_1.set(this, 3); } class_1.prototype.equals = function (other) { - return _classPrivateFieldSet(this, _foo, _classPrivateFieldGet(other, _foo)); + return _classPrivateFieldSet(this, _fooWeakMap_1, _classPrivateFieldGet(other, _fooWeakMap_1)); }; return class_1; }()), - _foo = new WeakMap(), + _fooWeakMap_1 = new WeakMap(), _a; } var a = new (createClass())(); diff --git a/tests/baselines/reference/privateNamedMemberOrder.js b/tests/baselines/reference/privateNamedMemberOrder.js new file mode 100644 index 0000000000000..65cab60e4679c --- /dev/null +++ b/tests/baselines/reference/privateNamedMemberOrder.js @@ -0,0 +1,24 @@ +//// [privateNamedMemberOrder.ts] +class A { + #foo: () => 1; + #bar() { + return this.#foo; + } + baz = this.#bar(); +} + +//// [privateNamedMemberOrder.js] +var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; +function _classPrivateNamedMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; } +var _fooWeakMap_1, _bar_1, _barWeakSet_1; +var A = /** @class */ (function () { + function A() { + _barWeakSet_1.add(this); + _fooWeakMap_1.set(this, void 0); + this.baz = _classPrivateNamedMethodGet(this, _barWeakSet_1, _bar_1).call(this); + } + return A; +}()); +_fooWeakMap_1 = new WeakMap(), _barWeakSet_1 = new WeakSet(), _bar_1 = function _bar_1() { + return _classPrivateFieldGet(this, _fooWeakMap_1); +}; diff --git a/tests/baselines/reference/privateNamedMemberOrder.symbols b/tests/baselines/reference/privateNamedMemberOrder.symbols new file mode 100644 index 0000000000000..04e3f3f58eacc --- /dev/null +++ b/tests/baselines/reference/privateNamedMemberOrder.symbols @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamedMemberOrder.ts === +class A { +>A : Symbol(A, Decl(privateNamedMemberOrder.ts, 0, 0)) + + #foo: () => 1; +>#foo : Symbol(A.#foo, Decl(privateNamedMemberOrder.ts, 0, 9)) + + #bar() { +>#bar : Symbol(A.#bar, Decl(privateNamedMemberOrder.ts, 1, 18)) + + return this.#foo; +>this.#foo : Symbol(A.#foo, Decl(privateNamedMemberOrder.ts, 0, 9)) +>this : Symbol(A, Decl(privateNamedMemberOrder.ts, 0, 0)) + } + baz = this.#bar(); +>baz : Symbol(A.baz, Decl(privateNamedMemberOrder.ts, 4, 5)) +>this.#bar : Symbol(A.#bar, Decl(privateNamedMemberOrder.ts, 1, 18)) +>this : Symbol(A, Decl(privateNamedMemberOrder.ts, 0, 0)) +} diff --git a/tests/baselines/reference/privateNamedMemberOrder.types b/tests/baselines/reference/privateNamedMemberOrder.types new file mode 100644 index 0000000000000..023f37488348f --- /dev/null +++ b/tests/baselines/reference/privateNamedMemberOrder.types @@ -0,0 +1,20 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamedMemberOrder.ts === +class A { +>A : A + + #foo: () => 1; +>#foo : () => 1 + + #bar() { +>#bar : () => () => 1 + + return this.#foo; +>this.#foo : () => 1 +>this : this + } + baz = this.#bar(); +>baz : () => 1 +>this.#bar() : () => 1 +>this.#bar : () => () => 1 +>this : this +} diff --git a/tests/baselines/reference/privateNamedMethod.js b/tests/baselines/reference/privateNamedMethod.js new file mode 100644 index 0000000000000..dae02ef94010d --- /dev/null +++ b/tests/baselines/reference/privateNamedMethod.js @@ -0,0 +1,51 @@ +//// [privateNamedMethod.ts] +class A { + #foo = "hello"; + #log(name: string) { + console.log(this.#foo); + console.log(name); + } + #logIfTallEnough(height: number, name: string) { + if (height >= 50) { + this.#log(name); + } + } + #logAll(height: number, ...names: string[]) { + for (const name of names) { + this.#logIfTallEnough(height, name); + } + } + constructor() { + this.#logIfTallEnough(100, "world"); + this.#logAll(100, ...["a", "b", "c"]); + } +} + + +//// [privateNamedMethod.js] +var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; +function _classPrivateNamedMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; } +var _fooWeakMap_1, _log_1, _logWeakSet_1, _logIfTallEnough_1, _logIfTallEnoughWeakSet_1, _logAll_1, _logAllWeakSet_1; +"use strict"; +class A { + constructor() { + _logWeakSet_1.add(this); + _logIfTallEnoughWeakSet_1.add(this); + _logAllWeakSet_1.add(this); + _fooWeakMap_1.set(this, "hello"); + _classPrivateNamedMethodGet(this, _logIfTallEnoughWeakSet_1, _logIfTallEnough_1).call(this, 100, "world"); + _classPrivateNamedMethodGet(this, _logAllWeakSet_1, _logAll_1).call(this, 100, ...["a", "b", "c"]); + } +} +_fooWeakMap_1 = new WeakMap(), _logWeakSet_1 = new WeakSet(), _logIfTallEnoughWeakSet_1 = new WeakSet(), _logAllWeakSet_1 = new WeakSet(), _log_1 = function _log_1(name) { + console.log(_classPrivateFieldGet(this, _fooWeakMap_1)); + console.log(name); +}, _logIfTallEnough_1 = function _logIfTallEnough_1(height, name) { + if (height >= 50) { + _classPrivateNamedMethodGet(this, _logWeakSet_1, _log_1).call(this, name); + } +}, _logAll_1 = function _logAll_1(height, ...names) { + for (const name of names) { + _classPrivateNamedMethodGet(this, _logIfTallEnoughWeakSet_1, _logIfTallEnough_1).call(this, height, name); + } +}; diff --git a/tests/baselines/reference/privateNamedMethod.symbols b/tests/baselines/reference/privateNamedMethod.symbols new file mode 100644 index 0000000000000..c1fe446ab25ff --- /dev/null +++ b/tests/baselines/reference/privateNamedMethod.symbols @@ -0,0 +1,65 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamedMethod.ts === +class A { +>A : Symbol(A, Decl(privateNamedMethod.ts, 0, 0)) + + #foo = "hello"; +>#foo : Symbol(A.#foo, Decl(privateNamedMethod.ts, 0, 9)) + + #log(name: string) { +>#log : Symbol(A.#log, Decl(privateNamedMethod.ts, 1, 19)) +>name : Symbol(name, Decl(privateNamedMethod.ts, 2, 9)) + + console.log(this.#foo); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>this.#foo : Symbol(A.#foo, Decl(privateNamedMethod.ts, 0, 9)) +>this : Symbol(A, Decl(privateNamedMethod.ts, 0, 0)) + + console.log(name); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>name : Symbol(name, Decl(privateNamedMethod.ts, 2, 9)) + } + #logIfTallEnough(height: number, name: string) { +>#logIfTallEnough : Symbol(A.#logIfTallEnough, Decl(privateNamedMethod.ts, 5, 5)) +>height : Symbol(height, Decl(privateNamedMethod.ts, 6, 21)) +>name : Symbol(name, Decl(privateNamedMethod.ts, 6, 36)) + + if (height >= 50) { +>height : Symbol(height, Decl(privateNamedMethod.ts, 6, 21)) + + this.#log(name); +>this.#log : Symbol(A.#log, Decl(privateNamedMethod.ts, 1, 19)) +>this : Symbol(A, Decl(privateNamedMethod.ts, 0, 0)) +>name : Symbol(name, Decl(privateNamedMethod.ts, 6, 36)) + } + } + #logAll(height: number, ...names: string[]) { +>#logAll : Symbol(A.#logAll, Decl(privateNamedMethod.ts, 10, 5)) +>height : Symbol(height, Decl(privateNamedMethod.ts, 11, 12)) +>names : Symbol(names, Decl(privateNamedMethod.ts, 11, 27)) + + for (const name of names) { +>name : Symbol(name, Decl(privateNamedMethod.ts, 12, 18)) +>names : Symbol(names, Decl(privateNamedMethod.ts, 11, 27)) + + this.#logIfTallEnough(height, name); +>this.#logIfTallEnough : Symbol(A.#logIfTallEnough, Decl(privateNamedMethod.ts, 5, 5)) +>this : Symbol(A, Decl(privateNamedMethod.ts, 0, 0)) +>height : Symbol(height, Decl(privateNamedMethod.ts, 11, 12)) +>name : Symbol(name, Decl(privateNamedMethod.ts, 12, 18)) + } + } + constructor() { + this.#logIfTallEnough(100, "world"); +>this.#logIfTallEnough : Symbol(A.#logIfTallEnough, Decl(privateNamedMethod.ts, 5, 5)) +>this : Symbol(A, Decl(privateNamedMethod.ts, 0, 0)) + + this.#logAll(100, ...["a", "b", "c"]); +>this.#logAll : Symbol(A.#logAll, Decl(privateNamedMethod.ts, 10, 5)) +>this : Symbol(A, Decl(privateNamedMethod.ts, 0, 0)) + } +} + diff --git a/tests/baselines/reference/privateNamedMethod.types b/tests/baselines/reference/privateNamedMethod.types new file mode 100644 index 0000000000000..f863bfae9f11e --- /dev/null +++ b/tests/baselines/reference/privateNamedMethod.types @@ -0,0 +1,82 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamedMethod.ts === +class A { +>A : A + + #foo = "hello"; +>#foo : string +>"hello" : "hello" + + #log(name: string) { +>#log : (name: string) => void +>name : string + + console.log(this.#foo); +>console.log(this.#foo) : void +>console.log : (message?: any, ...optionalParams: any[]) => void +>console : Console +>log : (message?: any, ...optionalParams: any[]) => void +>this.#foo : string +>this : this + + console.log(name); +>console.log(name) : void +>console.log : (message?: any, ...optionalParams: any[]) => void +>console : Console +>log : (message?: any, ...optionalParams: any[]) => void +>name : string + } + #logIfTallEnough(height: number, name: string) { +>#logIfTallEnough : (height: number, name: string) => void +>height : number +>name : string + + if (height >= 50) { +>height >= 50 : boolean +>height : number +>50 : 50 + + this.#log(name); +>this.#log(name) : void +>this.#log : (name: string) => void +>this : this +>name : string + } + } + #logAll(height: number, ...names: string[]) { +>#logAll : (height: number, ...names: string[]) => void +>height : number +>names : string[] + + for (const name of names) { +>name : string +>names : string[] + + this.#logIfTallEnough(height, name); +>this.#logIfTallEnough(height, name) : void +>this.#logIfTallEnough : (height: number, name: string) => void +>this : this +>height : number +>name : string + } + } + constructor() { + this.#logIfTallEnough(100, "world"); +>this.#logIfTallEnough(100, "world") : void +>this.#logIfTallEnough : (height: number, name: string) => void +>this : this +>100 : 100 +>"world" : "world" + + this.#logAll(100, ...["a", "b", "c"]); +>this.#logAll(100, ...["a", "b", "c"]) : void +>this.#logAll : (height: number, ...names: string[]) => void +>this : this +>100 : 100 +>...["a", "b", "c"] : string +>["a", "b", "c"] : string[] +>"a" : "a" +>"b" : "b" +>"c" : "c" + } +} + diff --git a/tests/baselines/reference/privateNamedMethodOrder.js b/tests/baselines/reference/privateNamedMethodOrder.js new file mode 100644 index 0000000000000..ef33ee0f1d74b --- /dev/null +++ b/tests/baselines/reference/privateNamedMethodOrder.js @@ -0,0 +1,29 @@ +//// [privateNamedMethodOrder.ts] +class A { + static bar: A | undefined = new A("max"); + #foo() { + A.bar = undefined + } + constructor (public name: string) { + this.#foo() + console.log(this) + } +} + + +//// [privateNamedMethodOrder.js] +function _classPrivateNamedMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; } +var _foo_1, _fooWeakSet_1; +"use strict"; +class A { + constructor(name) { + _fooWeakSet_1.add(this); + this.name = name; + _classPrivateNamedMethodGet(this, _fooWeakSet_1, _foo_1).call(this); + console.log(this); + } +} +_fooWeakSet_1 = new WeakSet(), _foo_1 = function _foo_1() { + A.bar = undefined; +}; +A.bar = new A("max"); diff --git a/tests/baselines/reference/privateNamedMethodOrder.symbols b/tests/baselines/reference/privateNamedMethodOrder.symbols new file mode 100644 index 0000000000000..60cca8d512f34 --- /dev/null +++ b/tests/baselines/reference/privateNamedMethodOrder.symbols @@ -0,0 +1,33 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamedMethodOrder.ts === +class A { +>A : Symbol(A, Decl(privateNamedMethodOrder.ts, 0, 0)) + + static bar: A | undefined = new A("max"); +>bar : Symbol(A.bar, Decl(privateNamedMethodOrder.ts, 0, 9)) +>A : Symbol(A, Decl(privateNamedMethodOrder.ts, 0, 0)) +>A : Symbol(A, Decl(privateNamedMethodOrder.ts, 0, 0)) + + #foo() { +>#foo : Symbol(A.#foo, Decl(privateNamedMethodOrder.ts, 1, 45)) + + A.bar = undefined +>A.bar : Symbol(A.bar, Decl(privateNamedMethodOrder.ts, 0, 9)) +>A : Symbol(A, Decl(privateNamedMethodOrder.ts, 0, 0)) +>bar : Symbol(A.bar, Decl(privateNamedMethodOrder.ts, 0, 9)) +>undefined : Symbol(undefined) + } + constructor (public name: string) { +>name : Symbol(A.name, Decl(privateNamedMethodOrder.ts, 5, 17)) + + this.#foo() +>this.#foo : Symbol(A.#foo, Decl(privateNamedMethodOrder.ts, 1, 45)) +>this : Symbol(A, Decl(privateNamedMethodOrder.ts, 0, 0)) + + console.log(this) +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>this : Symbol(A, Decl(privateNamedMethodOrder.ts, 0, 0)) + } +} + diff --git a/tests/baselines/reference/privateNamedMethodOrder.types b/tests/baselines/reference/privateNamedMethodOrder.types new file mode 100644 index 0000000000000..b35a689c544e4 --- /dev/null +++ b/tests/baselines/reference/privateNamedMethodOrder.types @@ -0,0 +1,37 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamedMethodOrder.ts === +class A { +>A : A + + static bar: A | undefined = new A("max"); +>bar : A | undefined +>new A("max") : A +>A : typeof A +>"max" : "max" + + #foo() { +>#foo : () => void + + A.bar = undefined +>A.bar = undefined : undefined +>A.bar : A | undefined +>A : typeof A +>bar : A | undefined +>undefined : undefined + } + constructor (public name: string) { +>name : string + + this.#foo() +>this.#foo() : void +>this.#foo : () => void +>this : this + + console.log(this) +>console.log(this) : void +>console.log : (message?: any, ...optionalParams: any[]) => void +>console : Console +>log : (message?: any, ...optionalParams: any[]) => void +>this : this + } +} + diff --git a/tests/baselines/reference/privateNamesAndDecorators.js b/tests/baselines/reference/privateNamesAndDecorators.js index 3e2e760933e12..e18ff2fd0e778 100644 --- a/tests/baselines/reference/privateNamesAndDecorators.js +++ b/tests/baselines/reference/privateNamesAndDecorators.js @@ -10,12 +10,12 @@ class A { //// [privateNamesAndDecorators.js] -var _foo; +var _fooWeakMap_1, _bar_1, _barWeakSet_1; var A = /** @class */ (function () { function A() { - _foo.set(this, 1); + _barWeakSet_1.add(this); + _fooWeakMap_1.set(this, 1); } - A.prototype.#bar = function () { }; return A; }()); -_foo = new WeakMap(); +_fooWeakMap_1 = new WeakMap(), _barWeakSet_1 = new WeakSet(), _bar_1 = function _bar_1() { }; diff --git a/tests/baselines/reference/privateNamesAndFields.js b/tests/baselines/reference/privateNamesAndFields.js index 4af48cfe9b245..52c0e64134978 100644 --- a/tests/baselines/reference/privateNamesAndFields.js +++ b/tests/baselines/reference/privateNamesAndFields.js @@ -33,24 +33,24 @@ var __extends = (this && this.__extends) || (function () { }; })(); var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; -var _foo, _foo_1; +var _fooWeakMap_1, _fooWeakMap_2; "use strict"; var A = /** @class */ (function () { function A() { - _foo.set(this, void 0); - _classPrivateFieldSet(this, _foo, 3); + _fooWeakMap_1.set(this, void 0); + _classPrivateFieldSet(this, _fooWeakMap_1, 3); } return A; }()); -_foo = new WeakMap(); +_fooWeakMap_1 = new WeakMap(); var B = /** @class */ (function (_super) { __extends(B, _super); function B() { var _this = _super.call(this) || this; - _foo_1.set(_this, void 0); - _classPrivateFieldSet(_this, _foo_1, "some string"); + _fooWeakMap_2.set(_this, void 0); + _classPrivateFieldSet(_this, _fooWeakMap_2, "some string"); return _this; } return B; }(A)); -_foo_1 = new WeakMap(); +_fooWeakMap_2 = new WeakMap(); diff --git a/tests/baselines/reference/privateNamesAndGenericClasses-2.js b/tests/baselines/reference/privateNamesAndGenericClasses-2.js index 972af4a681e20..3478c76d9024a 100644 --- a/tests/baselines/reference/privateNamesAndGenericClasses-2.js +++ b/tests/baselines/reference/privateNamesAndGenericClasses-2.js @@ -28,27 +28,28 @@ b = a; // Error //// [privateNamesAndGenericClasses-2.js] -var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; -var _foo; +var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; +function _classPrivateNamedMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; } +var _fooWeakMap_1, _bar_1, _barWeakSet_1; "use strict"; class C { constructor(t) { - _foo.set(this, void 0); - _classPrivateFieldSet(this, _foo, t); - t = this.#bar.call(this); - } - #bar() { - return _classPrivateFieldGet(this, _foo); + _barWeakSet_1.add(this); + _fooWeakMap_1.set(this, void 0); + _classPrivateFieldSet(this, _fooWeakMap_1, t); + t = _classPrivateNamedMethodGet(this, _barWeakSet_1, _bar_1).call(this); } set baz(t) { - _classPrivateFieldSet(this, _foo, t); + _classPrivateFieldSet(this, _fooWeakMap_1, t); } get baz() { - return _classPrivateFieldGet(this, _foo); + return _classPrivateFieldGet(this, _fooWeakMap_1); } } -_foo = new WeakMap(); +_fooWeakMap_1 = new WeakMap(), _barWeakSet_1 = new WeakSet(), _bar_1 = function _bar_1() { + return _classPrivateFieldGet(this, _fooWeakMap_1); +}; let a = new C(3); let b = new C("hello"); a.baz = 5; // OK diff --git a/tests/baselines/reference/privateNamesAndIndexedAccess.js b/tests/baselines/reference/privateNamesAndIndexedAccess.js index 44dde9629a8c6..ef9bfa0576793 100644 --- a/tests/baselines/reference/privateNamesAndIndexedAccess.js +++ b/tests/baselines/reference/privateNamesAndIndexedAccess.js @@ -13,13 +13,13 @@ class C { //// [privateNamesAndIndexedAccess.js] -var _bar, _bar_1; +var _barWeakMap_1, _barWeakMap_2; "use strict"; class C { constructor() { this.foo = 3; - _bar_1.set(this, 3); - _bar_1.set(this, void 0); + _barWeakMap_2.set(this, 3); + _barWeakMap_2.set(this, void 0); // will never use this syntax, already taken: this.badAlways = 3; // Error const ok = 3; @@ -27,4 +27,4 @@ class C { const badForNow; } } -_bar = new WeakMap(), _bar_1 = new WeakMap(); +_barWeakMap_1 = new WeakMap(), _barWeakMap_2 = new WeakMap(); diff --git a/tests/baselines/reference/privateNamesAndMethods.js b/tests/baselines/reference/privateNamesAndMethods.js index 7cb222a061164..fa25328427a19 100644 --- a/tests/baselines/reference/privateNamesAndMethods.js +++ b/tests/baselines/reference/privateNamesAndMethods.js @@ -31,35 +31,37 @@ class B extends A { //// [privateNamesAndMethods.js] +function _classPrivateNamedMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; } var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; -var __quux; +var _foo_1, _fooWeakSet_1, _bar_1, _barWeakSet_1, _baz_1, _bazWeakSet_1, __quuxWeakMap_1, _foo_2, _fooWeakSet_2; class A { constructor() { - __quux.set(this, void 0); - this.#foo.call(this, 30); - this.#bar.call(this, 30); - this.#bar.call(this, 30); + _fooWeakSet_1.add(this); + _barWeakSet_1.add(this); + _bazWeakSet_1.add(this); + __quuxWeakMap_1.set(this, void 0); + _classPrivateNamedMethodGet(this, _fooWeakSet_1, _foo_1).call(this, 30); + _classPrivateNamedMethodGet(this, _barWeakSet_1, _bar_1).call(this, 30); + _classPrivateNamedMethodGet(this, _barWeakSet_1, _bar_1).call(this, 30); this.#quux = this.#quux + 1; this.#quux++; } - #foo(a) { } - async #bar(a) { } - async *#baz(a) { - return 3; - } get #quux() { - return _classPrivateFieldGet(this, __quux); + return _classPrivateFieldGet(this, __quuxWeakMap_1); } set #quux(val) { - _classPrivateFieldSet(this, __quux, val); + _classPrivateFieldSet(this, __quuxWeakMap_1, val); } } -__quux = new WeakMap(); +_fooWeakSet_1 = new WeakSet(), _barWeakSet_1 = new WeakSet(), _bazWeakSet_1 = new WeakSet(), __quuxWeakMap_1 = new WeakMap(), _foo_1 = function _foo_1(a) { }, _bar_1 = function _bar_1(a) { }, _baz_1 = function _baz_1(a) { + return 3; +}; class B extends A { constructor() { super(); - this.#foo.call(this, "str"); + _fooWeakSet_2.add(this); + _classPrivateNamedMethodGet(this, _fooWeakSet_2, _foo_2).call(this, "str"); } - #foo(a) { } } +_fooWeakSet_2 = new WeakSet(), _foo_2 = function _foo_2(a) { }; diff --git a/tests/baselines/reference/privateNamesAndStaticFields.js b/tests/baselines/reference/privateNamesAndStaticFields.js index 7beaa98bdb674..00f1c5fbe5a0a 100644 --- a/tests/baselines/reference/privateNamesAndStaticFields.js +++ b/tests/baselines/reference/privateNamesAndStaticFields.js @@ -18,6 +18,7 @@ class B extends A { //// [privateNamesAndStaticFields.js] +"use strict"; // @target es6 var __extends = (this && this.__extends) || (function () { var extendStatics = function (d, b) { @@ -32,23 +33,18 @@ var __extends = (this && this.__extends) || (function () { d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; })(); -var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; -var _foo, _foo_1; -"use strict"; var A = /** @class */ (function () { function A() { - _classPrivateFieldSet(A, _foo, 3); + A.#foo = 3; } return A; }()); -_foo = new WeakMap(); var B = /** @class */ (function (_super) { __extends(B, _super); function B() { var _this = _super.call(this) || this; - _classPrivateFieldSet(B, _foo_1, "some string"); + B.#foo = "some string"; return _this; } return B; }(A)); -_foo_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNamesAndStaticMethods.js b/tests/baselines/reference/privateNamesAndStaticMethods.js index b021f6a606635..c1f05dbca087a 100644 --- a/tests/baselines/reference/privateNamesAndStaticMethods.js +++ b/tests/baselines/reference/privateNamesAndStaticMethods.js @@ -31,9 +31,6 @@ class B extends A { //// [privateNamesAndStaticMethods.js] -var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; -var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; -var __quux; "use strict"; class A { constructor() { @@ -44,24 +41,17 @@ class A { A.#quux = A.#quux + 1; A.#quux++; } - static #foo(a) { } - static async #bar(a) { } - static async *#baz(a) { - return 3; - } static get #quux() { - return _classPrivateFieldGet(this, __quux); + return this.#_quux; } static set #quux(val) { - _classPrivateFieldSet(this, __quux, val); + this.#_quux = val; } } -__quux = new WeakMap(); class B extends A { constructor() { var _a; super(); (_a = B).#foo.call(_a, "str"); } - static #foo(a) { } } diff --git a/tests/baselines/reference/privateNamesAndkeyof.js b/tests/baselines/reference/privateNamesAndkeyof.js index eeaade8458fc7..f1916d1f27448 100644 --- a/tests/baselines/reference/privateNamesAndkeyof.js +++ b/tests/baselines/reference/privateNamesAndkeyof.js @@ -12,14 +12,14 @@ type T = keyof A // should not include '#foo' //// [privateNamesAndkeyof.js] // @target es6 -var _foo; +var _fooWeakMap_1; "use strict"; var A = /** @class */ (function () { function A() { - _foo.set(this, 3); + _fooWeakMap_1.set(this, 3); this.bar = 3; this.baz = 3; } return A; }()); -_foo = new WeakMap(); +_fooWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNamesInGenericClasses.js b/tests/baselines/reference/privateNamesInGenericClasses.js index e92f777e3b673..8c35798c37cff 100644 --- a/tests/baselines/reference/privateNamesInGenericClasses.js +++ b/tests/baselines/reference/privateNamesInGenericClasses.js @@ -15,17 +15,17 @@ b = a; // Error //// [privateNamesInGenericClasses.js] var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; -var _foo; +var _fooWeakMap_1; "use strict"; class C { constructor() { - _foo.set(this, void 0); + _fooWeakMap_1.set(this, void 0); } - bar(x) { return _classPrivateFieldGet(x, _foo); } // OK - baz(x) { return _classPrivateFieldGet(x, _foo); } // OK - quux(x) { return _classPrivateFieldGet(x, _foo); } // OK + bar(x) { return _classPrivateFieldGet(x, _fooWeakMap_1); } // OK + baz(x) { return _classPrivateFieldGet(x, _fooWeakMap_1); } // OK + quux(x) { return _classPrivateFieldGet(x, _fooWeakMap_1); } // OK } -_foo = new WeakMap(); +_fooWeakMap_1 = new WeakMap(); a.#foo; // Error a = b; // Error b = a; // Error diff --git a/tests/baselines/reference/privateNamesInNestedClasses.js b/tests/baselines/reference/privateNamesInNestedClasses.js index 021528ae47be5..53865f34c01ab 100644 --- a/tests/baselines/reference/privateNamesInNestedClasses.js +++ b/tests/baselines/reference/privateNamesInNestedClasses.js @@ -30,31 +30,31 @@ new A().method(); //// [privateNamesInNestedClasses.js] // @target es6 var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; -var _foo, _bar; +var _fooWeakMap_1, _barWeakMap_1; "use strict"; var A = /** @class */ (function () { function A() { - _foo.set(this, "A's #foo"); - _bar.set(this, "A's #bar"); + _fooWeakMap_1.set(this, "A's #foo"); + _barWeakMap_1.set(this, "A's #bar"); } A.prototype.method = function () { - var _foo_1; + var _fooWeakMap_2; var B = /** @class */ (function () { function B() { - _foo_1.set(this, "B's #foo"); + _fooWeakMap_2.set(this, "B's #foo"); } B.prototype.bar = function (a) { - _classPrivateFieldGet(a, _foo_1); // OK, no compile-time error, don't know what `a` is + _classPrivateFieldGet(a, _fooWeakMap_2); // OK, no compile-time error, don't know what `a` is }; B.prototype.baz = function (a) { - _classPrivateFieldGet(a, _foo_1); // compile-time error, shadowed + _classPrivateFieldGet(a, _fooWeakMap_2); // compile-time error, shadowed }; B.prototype.quux = function (b) { - _classPrivateFieldGet(b, _foo_1); // OK + _classPrivateFieldGet(b, _fooWeakMap_2); // OK }; return B; }()); - _foo_1 = new WeakMap(); + _fooWeakMap_2 = new WeakMap(); var a = new A(); new B().bar(a); new B().baz(a); @@ -63,5 +63,5 @@ var A = /** @class */ (function () { }; return A; }()); -_foo = new WeakMap(), _bar = new WeakMap(); +_fooWeakMap_1 = new WeakMap(), _barWeakMap_1 = new WeakMap(); new A().method(); diff --git a/tests/baselines/reference/privateNamesNoAccessibilityModifiers.js b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.js index 23e102b0fa7d7..33a7a5f1191d2 100644 --- a/tests/baselines/reference/privateNamesNoAccessibilityModifiers.js +++ b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.js @@ -11,15 +11,15 @@ class A { //// [privateNamesNoAccessibilityModifiers.js] // @target es6 -var _foo, _bar, _baz, _qux; +var _fooWeakMap_1, _barWeakMap_1, _bazWeakMap_1, _quxWeakMap_1; "use strict"; var A = /** @class */ (function () { function A() { - _foo.set(this, 3); // Error - _bar.set(this, 3); // Error - _baz.set(this, 3); // Error - _qux.set(this, 3); // OK + _fooWeakMap_1.set(this, 3); // Error + _barWeakMap_1.set(this, 3); // Error + _bazWeakMap_1.set(this, 3); // Error + _quxWeakMap_1.set(this, 3); // OK } return A; }()); -_foo = new WeakMap(), _bar = new WeakMap(), _baz = new WeakMap(), _qux = new WeakMap(); +_fooWeakMap_1 = new WeakMap(), _barWeakMap_1 = new WeakMap(), _bazWeakMap_1 = new WeakMap(), _quxWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNamesNoConflictWhenInheriting.js b/tests/baselines/reference/privateNamesNoConflictWhenInheriting.js index f54b9d2f8cd6d..42f21cdadf56f 100644 --- a/tests/baselines/reference/privateNamesNoConflictWhenInheriting.js +++ b/tests/baselines/reference/privateNamesNoConflictWhenInheriting.js @@ -27,23 +27,23 @@ var __extends = (this && this.__extends) || (function () { d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; })(); -var _foo, _foo_1; +var _fooWeakMap_1, _fooWeakMap_2; "use strict"; var A = /** @class */ (function () { function A() { - _foo.set(this, void 0); + _fooWeakMap_1.set(this, void 0); } return A; }()); -_foo = new WeakMap(); +_fooWeakMap_1 = new WeakMap(); var B = /** @class */ (function (_super) { __extends(B, _super); function B() { var _this = _super !== null && _super.apply(this, arguments) || this; - _foo_1.set(_this, void 0); // OK: private names are unique to each class + _fooWeakMap_2.set(_this, void 0); // OK: private names are unique to each class return _this; } return B; }(A)); -_foo_1 = new WeakMap(); +_fooWeakMap_2 = new WeakMap(); var b = new B(); // OK diff --git a/tests/baselines/reference/privateNamesNoDelete.js b/tests/baselines/reference/privateNamesNoDelete.js index b7826b3aea2f4..396a5fc608e0f 100644 --- a/tests/baselines/reference/privateNamesNoDelete.js +++ b/tests/baselines/reference/privateNamesNoDelete.js @@ -12,13 +12,13 @@ class A { //// [privateNamesNoDelete.js] // @target es6 var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; -var _v; +var _vWeakMap_1; "use strict"; var A = /** @class */ (function () { function A() { - _v.set(this, 1); - delete _classPrivateFieldGet(this, _v); // Error: The operand of a delete operator cannot be a private name. + _vWeakMap_1.set(this, 1); + delete _classPrivateFieldGet(this, _vWeakMap_1); // Error: The operand of a delete operator cannot be a private name. } return A; }()); -_v = new WeakMap(); +_vWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNamesNotAllowedAsParameters.js b/tests/baselines/reference/privateNamesNotAllowedAsParameters.js index ab41d7579b42d..538ccf4fa52c7 100644 --- a/tests/baselines/reference/privateNamesNotAllowedAsParameters.js +++ b/tests/baselines/reference/privateNamesNotAllowedAsParameters.js @@ -8,13 +8,13 @@ class A { //// [privateNamesNotAllowedAsParameters.js] // @target es6 -var _foo; +var _fooWeakMap_1; var A = /** @class */ (function () { function A() { - _foo.set(this, void 0); + _fooWeakMap_1.set(this, void 0); } A.prototype.setFoo = function () { }; return A; }()); -_foo = new WeakMap(); +_fooWeakMap_1 = new WeakMap(); { } diff --git a/tests/baselines/reference/privateNamesUnique.js b/tests/baselines/reference/privateNamesUnique.js index a55fe8af1faa1..66e2bd9d1a42e 100644 --- a/tests/baselines/reference/privateNamesUnique.js +++ b/tests/baselines/reference/privateNamesUnique.js @@ -14,20 +14,20 @@ const b: A = new B(); // Error: Property #foo is missing //// [privateNamesUnique.js] // @target es6 -var _foo, _foo_1; +var _fooWeakMap_1, _fooWeakMap_2; "use strict"; var A = /** @class */ (function () { function A() { - _foo.set(this, void 0); + _fooWeakMap_1.set(this, void 0); } return A; }()); -_foo = new WeakMap(); +_fooWeakMap_1 = new WeakMap(); var B = /** @class */ (function () { function B() { - _foo_1.set(this, void 0); + _fooWeakMap_2.set(this, void 0); } return B; }()); -_foo_1 = new WeakMap(); +_fooWeakMap_2 = new WeakMap(); var b = new B(); // Error: Property #foo is missing diff --git a/tests/cases/conformance/classes/constructorDeclarations/classConstructorParametersCommentPlacement.ts b/tests/cases/conformance/classes/constructorDeclarations/classConstructorParametersCommentPlacement.ts new file mode 100644 index 0000000000000..958d890f9c9e2 --- /dev/null +++ b/tests/cases/conformance/classes/constructorDeclarations/classConstructorParametersCommentPlacement.ts @@ -0,0 +1,8 @@ + +// some comment +class A { + #a = "private hello"; + #b = "another private name"; + a = "public property"; + constructor(private b = "something") { } +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameFieldDeclaration.ts b/tests/cases/conformance/classes/members/privateNames/privateNameFieldDeclaration.ts new file mode 100644 index 0000000000000..e66fe5d894b64 --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNameFieldDeclaration.ts @@ -0,0 +1,3 @@ +class A { + #name: string; +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamedMemberOrder.ts b/tests/cases/conformance/classes/members/privateNames/privateNamedMemberOrder.ts new file mode 100644 index 0000000000000..c12cd83f515fd --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamedMemberOrder.ts @@ -0,0 +1,7 @@ +class A { + #foo: () => 1; + #bar() { + return this.#foo; + } + baz = this.#bar(); +} \ No newline at end of file diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamedMethod.ts b/tests/cases/conformance/classes/members/privateNames/privateNamedMethod.ts new file mode 100644 index 0000000000000..5d9adfa8e2039 --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamedMethod.ts @@ -0,0 +1,24 @@ +// @strict: true +// @target: es6 + +class A { + #foo = "hello"; + #log(name: string) { + console.log(this.#foo); + console.log(name); + } + #logIfTallEnough(height: number, name: string) { + if (height >= 50) { + this.#log(name); + } + } + #logAll(height: number, ...names: string[]) { + for (const name of names) { + this.#logIfTallEnough(height, name); + } + } + constructor() { + this.#logIfTallEnough(100, "world"); + this.#logAll(100, ...["a", "b", "c"]); + } +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamedMethodOrder.ts b/tests/cases/conformance/classes/members/privateNames/privateNamedMethodOrder.ts new file mode 100644 index 0000000000000..9862ab2e74c33 --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamedMethodOrder.ts @@ -0,0 +1,14 @@ +// @strict: true +// @target: es6 + + +class A { + static bar: A | undefined = new A("max"); + #foo() { + A.bar = undefined + } + constructor (public name: string) { + this.#foo() + console.log(this) + } +} From bdc8a5554ffd1562e734097763a91c3f482a7aac Mon Sep 17 00:00:00 2001 From: Max Heiber Date: Wed, 27 Mar 2019 22:40:57 +0000 Subject: [PATCH 2/2] implement transforming private-named static fields Implement transformation for private-named fields. This turned out to be as easy as ignoring whether a private-named field is static or not. Signed-off-by: Max Heiber --- src/compiler/transformers/classProperties.ts | 38 ++-- tests/baselines/reference/privateNameField.js | 11 +- .../reference/privateNameField.symbols | 18 +- .../reference/privateNameField.types | 11 +- .../reference/privateNameFieldAccess.js | 8 +- .../reference/privateNameFieldAccess.symbols | 10 + .../reference/privateNameFieldAccess.types | 12 + .../reference/privateNameFieldAssignment.js | 66 +++++- .../privateNameFieldAssignment.symbols | 193 ++++++++++++++--- .../privateNameFieldAssignment.types | 205 ++++++++++++++++++ .../privateNameFieldCallExpression.js | 15 +- .../privateNameFieldCallExpression.symbols | 33 ++- .../privateNameFieldCallExpression.types | 27 +++ .../reference/privateNameFieldDeclaration.js | 5 +- .../privateNameFieldDeclaration.symbols | 3 + .../privateNameFieldDeclaration.types | 3 + .../privateNameFieldDestructuredBinding.js | 12 +- ...rivateNameFieldDestructuredBinding.symbols | 44 +++- .../privateNameFieldDestructuredBinding.types | 29 +++ .../reference/privateNameFieldInitializer.js | 7 +- .../privateNameFieldInitializer.symbols | 8 +- .../privateNameFieldInitializer.types | 7 + .../privateNameFieldUnaryMutation.js | 28 ++- .../privateNameFieldUnaryMutation.symbols | 67 +++++- .../privateNameFieldUnaryMutation.types | 60 +++++ .../reference/privateNamesAndStaticFields.js | 10 +- .../reference/privateNamesAndStaticMethods.js | 8 +- .../members/privateNames/privateNameField.ts | 15 +- .../privateNames/privateNameFieldAccess.ts | 14 +- .../privateNameFieldAssignment.ts | 98 ++++++--- .../privateNameFieldCallExpression.ts | 23 +- .../privateNameFieldDeclaration.ts | 1 + .../privateNameFieldDestructuredBinding.ts | 31 +-- .../privateNameFieldInitializer.ts | 10 +- .../privateNameFieldUnaryMutation.ts | 42 ++-- 35 files changed, 968 insertions(+), 204 deletions(-) diff --git a/src/compiler/transformers/classProperties.ts b/src/compiler/transformers/classProperties.ts index 01bb21fe1b7a2..b6b8d257ae494 100644 --- a/src/compiler/transformers/classProperties.ts +++ b/src/compiler/transformers/classProperties.ts @@ -9,12 +9,12 @@ namespace ts { } const enum PrivateNamePlacement { - InstanceField, + Field, InstanceMethod } - interface PrivateNamedInstanceField { - placement: PrivateNamePlacement.InstanceField; + interface PrivateNamedField { + placement: PrivateNamePlacement.Field; accumulator: Identifier; } @@ -28,7 +28,7 @@ namespace ts { /** * A mapping of private names to information needed for transformation. */ - type PrivateNameEnvironment = UnderscoreEscapedMap; + type PrivateNameEnvironment = UnderscoreEscapedMap; /** * Transforms ECMAScript Class Syntax. @@ -181,7 +181,7 @@ namespace ts { const privateNameInfo = accessPrivateName(node.name); if (privateNameInfo) { switch (privateNameInfo.placement) { - case PrivateNamePlacement.InstanceField: + case PrivateNamePlacement.Field: return setOriginalNode( setTextRange( createClassPrivateFieldGetHelper( @@ -359,16 +359,15 @@ namespace ts { const privateNameInfo = accessPrivateName(node.left.name); if (privateNameInfo) { switch (privateNameInfo.placement) { - case PrivateNamePlacement.InstanceField: { - return transformPrivateNamedInstanceFieldAssignment(privateNameInfo, node); - } + case PrivateNamePlacement.Field: + return transformPrivateNamedFieldAssignment(privateNameInfo, node); } } } return visitEachChild(node, visitor, context); } - function transformPrivateNamedInstanceFieldAssignment(privateNameInfo: PrivateNamedInstanceField, node: PrivateNameAssignmentExpression) { + function transformPrivateNamedFieldAssignment(privateNameInfo: PrivateNamedField, node: PrivateNameAssignmentExpression) { if (isCompoundAssignment(node.operatorToken.kind)) { const isReceiverInlineable = isSimpleInlineableExpression(node.left.expression); const getReceiver = isReceiverInlineable ? node.left.expression : createTempVariable(hoistVariableDeclaration); @@ -532,7 +531,7 @@ namespace ts { pendingExpressions = pendingExpressions || []; last(privateNameEnvironmentStack).forEach(entry => { switch (entry.placement) { - case PrivateNamePlacement.InstanceField: + case PrivateNamePlacement.Field: break; case PrivateNamePlacement.InstanceMethod: const func = privateNamedMethodToFunction(entry.origFunc, entry.funcName); @@ -625,7 +624,7 @@ namespace ts { if (classDeclaresPrivateNames) { last(privateNameEnvironmentStack).forEach(({ placement, accumulator }) => { switch (placement) { - case PrivateNamePlacement.InstanceField: + case PrivateNamePlacement.Field: // handled in addInitializedPropertyStatements break; case PrivateNamePlacement.InstanceMethod: @@ -734,13 +733,12 @@ namespace ts { const privateNameInfo = accessPrivateName(propertyName); if (privateNameInfo) { switch (privateNameInfo.placement) { - case PrivateNamePlacement.InstanceField: { - return createPrivateInstanceFieldInitializer( + case PrivateNamePlacement.Field: + return createPrivateFieldInitializer( receiver, initializer, privateNameInfo.accumulator ); - } } } } @@ -868,16 +866,16 @@ namespace ts { let identifierName: string; let accumulator: Identifier; - if (hasModifier(element, ModifierFlags.Static)) { - // statics not supported yet - return; - } if (isPropertyDeclaration(element)) { identifierName = "WeakMap"; accumulator = createUniqueName(`_${text.slice(1)}WeakMap`); - env.set(escapedText, { placement: PrivateNamePlacement.InstanceField, accumulator }); + env.set(escapedText, { placement: PrivateNamePlacement.Field, accumulator }); } else if (isMethodDeclaration(element)) { + if (hasModifier(element, ModifierFlags.Static)) { + // static methods not supported yet + return; + } identifierName = "WeakSet"; accumulator = createUniqueName(`_${text.slice(1)}WeakSet`); const escapedText = element.name.escapedText; @@ -990,7 +988,7 @@ namespace ts { } } - function createPrivateInstanceFieldInitializer(receiver: LeftHandSideExpression, initializer: Expression | undefined, weakMapName: Identifier) { + function createPrivateFieldInitializer(receiver: LeftHandSideExpression, initializer: Expression | undefined, weakMapName: Identifier) { return createCall( createPropertyAccess(weakMapName, "set"), /*typeArguments*/ undefined, diff --git a/tests/baselines/reference/privateNameField.js b/tests/baselines/reference/privateNameField.js index d8a3ebed47af7..be00121da15cd 100644 --- a/tests/baselines/reference/privateNameField.js +++ b/tests/baselines/reference/privateNameField.js @@ -1,23 +1,22 @@ //// [privateNameField.ts] -// @target es6 - class A { #name: string; + static #staticName: string; constructor(name: string) { this.#name = name; + A.#staticName = name; } } //// [privateNameField.js] -// @target es6 var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; -var _nameWeakMap_1; -"use strict"; +var _nameWeakMap_1, _staticNameWeakMap_1; var A = /** @class */ (function () { function A(name) { _nameWeakMap_1.set(this, void 0); _classPrivateFieldSet(this, _nameWeakMap_1, name); + _classPrivateFieldSet(A, _staticNameWeakMap_1, name); } return A; }()); -_nameWeakMap_1 = new WeakMap(); +_nameWeakMap_1 = new WeakMap(), _staticNameWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameField.symbols b/tests/baselines/reference/privateNameField.symbols index c37ded65bd1a7..67ac59df1bb10 100644 --- a/tests/baselines/reference/privateNameField.symbols +++ b/tests/baselines/reference/privateNameField.symbols @@ -1,18 +1,24 @@ === tests/cases/conformance/classes/members/privateNames/privateNameField.ts === -// @target es6 - class A { >A : Symbol(A, Decl(privateNameField.ts, 0, 0)) #name: string; ->#name : Symbol(A.#name, Decl(privateNameField.ts, 2, 9)) +>#name : Symbol(A.#name, Decl(privateNameField.ts, 0, 9)) + + static #staticName: string; +>#staticName : Symbol(A.#staticName, Decl(privateNameField.ts, 1, 18)) constructor(name: string) { ->name : Symbol(name, Decl(privateNameField.ts, 4, 16)) +>name : Symbol(name, Decl(privateNameField.ts, 3, 16)) this.#name = name; ->this.#name : Symbol(A.#name, Decl(privateNameField.ts, 2, 9)) +>this.#name : Symbol(A.#name, Decl(privateNameField.ts, 0, 9)) >this : Symbol(A, Decl(privateNameField.ts, 0, 0)) ->name : Symbol(name, Decl(privateNameField.ts, 4, 16)) +>name : Symbol(name, Decl(privateNameField.ts, 3, 16)) + + A.#staticName = name; +>A.#staticName : Symbol(A.#staticName, Decl(privateNameField.ts, 1, 18)) +>A : Symbol(A, Decl(privateNameField.ts, 0, 0)) +>name : Symbol(name, Decl(privateNameField.ts, 3, 16)) } } diff --git a/tests/baselines/reference/privateNameField.types b/tests/baselines/reference/privateNameField.types index db7dba04475e8..3a8f2e0c5c706 100644 --- a/tests/baselines/reference/privateNameField.types +++ b/tests/baselines/reference/privateNameField.types @@ -1,12 +1,13 @@ === tests/cases/conformance/classes/members/privateNames/privateNameField.ts === -// @target es6 - class A { >A : A #name: string; >#name : string + static #staticName: string; +>#staticName : string + constructor(name: string) { >name : string @@ -14,6 +15,12 @@ class A { >this.#name = name : string >this.#name : string >this : this +>name : string + + A.#staticName = name; +>A.#staticName = name : string +>A.#staticName : string +>A : typeof A >name : string } } diff --git a/tests/baselines/reference/privateNameFieldAccess.js b/tests/baselines/reference/privateNameFieldAccess.js index f9a6a0b0dd78d..8b81031f5bf53 100644 --- a/tests/baselines/reference/privateNameFieldAccess.js +++ b/tests/baselines/reference/privateNameFieldAccess.js @@ -1,20 +1,24 @@ //// [privateNameFieldAccess.ts] class A { #myField = "hello world"; + static #myStaticField = "hello world"; constructor() { console.log(this.#myField); + console.log(A.#myStaticField); } } //// [privateNameFieldAccess.js] var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; -var _myFieldWeakMap_1; var A = /** @class */ (function () { function A() { _myFieldWeakMap_1.set(this, "hello world"); console.log(_classPrivateFieldGet(this, _myFieldWeakMap_1)); + console.log(_classPrivateFieldGet(A, _myStaticFieldWeakMap_1)); } + var _myFieldWeakMap_1, _myStaticFieldWeakMap_1; + _myFieldWeakMap_1 = new WeakMap(), _myStaticFieldWeakMap_1 = new WeakMap(); + _myStaticFieldWeakMap_1.set(A, "hello world"); return A; }()); -_myFieldWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameFieldAccess.symbols b/tests/baselines/reference/privateNameFieldAccess.symbols index d69eacd7131f9..78c12b5a1c9cf 100644 --- a/tests/baselines/reference/privateNameFieldAccess.symbols +++ b/tests/baselines/reference/privateNameFieldAccess.symbols @@ -5,6 +5,9 @@ class A { #myField = "hello world"; >#myField : Symbol(A.#myField, Decl(privateNameFieldAccess.ts, 0, 9)) + static #myStaticField = "hello world"; +>#myStaticField : Symbol(A.#myStaticField, Decl(privateNameFieldAccess.ts, 1, 29)) + constructor() { console.log(this.#myField); >console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) @@ -12,6 +15,13 @@ class A { >log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) >this.#myField : Symbol(A.#myField, Decl(privateNameFieldAccess.ts, 0, 9)) >this : Symbol(A, Decl(privateNameFieldAccess.ts, 0, 0)) + + console.log(A.#myStaticField); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>A.#myStaticField : Symbol(A.#myStaticField, Decl(privateNameFieldAccess.ts, 1, 29)) +>A : Symbol(A, Decl(privateNameFieldAccess.ts, 0, 0)) } } diff --git a/tests/baselines/reference/privateNameFieldAccess.types b/tests/baselines/reference/privateNameFieldAccess.types index 17568587e311d..7bc1ad648ece2 100644 --- a/tests/baselines/reference/privateNameFieldAccess.types +++ b/tests/baselines/reference/privateNameFieldAccess.types @@ -4,6 +4,10 @@ class A { #myField = "hello world"; >#myField : string +>"hello world" : "hello world" + + static #myStaticField = "hello world"; +>#myStaticField : string >"hello world" : "hello world" constructor() { @@ -14,6 +18,14 @@ class A { >log : (message?: any, ...optionalParams: any[]) => void >this.#myField : string >this : this + + console.log(A.#myStaticField); +>console.log(A.#myStaticField) : void +>console.log : (message?: any, ...optionalParams: any[]) => void +>console : Console +>log : (message?: any, ...optionalParams: any[]) => void +>A.#myStaticField : string +>A : typeof A } } diff --git a/tests/baselines/reference/privateNameFieldAssignment.js b/tests/baselines/reference/privateNameFieldAssignment.js index 4dad664c83109..93f5a024302d7 100644 --- a/tests/baselines/reference/privateNameFieldAssignment.js +++ b/tests/baselines/reference/privateNameFieldAssignment.js @@ -1,6 +1,7 @@ //// [privateNameFieldAssignment.ts] class A { #field = 0; + static #staticField = 0; constructor() { this.#field = 1; this.#field += 2; @@ -28,21 +29,49 @@ class A { A.getInstance().#field &= 11; A.getInstance().#field |= 12; A.getInstance().#field ^= 13; + A.#staticField = 1; + A.#staticField += 2; + A.#staticField -= 3; + A.#staticField /= 4; + A.#staticField *= 5; + A.#staticField **= 6; + A.#staticField %= 7; + A.#staticField <<= 8; + A.#staticField >>= 9; + A.#staticField >>>= 10; + A.#staticField &= 11; + A.#staticField |= 12; + A.#staticField ^= 13; + A.getClass().#staticField = 1; + A.getClass().#staticField += 2; + A.getClass().#staticField -= 3; + A.getClass().#staticField /= 4; + A.getClass().#staticField *= 5; + A.getClass().#staticField **= 6; + A.getClass().#staticField %= 7; + A.getClass().#staticField <<= 8; + A.getClass().#staticField >>= 9; + A.getClass().#staticField >>>= 10; + A.getClass().#staticField &= 11; + A.getClass().#staticField |= 12; + A.getClass().#staticField ^= 13; } static getInstance() { return new A(); } + static getClass() { + return this; + } } //// [privateNameFieldAssignment.js] var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; -var _fieldWeakMap_1; var A = /** @class */ (function () { function A() { _fieldWeakMap_1.set(this, 0); - var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m; + var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11; _classPrivateFieldSet(this, _fieldWeakMap_1, 1); _classPrivateFieldSet(this, _fieldWeakMap_1, _classPrivateFieldGet(this, _fieldWeakMap_1) + 2); _classPrivateFieldSet(this, _fieldWeakMap_1, _classPrivateFieldGet(this, _fieldWeakMap_1) - 3); @@ -69,10 +98,41 @@ var A = /** @class */ (function () { _classPrivateFieldSet(_k = A.getInstance(), _fieldWeakMap_1, _classPrivateFieldGet(_k, _fieldWeakMap_1) & 11); _classPrivateFieldSet(_l = A.getInstance(), _fieldWeakMap_1, _classPrivateFieldGet(_l, _fieldWeakMap_1) | 12); _classPrivateFieldSet(_m = A.getInstance(), _fieldWeakMap_1, _classPrivateFieldGet(_m, _fieldWeakMap_1) ^ 13); + _classPrivateFieldSet(A, _staticFieldWeakMap_1, 1); + _classPrivateFieldSet(_o = A, _staticFieldWeakMap_1, _classPrivateFieldGet(_o, _staticFieldWeakMap_1) + 2); + _classPrivateFieldSet(_p = A, _staticFieldWeakMap_1, _classPrivateFieldGet(_p, _staticFieldWeakMap_1) - 3); + _classPrivateFieldSet(_q = A, _staticFieldWeakMap_1, _classPrivateFieldGet(_q, _staticFieldWeakMap_1) / 4); + _classPrivateFieldSet(_r = A, _staticFieldWeakMap_1, _classPrivateFieldGet(_r, _staticFieldWeakMap_1) * 5); + _classPrivateFieldSet(_s = A, _staticFieldWeakMap_1, Math.pow(_classPrivateFieldGet(_s, _staticFieldWeakMap_1), 6)); + _classPrivateFieldSet(_t = A, _staticFieldWeakMap_1, _classPrivateFieldGet(_t, _staticFieldWeakMap_1) % 7); + _classPrivateFieldSet(_u = A, _staticFieldWeakMap_1, _classPrivateFieldGet(_u, _staticFieldWeakMap_1) << 8); + _classPrivateFieldSet(_v = A, _staticFieldWeakMap_1, _classPrivateFieldGet(_v, _staticFieldWeakMap_1) >> 9); + _classPrivateFieldSet(_w = A, _staticFieldWeakMap_1, _classPrivateFieldGet(_w, _staticFieldWeakMap_1) >>> 10); + _classPrivateFieldSet(_x = A, _staticFieldWeakMap_1, _classPrivateFieldGet(_x, _staticFieldWeakMap_1) & 11); + _classPrivateFieldSet(_y = A, _staticFieldWeakMap_1, _classPrivateFieldGet(_y, _staticFieldWeakMap_1) | 12); + _classPrivateFieldSet(_z = A, _staticFieldWeakMap_1, _classPrivateFieldGet(_z, _staticFieldWeakMap_1) ^ 13); + _classPrivateFieldSet(A.getClass(), _staticFieldWeakMap_1, 1); + _classPrivateFieldSet(_0 = A.getClass(), _staticFieldWeakMap_1, _classPrivateFieldGet(_0, _staticFieldWeakMap_1) + 2); + _classPrivateFieldSet(_1 = A.getClass(), _staticFieldWeakMap_1, _classPrivateFieldGet(_1, _staticFieldWeakMap_1) - 3); + _classPrivateFieldSet(_2 = A.getClass(), _staticFieldWeakMap_1, _classPrivateFieldGet(_2, _staticFieldWeakMap_1) / 4); + _classPrivateFieldSet(_3 = A.getClass(), _staticFieldWeakMap_1, _classPrivateFieldGet(_3, _staticFieldWeakMap_1) * 5); + _classPrivateFieldSet(_4 = A.getClass(), _staticFieldWeakMap_1, Math.pow(_classPrivateFieldGet(_4, _staticFieldWeakMap_1), 6)); + _classPrivateFieldSet(_5 = A.getClass(), _staticFieldWeakMap_1, _classPrivateFieldGet(_5, _staticFieldWeakMap_1) % 7); + _classPrivateFieldSet(_6 = A.getClass(), _staticFieldWeakMap_1, _classPrivateFieldGet(_6, _staticFieldWeakMap_1) << 8); + _classPrivateFieldSet(_7 = A.getClass(), _staticFieldWeakMap_1, _classPrivateFieldGet(_7, _staticFieldWeakMap_1) >> 9); + _classPrivateFieldSet(_8 = A.getClass(), _staticFieldWeakMap_1, _classPrivateFieldGet(_8, _staticFieldWeakMap_1) >>> 10); + _classPrivateFieldSet(_9 = A.getClass(), _staticFieldWeakMap_1, _classPrivateFieldGet(_9, _staticFieldWeakMap_1) & 11); + _classPrivateFieldSet(_10 = A.getClass(), _staticFieldWeakMap_1, _classPrivateFieldGet(_10, _staticFieldWeakMap_1) | 12); + _classPrivateFieldSet(_11 = A.getClass(), _staticFieldWeakMap_1, _classPrivateFieldGet(_11, _staticFieldWeakMap_1) ^ 13); } A.getInstance = function () { return new A(); }; + A.getClass = function () { + return this; + }; + var _fieldWeakMap_1, _staticFieldWeakMap_1; + _fieldWeakMap_1 = new WeakMap(), _staticFieldWeakMap_1 = new WeakMap(); + _staticFieldWeakMap_1.set(A, 0); return A; }()); -_fieldWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameFieldAssignment.symbols b/tests/baselines/reference/privateNameFieldAssignment.symbols index 3f08ea141f07f..90c62dea45458 100644 --- a/tests/baselines/reference/privateNameFieldAssignment.symbols +++ b/tests/baselines/reference/privateNameFieldAssignment.symbols @@ -5,6 +5,9 @@ class A { #field = 0; >#field : Symbol(A.#field, Decl(privateNameFieldAssignment.ts, 0, 9)) + static #staticField = 0; +>#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) + constructor() { this.#field = 1; >this.#field : Symbol(A.#field, Decl(privateNameFieldAssignment.ts, 0, 9)) @@ -60,87 +63,223 @@ class A { A.getInstance().#field = 1; >A.getInstance().#field : Symbol(A.#field, Decl(privateNameFieldAssignment.ts, 0, 9)) ->A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) >A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) ->getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) A.getInstance().#field += 2; >A.getInstance().#field : Symbol(A.#field, Decl(privateNameFieldAssignment.ts, 0, 9)) ->A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) >A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) ->getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) A.getInstance().#field -= 3; >A.getInstance().#field : Symbol(A.#field, Decl(privateNameFieldAssignment.ts, 0, 9)) ->A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) >A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) ->getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) A.getInstance().#field /= 4; >A.getInstance().#field : Symbol(A.#field, Decl(privateNameFieldAssignment.ts, 0, 9)) ->A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) >A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) ->getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) A.getInstance().#field *= 5; >A.getInstance().#field : Symbol(A.#field, Decl(privateNameFieldAssignment.ts, 0, 9)) ->A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) >A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) ->getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) A.getInstance().#field **= 6; >A.getInstance().#field : Symbol(A.#field, Decl(privateNameFieldAssignment.ts, 0, 9)) ->A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) >A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) ->getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) A.getInstance().#field %= 7; >A.getInstance().#field : Symbol(A.#field, Decl(privateNameFieldAssignment.ts, 0, 9)) ->A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) >A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) ->getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) A.getInstance().#field <<= 8; >A.getInstance().#field : Symbol(A.#field, Decl(privateNameFieldAssignment.ts, 0, 9)) ->A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) >A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) ->getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) A.getInstance().#field >>= 9; >A.getInstance().#field : Symbol(A.#field, Decl(privateNameFieldAssignment.ts, 0, 9)) ->A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) >A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) ->getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) A.getInstance().#field >>>= 10; >A.getInstance().#field : Symbol(A.#field, Decl(privateNameFieldAssignment.ts, 0, 9)) ->A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) >A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) ->getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) A.getInstance().#field &= 11; >A.getInstance().#field : Symbol(A.#field, Decl(privateNameFieldAssignment.ts, 0, 9)) ->A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) >A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) ->getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) A.getInstance().#field |= 12; >A.getInstance().#field : Symbol(A.#field, Decl(privateNameFieldAssignment.ts, 0, 9)) ->A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) >A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) ->getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) A.getInstance().#field ^= 13; >A.getInstance().#field : Symbol(A.#field, Decl(privateNameFieldAssignment.ts, 0, 9)) ->A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>A.getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) +>getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) + + A.#staticField = 1; +>A.#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) + + A.#staticField += 2; +>A.#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) + + A.#staticField -= 3; +>A.#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) + + A.#staticField /= 4; +>A.#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) + + A.#staticField *= 5; +>A.#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) + + A.#staticField **= 6; +>A.#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) + + A.#staticField %= 7; +>A.#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) + + A.#staticField <<= 8; +>A.#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) + + A.#staticField >>= 9; +>A.#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) + + A.#staticField >>>= 10; +>A.#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) + + A.#staticField &= 11; +>A.#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) + + A.#staticField |= 12; +>A.#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) + + A.#staticField ^= 13; +>A.#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) + + A.getClass().#staticField = 1; +>A.getClass().#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A.getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) +>getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) + + A.getClass().#staticField += 2; +>A.getClass().#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A.getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) +>getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) + + A.getClass().#staticField -= 3; +>A.getClass().#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A.getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) +>getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) + + A.getClass().#staticField /= 4; +>A.getClass().#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A.getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) +>getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) + + A.getClass().#staticField *= 5; +>A.getClass().#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A.getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) +>getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) + + A.getClass().#staticField **= 6; +>A.getClass().#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A.getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) +>getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) + + A.getClass().#staticField %= 7; +>A.getClass().#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A.getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) +>getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) + + A.getClass().#staticField <<= 8; +>A.getClass().#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A.getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) +>getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) + + A.getClass().#staticField >>= 9; +>A.getClass().#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A.getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) +>getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) + + A.getClass().#staticField >>>= 10; +>A.getClass().#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A.getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) +>getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) + + A.getClass().#staticField &= 11; +>A.getClass().#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A.getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) >A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) ->getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) + + A.getClass().#staticField |= 12; +>A.getClass().#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A.getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) +>getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) + + A.getClass().#staticField ^= 13; +>A.getClass().#staticField : Symbol(A.#staticField, Decl(privateNameFieldAssignment.ts, 1, 15)) +>A.getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) +>A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) +>getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) } static getInstance() { ->getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 29, 5)) +>getInstance : Symbol(A.getInstance, Decl(privateNameFieldAssignment.ts, 56, 5)) return new A(); >A : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) } + static getClass() { +>getClass : Symbol(A.getClass, Decl(privateNameFieldAssignment.ts, 59, 5)) + + return this; +>this : Symbol(A, Decl(privateNameFieldAssignment.ts, 0, 0)) + } } diff --git a/tests/baselines/reference/privateNameFieldAssignment.types b/tests/baselines/reference/privateNameFieldAssignment.types index 8a3c507c393f0..38c2117cdc1ad 100644 --- a/tests/baselines/reference/privateNameFieldAssignment.types +++ b/tests/baselines/reference/privateNameFieldAssignment.types @@ -4,6 +4,10 @@ class A { #field = 0; >#field : number +>0 : 0 + + static #staticField = 0; +>#staticField : number >0 : 0 constructor() { @@ -200,6 +204,201 @@ class A { >A.getInstance : () => A >A : typeof A >getInstance : () => A +>13 : 13 + + A.#staticField = 1; +>A.#staticField = 1 : 1 +>A.#staticField : number +>A : typeof A +>1 : 1 + + A.#staticField += 2; +>A.#staticField += 2 : number +>A.#staticField : number +>A : typeof A +>2 : 2 + + A.#staticField -= 3; +>A.#staticField -= 3 : number +>A.#staticField : number +>A : typeof A +>3 : 3 + + A.#staticField /= 4; +>A.#staticField /= 4 : number +>A.#staticField : number +>A : typeof A +>4 : 4 + + A.#staticField *= 5; +>A.#staticField *= 5 : number +>A.#staticField : number +>A : typeof A +>5 : 5 + + A.#staticField **= 6; +>A.#staticField **= 6 : number +>A.#staticField : number +>A : typeof A +>6 : 6 + + A.#staticField %= 7; +>A.#staticField %= 7 : number +>A.#staticField : number +>A : typeof A +>7 : 7 + + A.#staticField <<= 8; +>A.#staticField <<= 8 : number +>A.#staticField : number +>A : typeof A +>8 : 8 + + A.#staticField >>= 9; +>A.#staticField >>= 9 : number +>A.#staticField : number +>A : typeof A +>9 : 9 + + A.#staticField >>>= 10; +>A.#staticField >>>= 10 : number +>A.#staticField : number +>A : typeof A +>10 : 10 + + A.#staticField &= 11; +>A.#staticField &= 11 : number +>A.#staticField : number +>A : typeof A +>11 : 11 + + A.#staticField |= 12; +>A.#staticField |= 12 : number +>A.#staticField : number +>A : typeof A +>12 : 12 + + A.#staticField ^= 13; +>A.#staticField ^= 13 : number +>A.#staticField : number +>A : typeof A +>13 : 13 + + A.getClass().#staticField = 1; +>A.getClass().#staticField = 1 : 1 +>A.getClass().#staticField : number +>A.getClass() : typeof A +>A.getClass : () => typeof A +>A : typeof A +>getClass : () => typeof A +>1 : 1 + + A.getClass().#staticField += 2; +>A.getClass().#staticField += 2 : number +>A.getClass().#staticField : number +>A.getClass() : typeof A +>A.getClass : () => typeof A +>A : typeof A +>getClass : () => typeof A +>2 : 2 + + A.getClass().#staticField -= 3; +>A.getClass().#staticField -= 3 : number +>A.getClass().#staticField : number +>A.getClass() : typeof A +>A.getClass : () => typeof A +>A : typeof A +>getClass : () => typeof A +>3 : 3 + + A.getClass().#staticField /= 4; +>A.getClass().#staticField /= 4 : number +>A.getClass().#staticField : number +>A.getClass() : typeof A +>A.getClass : () => typeof A +>A : typeof A +>getClass : () => typeof A +>4 : 4 + + A.getClass().#staticField *= 5; +>A.getClass().#staticField *= 5 : number +>A.getClass().#staticField : number +>A.getClass() : typeof A +>A.getClass : () => typeof A +>A : typeof A +>getClass : () => typeof A +>5 : 5 + + A.getClass().#staticField **= 6; +>A.getClass().#staticField **= 6 : number +>A.getClass().#staticField : number +>A.getClass() : typeof A +>A.getClass : () => typeof A +>A : typeof A +>getClass : () => typeof A +>6 : 6 + + A.getClass().#staticField %= 7; +>A.getClass().#staticField %= 7 : number +>A.getClass().#staticField : number +>A.getClass() : typeof A +>A.getClass : () => typeof A +>A : typeof A +>getClass : () => typeof A +>7 : 7 + + A.getClass().#staticField <<= 8; +>A.getClass().#staticField <<= 8 : number +>A.getClass().#staticField : number +>A.getClass() : typeof A +>A.getClass : () => typeof A +>A : typeof A +>getClass : () => typeof A +>8 : 8 + + A.getClass().#staticField >>= 9; +>A.getClass().#staticField >>= 9 : number +>A.getClass().#staticField : number +>A.getClass() : typeof A +>A.getClass : () => typeof A +>A : typeof A +>getClass : () => typeof A +>9 : 9 + + A.getClass().#staticField >>>= 10; +>A.getClass().#staticField >>>= 10 : number +>A.getClass().#staticField : number +>A.getClass() : typeof A +>A.getClass : () => typeof A +>A : typeof A +>getClass : () => typeof A +>10 : 10 + + A.getClass().#staticField &= 11; +>A.getClass().#staticField &= 11 : number +>A.getClass().#staticField : number +>A.getClass() : typeof A +>A.getClass : () => typeof A +>A : typeof A +>getClass : () => typeof A +>11 : 11 + + A.getClass().#staticField |= 12; +>A.getClass().#staticField |= 12 : number +>A.getClass().#staticField : number +>A.getClass() : typeof A +>A.getClass : () => typeof A +>A : typeof A +>getClass : () => typeof A +>12 : 12 + + A.getClass().#staticField ^= 13; +>A.getClass().#staticField ^= 13 : number +>A.getClass().#staticField : number +>A.getClass() : typeof A +>A.getClass : () => typeof A +>A : typeof A +>getClass : () => typeof A >13 : 13 } static getInstance() { @@ -209,5 +408,11 @@ class A { >new A() : A >A : typeof A } + static getClass() { +>getClass : () => typeof A + + return this; +>this : typeof A + } } diff --git a/tests/baselines/reference/privateNameFieldCallExpression.js b/tests/baselines/reference/privateNameFieldCallExpression.js index ec548bc95a422..d028e8580a5c8 100644 --- a/tests/baselines/reference/privateNameFieldCallExpression.js +++ b/tests/baselines/reference/privateNameFieldCallExpression.js @@ -1,18 +1,22 @@ //// [privateNameFieldCallExpression.ts] class A { #fieldFunc = () => this.x = 10; + static #staticFieldFunc = () => A.staticX = 10; x = 1; + static staticX = 1; test() { this.#fieldFunc(); const func = this.#fieldFunc; func(); + A.#staticFieldFunc(); + const func2 = A.#staticFieldFunc; + func2(); } } //// [privateNameFieldCallExpression.js] var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; -var _fieldFuncWeakMap_1; var A = /** @class */ (function () { function A() { var _this = this; @@ -20,10 +24,17 @@ var A = /** @class */ (function () { this.x = 1; } A.prototype.test = function () { + var _a; _classPrivateFieldGet(this, _fieldFuncWeakMap_1).call(this); var func = _classPrivateFieldGet(this, _fieldFuncWeakMap_1); func(); + _classPrivateFieldGet((_a = A), _staticFieldFuncWeakMap_1).call(_a); + var func2 = _classPrivateFieldGet(A, _staticFieldFuncWeakMap_1); + func2(); }; + var _fieldFuncWeakMap_1, _staticFieldFuncWeakMap_1; + _fieldFuncWeakMap_1 = new WeakMap(), _staticFieldFuncWeakMap_1 = new WeakMap(); + _staticFieldFuncWeakMap_1.set(A, function () { return A.staticX = 10; }); + A.staticX = 1; return A; }()); -_fieldFuncWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameFieldCallExpression.symbols b/tests/baselines/reference/privateNameFieldCallExpression.symbols index 692141acb9878..ca8133d953cd0 100644 --- a/tests/baselines/reference/privateNameFieldCallExpression.symbols +++ b/tests/baselines/reference/privateNameFieldCallExpression.symbols @@ -4,27 +4,48 @@ class A { #fieldFunc = () => this.x = 10; >#fieldFunc : Symbol(A.#fieldFunc, Decl(privateNameFieldCallExpression.ts, 0, 9)) ->this.x : Symbol(A.x, Decl(privateNameFieldCallExpression.ts, 1, 35)) +>this.x : Symbol(A.x, Decl(privateNameFieldCallExpression.ts, 2, 51)) >this : Symbol(A, Decl(privateNameFieldCallExpression.ts, 0, 0)) ->x : Symbol(A.x, Decl(privateNameFieldCallExpression.ts, 1, 35)) +>x : Symbol(A.x, Decl(privateNameFieldCallExpression.ts, 2, 51)) + + static #staticFieldFunc = () => A.staticX = 10; +>#staticFieldFunc : Symbol(A.#staticFieldFunc, Decl(privateNameFieldCallExpression.ts, 1, 35)) +>A.staticX : Symbol(A.staticX, Decl(privateNameFieldCallExpression.ts, 3, 10)) +>A : Symbol(A, Decl(privateNameFieldCallExpression.ts, 0, 0)) +>staticX : Symbol(A.staticX, Decl(privateNameFieldCallExpression.ts, 3, 10)) x = 1; ->x : Symbol(A.x, Decl(privateNameFieldCallExpression.ts, 1, 35)) +>x : Symbol(A.x, Decl(privateNameFieldCallExpression.ts, 2, 51)) + + static staticX = 1; +>staticX : Symbol(A.staticX, Decl(privateNameFieldCallExpression.ts, 3, 10)) test() { ->test : Symbol(A.test, Decl(privateNameFieldCallExpression.ts, 2, 10)) +>test : Symbol(A.test, Decl(privateNameFieldCallExpression.ts, 4, 23)) this.#fieldFunc(); >this.#fieldFunc : Symbol(A.#fieldFunc, Decl(privateNameFieldCallExpression.ts, 0, 9)) >this : Symbol(A, Decl(privateNameFieldCallExpression.ts, 0, 0)) const func = this.#fieldFunc; ->func : Symbol(func, Decl(privateNameFieldCallExpression.ts, 5, 13)) +>func : Symbol(func, Decl(privateNameFieldCallExpression.ts, 7, 13)) >this.#fieldFunc : Symbol(A.#fieldFunc, Decl(privateNameFieldCallExpression.ts, 0, 9)) >this : Symbol(A, Decl(privateNameFieldCallExpression.ts, 0, 0)) func(); ->func : Symbol(func, Decl(privateNameFieldCallExpression.ts, 5, 13)) +>func : Symbol(func, Decl(privateNameFieldCallExpression.ts, 7, 13)) + + A.#staticFieldFunc(); +>A.#staticFieldFunc : Symbol(A.#staticFieldFunc, Decl(privateNameFieldCallExpression.ts, 1, 35)) +>A : Symbol(A, Decl(privateNameFieldCallExpression.ts, 0, 0)) + + const func2 = A.#staticFieldFunc; +>func2 : Symbol(func2, Decl(privateNameFieldCallExpression.ts, 10, 13)) +>A.#staticFieldFunc : Symbol(A.#staticFieldFunc, Decl(privateNameFieldCallExpression.ts, 1, 35)) +>A : Symbol(A, Decl(privateNameFieldCallExpression.ts, 0, 0)) + + func2(); +>func2 : Symbol(func2, Decl(privateNameFieldCallExpression.ts, 10, 13)) } } diff --git a/tests/baselines/reference/privateNameFieldCallExpression.types b/tests/baselines/reference/privateNameFieldCallExpression.types index e9d12b0d1741c..af96a52a9ab6a 100644 --- a/tests/baselines/reference/privateNameFieldCallExpression.types +++ b/tests/baselines/reference/privateNameFieldCallExpression.types @@ -9,10 +9,23 @@ class A { >this.x : number >this : this >x : number +>10 : 10 + + static #staticFieldFunc = () => A.staticX = 10; +>#staticFieldFunc : () => number +>() => A.staticX = 10 : () => number +>A.staticX = 10 : 10 +>A.staticX : number +>A : typeof A +>staticX : number >10 : 10 x = 1; >x : number +>1 : 1 + + static staticX = 1; +>staticX : number >1 : 1 test() { @@ -31,6 +44,20 @@ class A { func(); >func() : number >func : () => number + + A.#staticFieldFunc(); +>A.#staticFieldFunc() : number +>A.#staticFieldFunc : () => number +>A : typeof A + + const func2 = A.#staticFieldFunc; +>func2 : () => number +>A.#staticFieldFunc : () => number +>A : typeof A + + func2(); +>func2() : number +>func2 : () => number } } diff --git a/tests/baselines/reference/privateNameFieldDeclaration.js b/tests/baselines/reference/privateNameFieldDeclaration.js index 1b362003ba7b8..917892d44b888 100644 --- a/tests/baselines/reference/privateNameFieldDeclaration.js +++ b/tests/baselines/reference/privateNameFieldDeclaration.js @@ -1,15 +1,16 @@ //// [privateNameFieldDeclaration.ts] class A { #name: string; + static #staticName: string; } //// [privateNameFieldDeclaration.js] -var _nameWeakMap_1; +var _nameWeakMap_1, _staticNameWeakMap_1; var A = /** @class */ (function () { function A() { _nameWeakMap_1.set(this, void 0); } return A; }()); -_nameWeakMap_1 = new WeakMap(); +_nameWeakMap_1 = new WeakMap(), _staticNameWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameFieldDeclaration.symbols b/tests/baselines/reference/privateNameFieldDeclaration.symbols index 32a40fa42b89a..dbb9ca9197052 100644 --- a/tests/baselines/reference/privateNameFieldDeclaration.symbols +++ b/tests/baselines/reference/privateNameFieldDeclaration.symbols @@ -4,5 +4,8 @@ class A { #name: string; >#name : Symbol(A.#name, Decl(privateNameFieldDeclaration.ts, 0, 9)) + + static #staticName: string; +>#staticName : Symbol(A.#staticName, Decl(privateNameFieldDeclaration.ts, 1, 18)) } diff --git a/tests/baselines/reference/privateNameFieldDeclaration.types b/tests/baselines/reference/privateNameFieldDeclaration.types index ce6312a793ea6..f0e28f6ee769e 100644 --- a/tests/baselines/reference/privateNameFieldDeclaration.types +++ b/tests/baselines/reference/privateNameFieldDeclaration.types @@ -4,5 +4,8 @@ class A { #name: string; >#name : string + + static #staticName: string; +>#staticName : string } diff --git a/tests/baselines/reference/privateNameFieldDestructuredBinding.js b/tests/baselines/reference/privateNameFieldDestructuredBinding.js index c17ab70b39fd2..e1e4e31a3b0c7 100644 --- a/tests/baselines/reference/privateNameFieldDestructuredBinding.js +++ b/tests/baselines/reference/privateNameFieldDestructuredBinding.js @@ -1,6 +1,7 @@ //// [privateNameFieldDestructuredBinding.ts] class A { #field = 1; + static #staticField = 1; testObject() { return { x: 10, y: 6 }; } @@ -11,20 +12,23 @@ class A { let y: number; ({ x: this.#field, y } = this.testObject()); ([this.#field, y] = this.testArray()); + ({ x: A.#staticField, y } = this.testObject()); + ([A.#staticField, y] = this.testArray()); } } //// [privateNameFieldDestructuredBinding.js] var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; -var _fieldWeakMap_1; var A = /** @class */ (function () { function A() { - var _a, _b; + var _a, _b, _c, _d; _fieldWeakMap_1.set(this, 1); var y; (_a = this.testObject(), { set value(x) { _classPrivateFieldSet(this, _fieldWeakMap_1, x); } }.value = _a.x, y = _a.y); (_b = this.testArray(), { set value(x) { _classPrivateFieldSet(this, _fieldWeakMap_1, x); } }.value = _b[0], y = _b[1]); + (_c = this.testObject(), { set value(x) { _classPrivateFieldSet(A, _staticFieldWeakMap_1, x); } }.value = _c.x, y = _c.y); + (_d = this.testArray(), { set value(x) { _classPrivateFieldSet(A, _staticFieldWeakMap_1, x); } }.value = _d[0], y = _d[1]); } A.prototype.testObject = function () { return { x: 10, y: 6 }; @@ -32,6 +36,8 @@ var A = /** @class */ (function () { A.prototype.testArray = function () { return [10, 11]; }; + var _fieldWeakMap_1, _staticFieldWeakMap_1; + _fieldWeakMap_1 = new WeakMap(), _staticFieldWeakMap_1 = new WeakMap(); + _staticFieldWeakMap_1.set(A, 1); return A; }()); -_fieldWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameFieldDestructuredBinding.symbols b/tests/baselines/reference/privateNameFieldDestructuredBinding.symbols index efa03587dfc98..6508b57d801f3 100644 --- a/tests/baselines/reference/privateNameFieldDestructuredBinding.symbols +++ b/tests/baselines/reference/privateNameFieldDestructuredBinding.symbols @@ -5,38 +5,58 @@ class A { #field = 1; >#field : Symbol(A.#field, Decl(privateNameFieldDestructuredBinding.ts, 0, 9)) + static #staticField = 1; +>#staticField : Symbol(A.#staticField, Decl(privateNameFieldDestructuredBinding.ts, 1, 15)) + testObject() { ->testObject : Symbol(A.testObject, Decl(privateNameFieldDestructuredBinding.ts, 1, 15)) +>testObject : Symbol(A.testObject, Decl(privateNameFieldDestructuredBinding.ts, 2, 28)) return { x: 10, y: 6 }; ->x : Symbol(x, Decl(privateNameFieldDestructuredBinding.ts, 3, 16)) ->y : Symbol(y, Decl(privateNameFieldDestructuredBinding.ts, 3, 23)) +>x : Symbol(x, Decl(privateNameFieldDestructuredBinding.ts, 4, 16)) +>y : Symbol(y, Decl(privateNameFieldDestructuredBinding.ts, 4, 23)) } testArray() { ->testArray : Symbol(A.testArray, Decl(privateNameFieldDestructuredBinding.ts, 4, 5)) +>testArray : Symbol(A.testArray, Decl(privateNameFieldDestructuredBinding.ts, 5, 5)) return [10, 11]; } constructor() { let y: number; ->y : Symbol(y, Decl(privateNameFieldDestructuredBinding.ts, 9, 11)) +>y : Symbol(y, Decl(privateNameFieldDestructuredBinding.ts, 10, 11)) ({ x: this.#field, y } = this.testObject()); ->x : Symbol(x, Decl(privateNameFieldDestructuredBinding.ts, 10, 10)) +>x : Symbol(x, Decl(privateNameFieldDestructuredBinding.ts, 11, 10)) >this.#field : Symbol(A.#field, Decl(privateNameFieldDestructuredBinding.ts, 0, 9)) >this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) ->y : Symbol(y, Decl(privateNameFieldDestructuredBinding.ts, 10, 26)) ->this.testObject : Symbol(A.testObject, Decl(privateNameFieldDestructuredBinding.ts, 1, 15)) +>y : Symbol(y, Decl(privateNameFieldDestructuredBinding.ts, 11, 26)) +>this.testObject : Symbol(A.testObject, Decl(privateNameFieldDestructuredBinding.ts, 2, 28)) >this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) ->testObject : Symbol(A.testObject, Decl(privateNameFieldDestructuredBinding.ts, 1, 15)) +>testObject : Symbol(A.testObject, Decl(privateNameFieldDestructuredBinding.ts, 2, 28)) ([this.#field, y] = this.testArray()); >this.#field : Symbol(A.#field, Decl(privateNameFieldDestructuredBinding.ts, 0, 9)) >this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) ->y : Symbol(y, Decl(privateNameFieldDestructuredBinding.ts, 9, 11)) ->this.testArray : Symbol(A.testArray, Decl(privateNameFieldDestructuredBinding.ts, 4, 5)) +>y : Symbol(y, Decl(privateNameFieldDestructuredBinding.ts, 10, 11)) +>this.testArray : Symbol(A.testArray, Decl(privateNameFieldDestructuredBinding.ts, 5, 5)) +>this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) +>testArray : Symbol(A.testArray, Decl(privateNameFieldDestructuredBinding.ts, 5, 5)) + + ({ x: A.#staticField, y } = this.testObject()); +>x : Symbol(x, Decl(privateNameFieldDestructuredBinding.ts, 13, 10)) +>A.#staticField : Symbol(A.#staticField, Decl(privateNameFieldDestructuredBinding.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) +>y : Symbol(y, Decl(privateNameFieldDestructuredBinding.ts, 13, 29)) +>this.testObject : Symbol(A.testObject, Decl(privateNameFieldDestructuredBinding.ts, 2, 28)) +>this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) +>testObject : Symbol(A.testObject, Decl(privateNameFieldDestructuredBinding.ts, 2, 28)) + + ([A.#staticField, y] = this.testArray()); +>A.#staticField : Symbol(A.#staticField, Decl(privateNameFieldDestructuredBinding.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) +>y : Symbol(y, Decl(privateNameFieldDestructuredBinding.ts, 10, 11)) +>this.testArray : Symbol(A.testArray, Decl(privateNameFieldDestructuredBinding.ts, 5, 5)) >this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) ->testArray : Symbol(A.testArray, Decl(privateNameFieldDestructuredBinding.ts, 4, 5)) +>testArray : Symbol(A.testArray, Decl(privateNameFieldDestructuredBinding.ts, 5, 5)) } } diff --git a/tests/baselines/reference/privateNameFieldDestructuredBinding.types b/tests/baselines/reference/privateNameFieldDestructuredBinding.types index b948b04e66cd7..1764f70a05296 100644 --- a/tests/baselines/reference/privateNameFieldDestructuredBinding.types +++ b/tests/baselines/reference/privateNameFieldDestructuredBinding.types @@ -4,6 +4,10 @@ class A { #field = 1; >#field : number +>1 : 1 + + static #staticField = 1; +>#staticField : number >1 : 1 testObject() { @@ -51,6 +55,31 @@ class A { >this.testArray() : number[] >this.testArray : () => number[] >this : this +>testArray : () => number[] + + ({ x: A.#staticField, y } = this.testObject()); +>({ x: A.#staticField, y } = this.testObject()) : { x: number; y: number; } +>{ x: A.#staticField, y } = this.testObject() : { x: number; y: number; } +>{ x: A.#staticField, y } : { x: number; y: number; } +>x : number +>A.#staticField : number +>A : typeof A +>y : number +>this.testObject() : { x: number; y: number; } +>this.testObject : () => { x: number; y: number; } +>this : this +>testObject : () => { x: number; y: number; } + + ([A.#staticField, y] = this.testArray()); +>([A.#staticField, y] = this.testArray()) : number[] +>[A.#staticField, y] = this.testArray() : number[] +>[A.#staticField, y] : [number, number] +>A.#staticField : number +>A : typeof A +>y : number +>this.testArray() : number[] +>this.testArray : () => number[] +>this : this >testArray : () => number[] } } diff --git a/tests/baselines/reference/privateNameFieldInitializer.js b/tests/baselines/reference/privateNameFieldInitializer.js index d3162f7fbfb2a..5104bf321f920 100644 --- a/tests/baselines/reference/privateNameFieldInitializer.js +++ b/tests/baselines/reference/privateNameFieldInitializer.js @@ -1,17 +1,20 @@ //// [privateNameFieldInitializer.ts] class A { #field = 10; + static #staticField = 10; #uninitialized; + static #staticUninitialized; } //// [privateNameFieldInitializer.js] -var _fieldWeakMap_1, _uninitializedWeakMap_1; var A = /** @class */ (function () { function A() { _fieldWeakMap_1.set(this, 10); _uninitializedWeakMap_1.set(this, void 0); } + var _fieldWeakMap_1, _staticFieldWeakMap_1, _uninitializedWeakMap_1, _staticUninitializedWeakMap_1; + _fieldWeakMap_1 = new WeakMap(), _staticFieldWeakMap_1 = new WeakMap(), _uninitializedWeakMap_1 = new WeakMap(), _staticUninitializedWeakMap_1 = new WeakMap(); + _staticFieldWeakMap_1.set(A, 10); return A; }()); -_fieldWeakMap_1 = new WeakMap(), _uninitializedWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameFieldInitializer.symbols b/tests/baselines/reference/privateNameFieldInitializer.symbols index 015a4f9ef4aa1..95fab70458d6c 100644 --- a/tests/baselines/reference/privateNameFieldInitializer.symbols +++ b/tests/baselines/reference/privateNameFieldInitializer.symbols @@ -5,7 +5,13 @@ class A { #field = 10; >#field : Symbol(A.#field, Decl(privateNameFieldInitializer.ts, 0, 9)) + static #staticField = 10; +>#staticField : Symbol(A.#staticField, Decl(privateNameFieldInitializer.ts, 1, 16)) + #uninitialized; ->#uninitialized : Symbol(A.#uninitialized, Decl(privateNameFieldInitializer.ts, 1, 16)) +>#uninitialized : Symbol(A.#uninitialized, Decl(privateNameFieldInitializer.ts, 2, 29)) + + static #staticUninitialized; +>#staticUninitialized : Symbol(A.#staticUninitialized, Decl(privateNameFieldInitializer.ts, 3, 19)) } diff --git a/tests/baselines/reference/privateNameFieldInitializer.types b/tests/baselines/reference/privateNameFieldInitializer.types index e6e701777c80c..6ccb2f6de6a33 100644 --- a/tests/baselines/reference/privateNameFieldInitializer.types +++ b/tests/baselines/reference/privateNameFieldInitializer.types @@ -4,9 +4,16 @@ class A { #field = 10; >#field : number +>10 : 10 + + static #staticField = 10; +>#staticField : number >10 : 10 #uninitialized; >#uninitialized : any + + static #staticUninitialized; +>#staticUninitialized : any } diff --git a/tests/baselines/reference/privateNameFieldUnaryMutation.js b/tests/baselines/reference/privateNameFieldUnaryMutation.js index 2c96670c12922..b89a40f9525f1 100644 --- a/tests/baselines/reference/privateNameFieldUnaryMutation.js +++ b/tests/baselines/reference/privateNameFieldUnaryMutation.js @@ -1,43 +1,63 @@ //// [privateNameFieldUnaryMutation.ts] class C { #test: number = 24; + static #staticTest: number = 24; constructor() { this.#test++; this.#test--; ++this.#test; --this.#test; + C.#staticTest++; + C.#staticTest--; + ++C.#staticTest; + --C.#staticTest; } test() { this.getInstance().#test++; this.getInstance().#test--; ++this.getInstance().#test; --this.getInstance().#test; + this.getClass().#staticTest++; + this.getClass().#staticTest--; + ++this.getClass().#staticTest; + --this.getClass().#staticTest; } getInstance() { return new C(); } + getClass() { return C; } } //// [privateNameFieldUnaryMutation.js] var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; -var _testWeakMap_1; var C = /** @class */ (function () { function C() { _testWeakMap_1.set(this, 24); - var _a, _b; + var _a, _b, C_1, _c, C_2, _d, _e, _f; _a = _classPrivateFieldGet(this, _testWeakMap_1), _classPrivateFieldSet(this, _testWeakMap_1, _a + 1), _a; _b = _classPrivateFieldGet(this, _testWeakMap_1), _classPrivateFieldSet(this, _testWeakMap_1, _b - 1), _b; _classPrivateFieldSet(this, _testWeakMap_1, _classPrivateFieldGet(this, _testWeakMap_1) + 1); _classPrivateFieldSet(this, _testWeakMap_1, _classPrivateFieldGet(this, _testWeakMap_1) - 1); + C_1 = C, _c = _classPrivateFieldGet(C_1, _staticTestWeakMap_1), _classPrivateFieldSet(C_1, _staticTestWeakMap_1, _c + 1), _c; + C_2 = C, _d = _classPrivateFieldGet(C_2, _staticTestWeakMap_1), _classPrivateFieldSet(C_2, _staticTestWeakMap_1, _d - 1), _d; + _classPrivateFieldSet(_e = C, _staticTestWeakMap_1, _classPrivateFieldGet(_e, _staticTestWeakMap_1) + 1); + _classPrivateFieldSet(_f = C, _staticTestWeakMap_1, _classPrivateFieldGet(_f, _staticTestWeakMap_1) - 1); } C.prototype.test = function () { - var _a, _b, _c, _d, _e, _f; + var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m; _a = this.getInstance(), _b = _classPrivateFieldGet(_a, _testWeakMap_1), _classPrivateFieldSet(_a, _testWeakMap_1, _b + 1), _b; _c = this.getInstance(), _d = _classPrivateFieldGet(_c, _testWeakMap_1), _classPrivateFieldSet(_c, _testWeakMap_1, _d - 1), _d; _classPrivateFieldSet(_e = this.getInstance(), _testWeakMap_1, _classPrivateFieldGet(_e, _testWeakMap_1) + 1); _classPrivateFieldSet(_f = this.getInstance(), _testWeakMap_1, _classPrivateFieldGet(_f, _testWeakMap_1) - 1); + _g = this.getClass(), _h = _classPrivateFieldGet(_g, _staticTestWeakMap_1), _classPrivateFieldSet(_g, _staticTestWeakMap_1, _h + 1), _h; + _j = this.getClass(), _k = _classPrivateFieldGet(_j, _staticTestWeakMap_1), _classPrivateFieldSet(_j, _staticTestWeakMap_1, _k - 1), _k; + _classPrivateFieldSet(_l = this.getClass(), _staticTestWeakMap_1, _classPrivateFieldGet(_l, _staticTestWeakMap_1) + 1); + _classPrivateFieldSet(_m = this.getClass(), _staticTestWeakMap_1, _classPrivateFieldGet(_m, _staticTestWeakMap_1) - 1); }; C.prototype.getInstance = function () { return new C(); }; + C.prototype.getClass = function () { return C; }; + var _testWeakMap_1, _staticTestWeakMap_1; + _testWeakMap_1 = new WeakMap(), _staticTestWeakMap_1 = new WeakMap(); + _staticTestWeakMap_1.set(C, 24); return C; }()); -_testWeakMap_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameFieldUnaryMutation.symbols b/tests/baselines/reference/privateNameFieldUnaryMutation.symbols index f224ef769c379..106d85172b271 100644 --- a/tests/baselines/reference/privateNameFieldUnaryMutation.symbols +++ b/tests/baselines/reference/privateNameFieldUnaryMutation.symbols @@ -5,6 +5,9 @@ class C { #test: number = 24; >#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9)) + static #staticTest: number = 24; +>#staticTest : Symbol(C.#staticTest, Decl(privateNameFieldUnaryMutation.ts, 1, 23)) + constructor() { this.#test++; >this.#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9)) @@ -21,36 +24,80 @@ class C { --this.#test; >this.#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9)) >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0)) + + C.#staticTest++; +>C.#staticTest : Symbol(C.#staticTest, Decl(privateNameFieldUnaryMutation.ts, 1, 23)) +>C : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0)) + + C.#staticTest--; +>C.#staticTest : Symbol(C.#staticTest, Decl(privateNameFieldUnaryMutation.ts, 1, 23)) +>C : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0)) + + ++C.#staticTest; +>C.#staticTest : Symbol(C.#staticTest, Decl(privateNameFieldUnaryMutation.ts, 1, 23)) +>C : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0)) + + --C.#staticTest; +>C.#staticTest : Symbol(C.#staticTest, Decl(privateNameFieldUnaryMutation.ts, 1, 23)) +>C : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0)) } test() { ->test : Symbol(C.test, Decl(privateNameFieldUnaryMutation.ts, 7, 5)) +>test : Symbol(C.test, Decl(privateNameFieldUnaryMutation.ts, 12, 5)) this.getInstance().#test++; >this.getInstance().#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9)) ->this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 13, 5)) +>this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 22, 5)) >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0)) ->getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 13, 5)) +>getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 22, 5)) this.getInstance().#test--; >this.getInstance().#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9)) ->this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 13, 5)) +>this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 22, 5)) >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0)) ->getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 13, 5)) +>getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 22, 5)) ++this.getInstance().#test; >this.getInstance().#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9)) ->this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 13, 5)) +>this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 22, 5)) >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0)) ->getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 13, 5)) +>getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 22, 5)) --this.getInstance().#test; >this.getInstance().#test : Symbol(C.#test, Decl(privateNameFieldUnaryMutation.ts, 0, 9)) ->this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 13, 5)) +>this.getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 22, 5)) >this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0)) ->getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 13, 5)) +>getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 22, 5)) + + this.getClass().#staticTest++; +>this.getClass().#staticTest : Symbol(C.#staticTest, Decl(privateNameFieldUnaryMutation.ts, 1, 23)) +>this.getClass : Symbol(C.getClass, Decl(privateNameFieldUnaryMutation.ts, 23, 37)) +>this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0)) +>getClass : Symbol(C.getClass, Decl(privateNameFieldUnaryMutation.ts, 23, 37)) + + this.getClass().#staticTest--; +>this.getClass().#staticTest : Symbol(C.#staticTest, Decl(privateNameFieldUnaryMutation.ts, 1, 23)) +>this.getClass : Symbol(C.getClass, Decl(privateNameFieldUnaryMutation.ts, 23, 37)) +>this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0)) +>getClass : Symbol(C.getClass, Decl(privateNameFieldUnaryMutation.ts, 23, 37)) + + ++this.getClass().#staticTest; +>this.getClass().#staticTest : Symbol(C.#staticTest, Decl(privateNameFieldUnaryMutation.ts, 1, 23)) +>this.getClass : Symbol(C.getClass, Decl(privateNameFieldUnaryMutation.ts, 23, 37)) +>this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0)) +>getClass : Symbol(C.getClass, Decl(privateNameFieldUnaryMutation.ts, 23, 37)) + + --this.getClass().#staticTest; +>this.getClass().#staticTest : Symbol(C.#staticTest, Decl(privateNameFieldUnaryMutation.ts, 1, 23)) +>this.getClass : Symbol(C.getClass, Decl(privateNameFieldUnaryMutation.ts, 23, 37)) +>this : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0)) +>getClass : Symbol(C.getClass, Decl(privateNameFieldUnaryMutation.ts, 23, 37)) } getInstance() { return new C(); } ->getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 13, 5)) +>getInstance : Symbol(C.getInstance, Decl(privateNameFieldUnaryMutation.ts, 22, 5)) +>C : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0)) + + getClass() { return C; } +>getClass : Symbol(C.getClass, Decl(privateNameFieldUnaryMutation.ts, 23, 37)) >C : Symbol(C, Decl(privateNameFieldUnaryMutation.ts, 0, 0)) } diff --git a/tests/baselines/reference/privateNameFieldUnaryMutation.types b/tests/baselines/reference/privateNameFieldUnaryMutation.types index 130aa9bf39f82..cca4417c83802 100644 --- a/tests/baselines/reference/privateNameFieldUnaryMutation.types +++ b/tests/baselines/reference/privateNameFieldUnaryMutation.types @@ -4,6 +4,10 @@ class C { #test: number = 24; >#test : number +>24 : 24 + + static #staticTest: number = 24; +>#staticTest : number >24 : 24 constructor() { @@ -26,6 +30,26 @@ class C { >--this.#test : number >this.#test : number >this : this + + C.#staticTest++; +>C.#staticTest++ : number +>C.#staticTest : number +>C : typeof C + + C.#staticTest--; +>C.#staticTest-- : number +>C.#staticTest : number +>C : typeof C + + ++C.#staticTest; +>++C.#staticTest : number +>C.#staticTest : number +>C : typeof C + + --C.#staticTest; +>--C.#staticTest : number +>C.#staticTest : number +>C : typeof C } test() { >test : () => void @@ -61,10 +85,46 @@ class C { >this.getInstance : () => C >this : this >getInstance : () => C + + this.getClass().#staticTest++; +>this.getClass().#staticTest++ : number +>this.getClass().#staticTest : number +>this.getClass() : typeof C +>this.getClass : () => typeof C +>this : this +>getClass : () => typeof C + + this.getClass().#staticTest--; +>this.getClass().#staticTest-- : number +>this.getClass().#staticTest : number +>this.getClass() : typeof C +>this.getClass : () => typeof C +>this : this +>getClass : () => typeof C + + ++this.getClass().#staticTest; +>++this.getClass().#staticTest : number +>this.getClass().#staticTest : number +>this.getClass() : typeof C +>this.getClass : () => typeof C +>this : this +>getClass : () => typeof C + + --this.getClass().#staticTest; +>--this.getClass().#staticTest : number +>this.getClass().#staticTest : number +>this.getClass() : typeof C +>this.getClass : () => typeof C +>this : this +>getClass : () => typeof C } getInstance() { return new C(); } >getInstance : () => C >new C() : C +>C : typeof C + + getClass() { return C; } +>getClass : () => typeof C >C : typeof C } diff --git a/tests/baselines/reference/privateNamesAndStaticFields.js b/tests/baselines/reference/privateNamesAndStaticFields.js index 00f1c5fbe5a0a..f86b7f6bdb272 100644 --- a/tests/baselines/reference/privateNamesAndStaticFields.js +++ b/tests/baselines/reference/privateNamesAndStaticFields.js @@ -18,7 +18,6 @@ class B extends A { //// [privateNamesAndStaticFields.js] -"use strict"; // @target es6 var __extends = (this && this.__extends) || (function () { var extendStatics = function (d, b) { @@ -33,18 +32,23 @@ var __extends = (this && this.__extends) || (function () { d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; })(); +var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; +var _fooWeakMap_1, _fooWeakMap_2; +"use strict"; var A = /** @class */ (function () { function A() { - A.#foo = 3; + _classPrivateFieldSet(A, _fooWeakMap_1, 3); } return A; }()); +_fooWeakMap_1 = new WeakMap(); var B = /** @class */ (function (_super) { __extends(B, _super); function B() { var _this = _super.call(this) || this; - B.#foo = "some string"; + _classPrivateFieldSet(B, _fooWeakMap_2, "some string"); return _this; } return B; }(A)); +_fooWeakMap_2 = new WeakMap(); diff --git a/tests/baselines/reference/privateNamesAndStaticMethods.js b/tests/baselines/reference/privateNamesAndStaticMethods.js index c1f05dbca087a..24cf3ce556f3b 100644 --- a/tests/baselines/reference/privateNamesAndStaticMethods.js +++ b/tests/baselines/reference/privateNamesAndStaticMethods.js @@ -31,6 +31,9 @@ class B extends A { //// [privateNamesAndStaticMethods.js] +var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); }; +var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; }; +var __quuxWeakMap_1; "use strict"; class A { constructor() { @@ -42,12 +45,13 @@ class A { A.#quux++; } static get #quux() { - return this.#_quux; + return _classPrivateFieldGet(this, __quuxWeakMap_1); } static set #quux(val) { - this.#_quux = val; + _classPrivateFieldSet(this, __quuxWeakMap_1, val); } } +__quuxWeakMap_1 = new WeakMap(); class B extends A { constructor() { var _a; diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameField.ts b/tests/cases/conformance/classes/members/privateNames/privateNameField.ts index d4b823c49da63..cf49e8be57edb 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameField.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameField.ts @@ -1,9 +1,8 @@ -// @strict: true -// @target es6 - -class A { - #name: string; - constructor(name: string) { - this.#name = name; - } +class A { + #name: string; + static #staticName: string; + constructor(name: string) { + this.#name = name; + A.#staticName = name; + } } \ No newline at end of file diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameFieldAccess.ts b/tests/cases/conformance/classes/members/privateNames/privateNameFieldAccess.ts index 42b30a058dc03..785d4a50d837f 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameFieldAccess.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameFieldAccess.ts @@ -1,6 +1,8 @@ -class A { - #myField = "hello world"; - constructor() { - console.log(this.#myField); - } -} +class A { + #myField = "hello world"; + static #myStaticField = "hello world"; + constructor() { + console.log(this.#myField); + console.log(A.#myStaticField); + } +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameFieldAssignment.ts b/tests/cases/conformance/classes/members/privateNames/privateNameFieldAssignment.ts index c4551908427b9..346d95ed7189d 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameFieldAssignment.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameFieldAssignment.ts @@ -1,34 +1,64 @@ -class A { - #field = 0; - constructor() { - this.#field = 1; - this.#field += 2; - this.#field -= 3; - this.#field /= 4; - this.#field *= 5; - this.#field **= 6; - this.#field %= 7; - this.#field <<= 8; - this.#field >>= 9; - this.#field >>>= 10; - this.#field &= 11; - this.#field |= 12; - this.#field ^= 13; - A.getInstance().#field = 1; - A.getInstance().#field += 2; - A.getInstance().#field -= 3; - A.getInstance().#field /= 4; - A.getInstance().#field *= 5; - A.getInstance().#field **= 6; - A.getInstance().#field %= 7; - A.getInstance().#field <<= 8; - A.getInstance().#field >>= 9; - A.getInstance().#field >>>= 10; - A.getInstance().#field &= 11; - A.getInstance().#field |= 12; - A.getInstance().#field ^= 13; - } - static getInstance() { - return new A(); - } -} +class A { + #field = 0; + static #staticField = 0; + constructor() { + this.#field = 1; + this.#field += 2; + this.#field -= 3; + this.#field /= 4; + this.#field *= 5; + this.#field **= 6; + this.#field %= 7; + this.#field <<= 8; + this.#field >>= 9; + this.#field >>>= 10; + this.#field &= 11; + this.#field |= 12; + this.#field ^= 13; + A.getInstance().#field = 1; + A.getInstance().#field += 2; + A.getInstance().#field -= 3; + A.getInstance().#field /= 4; + A.getInstance().#field *= 5; + A.getInstance().#field **= 6; + A.getInstance().#field %= 7; + A.getInstance().#field <<= 8; + A.getInstance().#field >>= 9; + A.getInstance().#field >>>= 10; + A.getInstance().#field &= 11; + A.getInstance().#field |= 12; + A.getInstance().#field ^= 13; + A.#staticField = 1; + A.#staticField += 2; + A.#staticField -= 3; + A.#staticField /= 4; + A.#staticField *= 5; + A.#staticField **= 6; + A.#staticField %= 7; + A.#staticField <<= 8; + A.#staticField >>= 9; + A.#staticField >>>= 10; + A.#staticField &= 11; + A.#staticField |= 12; + A.#staticField ^= 13; + A.getClass().#staticField = 1; + A.getClass().#staticField += 2; + A.getClass().#staticField -= 3; + A.getClass().#staticField /= 4; + A.getClass().#staticField *= 5; + A.getClass().#staticField **= 6; + A.getClass().#staticField %= 7; + A.getClass().#staticField <<= 8; + A.getClass().#staticField >>= 9; + A.getClass().#staticField >>>= 10; + A.getClass().#staticField &= 11; + A.getClass().#staticField |= 12; + A.getClass().#staticField ^= 13; + } + static getInstance() { + return new A(); + } + static getClass() { + return this; + } +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameFieldCallExpression.ts b/tests/cases/conformance/classes/members/privateNames/privateNameFieldCallExpression.ts index 8feb41dbeb081..95a15a466985b 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameFieldCallExpression.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameFieldCallExpression.ts @@ -1,9 +1,14 @@ -class A { - #fieldFunc = () => this.x = 10; - x = 1; - test() { - this.#fieldFunc(); - const func = this.#fieldFunc; - func(); - } -} +class A { + #fieldFunc = () => this.x = 10; + static #staticFieldFunc = () => A.staticX = 10; + x = 1; + static staticX = 1; + test() { + this.#fieldFunc(); + const func = this.#fieldFunc; + func(); + A.#staticFieldFunc(); + const func2 = A.#staticFieldFunc; + func2(); + } +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameFieldDeclaration.ts b/tests/cases/conformance/classes/members/privateNames/privateNameFieldDeclaration.ts index e66fe5d894b64..369b2c92aa54a 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameFieldDeclaration.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameFieldDeclaration.ts @@ -1,3 +1,4 @@ class A { #name: string; + static #staticName: string; } diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameFieldDestructuredBinding.ts b/tests/cases/conformance/classes/members/privateNames/privateNameFieldDestructuredBinding.ts index e68d32e8bdb56..f647343054a76 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameFieldDestructuredBinding.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameFieldDestructuredBinding.ts @@ -1,14 +1,17 @@ -class A { - #field = 1; - testObject() { - return { x: 10, y: 6 }; - } - testArray() { - return [10, 11]; - } - constructor() { - let y: number; - ({ x: this.#field, y } = this.testObject()); - ([this.#field, y] = this.testArray()); - } -} +class A { + #field = 1; + static #staticField = 1; + testObject() { + return { x: 10, y: 6 }; + } + testArray() { + return [10, 11]; + } + constructor() { + let y: number; + ({ x: this.#field, y } = this.testObject()); + ([this.#field, y] = this.testArray()); + ({ x: A.#staticField, y } = this.testObject()); + ([A.#staticField, y] = this.testArray()); + } +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameFieldInitializer.ts b/tests/cases/conformance/classes/members/privateNames/privateNameFieldInitializer.ts index fa58a79d9f993..915aabb0b56ab 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameFieldInitializer.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameFieldInitializer.ts @@ -1,4 +1,6 @@ -class A { - #field = 10; - #uninitialized; -} +class A { + #field = 10; + static #staticField = 10; + #uninitialized; + static #staticUninitialized; +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameFieldUnaryMutation.ts b/tests/cases/conformance/classes/members/privateNames/privateNameFieldUnaryMutation.ts index 84dd6da2ec4d9..8ea15a0c8ccac 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameFieldUnaryMutation.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameFieldUnaryMutation.ts @@ -1,16 +1,26 @@ -class C { - #test: number = 24; - constructor() { - this.#test++; - this.#test--; - ++this.#test; - --this.#test; - } - test() { - this.getInstance().#test++; - this.getInstance().#test--; - ++this.getInstance().#test; - --this.getInstance().#test; - } - getInstance() { return new C(); } -} +class C { + #test: number = 24; + static #staticTest: number = 24; + constructor() { + this.#test++; + this.#test--; + ++this.#test; + --this.#test; + C.#staticTest++; + C.#staticTest--; + ++C.#staticTest; + --C.#staticTest; + } + test() { + this.getInstance().#test++; + this.getInstance().#test--; + ++this.getInstance().#test; + --this.getInstance().#test; + this.getClass().#staticTest++; + this.getClass().#staticTest--; + ++this.getClass().#staticTest; + --this.getClass().#staticTest; + } + getInstance() { return new C(); } + getClass() { return C; } +}