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) + } +}