From 1707f910205bfe78cae983e68810e4c6e9c5e5cc Mon Sep 17 00:00:00 2001 From: Max Heiber Date: Fri, 27 Jul 2018 15:39:57 -0400 Subject: [PATCH 1/8] begin update checker for private names - [x] treat private names as unique: - case 1: cannot say that a variable is of a class type unless the variable points to an instance of the class - see [test](https://github.com/mheiber/TypeScript/tree/checker/tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts) - case 2: private names in class hierarchies do not conflict - see [test](https://github.com/mheiber/TypeScript/tree/checker/tests/cases/conformance/classes/members/privateNames/privateNamesNoConflictWhenInheriting.ts) - [x] `#constructor` is reserved - see [test](https://github.com/mheiber/TypeScript/tree/checker/tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts) - check in `bindWorker`, where every node is visited - [x] Accessibility modifiers can't be used with private names - see [test](https://github.com/mheiber/TypeScript/tree/checker/tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts) - implemented in `checkAccessibilityModifiers`, using `ModifierFlags.AccessibilityModifier` - [x] `delete #foo` not allowed - [x] Private name accesses not allowed outside of the defining class - see test: https://github.com/mheiber/TypeScript/tree/checker/tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts - see [test](https://github.com/mheiber/TypeScript/tree/checker/tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts) - implemented in `checkDeleteExpression` - [x] Do [the right thing](https://gist.github.com/mheiber/b6fc7adb426c2e1cdaceb5d7786fc630) for nested classes Signed-off-by: Max Heiber --- src/compiler/binder.ts | 24 ++++- src/compiler/checker.ts | 102 ++++++++++++++---- src/compiler/diagnosticMessages.json | 20 +++- src/compiler/utilities.ts | 4 + ...ionMapsGeneratedMapsEnableMapping.baseline | 34 ++++++ ...onMapsGeneratedMapsEnableMapping2.baseline | 35 ++++++ ...onMapsGeneratedMapsEnableMapping3.baseline | 34 ++++++ ...neratedMapsEnableMapping_NoInline.baseline | 34 ++++++ ...MapsEnableMapping_NoInlineSources.baseline | 34 ++++++ .../privateNameConstructorReserved.errors.txt | 22 ++++ .../privateNameConstructorReserved.js | 22 ++++ .../privateNameConstructorReserved.symbols | 14 +++ .../privateNameConstructorReserved.types | 15 +++ ...tAccessibleOutsideDefiningClass.errors.txt | 15 +++ ...teNameNotAccessibleOutsideDefiningClass.js | 16 +++ ...eNotAccessibleOutsideDefiningClass.symbols | 11 ++ ...ameNotAccessibleOutsideDefiningClass.types | 16 +++ ...ivateNameNotAllowedOutsideClass.errors.txt | 13 +++ .../privateNameNotAllowedOutsideClass.js | 6 ++ .../privateNameNotAllowedOutsideClass.symbols | 3 + .../privateNameNotAllowedOutsideClass.types | 4 + .../privateNameSneakyRuntimeException.js | 30 ++++++ .../privateNameSneakyRuntimeException.symbols | 37 +++++++ .../privateNameSneakyRuntimeException.types | 49 +++++++++ .../reference/privateNamesAndkeyof.js | 16 +++ .../reference/privateNamesAndkeyof.symbols | 18 ++++ .../reference/privateNamesAndkeyof.types | 17 +++ .../privateNamesInGenericClasses.errors.txt | 32 ++++++ .../reference/privateNamesInGenericClasses.js | 27 +++++ .../privateNamesInGenericClasses.symbols | 51 +++++++++ .../privateNamesInGenericClasses.types | 46 ++++++++ .../privateNamesInNestedClasses.errors.txt | 34 ++++++ .../reference/privateNamesInNestedClasses.js | 58 ++++++++++ .../privateNamesInNestedClasses.symbols | 77 +++++++++++++ .../privateNamesInNestedClasses.types | 90 ++++++++++++++++ ...teNamesNoAccessibilityModifiers.errors.txt | 19 ++++ .../privateNamesNoAccessibilityModifiers.js | 15 +++ ...ivateNamesNoAccessibilityModifiers.symbols | 17 +++ ...privateNamesNoAccessibilityModifiers.types | 17 +++ .../privateNamesNoConflictWhenInheriting.js | 39 +++++++ ...ivateNamesNoConflictWhenInheriting.symbols | 21 ++++ ...privateNamesNoConflictWhenInheriting.types | 21 ++++ .../reference/privateNamesNoDelete.errors.txt | 13 +++ .../reference/privateNamesNoDelete.js | 17 +++ .../reference/privateNamesNoDelete.symbols | 14 +++ .../reference/privateNamesNoDelete.types | 16 +++ ...vateNamesNotAllowedAsParameters.errors.txt | 19 ++++ .../privateNamesNotAllowedAsParameters.js | 14 +++ ...privateNamesNotAllowedAsParameters.symbols | 9 ++ .../privateNamesNotAllowedAsParameters.types | 9 ++ ...otAllowedInVariableDeclarations.errors.txt | 13 +++ ...teNamesNotAllowedInVariableDeclarations.js | 6 ++ ...esNotAllowedInVariableDeclarations.symbols | 3 + ...amesNotAllowedInVariableDeclarations.types | 4 + .../reference/privateNamesUnique.errors.txt | 18 ++++ .../baselines/reference/privateNamesUnique.js | 24 +++++ .../reference/privateNamesUnique.symbols | 20 ++++ .../reference/privateNamesUnique.types | 20 ++++ .../privateNameAndIndexSignature.ts | 12 +-- .../privateNameConstructorReserved.ts | 7 ++ .../members/privateNames/privateNameField.ts | 10 +- ...teNameNotAccessibleOutsideDefiningClass.ts | 5 + .../privateNameNotAllowedOutsideClass.ts | 1 + .../privateNameSneakyRuntimeException.ts | 13 +++ .../privateNames/privateNamesAndkeyof.ts | 7 ++ .../privateNamesInGenericClasses.ts | 12 +++ .../privateNamesInNestedClasses.ts | 25 +++++ .../privateNamesNoAccessibilityModifiers.ts | 6 ++ .../privateNamesNoConflictWhenInheriting.ts | 9 ++ .../privateNames/privateNamesNoDelete.ts | 6 ++ .../privateNamesNotAllowedAsParameters.ts | 3 + .../privateNames/privateNamesUnique.ts | 9 ++ ...teNamesNotAllowedInVariableDeclarations.ts | 1 + 73 files changed, 1521 insertions(+), 33 deletions(-) create mode 100644 tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping.baseline create mode 100644 tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping2.baseline create mode 100644 tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping3.baseline create mode 100644 tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping_NoInline.baseline create mode 100644 tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping_NoInlineSources.baseline create mode 100644 tests/baselines/reference/privateNameConstructorReserved.errors.txt create mode 100644 tests/baselines/reference/privateNameConstructorReserved.js create mode 100644 tests/baselines/reference/privateNameConstructorReserved.symbols create mode 100644 tests/baselines/reference/privateNameConstructorReserved.types create mode 100644 tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.errors.txt create mode 100644 tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.js create mode 100644 tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.symbols create mode 100644 tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.types create mode 100644 tests/baselines/reference/privateNameNotAllowedOutsideClass.errors.txt create mode 100644 tests/baselines/reference/privateNameNotAllowedOutsideClass.js create mode 100644 tests/baselines/reference/privateNameNotAllowedOutsideClass.symbols create mode 100644 tests/baselines/reference/privateNameNotAllowedOutsideClass.types create mode 100644 tests/baselines/reference/privateNameSneakyRuntimeException.js create mode 100644 tests/baselines/reference/privateNameSneakyRuntimeException.symbols create mode 100644 tests/baselines/reference/privateNameSneakyRuntimeException.types create mode 100644 tests/baselines/reference/privateNamesAndkeyof.js create mode 100644 tests/baselines/reference/privateNamesAndkeyof.symbols create mode 100644 tests/baselines/reference/privateNamesAndkeyof.types create mode 100644 tests/baselines/reference/privateNamesInGenericClasses.errors.txt create mode 100644 tests/baselines/reference/privateNamesInGenericClasses.js create mode 100644 tests/baselines/reference/privateNamesInGenericClasses.symbols create mode 100644 tests/baselines/reference/privateNamesInGenericClasses.types create mode 100644 tests/baselines/reference/privateNamesInNestedClasses.errors.txt create mode 100644 tests/baselines/reference/privateNamesInNestedClasses.js create mode 100644 tests/baselines/reference/privateNamesInNestedClasses.symbols create mode 100644 tests/baselines/reference/privateNamesInNestedClasses.types create mode 100644 tests/baselines/reference/privateNamesNoAccessibilityModifiers.errors.txt create mode 100644 tests/baselines/reference/privateNamesNoAccessibilityModifiers.js create mode 100644 tests/baselines/reference/privateNamesNoAccessibilityModifiers.symbols create mode 100644 tests/baselines/reference/privateNamesNoAccessibilityModifiers.types create mode 100644 tests/baselines/reference/privateNamesNoConflictWhenInheriting.js create mode 100644 tests/baselines/reference/privateNamesNoConflictWhenInheriting.symbols create mode 100644 tests/baselines/reference/privateNamesNoConflictWhenInheriting.types create mode 100644 tests/baselines/reference/privateNamesNoDelete.errors.txt create mode 100644 tests/baselines/reference/privateNamesNoDelete.js create mode 100644 tests/baselines/reference/privateNamesNoDelete.symbols create mode 100644 tests/baselines/reference/privateNamesNoDelete.types create mode 100644 tests/baselines/reference/privateNamesNotAllowedAsParameters.errors.txt create mode 100644 tests/baselines/reference/privateNamesNotAllowedAsParameters.js create mode 100644 tests/baselines/reference/privateNamesNotAllowedAsParameters.symbols create mode 100644 tests/baselines/reference/privateNamesNotAllowedAsParameters.types create mode 100644 tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.errors.txt create mode 100644 tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.js create mode 100644 tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.symbols create mode 100644 tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.types create mode 100644 tests/baselines/reference/privateNamesUnique.errors.txt create mode 100644 tests/baselines/reference/privateNamesUnique.js create mode 100644 tests/baselines/reference/privateNamesUnique.symbols create mode 100644 tests/baselines/reference/privateNamesUnique.types create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNameSneakyRuntimeException.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamesAndkeyof.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamesNoConflictWhenInheriting.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts create mode 100644 tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index f26c8544d1ecd..f0bbc6a2d1241 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -271,8 +271,10 @@ namespace ts { Debug.assert(isWellKnownSymbolSyntactically(nameExpression)); return getPropertyNameForKnownSymbolName(idText((nameExpression).name)); } - if (isPrivateName(node)) { - return nodePosToString(node) as __String; + if (isPrivateName(name)) { + // containingClass exists because private names only allowed inside classes + const containingClassSymbol = getContainingClass(name.parent)!.symbol; + return getPropertyNameForPrivateNameDescription(containingClassSymbol, name.escapedText); } return isPropertyNameLiteral(name) ? getEscapedTextOfIdentifierOrLiteral(name) : undefined; } @@ -330,6 +332,10 @@ namespace ts { const isDefaultExport = hasModifier(node, ModifierFlags.Default); + // need this before getDeclarationName + if (isNamedDeclaration(node)) { + node.name.parent = node; + } // The exported symbol for an export default function/class node is always named "default" const name = isDefaultExport && parent ? InternalSymbolName.Default : getDeclarationName(node); @@ -1802,6 +1808,18 @@ namespace ts { return Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode; } + // The binder visits every node, so this is a good place to check for + // the reserved private name (there is only one) + function checkPrivateName(node: PrivateName) { + if (node.escapedText === "#constructor") { + // Report error only if there are no parse errors in file + if (!file.parseDiagnostics.length) { + file.bindDiagnostics.push(createDiagnosticForNode(node, + Diagnostics.constructor_is_a_reserved_word, declarationNameToString(node))); + } + } + } + function checkStrictModeBinaryExpression(node: BinaryExpression) { if (inStrictMode && isLeftHandSideExpression(node.left) && isAssignmentOperator(node.operatorToken.kind)) { // ECMA 262 (Annex C) The identifier eval or arguments may not appear as the LeftHandSideExpression of an @@ -2074,6 +2092,8 @@ namespace ts { node.flowNode = currentFlow; } return checkStrictModeIdentifier(node); + case SyntaxKind.PrivateName: + return checkPrivateName(node as PrivateName); case SyntaxKind.PropertyAccessExpression: case SyntaxKind.ElementAccessExpression: if (currentFlow && isNarrowableReference(node)) { diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 5888eb6f0b01f..d770c83d12545 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1572,8 +1572,8 @@ namespace ts { } } - function diagnosticName(nameArg: __String | Identifier) { - return isString(nameArg) ? unescapeLeadingUnderscores(nameArg as __String) : declarationNameToString(nameArg as Identifier); + function diagnosticName(nameArg: __String | Identifier | PrivateName) { + return isString(nameArg) ? unescapeLeadingUnderscores(nameArg as __String) : declarationNameToString(nameArg as Identifier | PrivateName); } function isTypeParameterSymbolDeclaredInContainer(symbol: Symbol, container: Node) { @@ -2679,15 +2679,16 @@ namespace ts { return getUnionType(arrayFrom(typeofEQFacts.keys(), getLiteralType)); } - // A reserved member name starts with two underscores, but the third character cannot be an underscore - // or the @ symbol. A third underscore indicates an escaped form of an identifer that started + // A reserved member name starts with two underscores, but the third character cannot be an underscore, + // @ or #. A third underscore indicates an escaped form of an identifer that started // with at least two underscores. The @ character indicates that the name is denoted by a well known ES - // Symbol instance. + // Symbol instance and the # indicates that the name is a PrivateName. function isReservedMemberName(name: __String) { return (name as string).charCodeAt(0) === CharacterCodes._ && (name as string).charCodeAt(1) === CharacterCodes._ && (name as string).charCodeAt(2) !== CharacterCodes._ && - (name as string).charCodeAt(2) !== CharacterCodes.at; + (name as string).charCodeAt(2) !== CharacterCodes.at && + (name as string).charCodeAt(2) !== CharacterCodes.hash; } function getNamedMembers(members: SymbolTable): Symbol[] { @@ -9258,7 +9259,9 @@ namespace ts { } function getLiteralTypeFromPropertyName(prop: Symbol, include: TypeFlags) { - if (!(getDeclarationModifierFlagsFromSymbol(prop) & ModifierFlags.NonPublicAccessibilityModifier)) { + const hasNonPublicModifier = !!(getDeclarationModifierFlagsFromSymbol(prop) & ModifierFlags.NonPublicAccessibilityModifier); + const hasPrivateName = prop.valueDeclaration && isNamedDeclaration(prop.valueDeclaration) && isPrivateName(prop.valueDeclaration.name); + if (!hasNonPublicModifier && !hasPrivateName) { let type = getLateBoundSymbol(prop).nameType; if (!type && !isKnownSymbol(prop)) { const name = prop.valueDeclaration && getNameOfDeclaration(prop.valueDeclaration); @@ -12205,7 +12208,28 @@ namespace ts { const unmatchedProperty = getUnmatchedProperty(source, target, requireOptionalProperties); if (unmatchedProperty) { if (reportErrors) { - reportError(Diagnostics.Property_0_is_missing_in_type_1, symbolToString(unmatchedProperty), typeToString(source)); + let hasReported = false; + // give specific error in case where private names have the same description + if ( + unmatchedProperty.valueDeclaration + && isNamedDeclaration(unmatchedProperty.valueDeclaration) + && isPrivateName(unmatchedProperty.valueDeclaration.name) + && isClassDeclaration(source.symbol.valueDeclaration) + ) { + const privateNameDescription = unmatchedProperty.valueDeclaration.name.escapedText; + const symbolTableKey = getPropertyNameForPrivateNameDescription(source.symbol, privateNameDescription); + if (symbolTableKey && !!getPropertyOfType(source, symbolTableKey)) { + reportError( + Diagnostics.Property_0_is_missing_in_type_1_While_type_1_has_a_private_member_with_the_same_spelling_its_declaration_and_accessibility_are_distinct, + diagnosticName(privateNameDescription), + diagnosticName(source.symbol.valueDeclaration.name || ("anonymous" as __String)) + ); + hasReported = true; + } + } + if (!hasReported) { + reportError(Diagnostics.Property_0_is_missing_in_type_1, symbolToString(unmatchedProperty), typeToString(source)); + } } return Ternary.False; } @@ -18423,6 +18447,46 @@ namespace ts { return checkPropertyAccessExpressionOrQualifiedName(node, node.left, node.right); } + function getPropertyByPrivateName(apparentType: Type, leftType: Type, right: PrivateName): Symbol | undefined { + let classWithShadowedPrivateName; + let klass = getContainingClass(right); + while (klass) { + const symbolTableKey = getPropertyNameForPrivateNameDescription(klass.symbol, right.escapedText); + if (symbolTableKey) { + const prop = getPropertyOfType(apparentType, symbolTableKey); + if (prop) { + if (classWithShadowedPrivateName) { + error( + right, + Diagnostics.This_usage_of_0_refers_to_the_private_member_declared_in_its_enclosing_class_While_type_1_has_a_private_member_with_the_same_spelling_its_declaration_and_accessibility_are_distinct, + diagnosticName(right), + diagnosticName(classWithShadowedPrivateName.name || ("anonymous" as __String)) + ); + return undefined; + } + return prop; + } + else { + classWithShadowedPrivateName = klass; + } + } + klass = getContainingClass(klass); + } + // If this isn't a case of shadowing, and the lhs has a property with the same + // private name description, then there is a privacy violation + if (leftType.symbol.members) { + const symbolTableKey = getPropertyNameForPrivateNameDescription(leftType.symbol, right.escapedText); + if (symbolTableKey) { + const prop = getPropertyOfType(apparentType, symbolTableKey); + if (prop) { + error(right, Diagnostics.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_name, symbolToString(prop), typeToString(getDeclaringClass(prop)!)); + } + } + } + // not found + return undefined; + } + function checkPropertyAccessExpressionOrQualifiedName(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, right: Identifier | PrivateName) { let propType: Type; const leftType = checkNonNullExpression(left); @@ -18435,7 +18499,7 @@ namespace ts { return apparentType; } const assignmentKind = getAssignmentTargetKind(node); - const prop = getPropertyOfType(apparentType, right.escapedText); + const prop = isPrivateName(right) ? getPropertyByPrivateName(apparentType, leftType, right) : getPropertyOfType(apparentType, right.escapedText); if (isIdentifier(left) && parentSymbol && !(prop && isConstEnumOrConstEnumOnlyModule(prop))) { markAliasReferenced(parentSymbol, node); } @@ -21376,10 +21440,16 @@ namespace ts { error(expr, Diagnostics.The_operand_of_a_delete_operator_must_be_a_property_reference); return booleanType; } + if (expr.kind === SyntaxKind.PropertyAccessExpression && isPrivateName((expr as PropertyAccessExpression).name)) { + error(expr, Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_private_name); + + } const links = getNodeLinks(expr); const symbol = getExportSymbolOfValueSymbolIfExported(links.resolvedSymbol); - if (symbol && isReadonlySymbol(symbol)) { - error(expr, Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property); + if (symbol) { + if (isReadonlySymbol(symbol)) { + error(expr, Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property); + } } return booleanType; } @@ -22529,9 +22599,6 @@ namespace ts { checkGrammarDecoratorsAndModifiers(node); checkVariableLikeDeclaration(node); - if (node.name && isIdentifier(node.name) && node.name.originalKeywordKind === SyntaxKind.PrivateName) { - error(node, Diagnostics.Private_names_cannot_be_used_as_parameters); - } const func = getContainingFunction(node)!; if (hasModifier(node, ModifierFlags.ParameterPropertyModifier)) { if (!(func.kind === SyntaxKind.Constructor && nodeIsPresent(func.body))) { @@ -29210,6 +29277,9 @@ namespace ts { else if (node.kind === SyntaxKind.Parameter && (flags & ModifierFlags.ParameterPropertyModifier) && (node).dotDotDotToken) { return grammarErrorOnNode(node, Diagnostics.A_parameter_property_cannot_be_declared_using_a_rest_parameter); } + else if (isNamedDeclaration(node) && (flags & ModifierFlags.AccessibilityModifier) && node.name.kind === SyntaxKind.PrivateName) { + return grammarErrorOnNode(node, Diagnostics.Accessibility_modifiers_cannot_be_used_with_private_names); + } if (flags & ModifierFlags.Async) { return checkGrammarAsyncModifier(node, lastAsync!); } @@ -30035,10 +30105,6 @@ namespace ts { checkESModuleMarker(node.name); } - if (isIdentifier(node.name) && node.name.originalKeywordKind === SyntaxKind.PrivateName) { - return grammarErrorOnNode(node.name, Diagnostics.Private_names_are_not_allowed_in_variable_declarations); - } - const checkLetConstNames = (isLet(node) || isVarConst(node)); // 1. LexicalDeclaration : LetOrConst BindingList ; diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 7d9e80385df67..8d8ae8a85c7c1 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -4299,14 +4299,30 @@ "category": "Error", "code": 18003 }, - "Private names are not allowed in variable declarations.": { + "Accessibility modifiers cannot be used with private names.": { "category": "Error", "code": 18004 }, - "Private names cannot be used as parameters": { + "The operand of a delete operator cannot be a private name.": { "category": "Error", "code": 18005 }, + "#constructor is a reserved word.": { + "category": "Error", + "code": 18006 + }, + "Property '{0}' is not accessible outside class '{1}' because it has a private name.": { + "category": "Error", + "code": 18007 + }, + "This usage of '{0}' refers to the private member declared in its enclosing class. While type '{1}' has a private member with the same spelling, its declaration and accessibility are distinct.": { + "category": "Error", + "code": 18008 + }, + "Property '{0}' is missing in type '{1}'. While type '{1}' has a private member with the same spelling, its declaration and accessibility are distinct": { + "category": "Error", + "code": 18009 + }, "File is a CommonJS module; it may be converted to an ES6 module.": { "category": "Suggestion", diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 790072271196a..cac31a75e72bf 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -2732,6 +2732,10 @@ namespace ts { return "__@" + symbolName as __String; } + export function getPropertyNameForPrivateNameDescription(containingClassSymbol: Symbol, description: __String): __String { + return `__#${getSymbolId(containingClassSymbol)}@${description}` as __String; + } + export function isKnownSymbol(symbol: Symbol): boolean { return startsWith(symbol.escapedName as string, "__@"); } diff --git a/tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping.baseline b/tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping.baseline new file mode 100644 index 0000000000000..5fae8ec8c9914 --- /dev/null +++ b/tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping.baseline @@ -0,0 +1,34 @@ +EmitSkipped: false +FileName : ./dist/index.js +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Foo = /** @class */ (function () { + function Foo() { + } + Foo.prototype.methodName = function (propName) { }; + Foo.prototype.otherMethod = function () { + if (Math.random() > 0.5) { + return { x: 42 }; + } + return { y: "yes" }; + }; + return Foo; +}()); +exports.Foo = Foo; +FileName : ./dist/index.d.ts.map +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../tests/cases/fourslash/index.ts"],"names":[],"mappings":"AAAA,qBAAa,GAAG;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IACpC,WAAW;;;;;;;CAMd;AAED,MAAM,WAAW,QAAQ;IACrB,MAAM,EAAE,MAAM,CAAC;CAClB"}FileName : ./dist/index.d.ts +export declare class Foo { + member: string; + methodName(propName: SomeType): void; + otherMethod(): { + x: number; + y?: undefined; + } | { + y: string; + x?: undefined; + }; +} +export interface SomeType { + member: number; +} +//# sourceMappingURL=index.d.ts.map diff --git a/tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping2.baseline b/tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping2.baseline new file mode 100644 index 0000000000000..151713a03bd45 --- /dev/null +++ b/tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping2.baseline @@ -0,0 +1,35 @@ +EmitSkipped: false +FileName : ./dist/index.js.map +{"version":3,"file":"index.js","sourceRoot":"/tests/cases/fourslash/","sources":["index.ts"],"names":[],"mappings":";;AAAA;IAAA;IASA,CAAC;IAPG,wBAAU,GAAV,UAAW,QAAkB,IAAS,CAAC;IACvC,yBAAW,GAAX;QACI,IAAI,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,EAAE;YACrB,OAAO,EAAC,CAAC,EAAE,EAAE,EAAC,CAAC;SAClB;QACD,OAAO,EAAC,CAAC,EAAE,KAAK,EAAC,CAAC;IACtB,CAAC;IACL,UAAC;AAAD,CAAC,AATD,IASC;AATY,kBAAG"}FileName : ./dist/index.js +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Foo = /** @class */ (function () { + function Foo() { + } + Foo.prototype.methodName = function (propName) { }; + Foo.prototype.otherMethod = function () { + if (Math.random() > 0.5) { + return { x: 42 }; + } + return { y: "yes" }; + }; + return Foo; +}()); +exports.Foo = Foo; +//# sourceMappingURL=index.js.mapFileName : ./dist/index.d.ts.map +{"version":3,"file":"index.d.ts","sourceRoot":"/tests/cases/fourslash/","sources":["index.ts"],"names":[],"mappings":"AAAA,qBAAa,GAAG;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IACpC,WAAW;;;;;;;CAMd;AAED,MAAM,WAAW,QAAQ;IACrB,MAAM,EAAE,MAAM,CAAC;CAClB"}FileName : ./dist/index.d.ts +export declare class Foo { + member: string; + methodName(propName: SomeType): void; + otherMethod(): { + x: number; + y?: undefined; + } | { + y: string; + x?: undefined; + }; +} +export interface SomeType { + member: number; +} +//# sourceMappingURL=index.d.ts.map diff --git a/tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping3.baseline b/tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping3.baseline new file mode 100644 index 0000000000000..f05cbbd4c351b --- /dev/null +++ b/tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping3.baseline @@ -0,0 +1,34 @@ +EmitSkipped: false +FileName : ./dist/index.js +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Foo = /** @class */ (function () { + function Foo() { + } + Foo.prototype.methodName = function (propName) { }; + Foo.prototype.otherMethod = function () { + if (Math.random() > 0.5) { + return { x: 42 }; + } + return { y: "yes" }; + }; + return Foo; +}()); +exports.Foo = Foo; +FileName : ./dist/index.d.ts.map +{"version":3,"file":"index.d.ts","sourceRoot":"/tests/cases/fourslash/","sources":["index.ts"],"names":[],"mappings":"AAAA,qBAAa,GAAG;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IACpC,WAAW;;;;;;;CAMd;AAED,MAAM,WAAW,QAAQ;IACrB,MAAM,EAAE,MAAM,CAAC;CAClB"}FileName : ./dist/index.d.ts +export declare class Foo { + member: string; + methodName(propName: SomeType): void; + otherMethod(): { + x: number; + y?: undefined; + } | { + y: string; + x?: undefined; + }; +} +export interface SomeType { + member: number; +} +//# sourceMappingURL=index.d.ts.map diff --git a/tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping_NoInline.baseline b/tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping_NoInline.baseline new file mode 100644 index 0000000000000..ad51be6ddc0f5 --- /dev/null +++ b/tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping_NoInline.baseline @@ -0,0 +1,34 @@ +EmitSkipped: false +FileName : ./dist/index.js +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Foo = /** @class */ (function () { + function Foo() { + } + Foo.prototype.methodName = function (propName) { }; + Foo.prototype.otherMethod = function () { + if (Math.random() > 0.5) { + return { x: 42 }; + } + return { y: "yes" }; + }; + return Foo; +}()); +exports.Foo = Foo; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90ZXN0cy9jYXNlcy9mb3Vyc2xhc2gvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQTtJQUFBO0lBU0EsQ0FBQztJQVBHLHdCQUFVLEdBQVYsVUFBVyxRQUFrQixJQUFTLENBQUM7SUFDdkMseUJBQVcsR0FBWDtRQUNJLElBQUksSUFBSSxDQUFDLE1BQU0sRUFBRSxHQUFHLEdBQUcsRUFBRTtZQUNyQixPQUFPLEVBQUMsQ0FBQyxFQUFFLEVBQUUsRUFBQyxDQUFDO1NBQ2xCO1FBQ0QsT0FBTyxFQUFDLENBQUMsRUFBRSxLQUFLLEVBQUMsQ0FBQztJQUN0QixDQUFDO0lBQ0wsVUFBQztBQUFELENBQUMsQUFURCxJQVNDO0FBVFksa0JBQUcifQ==FileName : ./dist/index.d.ts.map +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../tests/cases/fourslash/index.ts"],"names":[],"mappings":"AAAA,qBAAa,GAAG;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IACpC,WAAW;;;;;;;CAMd;AAED,MAAM,WAAW,QAAQ;IACrB,MAAM,EAAE,MAAM,CAAC;CAClB"}FileName : ./dist/index.d.ts +export declare class Foo { + member: string; + methodName(propName: SomeType): void; + otherMethod(): { + x: number; + y?: undefined; + } | { + y: string; + x?: undefined; + }; +} +export interface SomeType { + member: number; +} +//# sourceMappingURL=index.d.ts.map diff --git a/tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping_NoInlineSources.baseline b/tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping_NoInlineSources.baseline new file mode 100644 index 0000000000000..8f6440b29dc78 --- /dev/null +++ b/tests/baselines/reference/declarationMapsGeneratedMapsEnableMapping_NoInlineSources.baseline @@ -0,0 +1,34 @@ +EmitSkipped: false +FileName : ./dist/index.js +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var Foo = /** @class */ (function () { + function Foo() { + } + Foo.prototype.methodName = function (propName) { }; + Foo.prototype.otherMethod = function () { + if (Math.random() > 0.5) { + return { x: 42 }; + } + return { y: "yes" }; + }; + return Foo; +}()); +exports.Foo = Foo; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90ZXN0cy9jYXNlcy9mb3Vyc2xhc2gvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQTtJQUFBO0lBU0EsQ0FBQztJQVBHLHdCQUFVLEdBQVYsVUFBVyxRQUFrQixJQUFTLENBQUM7SUFDdkMseUJBQVcsR0FBWDtRQUNJLElBQUksSUFBSSxDQUFDLE1BQU0sRUFBRSxHQUFHLEdBQUcsRUFBRTtZQUNyQixPQUFPLEVBQUMsQ0FBQyxFQUFFLEVBQUUsRUFBQyxDQUFDO1NBQ2xCO1FBQ0QsT0FBTyxFQUFDLENBQUMsRUFBRSxLQUFLLEVBQUMsQ0FBQztJQUN0QixDQUFDO0lBQ0wsVUFBQztBQUFELENBQUMsQUFURCxJQVNDO0FBVFksa0JBQUciLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgRm9vIHtcbiAgICBtZW1iZXI6IHN0cmluZztcbiAgICBtZXRob2ROYW1lKHByb3BOYW1lOiBTb21lVHlwZSk6IHZvaWQge31cbiAgICBvdGhlck1ldGhvZCgpIHtcbiAgICAgICAgaWYgKE1hdGgucmFuZG9tKCkgPiAwLjUpIHtcbiAgICAgICAgICAgIHJldHVybiB7eDogNDJ9O1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiB7eTogXCJ5ZXNcIn07XG4gICAgfVxufVxuXG5leHBvcnQgaW50ZXJmYWNlIFNvbWVUeXBlIHtcbiAgICBtZW1iZXI6IG51bWJlcjtcbn0iXX0=FileName : ./dist/index.d.ts.map +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../tests/cases/fourslash/index.ts"],"names":[],"mappings":"AAAA,qBAAa,GAAG;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IACpC,WAAW;;;;;;;CAMd;AAED,MAAM,WAAW,QAAQ;IACrB,MAAM,EAAE,MAAM,CAAC;CAClB"}FileName : ./dist/index.d.ts +export declare class Foo { + member: string; + methodName(propName: SomeType): void; + otherMethod(): { + x: number; + y?: undefined; + } | { + y: string; + x?: undefined; + }; +} +export interface SomeType { + member: number; +} +//# sourceMappingURL=index.d.ts.map diff --git a/tests/baselines/reference/privateNameConstructorReserved.errors.txt b/tests/baselines/reference/privateNameConstructorReserved.errors.txt new file mode 100644 index 0000000000000..0e19a569e8fbe --- /dev/null +++ b/tests/baselines/reference/privateNameConstructorReserved.errors.txt @@ -0,0 +1,22 @@ +tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts(1,7): error TS2300: Duplicate identifier 'A'. +tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts(2,5): error TS18006: #constructor is a reserved word. +tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts(5,7): error TS2300: Duplicate identifier 'A'. +tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts(6,5): error TS18006: #constructor is a reserved word. + + +==== tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts (4 errors) ==== + class A { + ~ +!!! error TS2300: Duplicate identifier 'A'. + #constructor() {} // Error: `#constructor` is a reserved word. + ~~~~~~~~~~~~ +!!! error TS18006: #constructor is a reserved word. + } + + class A { + ~ +!!! error TS2300: Duplicate identifier 'A'. + #constructor = 5 // Error: `#constructor` is a reserved word. + ~~~~~~~~~~~~ +!!! error TS18006: #constructor is a reserved word. + } \ No newline at end of file diff --git a/tests/baselines/reference/privateNameConstructorReserved.js b/tests/baselines/reference/privateNameConstructorReserved.js new file mode 100644 index 0000000000000..e393334154560 --- /dev/null +++ b/tests/baselines/reference/privateNameConstructorReserved.js @@ -0,0 +1,22 @@ +//// [privateNameConstructorReserved.ts] +class A { + #constructor() {} // Error: `#constructor` is a reserved word. +} + +class A { + #constructor = 5 // Error: `#constructor` is a reserved word. +} + +//// [privateNameConstructorReserved.js] +var A = /** @class */ (function () { + function A() { + } + A.prototype.#constructor = function () { }; // Error: `#constructor` is a reserved word. + return A; +}()); +var A = /** @class */ (function () { + function A() { + this.#constructor = 5; // Error: `#constructor` is a reserved word. + } + return A; +}()); diff --git a/tests/baselines/reference/privateNameConstructorReserved.symbols b/tests/baselines/reference/privateNameConstructorReserved.symbols new file mode 100644 index 0000000000000..d61e750acb600 --- /dev/null +++ b/tests/baselines/reference/privateNameConstructorReserved.symbols @@ -0,0 +1,14 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts === +class A { +>A : Symbol(A, Decl(privateNameConstructorReserved.ts, 0, 0)) + + #constructor() {} // Error: `#constructor` is a reserved word. +>#constructor : Symbol(A[#constructor], Decl(privateNameConstructorReserved.ts, 0, 9)) +} + +class A { +>A : Symbol(A, Decl(privateNameConstructorReserved.ts, 2, 1)) + + #constructor = 5 // Error: `#constructor` is a reserved word. +>#constructor : Symbol(A[#constructor], Decl(privateNameConstructorReserved.ts, 4, 9)) +} diff --git a/tests/baselines/reference/privateNameConstructorReserved.types b/tests/baselines/reference/privateNameConstructorReserved.types new file mode 100644 index 0000000000000..008329efd5e30 --- /dev/null +++ b/tests/baselines/reference/privateNameConstructorReserved.types @@ -0,0 +1,15 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts === +class A { +>A : A + + #constructor() {} // Error: `#constructor` is a reserved word. +>#constructor : () => void +} + +class A { +>A : A + + #constructor = 5 // Error: `#constructor` is a reserved word. +>#constructor : number +>5 : 5 +} diff --git a/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.errors.txt b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.errors.txt new file mode 100644 index 0000000000000..d5deb40b261d8 --- /dev/null +++ b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.errors.txt @@ -0,0 +1,15 @@ +tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts(5,9): error TS2339: Property '#foo' does not exist on type 'A'. +tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts(5,9): error TS18007: Property '#foo' is not accessible outside class 'A' because it has a private name. + + +==== tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts (2 errors) ==== + class A { + #foo: number = 3; + } + + new A().#foo = 4; // Error + ~~~~ +!!! error TS2339: Property '#foo' does not exist on type 'A'. + ~~~~ +!!! error TS18007: Property '#foo' is not accessible outside class 'A' because it has a private name. + \ No newline at end of file diff --git a/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.js b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.js new file mode 100644 index 0000000000000..c096ffe8efe41 --- /dev/null +++ b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.js @@ -0,0 +1,16 @@ +//// [privateNameNotAccessibleOutsideDefiningClass.ts] +class A { + #foo: number = 3; +} + +new A().#foo = 4; // Error + + +//// [privateNameNotAccessibleOutsideDefiningClass.js] +var A = /** @class */ (function () { + function A() { + this.#foo = 3; + } + return A; +}()); +new A().#foo = 4; // Error diff --git a/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.symbols b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.symbols new file mode 100644 index 0000000000000..58b26f8e99d7c --- /dev/null +++ b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts === +class A { +>A : Symbol(A, Decl(privateNameNotAccessibleOutsideDefiningClass.ts, 0, 0)) + + #foo: number = 3; +>#foo : Symbol(A[#foo], Decl(privateNameNotAccessibleOutsideDefiningClass.ts, 0, 9)) +} + +new A().#foo = 4; // Error +>A : Symbol(A, Decl(privateNameNotAccessibleOutsideDefiningClass.ts, 0, 0)) + diff --git a/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.types b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.types new file mode 100644 index 0000000000000..19bf4a9476ca0 --- /dev/null +++ b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.types @@ -0,0 +1,16 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts === +class A { +>A : A + + #foo: number = 3; +>#foo : number +>3 : 3 +} + +new A().#foo = 4; // Error +>new A().#foo = 4 : 4 +>new A().#foo : any +>new A() : A +>A : typeof A +>4 : 4 + diff --git a/tests/baselines/reference/privateNameNotAllowedOutsideClass.errors.txt b/tests/baselines/reference/privateNameNotAllowedOutsideClass.errors.txt new file mode 100644 index 0000000000000..f4b6a6364f6b8 --- /dev/null +++ b/tests/baselines/reference/privateNameNotAllowedOutsideClass.errors.txt @@ -0,0 +1,13 @@ +tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts(1,7): error TS1134: Variable declaration expected. +tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts(1,12): error TS1134: Variable declaration expected. +tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts(1,14): error TS1134: Variable declaration expected. + + +==== tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts (3 errors) ==== + const #foo = 3; + ~~~~ +!!! error TS1134: Variable declaration expected. + ~ +!!! error TS1134: Variable declaration expected. + ~ +!!! error TS1134: Variable declaration expected. \ No newline at end of file diff --git a/tests/baselines/reference/privateNameNotAllowedOutsideClass.js b/tests/baselines/reference/privateNameNotAllowedOutsideClass.js new file mode 100644 index 0000000000000..ff289b3d29c54 --- /dev/null +++ b/tests/baselines/reference/privateNameNotAllowedOutsideClass.js @@ -0,0 +1,6 @@ +//// [privateNameNotAllowedOutsideClass.ts] +const #foo = 3; + +//// [privateNameNotAllowedOutsideClass.js] +var ; +3; diff --git a/tests/baselines/reference/privateNameNotAllowedOutsideClass.symbols b/tests/baselines/reference/privateNameNotAllowedOutsideClass.symbols new file mode 100644 index 0000000000000..b604786dda640 --- /dev/null +++ b/tests/baselines/reference/privateNameNotAllowedOutsideClass.symbols @@ -0,0 +1,3 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts === +const #foo = 3; +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/privateNameNotAllowedOutsideClass.types b/tests/baselines/reference/privateNameNotAllowedOutsideClass.types new file mode 100644 index 0000000000000..20826f41a55e1 --- /dev/null +++ b/tests/baselines/reference/privateNameNotAllowedOutsideClass.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts === +const #foo = 3; +>3 : 3 + diff --git a/tests/baselines/reference/privateNameSneakyRuntimeException.js b/tests/baselines/reference/privateNameSneakyRuntimeException.js new file mode 100644 index 0000000000000..decf2a41386f9 --- /dev/null +++ b/tests/baselines/reference/privateNameSneakyRuntimeException.js @@ -0,0 +1,30 @@ +//// [privateNameSneakyRuntimeException.ts] +function createClass () { + return class { + #foo; + equals(other) { + return this.#foo = other.#foo; + } + }; +} + +const a = new (createClass())(); +const b = new (createClass())(); + +console.log(a.equals(b)); // OK at compile time but will be a runtime error + + +//// [privateNameSneakyRuntimeException.js] +function createClass() { + return /** @class */ (function () { + function class_1() { + } + class_1.prototype.equals = function (other) { + return this.#foo = other.#foo; + }; + return class_1; + }()); +} +var a = new (createClass())(); +var b = new (createClass())(); +console.log(a.equals(b)); // OK at compile time but will be a runtime error diff --git a/tests/baselines/reference/privateNameSneakyRuntimeException.symbols b/tests/baselines/reference/privateNameSneakyRuntimeException.symbols new file mode 100644 index 0000000000000..277aa4229e173 --- /dev/null +++ b/tests/baselines/reference/privateNameSneakyRuntimeException.symbols @@ -0,0 +1,37 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameSneakyRuntimeException.ts === +function createClass () { +>createClass : Symbol(createClass, Decl(privateNameSneakyRuntimeException.ts, 0, 0)) + + return class { + #foo; +>#foo : Symbol((Anonymous class)[#foo], Decl(privateNameSneakyRuntimeException.ts, 1, 18)) + + equals(other) { +>equals : Symbol((Anonymous class).equals, Decl(privateNameSneakyRuntimeException.ts, 2, 13)) +>other : Symbol(other, Decl(privateNameSneakyRuntimeException.ts, 3, 15)) + + return this.#foo = other.#foo; +>this.#foo : Symbol((Anonymous class)[#foo], Decl(privateNameSneakyRuntimeException.ts, 1, 18)) +>this : Symbol((Anonymous class), Decl(privateNameSneakyRuntimeException.ts, 1, 10)) +>other : Symbol(other, Decl(privateNameSneakyRuntimeException.ts, 3, 15)) + } + }; +} + +const a = new (createClass())(); +>a : Symbol(a, Decl(privateNameSneakyRuntimeException.ts, 9, 5)) +>createClass : Symbol(createClass, Decl(privateNameSneakyRuntimeException.ts, 0, 0)) + +const b = new (createClass())(); +>b : Symbol(b, Decl(privateNameSneakyRuntimeException.ts, 10, 5)) +>createClass : Symbol(createClass, Decl(privateNameSneakyRuntimeException.ts, 0, 0)) + +console.log(a.equals(b)); // OK at compile time but will be a runtime error +>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.equals : Symbol((Anonymous class).equals, Decl(privateNameSneakyRuntimeException.ts, 2, 13)) +>a : Symbol(a, Decl(privateNameSneakyRuntimeException.ts, 9, 5)) +>equals : Symbol((Anonymous class).equals, Decl(privateNameSneakyRuntimeException.ts, 2, 13)) +>b : Symbol(b, Decl(privateNameSneakyRuntimeException.ts, 10, 5)) + diff --git a/tests/baselines/reference/privateNameSneakyRuntimeException.types b/tests/baselines/reference/privateNameSneakyRuntimeException.types new file mode 100644 index 0000000000000..c0e4056251bb5 --- /dev/null +++ b/tests/baselines/reference/privateNameSneakyRuntimeException.types @@ -0,0 +1,49 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameSneakyRuntimeException.ts === +function createClass () { +>createClass : () => typeof (Anonymous class) + + return class { +>class { #foo; equals(other) { return this.#foo = other.#foo; } } : typeof (Anonymous class) + + #foo; +>#foo : any + + equals(other) { +>equals : (other: any) => any +>other : any + + return this.#foo = other.#foo; +>this.#foo = other.#foo : any +>this.#foo : any +>this : this +>other.#foo : any +>other : any + } + }; +} + +const a = new (createClass())(); +>a : (Anonymous class) +>new (createClass())() : (Anonymous class) +>(createClass()) : typeof (Anonymous class) +>createClass() : typeof (Anonymous class) +>createClass : () => typeof (Anonymous class) + +const b = new (createClass())(); +>b : (Anonymous class) +>new (createClass())() : (Anonymous class) +>(createClass()) : typeof (Anonymous class) +>createClass() : typeof (Anonymous class) +>createClass : () => typeof (Anonymous class) + +console.log(a.equals(b)); // OK at compile time but will be a runtime error +>console.log(a.equals(b)) : void +>console.log : (message?: any, ...optionalParams: any[]) => void +>console : Console +>log : (message?: any, ...optionalParams: any[]) => void +>a.equals(b) : any +>a.equals : (other: any) => any +>a : (Anonymous class) +>equals : (other: any) => any +>b : (Anonymous class) + diff --git a/tests/baselines/reference/privateNamesAndkeyof.js b/tests/baselines/reference/privateNamesAndkeyof.js new file mode 100644 index 0000000000000..90d72a3b62944 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndkeyof.js @@ -0,0 +1,16 @@ +//// [privateNamesAndkeyof.ts] +class A { + #foo; + bar; + baz; +} + +type T = keyof A // should not include '#foo' + + +//// [privateNamesAndkeyof.js] +var A = /** @class */ (function () { + function A() { + } + return A; +}()); diff --git a/tests/baselines/reference/privateNamesAndkeyof.symbols b/tests/baselines/reference/privateNamesAndkeyof.symbols new file mode 100644 index 0000000000000..67a7d46b52dd7 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndkeyof.symbols @@ -0,0 +1,18 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndkeyof.ts === +class A { +>A : Symbol(A, Decl(privateNamesAndkeyof.ts, 0, 0)) + + #foo; +>#foo : Symbol(A[#foo], Decl(privateNamesAndkeyof.ts, 0, 9)) + + bar; +>bar : Symbol(A.bar, Decl(privateNamesAndkeyof.ts, 1, 9)) + + baz; +>baz : Symbol(A.baz, Decl(privateNamesAndkeyof.ts, 2, 8)) +} + +type T = keyof A // should not include '#foo' +>T : Symbol(T, Decl(privateNamesAndkeyof.ts, 4, 1)) +>A : Symbol(A, Decl(privateNamesAndkeyof.ts, 0, 0)) + diff --git a/tests/baselines/reference/privateNamesAndkeyof.types b/tests/baselines/reference/privateNamesAndkeyof.types new file mode 100644 index 0000000000000..a43c7dcd6c534 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndkeyof.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndkeyof.ts === +class A { +>A : A + + #foo; +>#foo : any + + bar; +>bar : any + + baz; +>baz : any +} + +type T = keyof A // should not include '#foo' +>T : "bar" | "baz" + diff --git a/tests/baselines/reference/privateNamesInGenericClasses.errors.txt b/tests/baselines/reference/privateNamesInGenericClasses.errors.txt new file mode 100644 index 0000000000000..041186d1d7a8b --- /dev/null +++ b/tests/baselines/reference/privateNamesInGenericClasses.errors.txt @@ -0,0 +1,32 @@ +tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(10,3): error TS2339: Property '#foo' does not exist on type 'C'. +tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(10,3): error TS18007: Property '#foo' is not accessible outside class 'C' because it has a private name. +tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(11,1): error TS2322: Type 'C' is not assignable to type 'C'. + Type 'string' is not assignable to type 'number'. +tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(12,1): error TS2322: Type 'C' is not assignable to type 'C'. + Type 'number' is not assignable to type 'string'. + + +==== tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts (4 errors) ==== + class C { + #foo: T; + bar(x: C) { return x.#foo; } // OK + baz(x: C) { return x.#foo; } // OK + quux(x: C) { return x.#foo; } // OK + } + + declare let a: C; + declare let b: C; + a.#foo; // OK + ~~~~ +!!! error TS2339: Property '#foo' does not exist on type 'C'. + ~~~~ +!!! error TS18007: Property '#foo' is not accessible outside class 'C' because it has a private name. + a = b; // Error + ~ +!!! error TS2322: Type 'C' is not assignable to type 'C'. +!!! error TS2322: Type 'string' is not assignable to type 'number'. + b = a; // Error + ~ +!!! error TS2322: Type 'C' is not assignable to type 'C'. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + \ No newline at end of file diff --git a/tests/baselines/reference/privateNamesInGenericClasses.js b/tests/baselines/reference/privateNamesInGenericClasses.js new file mode 100644 index 0000000000000..dcee4e0fd82ef --- /dev/null +++ b/tests/baselines/reference/privateNamesInGenericClasses.js @@ -0,0 +1,27 @@ +//// [privateNamesInGenericClasses.ts] +class C { + #foo: T; + bar(x: C) { return x.#foo; } // OK + baz(x: C) { return x.#foo; } // OK + quux(x: C) { return x.#foo; } // OK +} + +declare let a: C; +declare let b: C; +a.#foo; // OK +a = b; // Error +b = a; // Error + + +//// [privateNamesInGenericClasses.js] +var C = /** @class */ (function () { + function C() { + } + C.prototype.bar = function (x) { return x.#foo; }; // OK + C.prototype.baz = function (x) { return x.#foo; }; // OK + C.prototype.quux = function (x) { return x.#foo; }; // OK + return C; +}()); +a.#foo; // OK +a = b; // Error +b = a; // Error diff --git a/tests/baselines/reference/privateNamesInGenericClasses.symbols b/tests/baselines/reference/privateNamesInGenericClasses.symbols new file mode 100644 index 0000000000000..d9edd3eb629b0 --- /dev/null +++ b/tests/baselines/reference/privateNamesInGenericClasses.symbols @@ -0,0 +1,51 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts === +class C { +>C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) +>T : Symbol(T, Decl(privateNamesInGenericClasses.ts, 0, 8)) + + #foo: T; +>#foo : Symbol(C[#foo], Decl(privateNamesInGenericClasses.ts, 0, 12)) +>T : Symbol(T, Decl(privateNamesInGenericClasses.ts, 0, 8)) + + bar(x: C) { return x.#foo; } // OK +>bar : Symbol(C.bar, Decl(privateNamesInGenericClasses.ts, 1, 10)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 2, 6)) +>C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) +>T : Symbol(T, Decl(privateNamesInGenericClasses.ts, 0, 8)) +>x.#foo : Symbol(C[#foo], Decl(privateNamesInGenericClasses.ts, 0, 12)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 2, 6)) + + baz(x: C) { return x.#foo; } // OK +>baz : Symbol(C.baz, Decl(privateNamesInGenericClasses.ts, 2, 33)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 3, 6)) +>C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) +>x.#foo : Symbol(C[#foo], Decl(privateNamesInGenericClasses.ts, 0, 12)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 3, 6)) + + quux(x: C) { return x.#foo; } // OK +>quux : Symbol(C.quux, Decl(privateNamesInGenericClasses.ts, 3, 38)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 4, 7)) +>C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) +>x.#foo : Symbol(C[#foo], Decl(privateNamesInGenericClasses.ts, 0, 12)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 4, 7)) +} + +declare let a: C; +>a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 7, 11)) +>C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) + +declare let b: C; +>b : Symbol(b, Decl(privateNamesInGenericClasses.ts, 8, 11)) +>C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) + +a.#foo; // OK +>a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 7, 11)) + +a = b; // Error +>a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 7, 11)) +>b : Symbol(b, Decl(privateNamesInGenericClasses.ts, 8, 11)) + +b = a; // Error +>b : Symbol(b, Decl(privateNamesInGenericClasses.ts, 8, 11)) +>a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 7, 11)) + diff --git a/tests/baselines/reference/privateNamesInGenericClasses.types b/tests/baselines/reference/privateNamesInGenericClasses.types new file mode 100644 index 0000000000000..501bc59e05381 --- /dev/null +++ b/tests/baselines/reference/privateNamesInGenericClasses.types @@ -0,0 +1,46 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts === +class C { +>C : C + + #foo: T; +>#foo : T + + bar(x: C) { return x.#foo; } // OK +>bar : (x: C) => T +>x : C +>x.#foo : T +>x : C + + baz(x: C) { return x.#foo; } // OK +>baz : (x: C) => number +>x : C +>x.#foo : number +>x : C + + quux(x: C) { return x.#foo; } // OK +>quux : (x: C) => string +>x : C +>x.#foo : string +>x : C +} + +declare let a: C; +>a : C + +declare let b: C; +>b : C + +a.#foo; // OK +>a.#foo : any +>a : C + +a = b; // Error +>a = b : C +>a : C +>b : C + +b = a; // Error +>b = a : C +>b : C +>a : C + diff --git a/tests/baselines/reference/privateNamesInNestedClasses.errors.txt b/tests/baselines/reference/privateNamesInNestedClasses.errors.txt new file mode 100644 index 0000000000000..ca7a994a0eaa9 --- /dev/null +++ b/tests/baselines/reference/privateNamesInNestedClasses.errors.txt @@ -0,0 +1,34 @@ +tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts(11,18): error TS2339: Property '#foo' does not exist on type 'A'. +tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts(11,18): error TS18008: This usage of '#foo' refers to the private member declared in its enclosing class. While type 'B' has a private member with the same spelling, its declaration and accessibility are distinct. + + +==== tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts (2 errors) ==== + class A { + #foo = "A's #foo"; + #bar = "A's #bar"; + method () { + class B { + #foo = "B's #foo"; + bar (a) { + a.#foo; // OK, no compile-time error, don't know what `a` is + } + baz (a: A) { + a.#foo; // compile-time error, shadowed + ~~~~ +!!! error TS2339: Property '#foo' does not exist on type 'A'. + ~~~~ +!!! error TS18008: This usage of '#foo' refers to the private member declared in its enclosing class. While type 'B' has a private member with the same spelling, its declaration and accessibility are distinct. + } + quux (b: B) { + b.#foo; // OK + } + } + const a = new A(); + new B().bar(a); + new B().baz(a); + const b = new B(); + new B().quux(b); + } + } + + new A().method(); \ No newline at end of file diff --git a/tests/baselines/reference/privateNamesInNestedClasses.js b/tests/baselines/reference/privateNamesInNestedClasses.js new file mode 100644 index 0000000000000..b3d1159a40486 --- /dev/null +++ b/tests/baselines/reference/privateNamesInNestedClasses.js @@ -0,0 +1,58 @@ +//// [privateNamesInNestedClasses.ts] +class A { + #foo = "A's #foo"; + #bar = "A's #bar"; + method () { + class B { + #foo = "B's #foo"; + bar (a) { + a.#foo; // OK, no compile-time error, don't know what `a` is + } + baz (a: A) { + a.#foo; // compile-time error, shadowed + } + quux (b: B) { + b.#foo; // OK + } + } + const a = new A(); + new B().bar(a); + new B().baz(a); + const b = new B(); + new B().quux(b); + } +} + +new A().method(); + +//// [privateNamesInNestedClasses.js] +var A = /** @class */ (function () { + function A() { + this.#foo = "A's #foo"; + this.#bar = "A's #bar"; + } + A.prototype.method = function () { + var B = /** @class */ (function () { + function B() { + this.#foo = "B's #foo"; + } + B.prototype.bar = function (a) { + a.#foo; // OK, no compile-time error, don't know what `a` is + }; + B.prototype.baz = function (a) { + a.#foo; // compile-time error, shadowed + }; + B.prototype.quux = function (b) { + b.#foo; // OK + }; + return B; + }()); + var a = new A(); + new B().bar(a); + new B().baz(a); + var b = new B(); + new B().quux(b); + }; + return A; +}()); +new A().method(); diff --git a/tests/baselines/reference/privateNamesInNestedClasses.symbols b/tests/baselines/reference/privateNamesInNestedClasses.symbols new file mode 100644 index 0000000000000..85fcf81508506 --- /dev/null +++ b/tests/baselines/reference/privateNamesInNestedClasses.symbols @@ -0,0 +1,77 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts === +class A { +>A : Symbol(A, Decl(privateNamesInNestedClasses.ts, 0, 0)) + + #foo = "A's #foo"; +>#foo : Symbol(A[#foo], Decl(privateNamesInNestedClasses.ts, 0, 9)) + + #bar = "A's #bar"; +>#bar : Symbol(A[#bar], Decl(privateNamesInNestedClasses.ts, 1, 21)) + + method () { +>method : Symbol(A.method, Decl(privateNamesInNestedClasses.ts, 2, 21)) + + class B { +>B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 3, 14)) + + #foo = "B's #foo"; +>#foo : Symbol(B[#foo], Decl(privateNamesInNestedClasses.ts, 4, 16)) + + bar (a) { +>bar : Symbol(B.bar, Decl(privateNamesInNestedClasses.ts, 5, 29)) +>a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 6, 16)) + + a.#foo; // OK, no compile-time error, don't know what `a` is +>a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 6, 16)) + } + baz (a: A) { +>baz : Symbol(B.baz, Decl(privateNamesInNestedClasses.ts, 8, 12)) +>a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 9, 16)) +>A : Symbol(A, Decl(privateNamesInNestedClasses.ts, 0, 0)) + + a.#foo; // compile-time error, shadowed +>a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 9, 16)) + } + quux (b: B) { +>quux : Symbol(B.quux, Decl(privateNamesInNestedClasses.ts, 11, 12)) +>b : Symbol(b, Decl(privateNamesInNestedClasses.ts, 12, 17)) +>B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 3, 14)) + + b.#foo; // OK +>b.#foo : Symbol(B[#foo], Decl(privateNamesInNestedClasses.ts, 4, 16)) +>b : Symbol(b, Decl(privateNamesInNestedClasses.ts, 12, 17)) + } + } + const a = new A(); +>a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 16, 12)) +>A : Symbol(A, Decl(privateNamesInNestedClasses.ts, 0, 0)) + + new B().bar(a); +>new B().bar : Symbol(B.bar, Decl(privateNamesInNestedClasses.ts, 5, 29)) +>B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 3, 14)) +>bar : Symbol(B.bar, Decl(privateNamesInNestedClasses.ts, 5, 29)) +>a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 16, 12)) + + new B().baz(a); +>new B().baz : Symbol(B.baz, Decl(privateNamesInNestedClasses.ts, 8, 12)) +>B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 3, 14)) +>baz : Symbol(B.baz, Decl(privateNamesInNestedClasses.ts, 8, 12)) +>a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 16, 12)) + + const b = new B(); +>b : Symbol(b, Decl(privateNamesInNestedClasses.ts, 19, 12)) +>B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 3, 14)) + + new B().quux(b); +>new B().quux : Symbol(B.quux, Decl(privateNamesInNestedClasses.ts, 11, 12)) +>B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 3, 14)) +>quux : Symbol(B.quux, Decl(privateNamesInNestedClasses.ts, 11, 12)) +>b : Symbol(b, Decl(privateNamesInNestedClasses.ts, 19, 12)) + } +} + +new A().method(); +>new A().method : Symbol(A.method, Decl(privateNamesInNestedClasses.ts, 2, 21)) +>A : Symbol(A, Decl(privateNamesInNestedClasses.ts, 0, 0)) +>method : Symbol(A.method, Decl(privateNamesInNestedClasses.ts, 2, 21)) + diff --git a/tests/baselines/reference/privateNamesInNestedClasses.types b/tests/baselines/reference/privateNamesInNestedClasses.types new file mode 100644 index 0000000000000..8a15e34293e01 --- /dev/null +++ b/tests/baselines/reference/privateNamesInNestedClasses.types @@ -0,0 +1,90 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts === +class A { +>A : A + + #foo = "A's #foo"; +>#foo : string +>"A's #foo" : "A's #foo" + + #bar = "A's #bar"; +>#bar : string +>"A's #bar" : "A's #bar" + + method () { +>method : () => void + + class B { +>B : B + + #foo = "B's #foo"; +>#foo : string +>"B's #foo" : "B's #foo" + + bar (a) { +>bar : (a: any) => void +>a : any + + a.#foo; // OK, no compile-time error, don't know what `a` is +>a.#foo : any +>a : any + } + baz (a: A) { +>baz : (a: A) => void +>a : A + + a.#foo; // compile-time error, shadowed +>a.#foo : any +>a : A + } + quux (b: B) { +>quux : (b: B) => void +>b : B + + b.#foo; // OK +>b.#foo : string +>b : B + } + } + const a = new A(); +>a : A +>new A() : A +>A : typeof A + + new B().bar(a); +>new B().bar(a) : void +>new B().bar : (a: any) => void +>new B() : B +>B : typeof B +>bar : (a: any) => void +>a : A + + new B().baz(a); +>new B().baz(a) : void +>new B().baz : (a: A) => void +>new B() : B +>B : typeof B +>baz : (a: A) => void +>a : A + + const b = new B(); +>b : B +>new B() : B +>B : typeof B + + new B().quux(b); +>new B().quux(b) : void +>new B().quux : (b: B) => void +>new B() : B +>B : typeof B +>quux : (b: B) => void +>b : B + } +} + +new A().method(); +>new A().method() : void +>new A().method : () => void +>new A() : A +>A : typeof A +>method : () => void + diff --git a/tests/baselines/reference/privateNamesNoAccessibilityModifiers.errors.txt b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.errors.txt new file mode 100644 index 0000000000000..5ce9be967beca --- /dev/null +++ b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.errors.txt @@ -0,0 +1,19 @@ +tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts(2,12): error TS18004: Accessibility modifiers cannot be used with private names. +tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts(3,13): error TS18004: Accessibility modifiers cannot be used with private names. +tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts(4,15): error TS18004: Accessibility modifiers cannot be used with private names. + + +==== tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts (3 errors) ==== + class A { + public #foo; // Error + ~~~~ +!!! error TS18004: Accessibility modifiers cannot be used with private names. + private #bar; // Error + ~~~~ +!!! error TS18004: Accessibility modifiers cannot be used with private names. + protected #baz; // Error + ~~~~ +!!! error TS18004: Accessibility modifiers cannot be used with private names. + readonly #qux; // OK + } + \ No newline at end of file diff --git a/tests/baselines/reference/privateNamesNoAccessibilityModifiers.js b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.js new file mode 100644 index 0000000000000..43227f2b84ee6 --- /dev/null +++ b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.js @@ -0,0 +1,15 @@ +//// [privateNamesNoAccessibilityModifiers.ts] +class A { + public #foo; // Error + private #bar; // Error + protected #baz; // Error + readonly #qux; // OK +} + + +//// [privateNamesNoAccessibilityModifiers.js] +var A = /** @class */ (function () { + function A() { + } + return A; +}()); diff --git a/tests/baselines/reference/privateNamesNoAccessibilityModifiers.symbols b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.symbols new file mode 100644 index 0000000000000..7586d7c5bd6c1 --- /dev/null +++ b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts === +class A { +>A : Symbol(A, Decl(privateNamesNoAccessibilityModifiers.ts, 0, 0)) + + public #foo; // Error +>#foo : Symbol(A[#foo], Decl(privateNamesNoAccessibilityModifiers.ts, 0, 9)) + + private #bar; // Error +>#bar : Symbol(A[#bar], Decl(privateNamesNoAccessibilityModifiers.ts, 1, 16)) + + protected #baz; // Error +>#baz : Symbol(A[#baz], Decl(privateNamesNoAccessibilityModifiers.ts, 2, 17)) + + readonly #qux; // OK +>#qux : Symbol(A[#qux], Decl(privateNamesNoAccessibilityModifiers.ts, 3, 19)) +} + diff --git a/tests/baselines/reference/privateNamesNoAccessibilityModifiers.types b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.types new file mode 100644 index 0000000000000..fd1b35c1ded35 --- /dev/null +++ b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts === +class A { +>A : A + + public #foo; // Error +>#foo : any + + private #bar; // Error +>#bar : any + + protected #baz; // Error +>#baz : any + + readonly #qux; // OK +>#qux : any +} + diff --git a/tests/baselines/reference/privateNamesNoConflictWhenInheriting.js b/tests/baselines/reference/privateNamesNoConflictWhenInheriting.js new file mode 100644 index 0000000000000..39cca6b534d55 --- /dev/null +++ b/tests/baselines/reference/privateNamesNoConflictWhenInheriting.js @@ -0,0 +1,39 @@ +//// [privateNamesNoConflictWhenInheriting.ts] +class A { + #foo: number; +} + +class B extends A { + #foo: string; // OK: private names are unique to each class +} + +const b: A = new B() // OK + + +//// [privateNamesNoConflictWhenInheriting.js] +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var A = /** @class */ (function () { + function A() { + } + return A; +}()); +var B = /** @class */ (function (_super) { + __extends(B, _super); + function B() { + return _super !== null && _super.apply(this, arguments) || this; + } + return B; +}(A)); +var b = new B(); // OK diff --git a/tests/baselines/reference/privateNamesNoConflictWhenInheriting.symbols b/tests/baselines/reference/privateNamesNoConflictWhenInheriting.symbols new file mode 100644 index 0000000000000..11ee25651c95f --- /dev/null +++ b/tests/baselines/reference/privateNamesNoConflictWhenInheriting.symbols @@ -0,0 +1,21 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesNoConflictWhenInheriting.ts === +class A { +>A : Symbol(A, Decl(privateNamesNoConflictWhenInheriting.ts, 0, 0)) + + #foo: number; +>#foo : Symbol(A[#foo], Decl(privateNamesNoConflictWhenInheriting.ts, 0, 9)) +} + +class B extends A { +>B : Symbol(B, Decl(privateNamesNoConflictWhenInheriting.ts, 2, 1)) +>A : Symbol(A, Decl(privateNamesNoConflictWhenInheriting.ts, 0, 0)) + + #foo: string; // OK: private names are unique to each class +>#foo : Symbol(B[#foo], Decl(privateNamesNoConflictWhenInheriting.ts, 4, 19)) +} + +const b: A = new B() // OK +>b : Symbol(b, Decl(privateNamesNoConflictWhenInheriting.ts, 8, 5)) +>A : Symbol(A, Decl(privateNamesNoConflictWhenInheriting.ts, 0, 0)) +>B : Symbol(B, Decl(privateNamesNoConflictWhenInheriting.ts, 2, 1)) + diff --git a/tests/baselines/reference/privateNamesNoConflictWhenInheriting.types b/tests/baselines/reference/privateNamesNoConflictWhenInheriting.types new file mode 100644 index 0000000000000..40459f74d2e63 --- /dev/null +++ b/tests/baselines/reference/privateNamesNoConflictWhenInheriting.types @@ -0,0 +1,21 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesNoConflictWhenInheriting.ts === +class A { +>A : A + + #foo: number; +>#foo : number +} + +class B extends A { +>B : B +>A : A + + #foo: string; // OK: private names are unique to each class +>#foo : string +} + +const b: A = new B() // OK +>b : A +>new B() : B +>B : typeof B + diff --git a/tests/baselines/reference/privateNamesNoDelete.errors.txt b/tests/baselines/reference/privateNamesNoDelete.errors.txt new file mode 100644 index 0000000000000..ae45010321430 --- /dev/null +++ b/tests/baselines/reference/privateNamesNoDelete.errors.txt @@ -0,0 +1,13 @@ +tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts(4,16): error TS18005: The operand of a delete operator cannot be a private name. + + +==== tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts (1 errors) ==== + class A { + #v = 1; + constructor() { + delete this.#v; // Error: The operand of a delete operator cannot be a private name. + ~~~~~~~ +!!! error TS18005: The operand of a delete operator cannot be a private name. + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/privateNamesNoDelete.js b/tests/baselines/reference/privateNamesNoDelete.js new file mode 100644 index 0000000000000..7266285f807b5 --- /dev/null +++ b/tests/baselines/reference/privateNamesNoDelete.js @@ -0,0 +1,17 @@ +//// [privateNamesNoDelete.ts] +class A { + #v = 1; + constructor() { + delete this.#v; // Error: The operand of a delete operator cannot be a private name. + } +} + + +//// [privateNamesNoDelete.js] +var A = /** @class */ (function () { + function A() { + this.#v = 1; + delete this.#v; // Error: The operand of a delete operator cannot be a private name. + } + return A; +}()); diff --git a/tests/baselines/reference/privateNamesNoDelete.symbols b/tests/baselines/reference/privateNamesNoDelete.symbols new file mode 100644 index 0000000000000..ae5e4315675e4 --- /dev/null +++ b/tests/baselines/reference/privateNamesNoDelete.symbols @@ -0,0 +1,14 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts === +class A { +>A : Symbol(A, Decl(privateNamesNoDelete.ts, 0, 0)) + + #v = 1; +>#v : Symbol(A[#v], Decl(privateNamesNoDelete.ts, 0, 9)) + + constructor() { + delete this.#v; // Error: The operand of a delete operator cannot be a private name. +>this.#v : Symbol(A[#v], Decl(privateNamesNoDelete.ts, 0, 9)) +>this : Symbol(A, Decl(privateNamesNoDelete.ts, 0, 0)) + } +} + diff --git a/tests/baselines/reference/privateNamesNoDelete.types b/tests/baselines/reference/privateNamesNoDelete.types new file mode 100644 index 0000000000000..d23b8712dbdcb --- /dev/null +++ b/tests/baselines/reference/privateNamesNoDelete.types @@ -0,0 +1,16 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts === +class A { +>A : A + + #v = 1; +>#v : number +>1 : 1 + + constructor() { + delete this.#v; // Error: The operand of a delete operator cannot be a private name. +>delete this.#v : boolean +>this.#v : number +>this : this + } +} + diff --git a/tests/baselines/reference/privateNamesNotAllowedAsParameters.errors.txt b/tests/baselines/reference/privateNamesNotAllowedAsParameters.errors.txt new file mode 100644 index 0000000000000..7d6b45dc9581c --- /dev/null +++ b/tests/baselines/reference/privateNamesNotAllowedAsParameters.errors.txt @@ -0,0 +1,19 @@ +tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts(2,12): error TS1138: Parameter declaration expected. +tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts(2,24): error TS1005: ';' expected. +tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts(2,26): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. +tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts(3,1): error TS1128: Declaration or statement expected. + + +==== tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts (4 errors) ==== + class A { + setFoo(#foo: string) {} + ~~~~ +!!! error TS1138: Parameter declaration expected. + ~ +!!! error TS1005: ';' expected. + ~ +!!! error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. + } + ~ +!!! error TS1128: Declaration or statement expected. + \ No newline at end of file diff --git a/tests/baselines/reference/privateNamesNotAllowedAsParameters.js b/tests/baselines/reference/privateNamesNotAllowedAsParameters.js new file mode 100644 index 0000000000000..862409a851765 --- /dev/null +++ b/tests/baselines/reference/privateNamesNotAllowedAsParameters.js @@ -0,0 +1,14 @@ +//// [privateNamesNotAllowedAsParameters.ts] +class A { + setFoo(#foo: string) {} +} + + +//// [privateNamesNotAllowedAsParameters.js] +var A = /** @class */ (function () { + function A() { + } + A.prototype.setFoo = function () { }; + return A; +}()); +{ } diff --git a/tests/baselines/reference/privateNamesNotAllowedAsParameters.symbols b/tests/baselines/reference/privateNamesNotAllowedAsParameters.symbols new file mode 100644 index 0000000000000..013e0e192734c --- /dev/null +++ b/tests/baselines/reference/privateNamesNotAllowedAsParameters.symbols @@ -0,0 +1,9 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts === +class A { +>A : Symbol(A, Decl(privateNamesNotAllowedAsParameters.ts, 0, 0)) + + setFoo(#foo: string) {} +>setFoo : Symbol(A.setFoo, Decl(privateNamesNotAllowedAsParameters.ts, 0, 9)) +>#foo : Symbol(A[#foo], Decl(privateNamesNotAllowedAsParameters.ts, 1, 11)) +} + diff --git a/tests/baselines/reference/privateNamesNotAllowedAsParameters.types b/tests/baselines/reference/privateNamesNotAllowedAsParameters.types new file mode 100644 index 0000000000000..b11ecd42efe52 --- /dev/null +++ b/tests/baselines/reference/privateNamesNotAllowedAsParameters.types @@ -0,0 +1,9 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts === +class A { +>A : A + + setFoo(#foo: string) {} +>setFoo : () => any +>#foo : string +} + diff --git a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.errors.txt b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.errors.txt new file mode 100644 index 0000000000000..ad967f6b8c0ce --- /dev/null +++ b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.errors.txt @@ -0,0 +1,13 @@ +tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts(1,7): error TS1134: Variable declaration expected. +tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts(1,12): error TS1134: Variable declaration expected. +tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts(1,14): error TS1134: Variable declaration expected. + + +==== tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts (3 errors) ==== + const #foo = 3; + ~~~~ +!!! error TS1134: Variable declaration expected. + ~ +!!! error TS1134: Variable declaration expected. + ~ +!!! error TS1134: Variable declaration expected. \ No newline at end of file diff --git a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.js b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.js new file mode 100644 index 0000000000000..9b65ff8a3a0b0 --- /dev/null +++ b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.js @@ -0,0 +1,6 @@ +//// [privateNamesNotAllowedInVariableDeclarations.ts] +const #foo = 3; + +//// [privateNamesNotAllowedInVariableDeclarations.js] +var ; +3; diff --git a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.symbols b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.symbols new file mode 100644 index 0000000000000..b9b048bea1fb0 --- /dev/null +++ b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.symbols @@ -0,0 +1,3 @@ +=== tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts === +const #foo = 3; +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.types b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.types new file mode 100644 index 0000000000000..6c52944e553c7 --- /dev/null +++ b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts === +const #foo = 3; +>3 : 3 + diff --git a/tests/baselines/reference/privateNamesUnique.errors.txt b/tests/baselines/reference/privateNamesUnique.errors.txt new file mode 100644 index 0000000000000..921d7fe36ffea --- /dev/null +++ b/tests/baselines/reference/privateNamesUnique.errors.txt @@ -0,0 +1,18 @@ +tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts(9,7): error TS2322: Type 'B' is not assignable to type 'A'. + Property '#foo' is missing in type 'B'. While type 'B' has a private member with the same spelling, its declaration and accessibility are distinct + + +==== tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts (1 errors) ==== + class A { + #foo: number; + } + + class B { + #foo: number; + } + + const b: A = new B() // Error: Property #foo is missing + ~ +!!! error TS2322: Type 'B' is not assignable to type 'A'. +!!! error TS2322: Property '#foo' is missing in type 'B'. While type 'B' has a private member with the same spelling, its declaration and accessibility are distinct + \ No newline at end of file diff --git a/tests/baselines/reference/privateNamesUnique.js b/tests/baselines/reference/privateNamesUnique.js new file mode 100644 index 0000000000000..a5b5a2dad7b3e --- /dev/null +++ b/tests/baselines/reference/privateNamesUnique.js @@ -0,0 +1,24 @@ +//// [privateNamesUnique.ts] +class A { + #foo: number; +} + +class B { + #foo: number; +} + +const b: A = new B() // Error: Property #foo is missing + + +//// [privateNamesUnique.js] +var A = /** @class */ (function () { + function A() { + } + return A; +}()); +var B = /** @class */ (function () { + function B() { + } + return B; +}()); +var b = new B(); // Error: Property #foo is missing diff --git a/tests/baselines/reference/privateNamesUnique.symbols b/tests/baselines/reference/privateNamesUnique.symbols new file mode 100644 index 0000000000000..224785a388fca --- /dev/null +++ b/tests/baselines/reference/privateNamesUnique.symbols @@ -0,0 +1,20 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts === +class A { +>A : Symbol(A, Decl(privateNamesUnique.ts, 0, 0)) + + #foo: number; +>#foo : Symbol(A[#foo], Decl(privateNamesUnique.ts, 0, 9)) +} + +class B { +>B : Symbol(B, Decl(privateNamesUnique.ts, 2, 1)) + + #foo: number; +>#foo : Symbol(B[#foo], Decl(privateNamesUnique.ts, 4, 9)) +} + +const b: A = new B() // Error: Property #foo is missing +>b : Symbol(b, Decl(privateNamesUnique.ts, 8, 5)) +>A : Symbol(A, Decl(privateNamesUnique.ts, 0, 0)) +>B : Symbol(B, Decl(privateNamesUnique.ts, 2, 1)) + diff --git a/tests/baselines/reference/privateNamesUnique.types b/tests/baselines/reference/privateNamesUnique.types new file mode 100644 index 0000000000000..16fdb5a6f1629 --- /dev/null +++ b/tests/baselines/reference/privateNamesUnique.types @@ -0,0 +1,20 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts === +class A { +>A : A + + #foo: number; +>#foo : number +} + +class B { +>B : B + + #foo: number; +>#foo : number +} + +const b: A = new B() // Error: Property #foo is missing +>b : A +>new B() : B +>B : typeof B + diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts b/tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts index d4c0b8ad46efb..0efb1813fcefa 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts @@ -1,6 +1,6 @@ -class A { - [k: string]: any; - constructor(message: string) { - this.#f = 3 // Error Property '#f' does not exist on type 'A'. - } -} +class A { + [k: string]: any; + constructor(message: string) { + this.#f = 3 // Error Property '#f' does not exist on type 'A'. + } +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts b/tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts new file mode 100644 index 0000000000000..4a4c1525c852a --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts @@ -0,0 +1,7 @@ +class A { + #constructor() {} // Error: `#constructor` is a reserved word. +} + +class A { + #constructor = 5 // Error: `#constructor` is a reserved word. +} \ No newline at end of file diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameField.ts b/tests/cases/conformance/classes/members/privateNames/privateNameField.ts index 02e449fb3e002..3d38a3d651453 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameField.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameField.ts @@ -1,6 +1,6 @@ -class A { - #name: string; - constructor(name: string) { - this.#name = name; - } +class A { + #name: string; + constructor(name: string) { + this.#name = name; + } } \ No newline at end of file diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts b/tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts new file mode 100644 index 0000000000000..1d213d7e54509 --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts @@ -0,0 +1,5 @@ +class A { + #foo: number = 3; +} + +new A().#foo = 4; // Error diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts b/tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts new file mode 100644 index 0000000000000..7af2bf989ff3b --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts @@ -0,0 +1 @@ +const #foo = 3; \ No newline at end of file diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameSneakyRuntimeException.ts b/tests/cases/conformance/classes/members/privateNames/privateNameSneakyRuntimeException.ts new file mode 100644 index 0000000000000..3ee0eebfbda8d --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNameSneakyRuntimeException.ts @@ -0,0 +1,13 @@ +function createClass () { + return class { + #foo; + equals(other) { + return this.#foo = other.#foo; + } + }; +} + +const a = new (createClass())(); +const b = new (createClass())(); + +console.log(a.equals(b)); // OK at compile time but will be a runtime error diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesAndkeyof.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesAndkeyof.ts new file mode 100644 index 0000000000000..93edade95ce9e --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesAndkeyof.ts @@ -0,0 +1,7 @@ +class A { + #foo; + bar; + baz; +} + +type T = keyof A // should not include '#foo' diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts new file mode 100644 index 0000000000000..c1369caf48594 --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts @@ -0,0 +1,12 @@ +class C { + #foo: T; + bar(x: C) { return x.#foo; } // OK + baz(x: C) { return x.#foo; } // OK + quux(x: C) { return x.#foo; } // OK +} + +declare let a: C; +declare let b: C; +a.#foo; // OK +a = b; // Error +b = a; // Error diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts new file mode 100644 index 0000000000000..04d4a69c0b19b --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts @@ -0,0 +1,25 @@ +class A { + #foo = "A's #foo"; + #bar = "A's #bar"; + method () { + class B { + #foo = "B's #foo"; + bar (a) { + a.#foo; // OK, no compile-time error, don't know what `a` is + } + baz (a: A) { + a.#foo; // compile-time error, shadowed + } + quux (b: B) { + b.#foo; // OK + } + } + const a = new A(); + new B().bar(a); + new B().baz(a); + const b = new B(); + new B().quux(b); + } +} + +new A().method(); \ No newline at end of file diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts new file mode 100644 index 0000000000000..cd3f748196950 --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts @@ -0,0 +1,6 @@ +class A { + public #foo; // Error + private #bar; // Error + protected #baz; // Error + readonly #qux; // OK +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesNoConflictWhenInheriting.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesNoConflictWhenInheriting.ts new file mode 100644 index 0000000000000..bb55edd9b3dfc --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesNoConflictWhenInheriting.ts @@ -0,0 +1,9 @@ +class A { + #foo: number; +} + +class B extends A { + #foo: string; // OK: private names are unique to each class +} + +const b: A = new B() // OK diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts new file mode 100644 index 0000000000000..a71a733371023 --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts @@ -0,0 +1,6 @@ +class A { + #v = 1; + constructor() { + delete this.#v; // Error: The operand of a delete operator cannot be a private name. + } +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts new file mode 100644 index 0000000000000..edc846a0bf35d --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts @@ -0,0 +1,3 @@ +class A { + setFoo(#foo: string) {} +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts new file mode 100644 index 0000000000000..cee206eacd201 --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts @@ -0,0 +1,9 @@ +class A { + #foo: number; +} + +class B { + #foo: number; +} + +const b: A = new B() // Error: Property #foo is missing diff --git a/tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts b/tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts new file mode 100644 index 0000000000000..7af2bf989ff3b --- /dev/null +++ b/tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts @@ -0,0 +1 @@ +const #foo = 3; \ No newline at end of file From 90a6e57a797b97ad5958417b64497dd35f170e54 Mon Sep 17 00:00:00 2001 From: Max Heiber Date: Mon, 8 Oct 2018 16:32:23 -0400 Subject: [PATCH 2/8] Incorporate checker PR feedback Signed-off-by: Max Heiber --- src/compiler/checker.ts | 13 +++++------- src/compiler/diagnosticMessages.json | 2 +- .../privateNameConstructorReserved.errors.txt | 20 ++++--------------- .../privateNameConstructorReserved.js | 11 +--------- .../privateNameConstructorReserved.symbols | 6 ------ .../privateNameConstructorReserved.types | 7 ------- .../privateNameDuplicateField.errors.txt | 11 ++++++++++ .../reference/privateNameDuplicateField.js | 13 ++++++++++++ .../privateNameDuplicateField.symbols | 11 ++++++++++ .../reference/privateNameDuplicateField.types | 11 ++++++++++ .../privateNameConstructorReserved.ts | 4 ---- .../privateNames/privateNameDuplicateField.ts | 4 ++++ 12 files changed, 61 insertions(+), 52 deletions(-) create mode 100644 tests/baselines/reference/privateNameDuplicateField.errors.txt create mode 100644 tests/baselines/reference/privateNameDuplicateField.js create mode 100644 tests/baselines/reference/privateNameDuplicateField.symbols create mode 100644 tests/baselines/reference/privateNameDuplicateField.types create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index d770c83d12545..61be9fcefc1a6 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -2680,7 +2680,7 @@ namespace ts { } // A reserved member name starts with two underscores, but the third character cannot be an underscore, - // @ or #. A third underscore indicates an escaped form of an identifer that started + // @, or #. A third underscore indicates an escaped form of an identifer that started // with at least two underscores. The @ character indicates that the name is denoted by a well known ES // Symbol instance and the # indicates that the name is a PrivateName. function isReservedMemberName(name: __String) { @@ -12222,7 +12222,7 @@ namespace ts { reportError( Diagnostics.Property_0_is_missing_in_type_1_While_type_1_has_a_private_member_with_the_same_spelling_its_declaration_and_accessibility_are_distinct, diagnosticName(privateNameDescription), - diagnosticName(source.symbol.valueDeclaration.name || ("anonymous" as __String)) + diagnosticName(source.symbol.valueDeclaration.name || ("(anonymous)" as __String)) ); hasReported = true; } @@ -18460,7 +18460,7 @@ namespace ts { right, Diagnostics.This_usage_of_0_refers_to_the_private_member_declared_in_its_enclosing_class_While_type_1_has_a_private_member_with_the_same_spelling_its_declaration_and_accessibility_are_distinct, diagnosticName(right), - diagnosticName(classWithShadowedPrivateName.name || ("anonymous" as __String)) + diagnosticName(classWithShadowedPrivateName.name || ("(anonymous)" as __String)) ); return undefined; } @@ -21442,14 +21442,11 @@ namespace ts { } if (expr.kind === SyntaxKind.PropertyAccessExpression && isPrivateName((expr as PropertyAccessExpression).name)) { error(expr, Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_private_name); - } const links = getNodeLinks(expr); const symbol = getExportSymbolOfValueSymbolIfExported(links.resolvedSymbol); - if (symbol) { - if (isReadonlySymbol(symbol)) { - error(expr, Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property); - } + if (symbol && isReadonlySymbol(symbol)) { + error(expr, Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property); } return booleanType; } diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 8d8ae8a85c7c1..7afe1cf65c515 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -4307,7 +4307,7 @@ "category": "Error", "code": 18005 }, - "#constructor is a reserved word.": { + "'#constructor' is a reserved word.": { "category": "Error", "code": 18006 }, diff --git a/tests/baselines/reference/privateNameConstructorReserved.errors.txt b/tests/baselines/reference/privateNameConstructorReserved.errors.txt index 0e19a569e8fbe..e79145b7e3eb4 100644 --- a/tests/baselines/reference/privateNameConstructorReserved.errors.txt +++ b/tests/baselines/reference/privateNameConstructorReserved.errors.txt @@ -1,22 +1,10 @@ -tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts(1,7): error TS2300: Duplicate identifier 'A'. -tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts(2,5): error TS18006: #constructor is a reserved word. -tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts(5,7): error TS2300: Duplicate identifier 'A'. -tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts(6,5): error TS18006: #constructor is a reserved word. +tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts(2,5): error TS18006: '#constructor' is a reserved word. -==== tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts (4 errors) ==== +==== tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts (1 errors) ==== class A { - ~ -!!! error TS2300: Duplicate identifier 'A'. #constructor() {} // Error: `#constructor` is a reserved word. ~~~~~~~~~~~~ -!!! error TS18006: #constructor is a reserved word. +!!! error TS18006: '#constructor' is a reserved word. } - - class A { - ~ -!!! error TS2300: Duplicate identifier 'A'. - #constructor = 5 // Error: `#constructor` is a reserved word. - ~~~~~~~~~~~~ -!!! error TS18006: #constructor is a reserved word. - } \ No newline at end of file + \ No newline at end of file diff --git a/tests/baselines/reference/privateNameConstructorReserved.js b/tests/baselines/reference/privateNameConstructorReserved.js index e393334154560..dde1724421427 100644 --- a/tests/baselines/reference/privateNameConstructorReserved.js +++ b/tests/baselines/reference/privateNameConstructorReserved.js @@ -2,10 +2,7 @@ class A { #constructor() {} // Error: `#constructor` is a reserved word. } - -class A { - #constructor = 5 // Error: `#constructor` is a reserved word. -} + //// [privateNameConstructorReserved.js] var A = /** @class */ (function () { @@ -14,9 +11,3 @@ var A = /** @class */ (function () { A.prototype.#constructor = function () { }; // Error: `#constructor` is a reserved word. return A; }()); -var A = /** @class */ (function () { - function A() { - this.#constructor = 5; // Error: `#constructor` is a reserved word. - } - return A; -}()); diff --git a/tests/baselines/reference/privateNameConstructorReserved.symbols b/tests/baselines/reference/privateNameConstructorReserved.symbols index d61e750acb600..6b4d81fe324be 100644 --- a/tests/baselines/reference/privateNameConstructorReserved.symbols +++ b/tests/baselines/reference/privateNameConstructorReserved.symbols @@ -6,9 +6,3 @@ class A { >#constructor : Symbol(A[#constructor], Decl(privateNameConstructorReserved.ts, 0, 9)) } -class A { ->A : Symbol(A, Decl(privateNameConstructorReserved.ts, 2, 1)) - - #constructor = 5 // Error: `#constructor` is a reserved word. ->#constructor : Symbol(A[#constructor], Decl(privateNameConstructorReserved.ts, 4, 9)) -} diff --git a/tests/baselines/reference/privateNameConstructorReserved.types b/tests/baselines/reference/privateNameConstructorReserved.types index 008329efd5e30..f5e646b9a2190 100644 --- a/tests/baselines/reference/privateNameConstructorReserved.types +++ b/tests/baselines/reference/privateNameConstructorReserved.types @@ -6,10 +6,3 @@ class A { >#constructor : () => void } -class A { ->A : A - - #constructor = 5 // Error: `#constructor` is a reserved word. ->#constructor : number ->5 : 5 -} diff --git a/tests/baselines/reference/privateNameDuplicateField.errors.txt b/tests/baselines/reference/privateNameDuplicateField.errors.txt new file mode 100644 index 0000000000000..4c25506723124 --- /dev/null +++ b/tests/baselines/reference/privateNameDuplicateField.errors.txt @@ -0,0 +1,11 @@ +tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts(3,5): error TS2300: Duplicate identifier '#foo'. + + +==== tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts (1 errors) ==== + class A { + #foo; + #foo; + ~~~~ +!!! error TS2300: Duplicate identifier '#foo'. + } + \ No newline at end of file diff --git a/tests/baselines/reference/privateNameDuplicateField.js b/tests/baselines/reference/privateNameDuplicateField.js new file mode 100644 index 0000000000000..4d5741a26e91b --- /dev/null +++ b/tests/baselines/reference/privateNameDuplicateField.js @@ -0,0 +1,13 @@ +//// [privateNameDuplicateField.ts] +class A { + #foo; + #foo; +} + + +//// [privateNameDuplicateField.js] +var A = /** @class */ (function () { + function A() { + } + return A; +}()); diff --git a/tests/baselines/reference/privateNameDuplicateField.symbols b/tests/baselines/reference/privateNameDuplicateField.symbols new file mode 100644 index 0000000000000..a7dae178bc4a7 --- /dev/null +++ b/tests/baselines/reference/privateNameDuplicateField.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts === +class A { +>A : Symbol(A, Decl(privateNameDuplicateField.ts, 0, 0)) + + #foo; +>#foo : Symbol(A[#foo], Decl(privateNameDuplicateField.ts, 0, 9), Decl(privateNameDuplicateField.ts, 1, 9)) + + #foo; +>#foo : Symbol(A[#foo], Decl(privateNameDuplicateField.ts, 0, 9), Decl(privateNameDuplicateField.ts, 1, 9)) +} + diff --git a/tests/baselines/reference/privateNameDuplicateField.types b/tests/baselines/reference/privateNameDuplicateField.types new file mode 100644 index 0000000000000..9f5f65ccd34ce --- /dev/null +++ b/tests/baselines/reference/privateNameDuplicateField.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts === +class A { +>A : A + + #foo; +>#foo : any + + #foo; +>#foo : any +} + diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts b/tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts index 4a4c1525c852a..c30022b345846 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts @@ -1,7 +1,3 @@ class A { #constructor() {} // Error: `#constructor` is a reserved word. } - -class A { - #constructor = 5 // Error: `#constructor` is a reserved word. -} \ No newline at end of file diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts b/tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts new file mode 100644 index 0000000000000..a482161d4dc33 --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts @@ -0,0 +1,4 @@ +class A { + #foo; + #foo; +} From b1052a6172b6d3b92001ac4f7176f9287c41398f Mon Sep 17 00:00:00 2001 From: Max Heiber Date: Wed, 21 Nov 2018 12:16:53 -0500 Subject: [PATCH 3/8] mv private name tests together Signed-off-by: Max Heiber --- ...rivateNamesNotAllowedInVariableDeclarations.errors.txt | 8 ++++---- .../privateNamesNotAllowedInVariableDeclarations.symbols | 2 +- .../privateNamesNotAllowedInVariableDeclarations.types | 2 +- .../privateNamesNotAllowedInVariableDeclarations.ts | 0 4 files changed, 6 insertions(+), 6 deletions(-) rename tests/cases/conformance/classes/{ => members}/privateNames/privateNamesNotAllowedInVariableDeclarations.ts (100%) diff --git a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.errors.txt b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.errors.txt index ad967f6b8c0ce..9b996c5e6bac3 100644 --- a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.errors.txt +++ b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.errors.txt @@ -1,9 +1,9 @@ -tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts(1,7): error TS1134: Variable declaration expected. -tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts(1,12): error TS1134: Variable declaration expected. -tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts(1,14): error TS1134: Variable declaration expected. +tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts(1,7): error TS1134: Variable declaration expected. +tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts(1,12): error TS1134: Variable declaration expected. +tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts(1,14): error TS1134: Variable declaration expected. -==== tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts (3 errors) ==== +==== tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts (3 errors) ==== const #foo = 3; ~~~~ !!! error TS1134: Variable declaration expected. diff --git a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.symbols b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.symbols index b9b048bea1fb0..8ff859dfdd84a 100644 --- a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.symbols +++ b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.symbols @@ -1,3 +1,3 @@ -=== tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts === +=== tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts === const #foo = 3; No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.types b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.types index 6c52944e553c7..82cdaa63a9fb0 100644 --- a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.types +++ b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts === +=== tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts === const #foo = 3; >3 : 3 diff --git a/tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts similarity index 100% rename from tests/cases/conformance/classes/privateNames/privateNamesNotAllowedInVariableDeclarations.ts rename to tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts From 60bc29abbbe9302f9a56569678b03fd11adf4c60 Mon Sep 17 00:00:00 2001 From: Max Heiber Date: Wed, 21 Nov 2018 12:48:01 -0500 Subject: [PATCH 4/8] more checker tests for private names Signed-off-by: Max Heiber --- .../reference/privateNamesAndFields.js | 49 ++++++++++ .../reference/privateNamesAndFields.symbols | 33 +++++++ .../reference/privateNamesAndFields.types | 38 ++++++++ .../reference/privateNamesAndMethods.js | 60 ++++++++++++ .../reference/privateNamesAndMethods.symbols | 80 ++++++++++++++++ .../reference/privateNamesAndMethods.types | 95 +++++++++++++++++++ .../reference/privateNamesAndStaticFields.js | 49 ++++++++++ .../privateNamesAndStaticFields.symbols | 33 +++++++ .../privateNamesAndStaticFields.types | 38 ++++++++ .../reference/privateNamesAndStaticMethods.js | 60 ++++++++++++ .../privateNamesAndStaticMethods.symbols | 80 ++++++++++++++++ .../privateNamesAndStaticMethods.types | 95 +++++++++++++++++++ .../privateNames/privateNamesAndFields.ts | 16 ++++ .../privateNames/privateNamesAndMethods.ts | 32 +++++++ .../privateNamesAndStaticFields.ts | 16 ++++ .../privateNamesAndStaticMethods.ts | 32 +++++++ 16 files changed, 806 insertions(+) create mode 100644 tests/baselines/reference/privateNamesAndFields.js create mode 100644 tests/baselines/reference/privateNamesAndFields.symbols create mode 100644 tests/baselines/reference/privateNamesAndFields.types create mode 100644 tests/baselines/reference/privateNamesAndMethods.js create mode 100644 tests/baselines/reference/privateNamesAndMethods.symbols create mode 100644 tests/baselines/reference/privateNamesAndMethods.types create mode 100644 tests/baselines/reference/privateNamesAndStaticFields.js create mode 100644 tests/baselines/reference/privateNamesAndStaticFields.symbols create mode 100644 tests/baselines/reference/privateNamesAndStaticFields.types create mode 100644 tests/baselines/reference/privateNamesAndStaticMethods.js create mode 100644 tests/baselines/reference/privateNamesAndStaticMethods.symbols create mode 100644 tests/baselines/reference/privateNamesAndStaticMethods.types create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamesAndFields.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamesAndMethods.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticFields.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts diff --git a/tests/baselines/reference/privateNamesAndFields.js b/tests/baselines/reference/privateNamesAndFields.js new file mode 100644 index 0000000000000..4a242723cd9cc --- /dev/null +++ b/tests/baselines/reference/privateNamesAndFields.js @@ -0,0 +1,49 @@ +//// [privateNamesAndFields.ts] +// @target ESNext + +class A { + #foo: number; + constructor () { + this.#foo = 3; + } +} + +class B extends A { + #foo: string; + constructor () { + super(); + this.#foo = "some string"; + } +} + + +//// [privateNamesAndFields.js] +// @target ESNext +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var A = /** @class */ (function () { + function A() { + this.#foo = 3; + } + return A; +}()); +var B = /** @class */ (function (_super) { + __extends(B, _super); + function B() { + var _this = _super.call(this) || this; + _this.#foo = "some string"; + return _this; + } + return B; +}(A)); diff --git a/tests/baselines/reference/privateNamesAndFields.symbols b/tests/baselines/reference/privateNamesAndFields.symbols new file mode 100644 index 0000000000000..1af37cb5578c1 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndFields.symbols @@ -0,0 +1,33 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndFields.ts === +// @target ESNext + +class A { +>A : Symbol(A, Decl(privateNamesAndFields.ts, 0, 0)) + + #foo: number; +>#foo : Symbol(A[#foo], Decl(privateNamesAndFields.ts, 2, 9)) + + constructor () { + this.#foo = 3; +>this.#foo : Symbol(A[#foo], Decl(privateNamesAndFields.ts, 2, 9)) +>this : Symbol(A, Decl(privateNamesAndFields.ts, 0, 0)) + } +} + +class B extends A { +>B : Symbol(B, Decl(privateNamesAndFields.ts, 7, 1)) +>A : Symbol(A, Decl(privateNamesAndFields.ts, 0, 0)) + + #foo: string; +>#foo : Symbol(B[#foo], Decl(privateNamesAndFields.ts, 9, 19)) + + constructor () { + super(); +>super : Symbol(A, Decl(privateNamesAndFields.ts, 0, 0)) + + this.#foo = "some string"; +>this.#foo : Symbol(B[#foo], Decl(privateNamesAndFields.ts, 9, 19)) +>this : Symbol(B, Decl(privateNamesAndFields.ts, 7, 1)) + } +} + diff --git a/tests/baselines/reference/privateNamesAndFields.types b/tests/baselines/reference/privateNamesAndFields.types new file mode 100644 index 0000000000000..2b66a106b91e7 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndFields.types @@ -0,0 +1,38 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndFields.ts === +// @target ESNext + +class A { +>A : A + + #foo: number; +>#foo : number + + constructor () { + this.#foo = 3; +>this.#foo = 3 : 3 +>this.#foo : number +>this : this +>3 : 3 + } +} + +class B extends A { +>B : B +>A : A + + #foo: string; +>#foo : string + + constructor () { + super(); +>super() : void +>super : typeof A + + this.#foo = "some string"; +>this.#foo = "some string" : "some string" +>this.#foo : string +>this : this +>"some string" : "some string" + } +} + diff --git a/tests/baselines/reference/privateNamesAndMethods.js b/tests/baselines/reference/privateNamesAndMethods.js new file mode 100644 index 0000000000000..8ca4192b12fd0 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndMethods.js @@ -0,0 +1,60 @@ +//// [privateNamesAndMethods.ts] +class A { + #foo(a: number) {} + async #bar(a: number) {} + async *#baz(a: number) { + return 3; + } + #_quux: number; + get #quux (): number { + return this.#_quux; + } + set #quux (val: number) { + this.#_quux = val; + } + constructor () { + this.#foo(30); + this.#bar(30); + this.#bar(30); + this.#quux = this.#quux + 1; + this.#quux++; + } +} + +class B extends A { + #foo(a: string) {} + constructor () { + super(); + this.#foo("str"); + } +} + + +//// [privateNamesAndMethods.js] +class A { + #foo(a) { } + async #bar(a) { } + async *#baz(a) { + return 3; + } + get #quux() { + return this.#_quux; + } + set #quux(val) { + this.#_quux = val; + } + constructor() { + this.#foo(30); + this.#bar(30); + this.#bar(30); + this.#quux = this.#quux + 1; + this.#quux++; + } +} +class B extends A { + #foo(a) { } + constructor() { + super(); + this.#foo("str"); + } +} diff --git a/tests/baselines/reference/privateNamesAndMethods.symbols b/tests/baselines/reference/privateNamesAndMethods.symbols new file mode 100644 index 0000000000000..bad0e42aa5846 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndMethods.symbols @@ -0,0 +1,80 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndMethods.ts === +class A { +>A : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + #foo(a: number) {} +>#foo : Symbol(A[#foo], Decl(privateNamesAndMethods.ts, 0, 9)) +>a : Symbol(a, Decl(privateNamesAndMethods.ts, 1, 9)) + + async #bar(a: number) {} +>#bar : Symbol(A[#bar], Decl(privateNamesAndMethods.ts, 1, 22)) +>a : Symbol(a, Decl(privateNamesAndMethods.ts, 2, 15)) + + async *#baz(a: number) { +>#baz : Symbol(A[#baz], Decl(privateNamesAndMethods.ts, 2, 28)) +>a : Symbol(a, Decl(privateNamesAndMethods.ts, 3, 16)) + + return 3; + } + #_quux: number; +>#_quux : Symbol(A[#_quux], Decl(privateNamesAndMethods.ts, 5, 5)) + + get #quux (): number { +>#quux : Symbol(A[#quux], Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) + + return this.#_quux; +>this.#_quux : Symbol(A[#_quux], Decl(privateNamesAndMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + } + set #quux (val: number) { +>#quux : Symbol(A[#quux], Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>val : Symbol(val, Decl(privateNamesAndMethods.ts, 10, 15)) + + this.#_quux = val; +>this.#_quux : Symbol(A[#_quux], Decl(privateNamesAndMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) +>val : Symbol(val, Decl(privateNamesAndMethods.ts, 10, 15)) + } + constructor () { + this.#foo(30); +>this.#foo : Symbol(A[#foo], Decl(privateNamesAndMethods.ts, 0, 9)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + this.#bar(30); +>this.#bar : Symbol(A[#bar], Decl(privateNamesAndMethods.ts, 1, 22)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + this.#bar(30); +>this.#bar : Symbol(A[#bar], Decl(privateNamesAndMethods.ts, 1, 22)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + this.#quux = this.#quux + 1; +>this.#quux : Symbol(A[#quux], Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) +>this.#quux : Symbol(A[#quux], Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + this.#quux++; +>this.#quux : Symbol(A[#quux], Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + } +} + +class B extends A { +>B : Symbol(B, Decl(privateNamesAndMethods.ts, 20, 1)) +>A : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + #foo(a: string) {} +>#foo : Symbol(B[#foo], Decl(privateNamesAndMethods.ts, 22, 19)) +>a : Symbol(a, Decl(privateNamesAndMethods.ts, 23, 9)) + + constructor () { + super(); +>super : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + this.#foo("str"); +>this.#foo : Symbol(B[#foo], Decl(privateNamesAndMethods.ts, 22, 19)) +>this : Symbol(B, Decl(privateNamesAndMethods.ts, 20, 1)) + } +} + diff --git a/tests/baselines/reference/privateNamesAndMethods.types b/tests/baselines/reference/privateNamesAndMethods.types new file mode 100644 index 0000000000000..847ee901d527b --- /dev/null +++ b/tests/baselines/reference/privateNamesAndMethods.types @@ -0,0 +1,95 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndMethods.ts === +class A { +>A : A + + #foo(a: number) {} +>#foo : (a: number) => void +>a : number + + async #bar(a: number) {} +>#bar : (a: number) => Promise +>a : number + + async *#baz(a: number) { +>#baz : (a: number) => AsyncIterableIterator +>a : number + + return 3; +>3 : 3 + } + #_quux: number; +>#_quux : number + + get #quux (): number { +>#quux : number + + return this.#_quux; +>this.#_quux : number +>this : this + } + set #quux (val: number) { +>#quux : number +>val : number + + this.#_quux = val; +>this.#_quux = val : number +>this.#_quux : number +>this : this +>val : number + } + constructor () { + this.#foo(30); +>this.#foo(30) : void +>this.#foo : (a: number) => void +>this : this +>30 : 30 + + this.#bar(30); +>this.#bar(30) : Promise +>this.#bar : (a: number) => Promise +>this : this +>30 : 30 + + this.#bar(30); +>this.#bar(30) : Promise +>this.#bar : (a: number) => Promise +>this : this +>30 : 30 + + this.#quux = this.#quux + 1; +>this.#quux = this.#quux + 1 : number +>this.#quux : number +>this : this +>this.#quux + 1 : number +>this.#quux : number +>this : this +>1 : 1 + + this.#quux++; +>this.#quux++ : number +>this.#quux : number +>this : this + } +} + +class B extends A { +>B : B +>A : A + + #foo(a: string) {} +>#foo : (a: string) => void +>a : string + + constructor () { + super(); +>super() : void +>super : typeof A + + this.#foo("str"); +>this.#foo("str") : void +>this.#foo : (a: string) => void +>this : this +>"str" : "str" + } +} + diff --git a/tests/baselines/reference/privateNamesAndStaticFields.js b/tests/baselines/reference/privateNamesAndStaticFields.js new file mode 100644 index 0000000000000..fa98ac60bc923 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndStaticFields.js @@ -0,0 +1,49 @@ +//// [privateNamesAndStaticFields.ts] +// @target ESNext + +class A { + static #foo: number; + constructor () { + A.#foo = 3; + } +} + +class B extends A { + static #foo: string; + constructor () { + super(); + B.#foo = "some string"; + } +} + + +//// [privateNamesAndStaticFields.js] +// @target ESNext +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var A = /** @class */ (function () { + function A() { + A.#foo = 3; + } + return A; +}()); +var B = /** @class */ (function (_super) { + __extends(B, _super); + function B() { + var _this = _super.call(this) || this; + B.#foo = "some string"; + return _this; + } + return B; +}(A)); diff --git a/tests/baselines/reference/privateNamesAndStaticFields.symbols b/tests/baselines/reference/privateNamesAndStaticFields.symbols new file mode 100644 index 0000000000000..a978ec59f7f03 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndStaticFields.symbols @@ -0,0 +1,33 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticFields.ts === +// @target ESNext + +class A { +>A : Symbol(A, Decl(privateNamesAndStaticFields.ts, 0, 0)) + + static #foo: number; +>#foo : Symbol(A[#foo], Decl(privateNamesAndStaticFields.ts, 2, 9)) + + constructor () { + A.#foo = 3; +>A.#foo : Symbol(A[#foo], Decl(privateNamesAndStaticFields.ts, 2, 9)) +>A : Symbol(A, Decl(privateNamesAndStaticFields.ts, 0, 0)) + } +} + +class B extends A { +>B : Symbol(B, Decl(privateNamesAndStaticFields.ts, 7, 1)) +>A : Symbol(A, Decl(privateNamesAndStaticFields.ts, 0, 0)) + + static #foo: string; +>#foo : Symbol(B[#foo], Decl(privateNamesAndStaticFields.ts, 9, 19)) + + constructor () { + super(); +>super : Symbol(A, Decl(privateNamesAndStaticFields.ts, 0, 0)) + + B.#foo = "some string"; +>B.#foo : Symbol(B[#foo], Decl(privateNamesAndStaticFields.ts, 9, 19)) +>B : Symbol(B, Decl(privateNamesAndStaticFields.ts, 7, 1)) + } +} + diff --git a/tests/baselines/reference/privateNamesAndStaticFields.types b/tests/baselines/reference/privateNamesAndStaticFields.types new file mode 100644 index 0000000000000..ce2d5409fbf13 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndStaticFields.types @@ -0,0 +1,38 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticFields.ts === +// @target ESNext + +class A { +>A : A + + static #foo: number; +>#foo : number + + constructor () { + A.#foo = 3; +>A.#foo = 3 : 3 +>A.#foo : number +>A : typeof A +>3 : 3 + } +} + +class B extends A { +>B : B +>A : A + + static #foo: string; +>#foo : string + + constructor () { + super(); +>super() : void +>super : typeof A + + B.#foo = "some string"; +>B.#foo = "some string" : "some string" +>B.#foo : string +>B : typeof B +>"some string" : "some string" + } +} + diff --git a/tests/baselines/reference/privateNamesAndStaticMethods.js b/tests/baselines/reference/privateNamesAndStaticMethods.js new file mode 100644 index 0000000000000..b12b777e3d0bd --- /dev/null +++ b/tests/baselines/reference/privateNamesAndStaticMethods.js @@ -0,0 +1,60 @@ +//// [privateNamesAndStaticMethods.ts] +class A { + static #foo(a: number) {} + static async #bar(a: number) {} + static async *#baz(a: number) { + return 3; + } + static #_quux: number; + static get #quux (): number { + return this.#_quux; + } + static set #quux (val: number) { + this.#_quux = val; + } + constructor () { + A.#foo(30); + A.#bar(30); + A.#bar(30); + A.#quux = A.#quux + 1; + A.#quux++; + } +} + +class B extends A { + static #foo(a: string) {} + constructor () { + super(); + B.#foo("str"); + } +} + + +//// [privateNamesAndStaticMethods.js] +class A { + static #foo(a) { } + static async #bar(a) { } + static async *#baz(a) { + return 3; + } + static get #quux() { + return this.#_quux; + } + static set #quux(val) { + this.#_quux = val; + } + constructor() { + A.#foo(30); + A.#bar(30); + A.#bar(30); + A.#quux = A.#quux + 1; + A.#quux++; + } +} +class B extends A { + static #foo(a) { } + constructor() { + super(); + B.#foo("str"); + } +} diff --git a/tests/baselines/reference/privateNamesAndStaticMethods.symbols b/tests/baselines/reference/privateNamesAndStaticMethods.symbols new file mode 100644 index 0000000000000..d78b97ff60aef --- /dev/null +++ b/tests/baselines/reference/privateNamesAndStaticMethods.symbols @@ -0,0 +1,80 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts === +class A { +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + static #foo(a: number) {} +>#foo : Symbol(A[#foo], Decl(privateNamesAndStaticMethods.ts, 0, 9)) +>a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 1, 16)) + + static async #bar(a: number) {} +>#bar : Symbol(A[#bar], Decl(privateNamesAndStaticMethods.ts, 1, 29)) +>a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 2, 22)) + + static async *#baz(a: number) { +>#baz : Symbol(A[#baz], Decl(privateNamesAndStaticMethods.ts, 2, 35)) +>a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 3, 23)) + + return 3; + } + static #_quux: number; +>#_quux : Symbol(A[#_quux], Decl(privateNamesAndStaticMethods.ts, 5, 5)) + + static get #quux (): number { +>#quux : Symbol(A[#quux], Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) + + return this.#_quux; +>this.#_quux : Symbol(A[#_quux], Decl(privateNamesAndStaticMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + } + static set #quux (val: number) { +>#quux : Symbol(A[#quux], Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>val : Symbol(val, Decl(privateNamesAndStaticMethods.ts, 10, 22)) + + this.#_quux = val; +>this.#_quux : Symbol(A[#_quux], Decl(privateNamesAndStaticMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) +>val : Symbol(val, Decl(privateNamesAndStaticMethods.ts, 10, 22)) + } + constructor () { + A.#foo(30); +>A.#foo : Symbol(A[#foo], Decl(privateNamesAndStaticMethods.ts, 0, 9)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + A.#bar(30); +>A.#bar : Symbol(A[#bar], Decl(privateNamesAndStaticMethods.ts, 1, 29)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + A.#bar(30); +>A.#bar : Symbol(A[#bar], Decl(privateNamesAndStaticMethods.ts, 1, 29)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + A.#quux = A.#quux + 1; +>A.#quux : Symbol(A[#quux], Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) +>A.#quux : Symbol(A[#quux], Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + A.#quux++; +>A.#quux : Symbol(A[#quux], Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + } +} + +class B extends A { +>B : Symbol(B, Decl(privateNamesAndStaticMethods.ts, 20, 1)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + static #foo(a: string) {} +>#foo : Symbol(B[#foo], Decl(privateNamesAndStaticMethods.ts, 22, 19)) +>a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 23, 16)) + + constructor () { + super(); +>super : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + B.#foo("str"); +>B.#foo : Symbol(B[#foo], Decl(privateNamesAndStaticMethods.ts, 22, 19)) +>B : Symbol(B, Decl(privateNamesAndStaticMethods.ts, 20, 1)) + } +} + diff --git a/tests/baselines/reference/privateNamesAndStaticMethods.types b/tests/baselines/reference/privateNamesAndStaticMethods.types new file mode 100644 index 0000000000000..3a4a89dbd754d --- /dev/null +++ b/tests/baselines/reference/privateNamesAndStaticMethods.types @@ -0,0 +1,95 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts === +class A { +>A : A + + static #foo(a: number) {} +>#foo : (a: number) => void +>a : number + + static async #bar(a: number) {} +>#bar : (a: number) => Promise +>a : number + + static async *#baz(a: number) { +>#baz : (a: number) => AsyncIterableIterator +>a : number + + return 3; +>3 : 3 + } + static #_quux: number; +>#_quux : number + + static get #quux (): number { +>#quux : number + + return this.#_quux; +>this.#_quux : number +>this : typeof A + } + static set #quux (val: number) { +>#quux : number +>val : number + + this.#_quux = val; +>this.#_quux = val : number +>this.#_quux : number +>this : typeof A +>val : number + } + constructor () { + A.#foo(30); +>A.#foo(30) : void +>A.#foo : (a: number) => void +>A : typeof A +>30 : 30 + + A.#bar(30); +>A.#bar(30) : Promise +>A.#bar : (a: number) => Promise +>A : typeof A +>30 : 30 + + A.#bar(30); +>A.#bar(30) : Promise +>A.#bar : (a: number) => Promise +>A : typeof A +>30 : 30 + + A.#quux = A.#quux + 1; +>A.#quux = A.#quux + 1 : number +>A.#quux : number +>A : typeof A +>A.#quux + 1 : number +>A.#quux : number +>A : typeof A +>1 : 1 + + A.#quux++; +>A.#quux++ : number +>A.#quux : number +>A : typeof A + } +} + +class B extends A { +>B : B +>A : A + + static #foo(a: string) {} +>#foo : (a: string) => void +>a : string + + constructor () { + super(); +>super() : void +>super : typeof A + + B.#foo("str"); +>B.#foo("str") : void +>B.#foo : (a: string) => void +>B : typeof B +>"str" : "str" + } +} + diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesAndFields.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesAndFields.ts new file mode 100644 index 0000000000000..ddfdc1d9f1f88 --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesAndFields.ts @@ -0,0 +1,16 @@ +// @target ESNext + +class A { + #foo: number; + constructor () { + this.#foo = 3; + } +} + +class B extends A { + #foo: string; + constructor () { + super(); + this.#foo = "some string"; + } +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesAndMethods.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesAndMethods.ts new file mode 100644 index 0000000000000..d564860b56e97 --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesAndMethods.ts @@ -0,0 +1,32 @@ +// @target: esnext +// @lib: esnext + +class A { + #foo(a: number) {} + async #bar(a: number) {} + async *#baz(a: number) { + return 3; + } + #_quux: number; + get #quux (): number { + return this.#_quux; + } + set #quux (val: number) { + this.#_quux = val; + } + constructor () { + this.#foo(30); + this.#bar(30); + this.#bar(30); + this.#quux = this.#quux + 1; + this.#quux++; + } +} + +class B extends A { + #foo(a: string) {} + constructor () { + super(); + this.#foo("str"); + } +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticFields.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticFields.ts new file mode 100644 index 0000000000000..ad2e38736e3e1 --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticFields.ts @@ -0,0 +1,16 @@ +// @target ESNext + +class A { + static #foo: number; + constructor () { + A.#foo = 3; + } +} + +class B extends A { + static #foo: string; + constructor () { + super(); + B.#foo = "some string"; + } +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts new file mode 100644 index 0000000000000..b4577671d4e87 --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts @@ -0,0 +1,32 @@ +// @target: esnext +// @lib: esnext + +class A { + static #foo(a: number) {} + static async #bar(a: number) {} + static async *#baz(a: number) { + return 3; + } + static #_quux: number; + static get #quux (): number { + return this.#_quux; + } + static set #quux (val: number) { + this.#_quux = val; + } + constructor () { + A.#foo(30); + A.#bar(30); + A.#bar(30); + A.#quux = A.#quux + 1; + A.#quux++; + } +} + +class B extends A { + static #foo(a: string) {} + constructor () { + super(); + B.#foo("str"); + } +} From b5c093335bec08b41c07fdeadf8e2d2bcf660a9d Mon Sep 17 00:00:00 2001 From: Max Heiber Date: Thu, 6 Dec 2018 17:50:18 -0500 Subject: [PATCH 5/8] update naming and cleanup for check private names for private name support in the checker: - make names more consistent - remove unnecessary checks - add utility function to public API - other small cleanup Signed-off-by: Max Heiber --- src/compiler/binder.ts | 5 --- src/compiler/checker.ts | 35 ++++++++++--------- src/compiler/types.ts | 1 + .../reference/api/tsserverlibrary.d.ts | 1 + tests/baselines/reference/api/typescript.d.ts | 1 + 5 files changed, 22 insertions(+), 21 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index f0bbc6a2d1241..b873a2f7b8587 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -388,11 +388,6 @@ namespace ts { symbolTable.set(name, symbol = createSymbol(SymbolFlags.None, name)); } else if (!(includes & SymbolFlags.Variable && symbol.flags & SymbolFlags.Assignment)) { - // Assignment declarations are allowed to merge with variables, no matter what other flags they have. - if (isNamedDeclaration(node)) { - node.name.parent = node; - } - // Report errors every position with duplicate declaration // Report errors on previous encountered declarations let message = symbol.flags & SymbolFlags.BlockScopedVariable diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 61be9fcefc1a6..b73b87f282e5a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -122,6 +122,7 @@ namespace ts { getDeclaredTypeOfSymbol, getPropertiesOfType, getPropertyOfType: (type, name) => getPropertyOfType(type, escapeLeadingUnderscores(name)), + getPropertyForPrivateName, getTypeOfPropertyOfType: (type, name) => getTypeOfPropertyOfType(type, escapeLeadingUnderscores(name)), getIndexInfoOfType, getSignaturesOfType, @@ -18447,38 +18448,40 @@ namespace ts { return checkPropertyAccessExpressionOrQualifiedName(node, node.left, node.right); } - function getPropertyByPrivateName(apparentType: Type, leftType: Type, right: PrivateName): Symbol | undefined { + function getPropertyForPrivateName(apparentType: Type, leftType: Type, right: PrivateName, errorNode: Node | undefined): Symbol | undefined { let classWithShadowedPrivateName; - let klass = getContainingClass(right); - while (klass) { - const symbolTableKey = getPropertyNameForPrivateNameDescription(klass.symbol, right.escapedText); + let container = getContainingClass(right); + while (container) { + const symbolTableKey = getPropertyNameForPrivateNameDescription(container.symbol, right.escapedText); if (symbolTableKey) { const prop = getPropertyOfType(apparentType, symbolTableKey); if (prop) { if (classWithShadowedPrivateName) { - error( - right, - Diagnostics.This_usage_of_0_refers_to_the_private_member_declared_in_its_enclosing_class_While_type_1_has_a_private_member_with_the_same_spelling_its_declaration_and_accessibility_are_distinct, - diagnosticName(right), - diagnosticName(classWithShadowedPrivateName.name || ("(anonymous)" as __String)) - ); + if (errorNode) { + error( + errorNode, + Diagnostics.This_usage_of_0_refers_to_the_private_member_declared_in_its_enclosing_class_While_type_1_has_a_private_member_with_the_same_spelling_its_declaration_and_accessibility_are_distinct, + diagnosticName(right), + diagnosticName(classWithShadowedPrivateName.name || ("(anonymous)" as __String)) + ); + } return undefined; } return prop; } else { - classWithShadowedPrivateName = klass; + classWithShadowedPrivateName = container; } } - klass = getContainingClass(klass); + container = getContainingClass(container); } // If this isn't a case of shadowing, and the lhs has a property with the same // private name description, then there is a privacy violation if (leftType.symbol.members) { const symbolTableKey = getPropertyNameForPrivateNameDescription(leftType.symbol, right.escapedText); - if (symbolTableKey) { - const prop = getPropertyOfType(apparentType, symbolTableKey); - if (prop) { + const prop = getPropertyOfType(apparentType, symbolTableKey); + if (prop) { + if (errorNode) { error(right, Diagnostics.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_name, symbolToString(prop), typeToString(getDeclaringClass(prop)!)); } } @@ -18499,7 +18502,7 @@ namespace ts { return apparentType; } const assignmentKind = getAssignmentTargetKind(node); - const prop = isPrivateName(right) ? getPropertyByPrivateName(apparentType, leftType, right) : getPropertyOfType(apparentType, right.escapedText); + const prop = isPrivateName(right) ? getPropertyForPrivateName(apparentType, leftType, right, /* errorNode */ right) : getPropertyOfType(apparentType, right.escapedText); if (isIdentifier(left) && parentSymbol && !(prop && isConstEnumOrConstEnumOnlyModule(prop))) { markAliasReferenced(parentSymbol, node); } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 62b3a93e245da..c4e83670b6e40 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -3026,6 +3026,7 @@ namespace ts { getDeclaredTypeOfSymbol(symbol: Symbol): Type; getPropertiesOfType(type: Type): Symbol[]; getPropertyOfType(type: Type, propertyName: string): Symbol | undefined; + getPropertyForPrivateName(apparentType: Type, leftType: Type, right: PrivateName, errorNode: Node | undefined): Symbol | undefined; /* @internal */ getTypeOfPropertyOfType(type: Type, propertyName: string): Type | undefined; getIndexInfoOfType(type: Type, kind: IndexKind): IndexInfo | undefined; getSignaturesOfType(type: Type, kind: SignatureKind): ReadonlyArray; diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index ebb179af202a1..914eb81e4dbc0 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -1876,6 +1876,7 @@ declare namespace ts { getDeclaredTypeOfSymbol(symbol: Symbol): Type; getPropertiesOfType(type: Type): Symbol[]; getPropertyOfType(type: Type, propertyName: string): Symbol | undefined; + getPropertyForPrivateName(apparentType: Type, leftType: Type, right: PrivateName, errorNode: Node | undefined): Symbol | undefined; getIndexInfoOfType(type: Type, kind: IndexKind): IndexInfo | undefined; getSignaturesOfType(type: Type, kind: SignatureKind): ReadonlyArray; getIndexTypeOfType(type: Type, kind: IndexKind): Type | undefined; diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index 7d00bfb714bdc..50cb3d2ebb808 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -1876,6 +1876,7 @@ declare namespace ts { getDeclaredTypeOfSymbol(symbol: Symbol): Type; getPropertiesOfType(type: Type): Symbol[]; getPropertyOfType(type: Type, propertyName: string): Symbol | undefined; + getPropertyForPrivateName(apparentType: Type, leftType: Type, right: PrivateName, errorNode: Node | undefined): Symbol | undefined; getIndexInfoOfType(type: Type, kind: IndexKind): IndexInfo | undefined; getSignaturesOfType(type: Type, kind: SignatureKind): ReadonlyArray; getIndexTypeOfType(type: Type, kind: IndexKind): Type | undefined; From a4bc65bfe9eef785d956addee7194b5982fd2584 Mon Sep 17 00:00:00 2001 From: Max Heiber Date: Fri, 7 Dec 2018 11:13:25 -0500 Subject: [PATCH 6/8] Move getPropertyNameForUniqueESSymbol to utility for consistency with other calculation of special property names (starting with __), move the calculation of property names for unique es symbols to `utilities.ts`. Signed-off-by: Max Heiber --- src/compiler/checker.ts | 2 +- src/compiler/utilities.ts | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index b73b87f282e5a..9c56c9f33ff5a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6252,7 +6252,7 @@ namespace ts { */ function getLateBoundNameFromType(type: LiteralType | UniqueESSymbolType): __String { if (type.flags & TypeFlags.UniqueESSymbol) { - return `__@${type.symbol.escapedName}@${getSymbolId(type.symbol)}` as __String; + return getPropertyNameForUniqueESSymbol(type.symbol); } if (type.flags & (TypeFlags.StringLiteral | TypeFlags.NumberLiteral)) { return escapeLeadingUnderscores("" + (type).value); diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index cac31a75e72bf..208cbd3d0ceb5 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -2728,6 +2728,10 @@ namespace ts { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateName ? node.escapedText : escapeLeadingUnderscores(node.text); } + export function getPropertyNameForUniqueESSymbol(symbol: Symbol): __String { + return `__@${getSymbolId(symbol)}@${symbol.escapedName}` as __String; + } + export function getPropertyNameForKnownSymbolName(symbolName: string): __String { return "__@" + symbolName as __String; } From 351c75c55c312cd15f2fe81d2d44209c8c603b25 Mon Sep 17 00:00:00 2001 From: Max Date: Sat, 5 Jan 2019 14:49:59 -0500 Subject: [PATCH 7/8] private name tests strict+es6 Update private name tests to use 'strict' type checking and to target es6 instead of default. Makes the js output easier to read and tests more surface area with other checker features. Signed-off-by: Max Heiber --- .../privateNameAndIndexSignature.errors.txt | 4 +- .../reference/privateNameAndIndexSignature.js | 4 ++ .../privateNameAndIndexSignature.symbols | 6 +- .../privateNameAndIndexSignature.types | 2 + .../privateNameConstructorReserved.errors.txt | 4 +- .../privateNameConstructorReserved.js | 3 + .../privateNameConstructorReserved.symbols | 4 +- .../privateNameConstructorReserved.types | 2 + .../privateNameDuplicateField.errors.txt | 8 ++- .../reference/privateNameDuplicateField.js | 12 +++- .../privateNameDuplicateField.symbols | 10 +-- .../reference/privateNameDuplicateField.types | 12 ++-- tests/baselines/reference/privateNameField.js | 4 ++ .../reference/privateNameField.symbols | 10 +-- .../reference/privateNameField.types | 2 + ...tAccessibleOutsideDefiningClass.errors.txt | 6 +- ...teNameNotAccessibleOutsideDefiningClass.js | 8 ++- ...eNotAccessibleOutsideDefiningClass.symbols | 4 +- ...ameNotAccessibleOutsideDefiningClass.types | 2 + ...ivateNameNotAllowedOutsideClass.errors.txt | 8 ++- .../privateNameNotAllowedOutsideClass.js | 4 ++ .../privateNameNotAllowedOutsideClass.symbols | 4 +- .../privateNameNotAllowedOutsideClass.types | 2 + .../privateNameSneakyRuntimeException.js | 30 +++++--- .../privateNameSneakyRuntimeException.symbols | 30 ++++---- .../privateNameSneakyRuntimeException.types | 13 ++-- .../reference/privateNamesAndFields.js | 15 ++-- .../reference/privateNamesAndFields.symbols | 10 +-- .../reference/privateNamesAndFields.types | 2 +- .../reference/privateNamesAndMethods.js | 1 + .../reference/privateNamesAndMethods.symbols | 32 ++++----- .../reference/privateNamesAndStaticFields.js | 13 ++-- .../privateNamesAndStaticFields.symbols | 10 +-- .../privateNamesAndStaticFields.types | 2 +- .../reference/privateNamesAndStaticMethods.js | 2 + .../privateNamesAndStaticMethods.symbols | 32 ++++----- .../reference/privateNamesAndkeyof.js | 15 +++- .../reference/privateNamesAndkeyof.symbols | 16 +++-- .../reference/privateNamesAndkeyof.types | 17 +++-- .../privateNamesInGenericClasses.errors.txt | 10 +-- .../reference/privateNamesInGenericClasses.js | 14 +++- .../privateNamesInGenericClasses.symbols | 48 +++++++------ .../privateNamesInGenericClasses.types | 2 + .../privateNamesInNestedClasses.errors.txt | 8 ++- .../reference/privateNamesInNestedClasses.js | 23 ++++-- .../privateNamesInNestedClasses.symbols | 70 ++++++++++--------- .../privateNamesInNestedClasses.types | 4 +- ...teNamesNoAccessibilityModifiers.errors.txt | 16 +++-- .../privateNamesNoAccessibilityModifiers.js | 18 +++-- ...ivateNamesNoAccessibilityModifiers.symbols | 18 ++--- ...privateNamesNoAccessibilityModifiers.types | 22 +++--- .../privateNamesNoConflictWhenInheriting.js | 12 +++- ...ivateNamesNoConflictWhenInheriting.symbols | 12 ++-- ...privateNamesNoConflictWhenInheriting.types | 2 + .../reference/privateNamesNoDelete.errors.txt | 4 +- .../reference/privateNamesNoDelete.js | 11 ++- .../reference/privateNamesNoDelete.symbols | 6 +- .../reference/privateNamesNoDelete.types | 2 + ...vateNamesNotAllowedAsParameters.errors.txt | 10 +-- .../privateNamesNotAllowedAsParameters.js | 6 ++ ...privateNamesNotAllowedAsParameters.symbols | 6 +- .../privateNamesNotAllowedAsParameters.types | 2 + ...otAllowedInVariableDeclarations.errors.txt | 8 ++- ...teNamesNotAllowedInVariableDeclarations.js | 4 ++ ...esNotAllowedInVariableDeclarations.symbols | 4 +- ...amesNotAllowedInVariableDeclarations.types | 2 + .../reference/privateNamesUnique.errors.txt | 6 +- .../baselines/reference/privateNamesUnique.js | 11 ++- .../reference/privateNamesUnique.symbols | 14 ++-- .../reference/privateNamesUnique.types | 4 +- .../privateNameAndIndexSignature.ts | 3 + .../privateNameConstructorReserved.ts | 2 + .../privateNames/privateNameDuplicateField.ts | 11 +-- .../members/privateNames/privateNameField.ts | 3 + ...teNameNotAccessibleOutsideDefiningClass.ts | 3 + .../privateNameNotAllowedOutsideClass.ts | 3 + .../privateNameSneakyRuntimeException.ts | 29 ++++---- .../privateNames/privateNamesAndFields.ts | 33 ++++----- .../privateNamesAndStaticFields.ts | 33 ++++----- .../privateNamesAndStaticMethods.ts | 65 ++++++++--------- .../privateNames/privateNamesAndkeyof.ts | 17 +++-- .../privateNamesInGenericClasses.ts | 3 + .../privateNamesInNestedClasses.ts | 5 +- .../privateNamesNoAccessibilityModifiers.ts | 11 +-- .../privateNamesNoConflictWhenInheriting.ts | 3 + .../privateNames/privateNamesNoDelete.ts | 3 + .../privateNamesNotAllowedAsParameters.ts | 2 + ...teNamesNotAllowedInVariableDeclarations.ts | 3 + .../privateNames/privateNamesUnique.ts | 5 +- 89 files changed, 627 insertions(+), 354 deletions(-) diff --git a/tests/baselines/reference/privateNameAndIndexSignature.errors.txt b/tests/baselines/reference/privateNameAndIndexSignature.errors.txt index 1b4895bf23d64..cbe22ffb7c156 100644 --- a/tests/baselines/reference/privateNameAndIndexSignature.errors.txt +++ b/tests/baselines/reference/privateNameAndIndexSignature.errors.txt @@ -1,7 +1,9 @@ -tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts(4,14): error TS2339: Property '#f' does not exist on type 'A'. +tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts(6,14): error TS2339: Property '#f' does not exist on type 'A'. ==== tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts (1 errors) ==== + // @target es6 + class A { [k: string]: any; constructor(message: string) { diff --git a/tests/baselines/reference/privateNameAndIndexSignature.js b/tests/baselines/reference/privateNameAndIndexSignature.js index d1271acca8ce9..561a0ce1210b3 100644 --- a/tests/baselines/reference/privateNameAndIndexSignature.js +++ b/tests/baselines/reference/privateNameAndIndexSignature.js @@ -1,4 +1,6 @@ //// [privateNameAndIndexSignature.ts] +// @target es6 + class A { [k: string]: any; constructor(message: string) { @@ -8,6 +10,8 @@ class A { //// [privateNameAndIndexSignature.js] +"use strict"; +// @target es6 var A = /** @class */ (function () { function A(message) { this.#f = 3; // Error Property '#f' does not exist on type 'A'. diff --git a/tests/baselines/reference/privateNameAndIndexSignature.symbols b/tests/baselines/reference/privateNameAndIndexSignature.symbols index d8a153c04270e..609eb3a491779 100644 --- a/tests/baselines/reference/privateNameAndIndexSignature.symbols +++ b/tests/baselines/reference/privateNameAndIndexSignature.symbols @@ -1,12 +1,14 @@ === tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts === +// @target es6 + class A { >A : Symbol(A, Decl(privateNameAndIndexSignature.ts, 0, 0)) [k: string]: any; ->k : Symbol(k, Decl(privateNameAndIndexSignature.ts, 1, 5)) +>k : Symbol(k, Decl(privateNameAndIndexSignature.ts, 3, 5)) constructor(message: string) { ->message : Symbol(message, Decl(privateNameAndIndexSignature.ts, 2, 16)) +>message : Symbol(message, Decl(privateNameAndIndexSignature.ts, 4, 16)) this.#f = 3 // Error Property '#f' does not exist on type 'A'. >this : Symbol(A, Decl(privateNameAndIndexSignature.ts, 0, 0)) diff --git a/tests/baselines/reference/privateNameAndIndexSignature.types b/tests/baselines/reference/privateNameAndIndexSignature.types index d663d5b9517cc..47015a920bb28 100644 --- a/tests/baselines/reference/privateNameAndIndexSignature.types +++ b/tests/baselines/reference/privateNameAndIndexSignature.types @@ -1,4 +1,6 @@ === tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts === +// @target es6 + class A { >A : A diff --git a/tests/baselines/reference/privateNameConstructorReserved.errors.txt b/tests/baselines/reference/privateNameConstructorReserved.errors.txt index e79145b7e3eb4..ef48440e250a1 100644 --- a/tests/baselines/reference/privateNameConstructorReserved.errors.txt +++ b/tests/baselines/reference/privateNameConstructorReserved.errors.txt @@ -1,7 +1,9 @@ -tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts(2,5): error TS18006: '#constructor' is a reserved word. +tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts(4,5): error TS18006: '#constructor' is a reserved word. ==== tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts (1 errors) ==== + // @target es6 + class A { #constructor() {} // Error: `#constructor` is a reserved word. ~~~~~~~~~~~~ diff --git a/tests/baselines/reference/privateNameConstructorReserved.js b/tests/baselines/reference/privateNameConstructorReserved.js index dde1724421427..61585bd4eb127 100644 --- a/tests/baselines/reference/privateNameConstructorReserved.js +++ b/tests/baselines/reference/privateNameConstructorReserved.js @@ -1,10 +1,13 @@ //// [privateNameConstructorReserved.ts] +// @target es6 + class A { #constructor() {} // Error: `#constructor` is a reserved word. } //// [privateNameConstructorReserved.js] +// @target es6 var A = /** @class */ (function () { function A() { } diff --git a/tests/baselines/reference/privateNameConstructorReserved.symbols b/tests/baselines/reference/privateNameConstructorReserved.symbols index 6b4d81fe324be..3f3cbc722039f 100644 --- a/tests/baselines/reference/privateNameConstructorReserved.symbols +++ b/tests/baselines/reference/privateNameConstructorReserved.symbols @@ -1,8 +1,10 @@ === tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts === +// @target es6 + class A { >A : Symbol(A, Decl(privateNameConstructorReserved.ts, 0, 0)) #constructor() {} // Error: `#constructor` is a reserved word. ->#constructor : Symbol(A[#constructor], Decl(privateNameConstructorReserved.ts, 0, 9)) +>#constructor : Symbol(A.#constructor, Decl(privateNameConstructorReserved.ts, 2, 9)) } diff --git a/tests/baselines/reference/privateNameConstructorReserved.types b/tests/baselines/reference/privateNameConstructorReserved.types index f5e646b9a2190..2b75281b7a02e 100644 --- a/tests/baselines/reference/privateNameConstructorReserved.types +++ b/tests/baselines/reference/privateNameConstructorReserved.types @@ -1,4 +1,6 @@ === tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts === +// @target es6 + class A { >A : A diff --git a/tests/baselines/reference/privateNameDuplicateField.errors.txt b/tests/baselines/reference/privateNameDuplicateField.errors.txt index 4c25506723124..4a8428c6102c2 100644 --- a/tests/baselines/reference/privateNameDuplicateField.errors.txt +++ b/tests/baselines/reference/privateNameDuplicateField.errors.txt @@ -1,10 +1,12 @@ -tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts(3,5): error TS2300: Duplicate identifier '#foo'. +tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts(5,5): error TS2300: Duplicate identifier '#foo'. ==== tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts (1 errors) ==== + // @target es6 + class A { - #foo; - #foo; + #foo = "foo"; + #foo = "foo"; ~~~~ !!! error TS2300: Duplicate identifier '#foo'. } diff --git a/tests/baselines/reference/privateNameDuplicateField.js b/tests/baselines/reference/privateNameDuplicateField.js index 4d5741a26e91b..6ece4be8f032a 100644 --- a/tests/baselines/reference/privateNameDuplicateField.js +++ b/tests/baselines/reference/privateNameDuplicateField.js @@ -1,13 +1,21 @@ //// [privateNameDuplicateField.ts] +// @target es6 + class A { - #foo; - #foo; + #foo = "foo"; + #foo = "foo"; } //// [privateNameDuplicateField.js] +// @target es6 +var _foo, _foo_1; +"use strict"; var A = /** @class */ (function () { function A() { + _foo_1.set(this, "foo"); + _foo_1.set(this, "foo"); } return A; }()); +_foo = new WeakMap(), _foo_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNameDuplicateField.symbols b/tests/baselines/reference/privateNameDuplicateField.symbols index a7dae178bc4a7..0da02e645ada3 100644 --- a/tests/baselines/reference/privateNameDuplicateField.symbols +++ b/tests/baselines/reference/privateNameDuplicateField.symbols @@ -1,11 +1,13 @@ === tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts === +// @target es6 + class A { >A : Symbol(A, Decl(privateNameDuplicateField.ts, 0, 0)) - #foo; ->#foo : Symbol(A[#foo], Decl(privateNameDuplicateField.ts, 0, 9), Decl(privateNameDuplicateField.ts, 1, 9)) + #foo = "foo"; +>#foo : Symbol(A.#foo, Decl(privateNameDuplicateField.ts, 2, 9), Decl(privateNameDuplicateField.ts, 3, 17)) - #foo; ->#foo : Symbol(A[#foo], Decl(privateNameDuplicateField.ts, 0, 9), Decl(privateNameDuplicateField.ts, 1, 9)) + #foo = "foo"; +>#foo : Symbol(A.#foo, Decl(privateNameDuplicateField.ts, 2, 9), Decl(privateNameDuplicateField.ts, 3, 17)) } diff --git a/tests/baselines/reference/privateNameDuplicateField.types b/tests/baselines/reference/privateNameDuplicateField.types index 9f5f65ccd34ce..e73152ebd4455 100644 --- a/tests/baselines/reference/privateNameDuplicateField.types +++ b/tests/baselines/reference/privateNameDuplicateField.types @@ -1,11 +1,15 @@ === tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts === +// @target es6 + class A { >A : A - #foo; ->#foo : any + #foo = "foo"; +>#foo : string +>"foo" : "foo" - #foo; ->#foo : any + #foo = "foo"; +>#foo : string +>"foo" : "foo" } diff --git a/tests/baselines/reference/privateNameField.js b/tests/baselines/reference/privateNameField.js index 843461daceb29..57446748cb668 100644 --- a/tests/baselines/reference/privateNameField.js +++ b/tests/baselines/reference/privateNameField.js @@ -1,4 +1,6 @@ //// [privateNameField.ts] +// @target es6 + class A { #name: string; constructor(name: string) { @@ -7,8 +9,10 @@ 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; +"use strict"; var A = /** @class */ (function () { function A(name) { _name.set(this, void 0); diff --git a/tests/baselines/reference/privateNameField.symbols b/tests/baselines/reference/privateNameField.symbols index cbaedbc596caf..c37ded65bd1a7 100644 --- a/tests/baselines/reference/privateNameField.symbols +++ b/tests/baselines/reference/privateNameField.symbols @@ -1,16 +1,18 @@ === 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, 0, 9)) +>#name : Symbol(A.#name, Decl(privateNameField.ts, 2, 9)) constructor(name: string) { ->name : Symbol(name, Decl(privateNameField.ts, 2, 16)) +>name : Symbol(name, Decl(privateNameField.ts, 4, 16)) this.#name = name; ->this.#name : Symbol(A.#name, Decl(privateNameField.ts, 0, 9)) +>this.#name : Symbol(A.#name, Decl(privateNameField.ts, 2, 9)) >this : Symbol(A, Decl(privateNameField.ts, 0, 0)) ->name : Symbol(name, Decl(privateNameField.ts, 2, 16)) +>name : Symbol(name, Decl(privateNameField.ts, 4, 16)) } } diff --git a/tests/baselines/reference/privateNameField.types b/tests/baselines/reference/privateNameField.types index 1eb30eda52590..db7dba04475e8 100644 --- a/tests/baselines/reference/privateNameField.types +++ b/tests/baselines/reference/privateNameField.types @@ -1,4 +1,6 @@ === tests/cases/conformance/classes/members/privateNames/privateNameField.ts === +// @target es6 + class A { >A : A diff --git a/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.errors.txt b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.errors.txt index d5deb40b261d8..41a4d9c277cbf 100644 --- a/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.errors.txt +++ b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.errors.txt @@ -1,8 +1,10 @@ -tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts(5,9): error TS2339: Property '#foo' does not exist on type 'A'. -tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts(5,9): error TS18007: Property '#foo' is not accessible outside class 'A' because it has a private name. +tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts(7,9): error TS2339: Property '#foo' does not exist on type 'A'. +tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts(7,9): error TS18007: Property '#foo' is not accessible outside class 'A' because it has a private name. ==== tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts (2 errors) ==== + // @target es6 + class A { #foo: number = 3; } diff --git a/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.js b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.js index c096ffe8efe41..655f3c7c55d37 100644 --- a/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.js +++ b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.js @@ -1,4 +1,6 @@ //// [privateNameNotAccessibleOutsideDefiningClass.ts] +// @target es6 + class A { #foo: number = 3; } @@ -7,10 +9,14 @@ new A().#foo = 4; // Error //// [privateNameNotAccessibleOutsideDefiningClass.js] +// @target es6 +var _foo; +"use strict"; var A = /** @class */ (function () { function A() { - this.#foo = 3; + _foo.set(this, 3); } return A; }()); +_foo = new WeakMap(); new A().#foo = 4; // Error diff --git a/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.symbols b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.symbols index 58b26f8e99d7c..8d9427fc6d603 100644 --- a/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.symbols +++ b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.symbols @@ -1,9 +1,11 @@ === tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts === +// @target es6 + class A { >A : Symbol(A, Decl(privateNameNotAccessibleOutsideDefiningClass.ts, 0, 0)) #foo: number = 3; ->#foo : Symbol(A[#foo], Decl(privateNameNotAccessibleOutsideDefiningClass.ts, 0, 9)) +>#foo : Symbol(A.#foo, Decl(privateNameNotAccessibleOutsideDefiningClass.ts, 2, 9)) } new A().#foo = 4; // Error diff --git a/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.types b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.types index 19bf4a9476ca0..e6a0f5ac8f55b 100644 --- a/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.types +++ b/tests/baselines/reference/privateNameNotAccessibleOutsideDefiningClass.types @@ -1,4 +1,6 @@ === tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts === +// @target es6 + class A { >A : A diff --git a/tests/baselines/reference/privateNameNotAllowedOutsideClass.errors.txt b/tests/baselines/reference/privateNameNotAllowedOutsideClass.errors.txt index f4b6a6364f6b8..2e72fffc7ba78 100644 --- a/tests/baselines/reference/privateNameNotAllowedOutsideClass.errors.txt +++ b/tests/baselines/reference/privateNameNotAllowedOutsideClass.errors.txt @@ -1,9 +1,11 @@ -tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts(1,7): error TS1134: Variable declaration expected. -tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts(1,12): error TS1134: Variable declaration expected. -tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts(1,14): error TS1134: Variable declaration expected. +tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts(3,7): error TS1134: Variable declaration expected. +tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts(3,12): error TS1134: Variable declaration expected. +tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts(3,14): error TS1134: Variable declaration expected. ==== tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts (3 errors) ==== + // @target es6 + const #foo = 3; ~~~~ !!! error TS1134: Variable declaration expected. diff --git a/tests/baselines/reference/privateNameNotAllowedOutsideClass.js b/tests/baselines/reference/privateNameNotAllowedOutsideClass.js index ff289b3d29c54..ff2b64b910ca1 100644 --- a/tests/baselines/reference/privateNameNotAllowedOutsideClass.js +++ b/tests/baselines/reference/privateNameNotAllowedOutsideClass.js @@ -1,6 +1,10 @@ //// [privateNameNotAllowedOutsideClass.ts] +// @target es6 + const #foo = 3; //// [privateNameNotAllowedOutsideClass.js] +"use strict"; +// @target es6 var ; 3; diff --git a/tests/baselines/reference/privateNameNotAllowedOutsideClass.symbols b/tests/baselines/reference/privateNameNotAllowedOutsideClass.symbols index b604786dda640..6d6883e7fdf59 100644 --- a/tests/baselines/reference/privateNameNotAllowedOutsideClass.symbols +++ b/tests/baselines/reference/privateNameNotAllowedOutsideClass.symbols @@ -1,3 +1,5 @@ === tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts === -const #foo = 3; +// @target es6 +No type information for this code. +No type information for this code.const #foo = 3; No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/privateNameNotAllowedOutsideClass.types b/tests/baselines/reference/privateNameNotAllowedOutsideClass.types index 20826f41a55e1..534e5b042580f 100644 --- a/tests/baselines/reference/privateNameNotAllowedOutsideClass.types +++ b/tests/baselines/reference/privateNameNotAllowedOutsideClass.types @@ -1,4 +1,6 @@ === tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts === +// @target es6 + const #foo = 3; >3 : 3 diff --git a/tests/baselines/reference/privateNameSneakyRuntimeException.js b/tests/baselines/reference/privateNameSneakyRuntimeException.js index decf2a41386f9..e437f4da29fb5 100644 --- a/tests/baselines/reference/privateNameSneakyRuntimeException.js +++ b/tests/baselines/reference/privateNameSneakyRuntimeException.js @@ -1,8 +1,10 @@ //// [privateNameSneakyRuntimeException.ts] +// @target es6 + function createClass () { return class { - #foo; - equals(other) { + #foo = 3; + equals(other: any) { return this.#foo = other.#foo; } }; @@ -15,15 +17,23 @@ console.log(a.equals(b)); // OK at compile time but will be a runtime error //// [privateNameSneakyRuntimeException.js] +"use strict"; +// @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 _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() { - return /** @class */ (function () { - function class_1() { - } - class_1.prototype.equals = function (other) { - return this.#foo = other.#foo; - }; - return class_1; - }()); + var _foo, _a; + return _a = /** @class */ (function () { + function class_1() { + _foo.set(this, 3); + } + class_1.prototype.equals = function (other) { + return _classPrivateFieldSet(this, _foo, _classPrivateFieldGet(other, _foo)); + }; + return class_1; + }()), + _foo = new WeakMap(), + _a; } var a = new (createClass())(); var b = new (createClass())(); diff --git a/tests/baselines/reference/privateNameSneakyRuntimeException.symbols b/tests/baselines/reference/privateNameSneakyRuntimeException.symbols index 277aa4229e173..585bdbf782c43 100644 --- a/tests/baselines/reference/privateNameSneakyRuntimeException.symbols +++ b/tests/baselines/reference/privateNameSneakyRuntimeException.symbols @@ -1,37 +1,39 @@ === tests/cases/conformance/classes/members/privateNames/privateNameSneakyRuntimeException.ts === +// @target es6 + function createClass () { >createClass : Symbol(createClass, Decl(privateNameSneakyRuntimeException.ts, 0, 0)) return class { - #foo; ->#foo : Symbol((Anonymous class)[#foo], Decl(privateNameSneakyRuntimeException.ts, 1, 18)) + #foo = 3; +>#foo : Symbol((Anonymous class).#foo, Decl(privateNameSneakyRuntimeException.ts, 3, 18)) - equals(other) { ->equals : Symbol((Anonymous class).equals, Decl(privateNameSneakyRuntimeException.ts, 2, 13)) ->other : Symbol(other, Decl(privateNameSneakyRuntimeException.ts, 3, 15)) + equals(other: any) { +>equals : Symbol((Anonymous class).equals, Decl(privateNameSneakyRuntimeException.ts, 4, 17)) +>other : Symbol(other, Decl(privateNameSneakyRuntimeException.ts, 5, 15)) return this.#foo = other.#foo; ->this.#foo : Symbol((Anonymous class)[#foo], Decl(privateNameSneakyRuntimeException.ts, 1, 18)) ->this : Symbol((Anonymous class), Decl(privateNameSneakyRuntimeException.ts, 1, 10)) ->other : Symbol(other, Decl(privateNameSneakyRuntimeException.ts, 3, 15)) +>this.#foo : Symbol((Anonymous class).#foo, Decl(privateNameSneakyRuntimeException.ts, 3, 18)) +>this : Symbol((Anonymous class), Decl(privateNameSneakyRuntimeException.ts, 3, 10)) +>other : Symbol(other, Decl(privateNameSneakyRuntimeException.ts, 5, 15)) } }; } const a = new (createClass())(); ->a : Symbol(a, Decl(privateNameSneakyRuntimeException.ts, 9, 5)) +>a : Symbol(a, Decl(privateNameSneakyRuntimeException.ts, 11, 5)) >createClass : Symbol(createClass, Decl(privateNameSneakyRuntimeException.ts, 0, 0)) const b = new (createClass())(); ->b : Symbol(b, Decl(privateNameSneakyRuntimeException.ts, 10, 5)) +>b : Symbol(b, Decl(privateNameSneakyRuntimeException.ts, 12, 5)) >createClass : Symbol(createClass, Decl(privateNameSneakyRuntimeException.ts, 0, 0)) console.log(a.equals(b)); // OK at compile time but will be a runtime error >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.equals : Symbol((Anonymous class).equals, Decl(privateNameSneakyRuntimeException.ts, 2, 13)) ->a : Symbol(a, Decl(privateNameSneakyRuntimeException.ts, 9, 5)) ->equals : Symbol((Anonymous class).equals, Decl(privateNameSneakyRuntimeException.ts, 2, 13)) ->b : Symbol(b, Decl(privateNameSneakyRuntimeException.ts, 10, 5)) +>a.equals : Symbol((Anonymous class).equals, Decl(privateNameSneakyRuntimeException.ts, 4, 17)) +>a : Symbol(a, Decl(privateNameSneakyRuntimeException.ts, 11, 5)) +>equals : Symbol((Anonymous class).equals, Decl(privateNameSneakyRuntimeException.ts, 4, 17)) +>b : Symbol(b, Decl(privateNameSneakyRuntimeException.ts, 12, 5)) diff --git a/tests/baselines/reference/privateNameSneakyRuntimeException.types b/tests/baselines/reference/privateNameSneakyRuntimeException.types index c0e4056251bb5..6f080bb585fca 100644 --- a/tests/baselines/reference/privateNameSneakyRuntimeException.types +++ b/tests/baselines/reference/privateNameSneakyRuntimeException.types @@ -1,20 +1,23 @@ === tests/cases/conformance/classes/members/privateNames/privateNameSneakyRuntimeException.ts === +// @target es6 + function createClass () { >createClass : () => typeof (Anonymous class) return class { ->class { #foo; equals(other) { return this.#foo = other.#foo; } } : typeof (Anonymous class) +>class { #foo = 3; equals(other: any) { return this.#foo = other.#foo; } } : typeof (Anonymous class) - #foo; ->#foo : any + #foo = 3; +>#foo : number +>3 : 3 - equals(other) { + equals(other: any) { >equals : (other: any) => any >other : any return this.#foo = other.#foo; >this.#foo = other.#foo : any ->this.#foo : any +>this.#foo : number >this : this >other.#foo : any >other : any diff --git a/tests/baselines/reference/privateNamesAndFields.js b/tests/baselines/reference/privateNamesAndFields.js index 4a242723cd9cc..4af48cfe9b245 100644 --- a/tests/baselines/reference/privateNamesAndFields.js +++ b/tests/baselines/reference/privateNamesAndFields.js @@ -1,5 +1,5 @@ //// [privateNamesAndFields.ts] -// @target ESNext +// @target es6 class A { #foo: number; @@ -18,7 +18,7 @@ class B extends A { //// [privateNamesAndFields.js] -// @target ESNext +// @target es6 var __extends = (this && this.__extends) || (function () { var extendStatics = function (d, b) { extendStatics = Object.setPrototypeOf || @@ -32,18 +32,25 @@ 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() { - this.#foo = 3; + _foo.set(this, void 0); + _classPrivateFieldSet(this, _foo, 3); } return A; }()); +_foo = new WeakMap(); var B = /** @class */ (function (_super) { __extends(B, _super); function B() { var _this = _super.call(this) || this; - _this.#foo = "some string"; + _foo_1.set(_this, void 0); + _classPrivateFieldSet(_this, _foo_1, "some string"); return _this; } return B; }(A)); +_foo_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNamesAndFields.symbols b/tests/baselines/reference/privateNamesAndFields.symbols index 1af37cb5578c1..5300cd0427ff0 100644 --- a/tests/baselines/reference/privateNamesAndFields.symbols +++ b/tests/baselines/reference/privateNamesAndFields.symbols @@ -1,15 +1,15 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesAndFields.ts === -// @target ESNext +// @target es6 class A { >A : Symbol(A, Decl(privateNamesAndFields.ts, 0, 0)) #foo: number; ->#foo : Symbol(A[#foo], Decl(privateNamesAndFields.ts, 2, 9)) +>#foo : Symbol(A.#foo, Decl(privateNamesAndFields.ts, 2, 9)) constructor () { this.#foo = 3; ->this.#foo : Symbol(A[#foo], Decl(privateNamesAndFields.ts, 2, 9)) +>this.#foo : Symbol(A.#foo, Decl(privateNamesAndFields.ts, 2, 9)) >this : Symbol(A, Decl(privateNamesAndFields.ts, 0, 0)) } } @@ -19,14 +19,14 @@ class B extends A { >A : Symbol(A, Decl(privateNamesAndFields.ts, 0, 0)) #foo: string; ->#foo : Symbol(B[#foo], Decl(privateNamesAndFields.ts, 9, 19)) +>#foo : Symbol(B.#foo, Decl(privateNamesAndFields.ts, 9, 19)) constructor () { super(); >super : Symbol(A, Decl(privateNamesAndFields.ts, 0, 0)) this.#foo = "some string"; ->this.#foo : Symbol(B[#foo], Decl(privateNamesAndFields.ts, 9, 19)) +>this.#foo : Symbol(B.#foo, Decl(privateNamesAndFields.ts, 9, 19)) >this : Symbol(B, Decl(privateNamesAndFields.ts, 7, 1)) } } diff --git a/tests/baselines/reference/privateNamesAndFields.types b/tests/baselines/reference/privateNamesAndFields.types index 2b66a106b91e7..88a48ecd81298 100644 --- a/tests/baselines/reference/privateNamesAndFields.types +++ b/tests/baselines/reference/privateNamesAndFields.types @@ -1,5 +1,5 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesAndFields.ts === -// @target ESNext +// @target es6 class A { >A : A diff --git a/tests/baselines/reference/privateNamesAndMethods.js b/tests/baselines/reference/privateNamesAndMethods.js index 8ca4192b12fd0..6311443bbc29c 100644 --- a/tests/baselines/reference/privateNamesAndMethods.js +++ b/tests/baselines/reference/privateNamesAndMethods.js @@ -37,6 +37,7 @@ class A { async *#baz(a) { return 3; } + #_quux; get #quux() { return this.#_quux; } diff --git a/tests/baselines/reference/privateNamesAndMethods.symbols b/tests/baselines/reference/privateNamesAndMethods.symbols index bad0e42aa5846..817f1dcd31112 100644 --- a/tests/baselines/reference/privateNamesAndMethods.symbols +++ b/tests/baselines/reference/privateNamesAndMethods.symbols @@ -3,59 +3,59 @@ class A { >A : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) #foo(a: number) {} ->#foo : Symbol(A[#foo], Decl(privateNamesAndMethods.ts, 0, 9)) +>#foo : Symbol(A.#foo, Decl(privateNamesAndMethods.ts, 0, 9)) >a : Symbol(a, Decl(privateNamesAndMethods.ts, 1, 9)) async #bar(a: number) {} ->#bar : Symbol(A[#bar], Decl(privateNamesAndMethods.ts, 1, 22)) +>#bar : Symbol(A.#bar, Decl(privateNamesAndMethods.ts, 1, 22)) >a : Symbol(a, Decl(privateNamesAndMethods.ts, 2, 15)) async *#baz(a: number) { ->#baz : Symbol(A[#baz], Decl(privateNamesAndMethods.ts, 2, 28)) +>#baz : Symbol(A.#baz, Decl(privateNamesAndMethods.ts, 2, 28)) >a : Symbol(a, Decl(privateNamesAndMethods.ts, 3, 16)) return 3; } #_quux: number; ->#_quux : Symbol(A[#_quux], Decl(privateNamesAndMethods.ts, 5, 5)) +>#_quux : Symbol(A.#_quux, Decl(privateNamesAndMethods.ts, 5, 5)) get #quux (): number { ->#quux : Symbol(A[#quux], Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>#quux : Symbol(A.#quux, Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) return this.#_quux; ->this.#_quux : Symbol(A[#_quux], Decl(privateNamesAndMethods.ts, 5, 5)) +>this.#_quux : Symbol(A.#_quux, Decl(privateNamesAndMethods.ts, 5, 5)) >this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) } set #quux (val: number) { ->#quux : Symbol(A[#quux], Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>#quux : Symbol(A.#quux, Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) >val : Symbol(val, Decl(privateNamesAndMethods.ts, 10, 15)) this.#_quux = val; ->this.#_quux : Symbol(A[#_quux], Decl(privateNamesAndMethods.ts, 5, 5)) +>this.#_quux : Symbol(A.#_quux, Decl(privateNamesAndMethods.ts, 5, 5)) >this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) >val : Symbol(val, Decl(privateNamesAndMethods.ts, 10, 15)) } constructor () { this.#foo(30); ->this.#foo : Symbol(A[#foo], Decl(privateNamesAndMethods.ts, 0, 9)) +>this.#foo : Symbol(A.#foo, Decl(privateNamesAndMethods.ts, 0, 9)) >this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) this.#bar(30); ->this.#bar : Symbol(A[#bar], Decl(privateNamesAndMethods.ts, 1, 22)) +>this.#bar : Symbol(A.#bar, Decl(privateNamesAndMethods.ts, 1, 22)) >this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) this.#bar(30); ->this.#bar : Symbol(A[#bar], Decl(privateNamesAndMethods.ts, 1, 22)) +>this.#bar : Symbol(A.#bar, Decl(privateNamesAndMethods.ts, 1, 22)) >this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) this.#quux = this.#quux + 1; ->this.#quux : Symbol(A[#quux], Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>this.#quux : Symbol(A.#quux, Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) >this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) ->this.#quux : Symbol(A[#quux], Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>this.#quux : Symbol(A.#quux, Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) >this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) this.#quux++; ->this.#quux : Symbol(A[#quux], Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>this.#quux : Symbol(A.#quux, Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) >this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) } } @@ -65,7 +65,7 @@ class B extends A { >A : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) #foo(a: string) {} ->#foo : Symbol(B[#foo], Decl(privateNamesAndMethods.ts, 22, 19)) +>#foo : Symbol(B.#foo, Decl(privateNamesAndMethods.ts, 22, 19)) >a : Symbol(a, Decl(privateNamesAndMethods.ts, 23, 9)) constructor () { @@ -73,7 +73,7 @@ class B extends A { >super : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) this.#foo("str"); ->this.#foo : Symbol(B[#foo], Decl(privateNamesAndMethods.ts, 22, 19)) +>this.#foo : Symbol(B.#foo, Decl(privateNamesAndMethods.ts, 22, 19)) >this : Symbol(B, Decl(privateNamesAndMethods.ts, 20, 1)) } } diff --git a/tests/baselines/reference/privateNamesAndStaticFields.js b/tests/baselines/reference/privateNamesAndStaticFields.js index fa98ac60bc923..7beaa98bdb674 100644 --- a/tests/baselines/reference/privateNamesAndStaticFields.js +++ b/tests/baselines/reference/privateNamesAndStaticFields.js @@ -1,5 +1,5 @@ //// [privateNamesAndStaticFields.ts] -// @target ESNext +// @target es6 class A { static #foo: number; @@ -18,7 +18,7 @@ class B extends A { //// [privateNamesAndStaticFields.js] -// @target ESNext +// @target es6 var __extends = (this && this.__extends) || (function () { var extendStatics = function (d, b) { extendStatics = Object.setPrototypeOf || @@ -32,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 _foo, _foo_1; +"use strict"; var A = /** @class */ (function () { function A() { - A.#foo = 3; + _classPrivateFieldSet(A, _foo, 3); } return A; }()); +_foo = new WeakMap(); var B = /** @class */ (function (_super) { __extends(B, _super); function B() { var _this = _super.call(this) || this; - B.#foo = "some string"; + _classPrivateFieldSet(B, _foo_1, "some string"); return _this; } return B; }(A)); +_foo_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNamesAndStaticFields.symbols b/tests/baselines/reference/privateNamesAndStaticFields.symbols index a978ec59f7f03..5898928bfb741 100644 --- a/tests/baselines/reference/privateNamesAndStaticFields.symbols +++ b/tests/baselines/reference/privateNamesAndStaticFields.symbols @@ -1,15 +1,15 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticFields.ts === -// @target ESNext +// @target es6 class A { >A : Symbol(A, Decl(privateNamesAndStaticFields.ts, 0, 0)) static #foo: number; ->#foo : Symbol(A[#foo], Decl(privateNamesAndStaticFields.ts, 2, 9)) +>#foo : Symbol(A.#foo, Decl(privateNamesAndStaticFields.ts, 2, 9)) constructor () { A.#foo = 3; ->A.#foo : Symbol(A[#foo], Decl(privateNamesAndStaticFields.ts, 2, 9)) +>A.#foo : Symbol(A.#foo, Decl(privateNamesAndStaticFields.ts, 2, 9)) >A : Symbol(A, Decl(privateNamesAndStaticFields.ts, 0, 0)) } } @@ -19,14 +19,14 @@ class B extends A { >A : Symbol(A, Decl(privateNamesAndStaticFields.ts, 0, 0)) static #foo: string; ->#foo : Symbol(B[#foo], Decl(privateNamesAndStaticFields.ts, 9, 19)) +>#foo : Symbol(B.#foo, Decl(privateNamesAndStaticFields.ts, 9, 19)) constructor () { super(); >super : Symbol(A, Decl(privateNamesAndStaticFields.ts, 0, 0)) B.#foo = "some string"; ->B.#foo : Symbol(B[#foo], Decl(privateNamesAndStaticFields.ts, 9, 19)) +>B.#foo : Symbol(B.#foo, Decl(privateNamesAndStaticFields.ts, 9, 19)) >B : Symbol(B, Decl(privateNamesAndStaticFields.ts, 7, 1)) } } diff --git a/tests/baselines/reference/privateNamesAndStaticFields.types b/tests/baselines/reference/privateNamesAndStaticFields.types index ce2d5409fbf13..ba630cbcf7709 100644 --- a/tests/baselines/reference/privateNamesAndStaticFields.types +++ b/tests/baselines/reference/privateNamesAndStaticFields.types @@ -1,5 +1,5 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticFields.ts === -// @target ESNext +// @target es6 class A { >A : A diff --git a/tests/baselines/reference/privateNamesAndStaticMethods.js b/tests/baselines/reference/privateNamesAndStaticMethods.js index b12b777e3d0bd..12b4fe91d8ae5 100644 --- a/tests/baselines/reference/privateNamesAndStaticMethods.js +++ b/tests/baselines/reference/privateNamesAndStaticMethods.js @@ -31,12 +31,14 @@ class B extends A { //// [privateNamesAndStaticMethods.js] +"use strict"; class A { static #foo(a) { } static async #bar(a) { } static async *#baz(a) { return 3; } + static #_quux; static get #quux() { return this.#_quux; } diff --git a/tests/baselines/reference/privateNamesAndStaticMethods.symbols b/tests/baselines/reference/privateNamesAndStaticMethods.symbols index d78b97ff60aef..57d684a70696d 100644 --- a/tests/baselines/reference/privateNamesAndStaticMethods.symbols +++ b/tests/baselines/reference/privateNamesAndStaticMethods.symbols @@ -3,59 +3,59 @@ class A { >A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) static #foo(a: number) {} ->#foo : Symbol(A[#foo], Decl(privateNamesAndStaticMethods.ts, 0, 9)) +>#foo : Symbol(A.#foo, Decl(privateNamesAndStaticMethods.ts, 0, 9)) >a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 1, 16)) static async #bar(a: number) {} ->#bar : Symbol(A[#bar], Decl(privateNamesAndStaticMethods.ts, 1, 29)) +>#bar : Symbol(A.#bar, Decl(privateNamesAndStaticMethods.ts, 1, 29)) >a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 2, 22)) static async *#baz(a: number) { ->#baz : Symbol(A[#baz], Decl(privateNamesAndStaticMethods.ts, 2, 35)) +>#baz : Symbol(A.#baz, Decl(privateNamesAndStaticMethods.ts, 2, 35)) >a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 3, 23)) return 3; } static #_quux: number; ->#_quux : Symbol(A[#_quux], Decl(privateNamesAndStaticMethods.ts, 5, 5)) +>#_quux : Symbol(A.#_quux, Decl(privateNamesAndStaticMethods.ts, 5, 5)) static get #quux (): number { ->#quux : Symbol(A[#quux], Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>#quux : Symbol(A.#quux, Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) return this.#_quux; ->this.#_quux : Symbol(A[#_quux], Decl(privateNamesAndStaticMethods.ts, 5, 5)) +>this.#_quux : Symbol(A.#_quux, Decl(privateNamesAndStaticMethods.ts, 5, 5)) >this : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) } static set #quux (val: number) { ->#quux : Symbol(A[#quux], Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>#quux : Symbol(A.#quux, Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) >val : Symbol(val, Decl(privateNamesAndStaticMethods.ts, 10, 22)) this.#_quux = val; ->this.#_quux : Symbol(A[#_quux], Decl(privateNamesAndStaticMethods.ts, 5, 5)) +>this.#_quux : Symbol(A.#_quux, Decl(privateNamesAndStaticMethods.ts, 5, 5)) >this : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) >val : Symbol(val, Decl(privateNamesAndStaticMethods.ts, 10, 22)) } constructor () { A.#foo(30); ->A.#foo : Symbol(A[#foo], Decl(privateNamesAndStaticMethods.ts, 0, 9)) +>A.#foo : Symbol(A.#foo, Decl(privateNamesAndStaticMethods.ts, 0, 9)) >A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) A.#bar(30); ->A.#bar : Symbol(A[#bar], Decl(privateNamesAndStaticMethods.ts, 1, 29)) +>A.#bar : Symbol(A.#bar, Decl(privateNamesAndStaticMethods.ts, 1, 29)) >A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) A.#bar(30); ->A.#bar : Symbol(A[#bar], Decl(privateNamesAndStaticMethods.ts, 1, 29)) +>A.#bar : Symbol(A.#bar, Decl(privateNamesAndStaticMethods.ts, 1, 29)) >A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) A.#quux = A.#quux + 1; ->A.#quux : Symbol(A[#quux], Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>A.#quux : Symbol(A.#quux, Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) >A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) ->A.#quux : Symbol(A[#quux], Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>A.#quux : Symbol(A.#quux, Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) >A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) A.#quux++; ->A.#quux : Symbol(A[#quux], Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>A.#quux : Symbol(A.#quux, Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) >A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) } } @@ -65,7 +65,7 @@ class B extends A { >A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) static #foo(a: string) {} ->#foo : Symbol(B[#foo], Decl(privateNamesAndStaticMethods.ts, 22, 19)) +>#foo : Symbol(B.#foo, Decl(privateNamesAndStaticMethods.ts, 22, 19)) >a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 23, 16)) constructor () { @@ -73,7 +73,7 @@ class B extends A { >super : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) B.#foo("str"); ->B.#foo : Symbol(B[#foo], Decl(privateNamesAndStaticMethods.ts, 22, 19)) +>B.#foo : Symbol(B.#foo, Decl(privateNamesAndStaticMethods.ts, 22, 19)) >B : Symbol(B, Decl(privateNamesAndStaticMethods.ts, 20, 1)) } } diff --git a/tests/baselines/reference/privateNamesAndkeyof.js b/tests/baselines/reference/privateNamesAndkeyof.js index 90d72a3b62944..eeaade8458fc7 100644 --- a/tests/baselines/reference/privateNamesAndkeyof.js +++ b/tests/baselines/reference/privateNamesAndkeyof.js @@ -1,16 +1,25 @@ //// [privateNamesAndkeyof.ts] +// @target es6 + class A { - #foo; - bar; - baz; + #foo = 3; + bar = 3; + baz = 3; } type T = keyof A // should not include '#foo' //// [privateNamesAndkeyof.js] +// @target es6 +var _foo; +"use strict"; var A = /** @class */ (function () { function A() { + _foo.set(this, 3); + this.bar = 3; + this.baz = 3; } return A; }()); +_foo = new WeakMap(); diff --git a/tests/baselines/reference/privateNamesAndkeyof.symbols b/tests/baselines/reference/privateNamesAndkeyof.symbols index 67a7d46b52dd7..3b633505522a1 100644 --- a/tests/baselines/reference/privateNamesAndkeyof.symbols +++ b/tests/baselines/reference/privateNamesAndkeyof.symbols @@ -1,18 +1,20 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesAndkeyof.ts === +// @target es6 + class A { >A : Symbol(A, Decl(privateNamesAndkeyof.ts, 0, 0)) - #foo; ->#foo : Symbol(A[#foo], Decl(privateNamesAndkeyof.ts, 0, 9)) + #foo = 3; +>#foo : Symbol(A.#foo, Decl(privateNamesAndkeyof.ts, 2, 9)) - bar; ->bar : Symbol(A.bar, Decl(privateNamesAndkeyof.ts, 1, 9)) + bar = 3; +>bar : Symbol(A.bar, Decl(privateNamesAndkeyof.ts, 3, 13)) - baz; ->baz : Symbol(A.baz, Decl(privateNamesAndkeyof.ts, 2, 8)) + baz = 3; +>baz : Symbol(A.baz, Decl(privateNamesAndkeyof.ts, 4, 12)) } type T = keyof A // should not include '#foo' ->T : Symbol(T, Decl(privateNamesAndkeyof.ts, 4, 1)) +>T : Symbol(T, Decl(privateNamesAndkeyof.ts, 6, 1)) >A : Symbol(A, Decl(privateNamesAndkeyof.ts, 0, 0)) diff --git a/tests/baselines/reference/privateNamesAndkeyof.types b/tests/baselines/reference/privateNamesAndkeyof.types index a43c7dcd6c534..f8d3d99de7369 100644 --- a/tests/baselines/reference/privateNamesAndkeyof.types +++ b/tests/baselines/reference/privateNamesAndkeyof.types @@ -1,15 +1,20 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesAndkeyof.ts === +// @target es6 + class A { >A : A - #foo; ->#foo : any + #foo = 3; +>#foo : number +>3 : 3 - bar; ->bar : any + bar = 3; +>bar : number +>3 : 3 - baz; ->baz : any + baz = 3; +>baz : number +>3 : 3 } type T = keyof A // should not include '#foo' diff --git a/tests/baselines/reference/privateNamesInGenericClasses.errors.txt b/tests/baselines/reference/privateNamesInGenericClasses.errors.txt index 041186d1d7a8b..fc11628a5634e 100644 --- a/tests/baselines/reference/privateNamesInGenericClasses.errors.txt +++ b/tests/baselines/reference/privateNamesInGenericClasses.errors.txt @@ -1,12 +1,14 @@ -tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(10,3): error TS2339: Property '#foo' does not exist on type 'C'. -tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(10,3): error TS18007: Property '#foo' is not accessible outside class 'C' because it has a private name. -tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(11,1): error TS2322: Type 'C' is not assignable to type 'C'. +tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(12,3): error TS2339: Property '#foo' does not exist on type 'C'. +tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(12,3): error TS18007: Property '#foo' is not accessible outside class 'C' because it has a private name. +tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(13,1): error TS2322: Type 'C' is not assignable to type 'C'. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(12,1): error TS2322: Type 'C' is not assignable to type 'C'. +tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(14,1): error TS2322: Type 'C' is not assignable to type 'C'. Type 'number' is not assignable to type 'string'. ==== tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts (4 errors) ==== + // @target es6 + class C { #foo: T; bar(x: C) { return x.#foo; } // OK diff --git a/tests/baselines/reference/privateNamesInGenericClasses.js b/tests/baselines/reference/privateNamesInGenericClasses.js index dcee4e0fd82ef..750471c74bc18 100644 --- a/tests/baselines/reference/privateNamesInGenericClasses.js +++ b/tests/baselines/reference/privateNamesInGenericClasses.js @@ -1,4 +1,6 @@ //// [privateNamesInGenericClasses.ts] +// @target es6 + class C { #foo: T; bar(x: C) { return x.#foo; } // OK @@ -14,14 +16,20 @@ b = a; // Error //// [privateNamesInGenericClasses.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; +"use strict"; var C = /** @class */ (function () { function C() { + _foo.set(this, void 0); } - C.prototype.bar = function (x) { return x.#foo; }; // OK - C.prototype.baz = function (x) { return x.#foo; }; // OK - C.prototype.quux = function (x) { return x.#foo; }; // OK + C.prototype.bar = function (x) { return _classPrivateFieldGet(x, _foo); }; // OK + C.prototype.baz = function (x) { return _classPrivateFieldGet(x, _foo); }; // OK + C.prototype.quux = function (x) { return _classPrivateFieldGet(x, _foo); }; // OK return C; }()); +_foo = new WeakMap(); a.#foo; // OK a = b; // Error b = a; // Error diff --git a/tests/baselines/reference/privateNamesInGenericClasses.symbols b/tests/baselines/reference/privateNamesInGenericClasses.symbols index d9edd3eb629b0..184e21596a7de 100644 --- a/tests/baselines/reference/privateNamesInGenericClasses.symbols +++ b/tests/baselines/reference/privateNamesInGenericClasses.symbols @@ -1,51 +1,53 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts === +// @target es6 + class C { >C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) ->T : Symbol(T, Decl(privateNamesInGenericClasses.ts, 0, 8)) +>T : Symbol(T, Decl(privateNamesInGenericClasses.ts, 2, 8)) #foo: T; ->#foo : Symbol(C[#foo], Decl(privateNamesInGenericClasses.ts, 0, 12)) ->T : Symbol(T, Decl(privateNamesInGenericClasses.ts, 0, 8)) +>#foo : Symbol(C.#foo, Decl(privateNamesInGenericClasses.ts, 2, 12)) +>T : Symbol(T, Decl(privateNamesInGenericClasses.ts, 2, 8)) bar(x: C) { return x.#foo; } // OK ->bar : Symbol(C.bar, Decl(privateNamesInGenericClasses.ts, 1, 10)) ->x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 2, 6)) +>bar : Symbol(C.bar, Decl(privateNamesInGenericClasses.ts, 3, 10)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 4, 6)) >C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) ->T : Symbol(T, Decl(privateNamesInGenericClasses.ts, 0, 8)) ->x.#foo : Symbol(C[#foo], Decl(privateNamesInGenericClasses.ts, 0, 12)) ->x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 2, 6)) +>T : Symbol(T, Decl(privateNamesInGenericClasses.ts, 2, 8)) +>x.#foo : Symbol(C.#foo, Decl(privateNamesInGenericClasses.ts, 2, 12)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 4, 6)) baz(x: C) { return x.#foo; } // OK ->baz : Symbol(C.baz, Decl(privateNamesInGenericClasses.ts, 2, 33)) ->x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 3, 6)) +>baz : Symbol(C.baz, Decl(privateNamesInGenericClasses.ts, 4, 33)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 5, 6)) >C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) ->x.#foo : Symbol(C[#foo], Decl(privateNamesInGenericClasses.ts, 0, 12)) ->x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 3, 6)) +>x.#foo : Symbol(C.#foo, Decl(privateNamesInGenericClasses.ts, 2, 12)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 5, 6)) quux(x: C) { return x.#foo; } // OK ->quux : Symbol(C.quux, Decl(privateNamesInGenericClasses.ts, 3, 38)) ->x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 4, 7)) +>quux : Symbol(C.quux, Decl(privateNamesInGenericClasses.ts, 5, 38)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 6, 7)) >C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) ->x.#foo : Symbol(C[#foo], Decl(privateNamesInGenericClasses.ts, 0, 12)) ->x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 4, 7)) +>x.#foo : Symbol(C.#foo, Decl(privateNamesInGenericClasses.ts, 2, 12)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 6, 7)) } declare let a: C; ->a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 7, 11)) +>a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 9, 11)) >C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) declare let b: C; ->b : Symbol(b, Decl(privateNamesInGenericClasses.ts, 8, 11)) +>b : Symbol(b, Decl(privateNamesInGenericClasses.ts, 10, 11)) >C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) a.#foo; // OK ->a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 7, 11)) +>a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 9, 11)) a = b; // Error ->a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 7, 11)) ->b : Symbol(b, Decl(privateNamesInGenericClasses.ts, 8, 11)) +>a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 9, 11)) +>b : Symbol(b, Decl(privateNamesInGenericClasses.ts, 10, 11)) b = a; // Error ->b : Symbol(b, Decl(privateNamesInGenericClasses.ts, 8, 11)) ->a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 7, 11)) +>b : Symbol(b, Decl(privateNamesInGenericClasses.ts, 10, 11)) +>a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 9, 11)) diff --git a/tests/baselines/reference/privateNamesInGenericClasses.types b/tests/baselines/reference/privateNamesInGenericClasses.types index 501bc59e05381..63fc9cce473f9 100644 --- a/tests/baselines/reference/privateNamesInGenericClasses.types +++ b/tests/baselines/reference/privateNamesInGenericClasses.types @@ -1,4 +1,6 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts === +// @target es6 + class C { >C : C diff --git a/tests/baselines/reference/privateNamesInNestedClasses.errors.txt b/tests/baselines/reference/privateNamesInNestedClasses.errors.txt index ca7a994a0eaa9..3f6efdf5155f8 100644 --- a/tests/baselines/reference/privateNamesInNestedClasses.errors.txt +++ b/tests/baselines/reference/privateNamesInNestedClasses.errors.txt @@ -1,15 +1,17 @@ -tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts(11,18): error TS2339: Property '#foo' does not exist on type 'A'. -tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts(11,18): error TS18008: This usage of '#foo' refers to the private member declared in its enclosing class. While type 'B' has a private member with the same spelling, its declaration and accessibility are distinct. +tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts(13,18): error TS2339: Property '#foo' does not exist on type 'A'. +tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts(13,18): error TS18008: This usage of '#foo' refers to the private member declared in its enclosing class. While type 'B' has a private member with the same spelling, its declaration and accessibility are distinct. ==== tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts (2 errors) ==== + // @target es6 + class A { #foo = "A's #foo"; #bar = "A's #bar"; method () { class B { #foo = "B's #foo"; - bar (a) { + bar (a: any) { a.#foo; // OK, no compile-time error, don't know what `a` is } baz (a: A) { diff --git a/tests/baselines/reference/privateNamesInNestedClasses.js b/tests/baselines/reference/privateNamesInNestedClasses.js index b3d1159a40486..021528ae47be5 100644 --- a/tests/baselines/reference/privateNamesInNestedClasses.js +++ b/tests/baselines/reference/privateNamesInNestedClasses.js @@ -1,11 +1,13 @@ //// [privateNamesInNestedClasses.ts] +// @target es6 + class A { #foo = "A's #foo"; #bar = "A's #bar"; method () { class B { #foo = "B's #foo"; - bar (a) { + bar (a: any) { a.#foo; // OK, no compile-time error, don't know what `a` is } baz (a: A) { @@ -26,27 +28,33 @@ class A { 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; +"use strict"; var A = /** @class */ (function () { function A() { - this.#foo = "A's #foo"; - this.#bar = "A's #bar"; + _foo.set(this, "A's #foo"); + _bar.set(this, "A's #bar"); } A.prototype.method = function () { + var _foo_1; var B = /** @class */ (function () { function B() { - this.#foo = "B's #foo"; + _foo_1.set(this, "B's #foo"); } B.prototype.bar = function (a) { - a.#foo; // OK, no compile-time error, don't know what `a` is + _classPrivateFieldGet(a, _foo_1); // OK, no compile-time error, don't know what `a` is }; B.prototype.baz = function (a) { - a.#foo; // compile-time error, shadowed + _classPrivateFieldGet(a, _foo_1); // compile-time error, shadowed }; B.prototype.quux = function (b) { - b.#foo; // OK + _classPrivateFieldGet(b, _foo_1); // OK }; return B; }()); + _foo_1 = new WeakMap(); var a = new A(); new B().bar(a); new B().baz(a); @@ -55,4 +63,5 @@ var A = /** @class */ (function () { }; return A; }()); +_foo = new WeakMap(), _bar = new WeakMap(); new A().method(); diff --git a/tests/baselines/reference/privateNamesInNestedClasses.symbols b/tests/baselines/reference/privateNamesInNestedClasses.symbols index 85fcf81508506..14eaae87aa402 100644 --- a/tests/baselines/reference/privateNamesInNestedClasses.symbols +++ b/tests/baselines/reference/privateNamesInNestedClasses.symbols @@ -1,77 +1,79 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts === +// @target es6 + class A { >A : Symbol(A, Decl(privateNamesInNestedClasses.ts, 0, 0)) #foo = "A's #foo"; ->#foo : Symbol(A[#foo], Decl(privateNamesInNestedClasses.ts, 0, 9)) +>#foo : Symbol(A.#foo, Decl(privateNamesInNestedClasses.ts, 2, 9)) #bar = "A's #bar"; ->#bar : Symbol(A[#bar], Decl(privateNamesInNestedClasses.ts, 1, 21)) +>#bar : Symbol(A.#bar, Decl(privateNamesInNestedClasses.ts, 3, 21)) method () { ->method : Symbol(A.method, Decl(privateNamesInNestedClasses.ts, 2, 21)) +>method : Symbol(A.method, Decl(privateNamesInNestedClasses.ts, 4, 21)) class B { ->B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 3, 14)) +>B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 5, 14)) #foo = "B's #foo"; ->#foo : Symbol(B[#foo], Decl(privateNamesInNestedClasses.ts, 4, 16)) +>#foo : Symbol(B.#foo, Decl(privateNamesInNestedClasses.ts, 6, 16)) - bar (a) { ->bar : Symbol(B.bar, Decl(privateNamesInNestedClasses.ts, 5, 29)) ->a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 6, 16)) + bar (a: any) { +>bar : Symbol(B.bar, Decl(privateNamesInNestedClasses.ts, 7, 29)) +>a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 8, 16)) a.#foo; // OK, no compile-time error, don't know what `a` is ->a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 6, 16)) +>a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 8, 16)) } baz (a: A) { ->baz : Symbol(B.baz, Decl(privateNamesInNestedClasses.ts, 8, 12)) ->a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 9, 16)) +>baz : Symbol(B.baz, Decl(privateNamesInNestedClasses.ts, 10, 12)) +>a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 11, 16)) >A : Symbol(A, Decl(privateNamesInNestedClasses.ts, 0, 0)) a.#foo; // compile-time error, shadowed ->a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 9, 16)) +>a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 11, 16)) } quux (b: B) { ->quux : Symbol(B.quux, Decl(privateNamesInNestedClasses.ts, 11, 12)) ->b : Symbol(b, Decl(privateNamesInNestedClasses.ts, 12, 17)) ->B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 3, 14)) +>quux : Symbol(B.quux, Decl(privateNamesInNestedClasses.ts, 13, 12)) +>b : Symbol(b, Decl(privateNamesInNestedClasses.ts, 14, 17)) +>B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 5, 14)) b.#foo; // OK ->b.#foo : Symbol(B[#foo], Decl(privateNamesInNestedClasses.ts, 4, 16)) ->b : Symbol(b, Decl(privateNamesInNestedClasses.ts, 12, 17)) +>b.#foo : Symbol(B.#foo, Decl(privateNamesInNestedClasses.ts, 6, 16)) +>b : Symbol(b, Decl(privateNamesInNestedClasses.ts, 14, 17)) } } const a = new A(); ->a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 16, 12)) +>a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 18, 12)) >A : Symbol(A, Decl(privateNamesInNestedClasses.ts, 0, 0)) new B().bar(a); ->new B().bar : Symbol(B.bar, Decl(privateNamesInNestedClasses.ts, 5, 29)) ->B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 3, 14)) ->bar : Symbol(B.bar, Decl(privateNamesInNestedClasses.ts, 5, 29)) ->a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 16, 12)) +>new B().bar : Symbol(B.bar, Decl(privateNamesInNestedClasses.ts, 7, 29)) +>B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 5, 14)) +>bar : Symbol(B.bar, Decl(privateNamesInNestedClasses.ts, 7, 29)) +>a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 18, 12)) new B().baz(a); ->new B().baz : Symbol(B.baz, Decl(privateNamesInNestedClasses.ts, 8, 12)) ->B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 3, 14)) ->baz : Symbol(B.baz, Decl(privateNamesInNestedClasses.ts, 8, 12)) ->a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 16, 12)) +>new B().baz : Symbol(B.baz, Decl(privateNamesInNestedClasses.ts, 10, 12)) +>B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 5, 14)) +>baz : Symbol(B.baz, Decl(privateNamesInNestedClasses.ts, 10, 12)) +>a : Symbol(a, Decl(privateNamesInNestedClasses.ts, 18, 12)) const b = new B(); ->b : Symbol(b, Decl(privateNamesInNestedClasses.ts, 19, 12)) ->B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 3, 14)) +>b : Symbol(b, Decl(privateNamesInNestedClasses.ts, 21, 12)) +>B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 5, 14)) new B().quux(b); ->new B().quux : Symbol(B.quux, Decl(privateNamesInNestedClasses.ts, 11, 12)) ->B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 3, 14)) ->quux : Symbol(B.quux, Decl(privateNamesInNestedClasses.ts, 11, 12)) ->b : Symbol(b, Decl(privateNamesInNestedClasses.ts, 19, 12)) +>new B().quux : Symbol(B.quux, Decl(privateNamesInNestedClasses.ts, 13, 12)) +>B : Symbol(B, Decl(privateNamesInNestedClasses.ts, 5, 14)) +>quux : Symbol(B.quux, Decl(privateNamesInNestedClasses.ts, 13, 12)) +>b : Symbol(b, Decl(privateNamesInNestedClasses.ts, 21, 12)) } } new A().method(); ->new A().method : Symbol(A.method, Decl(privateNamesInNestedClasses.ts, 2, 21)) +>new A().method : Symbol(A.method, Decl(privateNamesInNestedClasses.ts, 4, 21)) >A : Symbol(A, Decl(privateNamesInNestedClasses.ts, 0, 0)) ->method : Symbol(A.method, Decl(privateNamesInNestedClasses.ts, 2, 21)) +>method : Symbol(A.method, Decl(privateNamesInNestedClasses.ts, 4, 21)) diff --git a/tests/baselines/reference/privateNamesInNestedClasses.types b/tests/baselines/reference/privateNamesInNestedClasses.types index 8a15e34293e01..12986429358da 100644 --- a/tests/baselines/reference/privateNamesInNestedClasses.types +++ b/tests/baselines/reference/privateNamesInNestedClasses.types @@ -1,4 +1,6 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts === +// @target es6 + class A { >A : A @@ -20,7 +22,7 @@ class A { >#foo : string >"B's #foo" : "B's #foo" - bar (a) { + bar (a: any) { >bar : (a: any) => void >a : any diff --git a/tests/baselines/reference/privateNamesNoAccessibilityModifiers.errors.txt b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.errors.txt index 5ce9be967beca..751ddafa1c669 100644 --- a/tests/baselines/reference/privateNamesNoAccessibilityModifiers.errors.txt +++ b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.errors.txt @@ -1,19 +1,21 @@ -tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts(2,12): error TS18004: Accessibility modifiers cannot be used with private names. -tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts(3,13): error TS18004: Accessibility modifiers cannot be used with private names. -tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts(4,15): error TS18004: Accessibility modifiers cannot be used with private names. +tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts(4,12): error TS18004: Accessibility modifiers cannot be used with private names. +tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts(5,13): error TS18004: Accessibility modifiers cannot be used with private names. +tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts(6,15): error TS18004: Accessibility modifiers cannot be used with private names. ==== tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts (3 errors) ==== + // @target es6 + class A { - public #foo; // Error + public #foo = 3; // Error ~~~~ !!! error TS18004: Accessibility modifiers cannot be used with private names. - private #bar; // Error + private #bar = 3; // Error ~~~~ !!! error TS18004: Accessibility modifiers cannot be used with private names. - protected #baz; // Error + protected #baz = 3; // Error ~~~~ !!! error TS18004: Accessibility modifiers cannot be used with private names. - readonly #qux; // OK + readonly #qux = 3; // OK } \ No newline at end of file diff --git a/tests/baselines/reference/privateNamesNoAccessibilityModifiers.js b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.js index 43227f2b84ee6..23e102b0fa7d7 100644 --- a/tests/baselines/reference/privateNamesNoAccessibilityModifiers.js +++ b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.js @@ -1,15 +1,25 @@ //// [privateNamesNoAccessibilityModifiers.ts] +// @target es6 + class A { - public #foo; // Error - private #bar; // Error - protected #baz; // Error - readonly #qux; // OK + public #foo = 3; // Error + private #bar = 3; // Error + protected #baz = 3; // Error + readonly #qux = 3; // OK } //// [privateNamesNoAccessibilityModifiers.js] +// @target es6 +var _foo, _bar, _baz, _qux; +"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 } return A; }()); +_foo = new WeakMap(), _bar = new WeakMap(), _baz = new WeakMap(), _qux = new WeakMap(); diff --git a/tests/baselines/reference/privateNamesNoAccessibilityModifiers.symbols b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.symbols index 7586d7c5bd6c1..49bd89a39842a 100644 --- a/tests/baselines/reference/privateNamesNoAccessibilityModifiers.symbols +++ b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.symbols @@ -1,17 +1,19 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts === +// @target es6 + class A { >A : Symbol(A, Decl(privateNamesNoAccessibilityModifiers.ts, 0, 0)) - public #foo; // Error ->#foo : Symbol(A[#foo], Decl(privateNamesNoAccessibilityModifiers.ts, 0, 9)) + public #foo = 3; // Error +>#foo : Symbol(A.#foo, Decl(privateNamesNoAccessibilityModifiers.ts, 2, 9)) - private #bar; // Error ->#bar : Symbol(A[#bar], Decl(privateNamesNoAccessibilityModifiers.ts, 1, 16)) + private #bar = 3; // Error +>#bar : Symbol(A.#bar, Decl(privateNamesNoAccessibilityModifiers.ts, 3, 20)) - protected #baz; // Error ->#baz : Symbol(A[#baz], Decl(privateNamesNoAccessibilityModifiers.ts, 2, 17)) + protected #baz = 3; // Error +>#baz : Symbol(A.#baz, Decl(privateNamesNoAccessibilityModifiers.ts, 4, 21)) - readonly #qux; // OK ->#qux : Symbol(A[#qux], Decl(privateNamesNoAccessibilityModifiers.ts, 3, 19)) + readonly #qux = 3; // OK +>#qux : Symbol(A.#qux, Decl(privateNamesNoAccessibilityModifiers.ts, 5, 23)) } diff --git a/tests/baselines/reference/privateNamesNoAccessibilityModifiers.types b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.types index fd1b35c1ded35..d727c9a2f2dc3 100644 --- a/tests/baselines/reference/privateNamesNoAccessibilityModifiers.types +++ b/tests/baselines/reference/privateNamesNoAccessibilityModifiers.types @@ -1,17 +1,23 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts === +// @target es6 + class A { >A : A - public #foo; // Error ->#foo : any + public #foo = 3; // Error +>#foo : number +>3 : 3 - private #bar; // Error ->#bar : any + private #bar = 3; // Error +>#bar : number +>3 : 3 - protected #baz; // Error ->#baz : any + protected #baz = 3; // Error +>#baz : number +>3 : 3 - readonly #qux; // OK ->#qux : any + readonly #qux = 3; // OK +>#qux : 3 +>3 : 3 } diff --git a/tests/baselines/reference/privateNamesNoConflictWhenInheriting.js b/tests/baselines/reference/privateNamesNoConflictWhenInheriting.js index 39cca6b534d55..f54b9d2f8cd6d 100644 --- a/tests/baselines/reference/privateNamesNoConflictWhenInheriting.js +++ b/tests/baselines/reference/privateNamesNoConflictWhenInheriting.js @@ -1,4 +1,6 @@ //// [privateNamesNoConflictWhenInheriting.ts] +// @target es6 + class A { #foo: number; } @@ -11,6 +13,7 @@ const b: A = new B() // OK //// [privateNamesNoConflictWhenInheriting.js] +// @target es6 var __extends = (this && this.__extends) || (function () { var extendStatics = function (d, b) { extendStatics = Object.setPrototypeOf || @@ -24,16 +27,23 @@ var __extends = (this && this.__extends) || (function () { d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; })(); +var _foo, _foo_1; +"use strict"; var A = /** @class */ (function () { function A() { + _foo.set(this, void 0); } return A; }()); +_foo = new WeakMap(); var B = /** @class */ (function (_super) { __extends(B, _super); function B() { - return _super !== null && _super.apply(this, arguments) || this; + var _this = _super !== null && _super.apply(this, arguments) || this; + _foo_1.set(_this, void 0); // OK: private names are unique to each class + return _this; } return B; }(A)); +_foo_1 = new WeakMap(); var b = new B(); // OK diff --git a/tests/baselines/reference/privateNamesNoConflictWhenInheriting.symbols b/tests/baselines/reference/privateNamesNoConflictWhenInheriting.symbols index 11ee25651c95f..d1442d5750cd5 100644 --- a/tests/baselines/reference/privateNamesNoConflictWhenInheriting.symbols +++ b/tests/baselines/reference/privateNamesNoConflictWhenInheriting.symbols @@ -1,21 +1,23 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesNoConflictWhenInheriting.ts === +// @target es6 + class A { >A : Symbol(A, Decl(privateNamesNoConflictWhenInheriting.ts, 0, 0)) #foo: number; ->#foo : Symbol(A[#foo], Decl(privateNamesNoConflictWhenInheriting.ts, 0, 9)) +>#foo : Symbol(A.#foo, Decl(privateNamesNoConflictWhenInheriting.ts, 2, 9)) } class B extends A { ->B : Symbol(B, Decl(privateNamesNoConflictWhenInheriting.ts, 2, 1)) +>B : Symbol(B, Decl(privateNamesNoConflictWhenInheriting.ts, 4, 1)) >A : Symbol(A, Decl(privateNamesNoConflictWhenInheriting.ts, 0, 0)) #foo: string; // OK: private names are unique to each class ->#foo : Symbol(B[#foo], Decl(privateNamesNoConflictWhenInheriting.ts, 4, 19)) +>#foo : Symbol(B.#foo, Decl(privateNamesNoConflictWhenInheriting.ts, 6, 19)) } const b: A = new B() // OK ->b : Symbol(b, Decl(privateNamesNoConflictWhenInheriting.ts, 8, 5)) +>b : Symbol(b, Decl(privateNamesNoConflictWhenInheriting.ts, 10, 5)) >A : Symbol(A, Decl(privateNamesNoConflictWhenInheriting.ts, 0, 0)) ->B : Symbol(B, Decl(privateNamesNoConflictWhenInheriting.ts, 2, 1)) +>B : Symbol(B, Decl(privateNamesNoConflictWhenInheriting.ts, 4, 1)) diff --git a/tests/baselines/reference/privateNamesNoConflictWhenInheriting.types b/tests/baselines/reference/privateNamesNoConflictWhenInheriting.types index 40459f74d2e63..fd88a20816e15 100644 --- a/tests/baselines/reference/privateNamesNoConflictWhenInheriting.types +++ b/tests/baselines/reference/privateNamesNoConflictWhenInheriting.types @@ -1,4 +1,6 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesNoConflictWhenInheriting.ts === +// @target es6 + class A { >A : A diff --git a/tests/baselines/reference/privateNamesNoDelete.errors.txt b/tests/baselines/reference/privateNamesNoDelete.errors.txt index ae45010321430..f490c83c6bffb 100644 --- a/tests/baselines/reference/privateNamesNoDelete.errors.txt +++ b/tests/baselines/reference/privateNamesNoDelete.errors.txt @@ -1,7 +1,9 @@ -tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts(4,16): error TS18005: The operand of a delete operator cannot be a private name. +tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts(6,16): error TS18005: The operand of a delete operator cannot be a private name. ==== tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts (1 errors) ==== + // @target es6 + class A { #v = 1; constructor() { diff --git a/tests/baselines/reference/privateNamesNoDelete.js b/tests/baselines/reference/privateNamesNoDelete.js index 7266285f807b5..b7826b3aea2f4 100644 --- a/tests/baselines/reference/privateNamesNoDelete.js +++ b/tests/baselines/reference/privateNamesNoDelete.js @@ -1,4 +1,6 @@ //// [privateNamesNoDelete.ts] +// @target es6 + class A { #v = 1; constructor() { @@ -8,10 +10,15 @@ 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; +"use strict"; var A = /** @class */ (function () { function A() { - this.#v = 1; - delete this.#v; // Error: The operand of a delete operator cannot be a private name. + _v.set(this, 1); + delete _classPrivateFieldGet(this, _v); // Error: The operand of a delete operator cannot be a private name. } return A; }()); +_v = new WeakMap(); diff --git a/tests/baselines/reference/privateNamesNoDelete.symbols b/tests/baselines/reference/privateNamesNoDelete.symbols index ae5e4315675e4..50e2542c07877 100644 --- a/tests/baselines/reference/privateNamesNoDelete.symbols +++ b/tests/baselines/reference/privateNamesNoDelete.symbols @@ -1,13 +1,15 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts === +// @target es6 + class A { >A : Symbol(A, Decl(privateNamesNoDelete.ts, 0, 0)) #v = 1; ->#v : Symbol(A[#v], Decl(privateNamesNoDelete.ts, 0, 9)) +>#v : Symbol(A.#v, Decl(privateNamesNoDelete.ts, 2, 9)) constructor() { delete this.#v; // Error: The operand of a delete operator cannot be a private name. ->this.#v : Symbol(A[#v], Decl(privateNamesNoDelete.ts, 0, 9)) +>this.#v : Symbol(A.#v, Decl(privateNamesNoDelete.ts, 2, 9)) >this : Symbol(A, Decl(privateNamesNoDelete.ts, 0, 0)) } } diff --git a/tests/baselines/reference/privateNamesNoDelete.types b/tests/baselines/reference/privateNamesNoDelete.types index d23b8712dbdcb..681651a4f770a 100644 --- a/tests/baselines/reference/privateNamesNoDelete.types +++ b/tests/baselines/reference/privateNamesNoDelete.types @@ -1,4 +1,6 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts === +// @target es6 + class A { >A : A diff --git a/tests/baselines/reference/privateNamesNotAllowedAsParameters.errors.txt b/tests/baselines/reference/privateNamesNotAllowedAsParameters.errors.txt index 7d6b45dc9581c..942bea1e251a8 100644 --- a/tests/baselines/reference/privateNamesNotAllowedAsParameters.errors.txt +++ b/tests/baselines/reference/privateNamesNotAllowedAsParameters.errors.txt @@ -1,10 +1,12 @@ -tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts(2,12): error TS1138: Parameter declaration expected. -tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts(2,24): error TS1005: ';' expected. -tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts(2,26): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. -tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts(3,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts(4,12): error TS1138: Parameter declaration expected. +tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts(4,24): error TS1005: ';' expected. +tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts(4,26): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. +tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts(5,1): error TS1128: Declaration or statement expected. ==== tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts (4 errors) ==== + // @target es6 + class A { setFoo(#foo: string) {} ~~~~ diff --git a/tests/baselines/reference/privateNamesNotAllowedAsParameters.js b/tests/baselines/reference/privateNamesNotAllowedAsParameters.js index 862409a851765..ab41d7579b42d 100644 --- a/tests/baselines/reference/privateNamesNotAllowedAsParameters.js +++ b/tests/baselines/reference/privateNamesNotAllowedAsParameters.js @@ -1,14 +1,20 @@ //// [privateNamesNotAllowedAsParameters.ts] +// @target es6 + class A { setFoo(#foo: string) {} } //// [privateNamesNotAllowedAsParameters.js] +// @target es6 +var _foo; var A = /** @class */ (function () { function A() { + _foo.set(this, void 0); } A.prototype.setFoo = function () { }; return A; }()); +_foo = new WeakMap(); { } diff --git a/tests/baselines/reference/privateNamesNotAllowedAsParameters.symbols b/tests/baselines/reference/privateNamesNotAllowedAsParameters.symbols index 013e0e192734c..b7ea0b4850fb9 100644 --- a/tests/baselines/reference/privateNamesNotAllowedAsParameters.symbols +++ b/tests/baselines/reference/privateNamesNotAllowedAsParameters.symbols @@ -1,9 +1,11 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts === +// @target es6 + class A { >A : Symbol(A, Decl(privateNamesNotAllowedAsParameters.ts, 0, 0)) setFoo(#foo: string) {} ->setFoo : Symbol(A.setFoo, Decl(privateNamesNotAllowedAsParameters.ts, 0, 9)) ->#foo : Symbol(A[#foo], Decl(privateNamesNotAllowedAsParameters.ts, 1, 11)) +>setFoo : Symbol(A.setFoo, Decl(privateNamesNotAllowedAsParameters.ts, 2, 9)) +>#foo : Symbol(A.#foo, Decl(privateNamesNotAllowedAsParameters.ts, 3, 11)) } diff --git a/tests/baselines/reference/privateNamesNotAllowedAsParameters.types b/tests/baselines/reference/privateNamesNotAllowedAsParameters.types index b11ecd42efe52..effe8726a9470 100644 --- a/tests/baselines/reference/privateNamesNotAllowedAsParameters.types +++ b/tests/baselines/reference/privateNamesNotAllowedAsParameters.types @@ -1,4 +1,6 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts === +// @target es6 + class A { >A : A diff --git a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.errors.txt b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.errors.txt index 9b996c5e6bac3..5d79de2754392 100644 --- a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.errors.txt +++ b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.errors.txt @@ -1,9 +1,11 @@ -tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts(1,7): error TS1134: Variable declaration expected. -tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts(1,12): error TS1134: Variable declaration expected. -tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts(1,14): error TS1134: Variable declaration expected. +tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts(3,7): error TS1134: Variable declaration expected. +tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts(3,12): error TS1134: Variable declaration expected. +tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts(3,14): error TS1134: Variable declaration expected. ==== tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts (3 errors) ==== + // @target es6 + const #foo = 3; ~~~~ !!! error TS1134: Variable declaration expected. diff --git a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.js b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.js index 9b65ff8a3a0b0..3a5f19724d38e 100644 --- a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.js +++ b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.js @@ -1,6 +1,10 @@ //// [privateNamesNotAllowedInVariableDeclarations.ts] +// @target es6 + const #foo = 3; //// [privateNamesNotAllowedInVariableDeclarations.js] +"use strict"; +// @target es6 var ; 3; diff --git a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.symbols b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.symbols index 8ff859dfdd84a..8a90d43a114c9 100644 --- a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.symbols +++ b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.symbols @@ -1,3 +1,5 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts === -const #foo = 3; +// @target es6 +No type information for this code. +No type information for this code.const #foo = 3; No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.types b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.types index 82cdaa63a9fb0..1def5f332d291 100644 --- a/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.types +++ b/tests/baselines/reference/privateNamesNotAllowedInVariableDeclarations.types @@ -1,4 +1,6 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts === +// @target es6 + const #foo = 3; >3 : 3 diff --git a/tests/baselines/reference/privateNamesUnique.errors.txt b/tests/baselines/reference/privateNamesUnique.errors.txt index 921d7fe36ffea..799a580eb502a 100644 --- a/tests/baselines/reference/privateNamesUnique.errors.txt +++ b/tests/baselines/reference/privateNamesUnique.errors.txt @@ -1,8 +1,10 @@ -tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts(9,7): error TS2322: Type 'B' is not assignable to type 'A'. +tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts(11,7): error TS2322: Type 'B' is not assignable to type 'A'. Property '#foo' is missing in type 'B'. While type 'B' has a private member with the same spelling, its declaration and accessibility are distinct ==== tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts (1 errors) ==== + // @target es6 + class A { #foo: number; } @@ -11,7 +13,7 @@ tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts(9,7): #foo: number; } - const b: A = new B() // Error: Property #foo is missing + const b: A = new B(); // Error: Property #foo is missing ~ !!! error TS2322: Type 'B' is not assignable to type 'A'. !!! error TS2322: Property '#foo' is missing in type 'B'. While type 'B' has a private member with the same spelling, its declaration and accessibility are distinct diff --git a/tests/baselines/reference/privateNamesUnique.js b/tests/baselines/reference/privateNamesUnique.js index a5b5a2dad7b3e..a55fe8af1faa1 100644 --- a/tests/baselines/reference/privateNamesUnique.js +++ b/tests/baselines/reference/privateNamesUnique.js @@ -1,4 +1,6 @@ //// [privateNamesUnique.ts] +// @target es6 + class A { #foo: number; } @@ -7,18 +9,25 @@ class B { #foo: number; } -const b: A = new B() // Error: Property #foo is missing +const b: A = new B(); // Error: Property #foo is missing //// [privateNamesUnique.js] +// @target es6 +var _foo, _foo_1; +"use strict"; var A = /** @class */ (function () { function A() { + _foo.set(this, void 0); } return A; }()); +_foo = new WeakMap(); var B = /** @class */ (function () { function B() { + _foo_1.set(this, void 0); } return B; }()); +_foo_1 = new WeakMap(); var b = new B(); // Error: Property #foo is missing diff --git a/tests/baselines/reference/privateNamesUnique.symbols b/tests/baselines/reference/privateNamesUnique.symbols index 224785a388fca..5266e47918187 100644 --- a/tests/baselines/reference/privateNamesUnique.symbols +++ b/tests/baselines/reference/privateNamesUnique.symbols @@ -1,20 +1,22 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts === +// @target es6 + class A { >A : Symbol(A, Decl(privateNamesUnique.ts, 0, 0)) #foo: number; ->#foo : Symbol(A[#foo], Decl(privateNamesUnique.ts, 0, 9)) +>#foo : Symbol(A.#foo, Decl(privateNamesUnique.ts, 2, 9)) } class B { ->B : Symbol(B, Decl(privateNamesUnique.ts, 2, 1)) +>B : Symbol(B, Decl(privateNamesUnique.ts, 4, 1)) #foo: number; ->#foo : Symbol(B[#foo], Decl(privateNamesUnique.ts, 4, 9)) +>#foo : Symbol(B.#foo, Decl(privateNamesUnique.ts, 6, 9)) } -const b: A = new B() // Error: Property #foo is missing ->b : Symbol(b, Decl(privateNamesUnique.ts, 8, 5)) +const b: A = new B(); // Error: Property #foo is missing +>b : Symbol(b, Decl(privateNamesUnique.ts, 10, 5)) >A : Symbol(A, Decl(privateNamesUnique.ts, 0, 0)) ->B : Symbol(B, Decl(privateNamesUnique.ts, 2, 1)) +>B : Symbol(B, Decl(privateNamesUnique.ts, 4, 1)) diff --git a/tests/baselines/reference/privateNamesUnique.types b/tests/baselines/reference/privateNamesUnique.types index 16fdb5a6f1629..a9d738ee0ca5b 100644 --- a/tests/baselines/reference/privateNamesUnique.types +++ b/tests/baselines/reference/privateNamesUnique.types @@ -1,4 +1,6 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts === +// @target es6 + class A { >A : A @@ -13,7 +15,7 @@ class B { >#foo : number } -const b: A = new B() // Error: Property #foo is missing +const b: A = new B(); // Error: Property #foo is missing >b : A >new B() : B >B : typeof B diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts b/tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts index 0efb1813fcefa..1f5da9ab9171e 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts @@ -1,3 +1,6 @@ +// @strict: true +// @target es6 + class A { [k: string]: any; constructor(message: string) { diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts b/tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts index c30022b345846..1421db99944d8 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts @@ -1,3 +1,5 @@ +// @target es6 + class A { #constructor() {} // Error: `#constructor` is a reserved word. } diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts b/tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts index a482161d4dc33..ba8160cb122ab 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameDuplicateField.ts @@ -1,4 +1,7 @@ -class A { - #foo; - #foo; -} +// @strict: true +// @target es6 + +class A { + #foo = "foo"; + #foo = "foo"; +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameField.ts b/tests/cases/conformance/classes/members/privateNames/privateNameField.ts index 3d38a3d651453..d4b823c49da63 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameField.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameField.ts @@ -1,3 +1,6 @@ +// @strict: true +// @target es6 + class A { #name: string; constructor(name: string) { diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts b/tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts index 1d213d7e54509..6f14d0ec8d72e 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameNotAccessibleOutsideDefiningClass.ts @@ -1,3 +1,6 @@ +// @strict: true +// @target es6 + class A { #foo: number = 3; } diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts b/tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts index 7af2bf989ff3b..26aacc421a19a 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts @@ -1 +1,4 @@ +// @strict: true +// @target es6 + const #foo = 3; \ No newline at end of file diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameSneakyRuntimeException.ts b/tests/cases/conformance/classes/members/privateNames/privateNameSneakyRuntimeException.ts index 3ee0eebfbda8d..f4450f031ab75 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameSneakyRuntimeException.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameSneakyRuntimeException.ts @@ -1,13 +1,16 @@ -function createClass () { - return class { - #foo; - equals(other) { - return this.#foo = other.#foo; - } - }; -} - -const a = new (createClass())(); -const b = new (createClass())(); - -console.log(a.equals(b)); // OK at compile time but will be a runtime error +// @strict: true +// @target es6 + +function createClass () { + return class { + #foo = 3; + equals(other: any) { + return this.#foo = other.#foo; + } + }; +} + +const a = new (createClass())(); +const b = new (createClass())(); + +console.log(a.equals(b)); // OK at compile time but will be a runtime error diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesAndFields.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesAndFields.ts index ddfdc1d9f1f88..ebf44118093aa 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesAndFields.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesAndFields.ts @@ -1,16 +1,17 @@ -// @target ESNext - -class A { - #foo: number; - constructor () { - this.#foo = 3; - } -} - -class B extends A { - #foo: string; - constructor () { - super(); - this.#foo = "some string"; - } -} +// @strict: true +// @target es6 + +class A { + #foo: number; + constructor () { + this.#foo = 3; + } +} + +class B extends A { + #foo: string; + constructor () { + super(); + this.#foo = "some string"; + } +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticFields.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticFields.ts index ad2e38736e3e1..ec9906a8ef00d 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticFields.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticFields.ts @@ -1,16 +1,17 @@ -// @target ESNext - -class A { - static #foo: number; - constructor () { - A.#foo = 3; - } -} - -class B extends A { - static #foo: string; - constructor () { - super(); - B.#foo = "some string"; - } -} +// @strict: true +// @target es6 + +class A { + static #foo: number; + constructor () { + A.#foo = 3; + } +} + +class B extends A { + static #foo: string; + constructor () { + super(); + B.#foo = "some string"; + } +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts index b4577671d4e87..7cbf9f8f9992b 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts @@ -1,32 +1,33 @@ -// @target: esnext -// @lib: esnext - -class A { - static #foo(a: number) {} - static async #bar(a: number) {} - static async *#baz(a: number) { - return 3; - } - static #_quux: number; - static get #quux (): number { - return this.#_quux; - } - static set #quux (val: number) { - this.#_quux = val; - } - constructor () { - A.#foo(30); - A.#bar(30); - A.#bar(30); - A.#quux = A.#quux + 1; - A.#quux++; - } -} - -class B extends A { - static #foo(a: string) {} - constructor () { - super(); - B.#foo("str"); - } -} +// @strict: true +// @target: esnext +// @lib: esnext + +class A { + static #foo(a: number) {} + static async #bar(a: number) {} + static async *#baz(a: number) { + return 3; + } + static #_quux: number; + static get #quux (): number { + return this.#_quux; + } + static set #quux (val: number) { + this.#_quux = val; + } + constructor () { + A.#foo(30); + A.#bar(30); + A.#bar(30); + A.#quux = A.#quux + 1; + A.#quux++; + } +} + +class B extends A { + static #foo(a: string) {} + constructor () { + super(); + B.#foo("str"); + } +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesAndkeyof.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesAndkeyof.ts index 93edade95ce9e..1e178092c7e8d 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesAndkeyof.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesAndkeyof.ts @@ -1,7 +1,10 @@ -class A { - #foo; - bar; - baz; -} - -type T = keyof A // should not include '#foo' +// @strict: true +// @target es6 + +class A { + #foo = 3; + bar = 3; + baz = 3; +} + +type T = keyof A // should not include '#foo' diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts index c1369caf48594..be79278580cc4 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts @@ -1,3 +1,6 @@ +// @strict: true +// @target es6 + class C { #foo: T; bar(x: C) { return x.#foo; } // OK diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts index 04d4a69c0b19b..dc6076ffbe096 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesInNestedClasses.ts @@ -1,10 +1,13 @@ +// @strict: true +// @target es6 + class A { #foo = "A's #foo"; #bar = "A's #bar"; method () { class B { #foo = "B's #foo"; - bar (a) { + bar (a: any) { a.#foo; // OK, no compile-time error, don't know what `a` is } baz (a: A) { diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts index cd3f748196950..a70c8acd143ac 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesNoAccessibilityModifiers.ts @@ -1,6 +1,9 @@ +// @strict: true +// @target es6 + class A { - public #foo; // Error - private #bar; // Error - protected #baz; // Error - readonly #qux; // OK + public #foo = 3; // Error + private #bar = 3; // Error + protected #baz = 3; // Error + readonly #qux = 3; // OK } diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesNoConflictWhenInheriting.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesNoConflictWhenInheriting.ts index bb55edd9b3dfc..937ed9c4c3cfa 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesNoConflictWhenInheriting.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesNoConflictWhenInheriting.ts @@ -1,3 +1,6 @@ +// @strict: true +// @target es6 + class A { #foo: number; } diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts index a71a733371023..70b099a0e5397 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts @@ -1,3 +1,6 @@ +// @strict: true +// @target es6 + class A { #v = 1; constructor() { diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts index edc846a0bf35d..5a71fc00803c2 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts @@ -1,3 +1,5 @@ +// @target es6 + class A { setFoo(#foo: string) {} } diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts index 7af2bf989ff3b..26aacc421a19a 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedInVariableDeclarations.ts @@ -1 +1,4 @@ +// @strict: true +// @target es6 + const #foo = 3; \ No newline at end of file diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts index cee206eacd201..1e9891095512d 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts @@ -1,3 +1,6 @@ +// @strict: true +// @target es6 + class A { #foo: number; } @@ -6,4 +9,4 @@ class B { #foo: number; } -const b: A = new B() // Error: Property #foo is missing +const b: A = new B(); // Error: Property #foo is missing From 99146e574d426ad7945bc1e00d6991fd48e37a5d Mon Sep 17 00:00:00 2001 From: Max Heiber Date: Wed, 23 Jan 2019 14:58:45 -0500 Subject: [PATCH 8/8] error message for private names in obj literals Signed-off-by: Max Heiber --- src/compiler/binder.ts | 7 +- src/compiler/checker.ts | 4 + src/compiler/diagnosticMessages.json | 6 +- .../privateNameInObjectLiteral-1.errors.txt | 10 +++ .../reference/privateNameInObjectLiteral-1.js | 10 +++ .../privateNameInObjectLiteral-1.symbols | 9 ++ .../privateNameInObjectLiteral-1.types | 11 +++ .../privateNameInObjectLiteral-2.errors.txt | 12 +++ .../reference/privateNameInObjectLiteral-2.js | 13 +++ .../privateNameInObjectLiteral-2.symbols | 10 +++ .../privateNameInObjectLiteral-2.types | 11 +++ .../privateNameInObjectLiteral.errors.txt | 14 +++ .../reference/privateNameInObjectLiteral.js | 18 ++++ .../privateNameInObjectLiteral.symbols | 17 ++++ .../privateNameInObjectLiteral.types | 22 +++++ ...privateNamesAndGenericClasses-2.errors.txt | 46 ++++++++++ .../privateNamesAndGenericClasses-2.js | 58 ++++++++++++ .../privateNamesAndGenericClasses-2.symbols | 82 +++++++++++++++++ .../privateNamesAndGenericClasses-2.types | 89 +++++++++++++++++++ .../privateNamesAndIndexedAccess.errors.txt | 39 ++++++++ .../reference/privateNamesAndIndexedAccess.js | 30 +++++++ .../privateNamesAndIndexedAccess.symbols | 29 ++++++ .../privateNamesAndIndexedAccess.types | 30 +++++++ .../privateNamesInGenericClasses.errors.txt | 20 ++--- .../reference/privateNamesInGenericClasses.js | 28 +++--- .../privateNamesInGenericClasses.symbols | 58 ++++++------ .../privateNamesInGenericClasses.types | 12 ++- .../reference/privateNamesUnique.errors.txt | 4 +- .../privateNameInObjectLiteral-1.ts | 3 + .../privateNameInObjectLiteral-2.ts | 5 ++ .../privateNamesAndGenericClasses-2.ts | 29 ++++++ .../privateNamesAndIndexedAccess.ts | 14 +++ .../privateNamesInGenericClasses.ts | 12 +-- 33 files changed, 688 insertions(+), 74 deletions(-) create mode 100644 tests/baselines/reference/privateNameInObjectLiteral-1.errors.txt create mode 100644 tests/baselines/reference/privateNameInObjectLiteral-1.js create mode 100644 tests/baselines/reference/privateNameInObjectLiteral-1.symbols create mode 100644 tests/baselines/reference/privateNameInObjectLiteral-1.types create mode 100644 tests/baselines/reference/privateNameInObjectLiteral-2.errors.txt create mode 100644 tests/baselines/reference/privateNameInObjectLiteral-2.js create mode 100644 tests/baselines/reference/privateNameInObjectLiteral-2.symbols create mode 100644 tests/baselines/reference/privateNameInObjectLiteral-2.types create mode 100644 tests/baselines/reference/privateNameInObjectLiteral.errors.txt create mode 100644 tests/baselines/reference/privateNameInObjectLiteral.js create mode 100644 tests/baselines/reference/privateNameInObjectLiteral.symbols create mode 100644 tests/baselines/reference/privateNameInObjectLiteral.types create mode 100644 tests/baselines/reference/privateNamesAndGenericClasses-2.errors.txt create mode 100644 tests/baselines/reference/privateNamesAndGenericClasses-2.js create mode 100644 tests/baselines/reference/privateNamesAndGenericClasses-2.symbols create mode 100644 tests/baselines/reference/privateNamesAndGenericClasses-2.types create mode 100644 tests/baselines/reference/privateNamesAndIndexedAccess.errors.txt create mode 100644 tests/baselines/reference/privateNamesAndIndexedAccess.js create mode 100644 tests/baselines/reference/privateNamesAndIndexedAccess.symbols create mode 100644 tests/baselines/reference/privateNamesAndIndexedAccess.types create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-1.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-2.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamesAndGenericClasses-2.ts create mode 100644 tests/cases/conformance/classes/members/privateNames/privateNamesAndIndexedAccess.ts diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index b873a2f7b8587..14714c7325394 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -273,7 +273,12 @@ namespace ts { } if (isPrivateName(name)) { // containingClass exists because private names only allowed inside classes - const containingClassSymbol = getContainingClass(name.parent)!.symbol; + const containingClass = getContainingClass(name.parent); + if (!containingClass) { + // we're in a case where there's a private name outside a class (invalid) + return undefined; + } + const containingClassSymbol = containingClass.symbol; return getPropertyNameForPrivateNameDescription(containingClassSymbol, name.escapedText); } return isPropertyNameLiteral(name) ? getEscapedTextOfIdentifierOrLiteral(name) : undefined; diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 9c56c9f33ff5a..7c8e7ddf05904 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -29681,6 +29681,10 @@ namespace ts { return grammarErrorOnNode(prop.equalsToken!, Diagnostics.can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment); } + if (name.kind === SyntaxKind.PrivateName) { + return grammarErrorOnNode(name, Diagnostics.Private_names_are_not_allowed_outside_class_bodies); + } + // Modifiers are never allowed on properties except for 'async' on a method declaration if (prop.modifiers) { for (const mod of prop.modifiers!) { // TODO: GH#19955 diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 7afe1cf65c515..b6cd971643e7f 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -4319,10 +4319,14 @@ "category": "Error", "code": 18008 }, - "Property '{0}' is missing in type '{1}'. While type '{1}' has a private member with the same spelling, its declaration and accessibility are distinct": { + "Property '{0}' is missing in type '{1}'. While type '{1}' has a private member with the same spelling, its declaration and accessibility are distinct.": { "category": "Error", "code": 18009 }, + "Private names are not allowed outside class bodies.": { + "category": "Error", + "code": 18010 + }, "File is a CommonJS module; it may be converted to an ES6 module.": { "category": "Suggestion", diff --git a/tests/baselines/reference/privateNameInObjectLiteral-1.errors.txt b/tests/baselines/reference/privateNameInObjectLiteral-1.errors.txt new file mode 100644 index 0000000000000..cd17f4caf1545 --- /dev/null +++ b/tests/baselines/reference/privateNameInObjectLiteral-1.errors.txt @@ -0,0 +1,10 @@ +tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-1.ts(2,5): error TS18010: Private names are not allowed outside class bodies. + + +==== tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-1.ts (1 errors) ==== + const obj = { + #foo: 1 + ~~~~ +!!! error TS18010: Private names are not allowed outside class bodies. + }; + \ No newline at end of file diff --git a/tests/baselines/reference/privateNameInObjectLiteral-1.js b/tests/baselines/reference/privateNameInObjectLiteral-1.js new file mode 100644 index 0000000000000..58af5d0ec5158 --- /dev/null +++ b/tests/baselines/reference/privateNameInObjectLiteral-1.js @@ -0,0 +1,10 @@ +//// [privateNameInObjectLiteral-1.ts] +const obj = { + #foo: 1 +}; + + +//// [privateNameInObjectLiteral-1.js] +var obj = { + #foo: 1 +}; diff --git a/tests/baselines/reference/privateNameInObjectLiteral-1.symbols b/tests/baselines/reference/privateNameInObjectLiteral-1.symbols new file mode 100644 index 0000000000000..c675ee7cc758c --- /dev/null +++ b/tests/baselines/reference/privateNameInObjectLiteral-1.symbols @@ -0,0 +1,9 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-1.ts === +const obj = { +>obj : Symbol(obj, Decl(privateNameInObjectLiteral-1.ts, 0, 5)) + + #foo: 1 +>#foo : Symbol(#foo, Decl(privateNameInObjectLiteral-1.ts, 0, 13)) + +}; + diff --git a/tests/baselines/reference/privateNameInObjectLiteral-1.types b/tests/baselines/reference/privateNameInObjectLiteral-1.types new file mode 100644 index 0000000000000..48de261be2900 --- /dev/null +++ b/tests/baselines/reference/privateNameInObjectLiteral-1.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-1.ts === +const obj = { +>obj : {} +>{ #foo: 1} : {} + + #foo: 1 +>#foo : number +>1 : 1 + +}; + diff --git a/tests/baselines/reference/privateNameInObjectLiteral-2.errors.txt b/tests/baselines/reference/privateNameInObjectLiteral-2.errors.txt new file mode 100644 index 0000000000000..b79507b32000f --- /dev/null +++ b/tests/baselines/reference/privateNameInObjectLiteral-2.errors.txt @@ -0,0 +1,12 @@ +tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-2.ts(2,5): error TS18010: Private names are not allowed outside class bodies. + + +==== tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-2.ts (1 errors) ==== + const obj = { + #foo() { + ~~~~ +!!! error TS18010: Private names are not allowed outside class bodies. + + } + }; + \ No newline at end of file diff --git a/tests/baselines/reference/privateNameInObjectLiteral-2.js b/tests/baselines/reference/privateNameInObjectLiteral-2.js new file mode 100644 index 0000000000000..6bb2c99d4c169 --- /dev/null +++ b/tests/baselines/reference/privateNameInObjectLiteral-2.js @@ -0,0 +1,13 @@ +//// [privateNameInObjectLiteral-2.ts] +const obj = { + #foo() { + + } +}; + + +//// [privateNameInObjectLiteral-2.js] +var obj = { + #foo: function () { + } +}; diff --git a/tests/baselines/reference/privateNameInObjectLiteral-2.symbols b/tests/baselines/reference/privateNameInObjectLiteral-2.symbols new file mode 100644 index 0000000000000..b9a25ac870963 --- /dev/null +++ b/tests/baselines/reference/privateNameInObjectLiteral-2.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-2.ts === +const obj = { +>obj : Symbol(obj, Decl(privateNameInObjectLiteral-2.ts, 0, 5)) + + #foo() { +>#foo : Symbol(#foo, Decl(privateNameInObjectLiteral-2.ts, 0, 13)) + + } +}; + diff --git a/tests/baselines/reference/privateNameInObjectLiteral-2.types b/tests/baselines/reference/privateNameInObjectLiteral-2.types new file mode 100644 index 0000000000000..a1e36e82380b1 --- /dev/null +++ b/tests/baselines/reference/privateNameInObjectLiteral-2.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-2.ts === +const obj = { +>obj : {} +>{ #foo() { }} : {} + + #foo() { +>#foo : () => void + + } +}; + diff --git a/tests/baselines/reference/privateNameInObjectLiteral.errors.txt b/tests/baselines/reference/privateNameInObjectLiteral.errors.txt new file mode 100644 index 0000000000000..2f5101ec98646 --- /dev/null +++ b/tests/baselines/reference/privateNameInObjectLiteral.errors.txt @@ -0,0 +1,14 @@ +tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral.ts(2,5): error TS18010: Private names are not allowed outside class bodies. + + +==== tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral.ts (1 errors) ==== + const obj = { + #foo: "#foo", + ~~~~ +!!! error TS18010: Private names are not allowed outside class bodies. + #bar: () => true, + #baz() { + return true; + } + }; + \ No newline at end of file diff --git a/tests/baselines/reference/privateNameInObjectLiteral.js b/tests/baselines/reference/privateNameInObjectLiteral.js new file mode 100644 index 0000000000000..a95d80d4add5f --- /dev/null +++ b/tests/baselines/reference/privateNameInObjectLiteral.js @@ -0,0 +1,18 @@ +//// [privateNameInObjectLiteral.ts] +const obj = { + #foo: "#foo", + #bar: () => true, + #baz() { + return true; + } +}; + + +//// [privateNameInObjectLiteral.js] +var obj = { + #foo: "#foo", + #bar: function () { return true; }, + #baz: function () { + return true; + } +}; diff --git a/tests/baselines/reference/privateNameInObjectLiteral.symbols b/tests/baselines/reference/privateNameInObjectLiteral.symbols new file mode 100644 index 0000000000000..f5592c7384305 --- /dev/null +++ b/tests/baselines/reference/privateNameInObjectLiteral.symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral.ts === +const obj = { +>obj : Symbol(obj, Decl(privateNameInObjectLiteral.ts, 0, 5)) + + #foo: "#foo", +>#foo : Symbol(#foo, Decl(privateNameInObjectLiteral.ts, 0, 13)) + + #bar: () => true, +>#bar : Symbol(#bar, Decl(privateNameInObjectLiteral.ts, 1, 17)) + + #baz() { +>#baz : Symbol(#baz, Decl(privateNameInObjectLiteral.ts, 2, 21)) + + return true; + } +}; + diff --git a/tests/baselines/reference/privateNameInObjectLiteral.types b/tests/baselines/reference/privateNameInObjectLiteral.types new file mode 100644 index 0000000000000..372dc87bae5c3 --- /dev/null +++ b/tests/baselines/reference/privateNameInObjectLiteral.types @@ -0,0 +1,22 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral.ts === +const obj = { +>obj : {} +>{ #foo: "#foo", #bar: () => true, #baz() { return true; }} : {} + + #foo: "#foo", +>#foo : string +>"#foo" : "#foo" + + #bar: () => true, +>#bar : () => boolean +>() => true : () => boolean +>true : true + + #baz() { +>#baz : () => boolean + + return true; +>true : true + } +}; + diff --git a/tests/baselines/reference/privateNamesAndGenericClasses-2.errors.txt b/tests/baselines/reference/privateNamesAndGenericClasses-2.errors.txt new file mode 100644 index 0000000000000..f9b6ebacba805 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndGenericClasses-2.errors.txt @@ -0,0 +1,46 @@ +tests/cases/conformance/classes/members/privateNames/privateNamesAndGenericClasses-2.ts(24,3): error TS2339: Property '#foo' does not exist on type 'C'. +tests/cases/conformance/classes/members/privateNames/privateNamesAndGenericClasses-2.ts(24,3): error TS18007: Property '#foo' is not accessible outside class 'C' because it has a private name. +tests/cases/conformance/classes/members/privateNames/privateNamesAndGenericClasses-2.ts(25,1): error TS2322: Type 'C' is not assignable to type 'C'. + Type 'string' is not assignable to type 'number'. +tests/cases/conformance/classes/members/privateNames/privateNamesAndGenericClasses-2.ts(26,1): error TS2322: Type 'C' is not assignable to type 'C'. + Type 'number' is not assignable to type 'string'. + + +==== tests/cases/conformance/classes/members/privateNames/privateNamesAndGenericClasses-2.ts (4 errors) ==== + class C { + #foo: T; + #bar(): T { + return this.#foo; + } + constructor(t: T) { + this.#foo = t; + t = this.#bar(); + } + set baz(t: T) { + this.#foo = t; + + } + get baz(): T { + return this.#foo; + } + } + + let a = new C(3); + let b = new C("hello"); + + a.baz = 5 // OK + const x: number = a.baz // OK + a.#foo; // Error + ~~~~ +!!! error TS2339: Property '#foo' does not exist on type 'C'. + ~~~~ +!!! error TS18007: Property '#foo' is not accessible outside class 'C' because it has a private name. + a = b; // Error + ~ +!!! error TS2322: Type 'C' is not assignable to type 'C'. +!!! error TS2322: Type 'string' is not assignable to type 'number'. + b = a; // Error + ~ +!!! error TS2322: Type 'C' is not assignable to type 'C'. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + \ No newline at end of file diff --git a/tests/baselines/reference/privateNamesAndGenericClasses-2.js b/tests/baselines/reference/privateNamesAndGenericClasses-2.js new file mode 100644 index 0000000000000..972af4a681e20 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndGenericClasses-2.js @@ -0,0 +1,58 @@ +//// [privateNamesAndGenericClasses-2.ts] +class C { + #foo: T; + #bar(): T { + return this.#foo; + } + constructor(t: T) { + this.#foo = t; + t = this.#bar(); + } + set baz(t: T) { + this.#foo = t; + + } + get baz(): T { + return this.#foo; + } +} + +let a = new C(3); +let b = new C("hello"); + +a.baz = 5 // OK +const x: number = a.baz // OK +a.#foo; // Error +a = b; // Error +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; +"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); + } + set baz(t) { + _classPrivateFieldSet(this, _foo, t); + } + get baz() { + return _classPrivateFieldGet(this, _foo); + } +} +_foo = new WeakMap(); +let a = new C(3); +let b = new C("hello"); +a.baz = 5; // OK +const x = a.baz; // OK +a.#foo; // Error +a = b; // Error +b = a; // Error diff --git a/tests/baselines/reference/privateNamesAndGenericClasses-2.symbols b/tests/baselines/reference/privateNamesAndGenericClasses-2.symbols new file mode 100644 index 0000000000000..0f84af4a027f0 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndGenericClasses-2.symbols @@ -0,0 +1,82 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndGenericClasses-2.ts === +class C { +>C : Symbol(C, Decl(privateNamesAndGenericClasses-2.ts, 0, 0)) +>T : Symbol(T, Decl(privateNamesAndGenericClasses-2.ts, 0, 8)) + + #foo: T; +>#foo : Symbol(C.#foo, Decl(privateNamesAndGenericClasses-2.ts, 0, 12)) +>T : Symbol(T, Decl(privateNamesAndGenericClasses-2.ts, 0, 8)) + + #bar(): T { +>#bar : Symbol(C.#bar, Decl(privateNamesAndGenericClasses-2.ts, 1, 12)) +>T : Symbol(T, Decl(privateNamesAndGenericClasses-2.ts, 0, 8)) + + return this.#foo; +>this.#foo : Symbol(C.#foo, Decl(privateNamesAndGenericClasses-2.ts, 0, 12)) +>this : Symbol(C, Decl(privateNamesAndGenericClasses-2.ts, 0, 0)) + } + constructor(t: T) { +>t : Symbol(t, Decl(privateNamesAndGenericClasses-2.ts, 5, 16)) +>T : Symbol(T, Decl(privateNamesAndGenericClasses-2.ts, 0, 8)) + + this.#foo = t; +>this.#foo : Symbol(C.#foo, Decl(privateNamesAndGenericClasses-2.ts, 0, 12)) +>this : Symbol(C, Decl(privateNamesAndGenericClasses-2.ts, 0, 0)) +>t : Symbol(t, Decl(privateNamesAndGenericClasses-2.ts, 5, 16)) + + t = this.#bar(); +>t : Symbol(t, Decl(privateNamesAndGenericClasses-2.ts, 5, 16)) +>this.#bar : Symbol(C.#bar, Decl(privateNamesAndGenericClasses-2.ts, 1, 12)) +>this : Symbol(C, Decl(privateNamesAndGenericClasses-2.ts, 0, 0)) + } + set baz(t: T) { +>baz : Symbol(C.baz, Decl(privateNamesAndGenericClasses-2.ts, 8, 5), Decl(privateNamesAndGenericClasses-2.ts, 12, 5)) +>t : Symbol(t, Decl(privateNamesAndGenericClasses-2.ts, 9, 12)) +>T : Symbol(T, Decl(privateNamesAndGenericClasses-2.ts, 0, 8)) + + this.#foo = t; +>this.#foo : Symbol(C.#foo, Decl(privateNamesAndGenericClasses-2.ts, 0, 12)) +>this : Symbol(C, Decl(privateNamesAndGenericClasses-2.ts, 0, 0)) +>t : Symbol(t, Decl(privateNamesAndGenericClasses-2.ts, 9, 12)) + + } + get baz(): T { +>baz : Symbol(C.baz, Decl(privateNamesAndGenericClasses-2.ts, 8, 5), Decl(privateNamesAndGenericClasses-2.ts, 12, 5)) +>T : Symbol(T, Decl(privateNamesAndGenericClasses-2.ts, 0, 8)) + + return this.#foo; +>this.#foo : Symbol(C.#foo, Decl(privateNamesAndGenericClasses-2.ts, 0, 12)) +>this : Symbol(C, Decl(privateNamesAndGenericClasses-2.ts, 0, 0)) + } +} + +let a = new C(3); +>a : Symbol(a, Decl(privateNamesAndGenericClasses-2.ts, 18, 3)) +>C : Symbol(C, Decl(privateNamesAndGenericClasses-2.ts, 0, 0)) + +let b = new C("hello"); +>b : Symbol(b, Decl(privateNamesAndGenericClasses-2.ts, 19, 3)) +>C : Symbol(C, Decl(privateNamesAndGenericClasses-2.ts, 0, 0)) + +a.baz = 5 // OK +>a.baz : Symbol(C.baz, Decl(privateNamesAndGenericClasses-2.ts, 8, 5), Decl(privateNamesAndGenericClasses-2.ts, 12, 5)) +>a : Symbol(a, Decl(privateNamesAndGenericClasses-2.ts, 18, 3)) +>baz : Symbol(C.baz, Decl(privateNamesAndGenericClasses-2.ts, 8, 5), Decl(privateNamesAndGenericClasses-2.ts, 12, 5)) + +const x: number = a.baz // OK +>x : Symbol(x, Decl(privateNamesAndGenericClasses-2.ts, 22, 5)) +>a.baz : Symbol(C.baz, Decl(privateNamesAndGenericClasses-2.ts, 8, 5), Decl(privateNamesAndGenericClasses-2.ts, 12, 5)) +>a : Symbol(a, Decl(privateNamesAndGenericClasses-2.ts, 18, 3)) +>baz : Symbol(C.baz, Decl(privateNamesAndGenericClasses-2.ts, 8, 5), Decl(privateNamesAndGenericClasses-2.ts, 12, 5)) + +a.#foo; // Error +>a : Symbol(a, Decl(privateNamesAndGenericClasses-2.ts, 18, 3)) + +a = b; // Error +>a : Symbol(a, Decl(privateNamesAndGenericClasses-2.ts, 18, 3)) +>b : Symbol(b, Decl(privateNamesAndGenericClasses-2.ts, 19, 3)) + +b = a; // Error +>b : Symbol(b, Decl(privateNamesAndGenericClasses-2.ts, 19, 3)) +>a : Symbol(a, Decl(privateNamesAndGenericClasses-2.ts, 18, 3)) + diff --git a/tests/baselines/reference/privateNamesAndGenericClasses-2.types b/tests/baselines/reference/privateNamesAndGenericClasses-2.types new file mode 100644 index 0000000000000..42f5b237d06fa --- /dev/null +++ b/tests/baselines/reference/privateNamesAndGenericClasses-2.types @@ -0,0 +1,89 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndGenericClasses-2.ts === +class C { +>C : C + + #foo: T; +>#foo : T + + #bar(): T { +>#bar : () => T + + return this.#foo; +>this.#foo : T +>this : this + } + constructor(t: T) { +>t : T + + this.#foo = t; +>this.#foo = t : T +>this.#foo : T +>this : this +>t : T + + t = this.#bar(); +>t = this.#bar() : T +>t : T +>this.#bar() : T +>this.#bar : () => T +>this : this + } + set baz(t: T) { +>baz : T +>t : T + + this.#foo = t; +>this.#foo = t : T +>this.#foo : T +>this : this +>t : T + + } + get baz(): T { +>baz : T + + return this.#foo; +>this.#foo : T +>this : this + } +} + +let a = new C(3); +>a : C +>new C(3) : C +>C : typeof C +>3 : 3 + +let b = new C("hello"); +>b : C +>new C("hello") : C +>C : typeof C +>"hello" : "hello" + +a.baz = 5 // OK +>a.baz = 5 : 5 +>a.baz : number +>a : C +>baz : number +>5 : 5 + +const x: number = a.baz // OK +>x : number +>a.baz : number +>a : C +>baz : number + +a.#foo; // Error +>a.#foo : any +>a : C + +a = b; // Error +>a = b : C +>a : C +>b : C + +b = a; // Error +>b = a : C +>b : C +>a : C + diff --git a/tests/baselines/reference/privateNamesAndIndexedAccess.errors.txt b/tests/baselines/reference/privateNamesAndIndexedAccess.errors.txt new file mode 100644 index 0000000000000..95b8ab2a61bf7 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndIndexedAccess.errors.txt @@ -0,0 +1,39 @@ +tests/cases/conformance/classes/members/privateNames/privateNamesAndIndexedAccess.ts(7,28): error TS1005: ']' expected. +tests/cases/conformance/classes/members/privateNames/privateNamesAndIndexedAccess.ts(7,28): error TS2300: Duplicate identifier '#bar'. +tests/cases/conformance/classes/members/privateNames/privateNamesAndIndexedAccess.ts(7,28): error TS2717: Subsequent property declarations must have the same type. Property '#bar' must be of type 'number', but here has type 'any'. +tests/cases/conformance/classes/members/privateNames/privateNamesAndIndexedAccess.ts(7,32): error TS1005: ';' expected. +tests/cases/conformance/classes/members/privateNames/privateNamesAndIndexedAccess.ts(7,34): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. +tests/cases/conformance/classes/members/privateNames/privateNamesAndIndexedAccess.ts(7,36): error TS7008: Member '3' implicitly has an 'any' type. +tests/cases/conformance/classes/members/privateNames/privateNamesAndIndexedAccess.ts(9,28): error TS2339: Property '#bar' does not exist on type 'C'. +tests/cases/conformance/classes/members/privateNames/privateNamesAndIndexedAccess.ts(11,1): error TS1128: Declaration or statement expected. + + +==== tests/cases/conformance/classes/members/privateNames/privateNamesAndIndexedAccess.ts (8 errors) ==== + class C { + foo = 3; + #bar = 3; + constructor () { + const ok: C["foo"] = 3; + // not supported yet, could support in future: + const badForNow: C[#bar] = 3; // Error + ~~~~ +!!! error TS1005: ']' expected. + ~~~~ +!!! error TS2300: Duplicate identifier '#bar'. + ~~~~ +!!! error TS2717: Subsequent property declarations must have the same type. Property '#bar' must be of type 'number', but here has type 'any'. + ~ +!!! error TS1005: ';' expected. + ~ +!!! error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. + ~ +!!! error TS7008: Member '3' implicitly has an 'any' type. + // will never use this syntax, already taken: + const badAlways: C["#bar"] = 3; // Error + ~~~~~~ +!!! error TS2339: Property '#bar' does not exist on type 'C'. + } + } + ~ +!!! error TS1128: Declaration or statement expected. + \ No newline at end of file diff --git a/tests/baselines/reference/privateNamesAndIndexedAccess.js b/tests/baselines/reference/privateNamesAndIndexedAccess.js new file mode 100644 index 0000000000000..44dde9629a8c6 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndIndexedAccess.js @@ -0,0 +1,30 @@ +//// [privateNamesAndIndexedAccess.ts] +class C { + foo = 3; + #bar = 3; + constructor () { + const ok: C["foo"] = 3; + // not supported yet, could support in future: + const badForNow: C[#bar] = 3; // Error + // will never use this syntax, already taken: + const badAlways: C["#bar"] = 3; // Error + } +} + + +//// [privateNamesAndIndexedAccess.js] +var _bar, _bar_1; +"use strict"; +class C { + constructor() { + this.foo = 3; + _bar_1.set(this, 3); + _bar_1.set(this, void 0); + // will never use this syntax, already taken: + this.badAlways = 3; // Error + const ok = 3; + // not supported yet, could support in future: + const badForNow; + } +} +_bar = new WeakMap(), _bar_1 = new WeakMap(); diff --git a/tests/baselines/reference/privateNamesAndIndexedAccess.symbols b/tests/baselines/reference/privateNamesAndIndexedAccess.symbols new file mode 100644 index 0000000000000..43a743810dca6 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndIndexedAccess.symbols @@ -0,0 +1,29 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndIndexedAccess.ts === +class C { +>C : Symbol(C, Decl(privateNamesAndIndexedAccess.ts, 0, 0)) + + foo = 3; +>foo : Symbol(C.foo, Decl(privateNamesAndIndexedAccess.ts, 0, 9)) + + #bar = 3; +>#bar : Symbol(C.#bar, Decl(privateNamesAndIndexedAccess.ts, 1, 12), Decl(privateNamesAndIndexedAccess.ts, 6, 27)) + + constructor () { + const ok: C["foo"] = 3; +>ok : Symbol(ok, Decl(privateNamesAndIndexedAccess.ts, 4, 13)) +>C : Symbol(C, Decl(privateNamesAndIndexedAccess.ts, 0, 0)) + + // not supported yet, could support in future: + const badForNow: C[#bar] = 3; // Error +>badForNow : Symbol(badForNow, Decl(privateNamesAndIndexedAccess.ts, 6, 13)) +>C : Symbol(C, Decl(privateNamesAndIndexedAccess.ts, 0, 0)) +>#bar : Symbol(C.#bar, Decl(privateNamesAndIndexedAccess.ts, 1, 12), Decl(privateNamesAndIndexedAccess.ts, 6, 27)) +>3 : Symbol(C[3], Decl(privateNamesAndIndexedAccess.ts, 6, 34)) + + // will never use this syntax, already taken: + const badAlways: C["#bar"] = 3; // Error +>badAlways : Symbol(C.badAlways, Decl(privateNamesAndIndexedAccess.ts, 6, 37)) +>C : Symbol(C, Decl(privateNamesAndIndexedAccess.ts, 0, 0)) + } +} + diff --git a/tests/baselines/reference/privateNamesAndIndexedAccess.types b/tests/baselines/reference/privateNamesAndIndexedAccess.types new file mode 100644 index 0000000000000..84ac9d43ffed9 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndIndexedAccess.types @@ -0,0 +1,30 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndIndexedAccess.ts === +class C { +>C : C + + foo = 3; +>foo : number +>3 : 3 + + #bar = 3; +>#bar : number +>3 : 3 + + constructor () { + const ok: C["foo"] = 3; +>ok : number +>3 : 3 + + // not supported yet, could support in future: + const badForNow: C[#bar] = 3; // Error +>badForNow : C[] +>#bar : number +>3 : any + + // will never use this syntax, already taken: + const badAlways: C["#bar"] = 3; // Error +>badAlways : any +>3 : 3 + } +} + diff --git a/tests/baselines/reference/privateNamesInGenericClasses.errors.txt b/tests/baselines/reference/privateNamesInGenericClasses.errors.txt index fc11628a5634e..7e5435ffa2c58 100644 --- a/tests/baselines/reference/privateNamesInGenericClasses.errors.txt +++ b/tests/baselines/reference/privateNamesInGenericClasses.errors.txt @@ -1,24 +1,22 @@ -tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(12,3): error TS2339: Property '#foo' does not exist on type 'C'. -tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(12,3): error TS18007: Property '#foo' is not accessible outside class 'C' because it has a private name. -tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(13,1): error TS2322: Type 'C' is not assignable to type 'C'. +tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(10,3): error TS2339: Property '#foo' does not exist on type 'C'. +tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(10,3): error TS18007: Property '#foo' is not accessible outside class 'C' because it has a private name. +tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(11,1): error TS2322: Type 'C' is not assignable to type 'C'. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(14,1): error TS2322: Type 'C' is not assignable to type 'C'. +tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts(12,1): error TS2322: Type 'C' is not assignable to type 'C'. Type 'number' is not assignable to type 'string'. ==== tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts (4 errors) ==== - // @target es6 - class C { - #foo: T; - bar(x: C) { return x.#foo; } // OK - baz(x: C) { return x.#foo; } // OK - quux(x: C) { return x.#foo; } // OK + #foo: T; + bar(x: C) { return x.#foo; } // OK + baz(x: C) { return x.#foo; } // OK + quux(x: C) { return x.#foo; } // OK } declare let a: C; declare let b: C; - a.#foo; // OK + a.#foo; // Error ~~~~ !!! error TS2339: Property '#foo' does not exist on type 'C'. ~~~~ diff --git a/tests/baselines/reference/privateNamesInGenericClasses.js b/tests/baselines/reference/privateNamesInGenericClasses.js index 750471c74bc18..e92f777e3b673 100644 --- a/tests/baselines/reference/privateNamesInGenericClasses.js +++ b/tests/baselines/reference/privateNamesInGenericClasses.js @@ -1,35 +1,31 @@ //// [privateNamesInGenericClasses.ts] -// @target es6 - class C { - #foo: T; - bar(x: C) { return x.#foo; } // OK - baz(x: C) { return x.#foo; } // OK - quux(x: C) { return x.#foo; } // OK + #foo: T; + bar(x: C) { return x.#foo; } // OK + baz(x: C) { return x.#foo; } // OK + quux(x: C) { return x.#foo; } // OK } declare let a: C; declare let b: C; -a.#foo; // OK +a.#foo; // Error a = b; // Error b = a; // Error //// [privateNamesInGenericClasses.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; "use strict"; -var C = /** @class */ (function () { - function C() { +class C { + constructor() { _foo.set(this, void 0); } - C.prototype.bar = function (x) { return _classPrivateFieldGet(x, _foo); }; // OK - C.prototype.baz = function (x) { return _classPrivateFieldGet(x, _foo); }; // OK - C.prototype.quux = function (x) { return _classPrivateFieldGet(x, _foo); }; // OK - return C; -}()); + bar(x) { return _classPrivateFieldGet(x, _foo); } // OK + baz(x) { return _classPrivateFieldGet(x, _foo); } // OK + quux(x) { return _classPrivateFieldGet(x, _foo); } // OK +} _foo = new WeakMap(); -a.#foo; // OK +a.#foo; // Error a = b; // Error b = a; // Error diff --git a/tests/baselines/reference/privateNamesInGenericClasses.symbols b/tests/baselines/reference/privateNamesInGenericClasses.symbols index 184e21596a7de..c697c06390869 100644 --- a/tests/baselines/reference/privateNamesInGenericClasses.symbols +++ b/tests/baselines/reference/privateNamesInGenericClasses.symbols @@ -1,53 +1,51 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts === -// @target es6 - class C { >C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) ->T : Symbol(T, Decl(privateNamesInGenericClasses.ts, 2, 8)) +>T : Symbol(T, Decl(privateNamesInGenericClasses.ts, 0, 8)) - #foo: T; ->#foo : Symbol(C.#foo, Decl(privateNamesInGenericClasses.ts, 2, 12)) ->T : Symbol(T, Decl(privateNamesInGenericClasses.ts, 2, 8)) + #foo: T; +>#foo : Symbol(C.#foo, Decl(privateNamesInGenericClasses.ts, 0, 12)) +>T : Symbol(T, Decl(privateNamesInGenericClasses.ts, 0, 8)) - bar(x: C) { return x.#foo; } // OK ->bar : Symbol(C.bar, Decl(privateNamesInGenericClasses.ts, 3, 10)) ->x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 4, 6)) + bar(x: C) { return x.#foo; } // OK +>bar : Symbol(C.bar, Decl(privateNamesInGenericClasses.ts, 1, 12)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 2, 8)) >C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) ->T : Symbol(T, Decl(privateNamesInGenericClasses.ts, 2, 8)) ->x.#foo : Symbol(C.#foo, Decl(privateNamesInGenericClasses.ts, 2, 12)) ->x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 4, 6)) +>T : Symbol(T, Decl(privateNamesInGenericClasses.ts, 0, 8)) +>x.#foo : Symbol(C.#foo, Decl(privateNamesInGenericClasses.ts, 0, 12)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 2, 8)) - baz(x: C) { return x.#foo; } // OK ->baz : Symbol(C.baz, Decl(privateNamesInGenericClasses.ts, 4, 33)) ->x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 5, 6)) + baz(x: C) { return x.#foo; } // OK +>baz : Symbol(C.baz, Decl(privateNamesInGenericClasses.ts, 2, 35)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 3, 8)) >C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) ->x.#foo : Symbol(C.#foo, Decl(privateNamesInGenericClasses.ts, 2, 12)) ->x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 5, 6)) +>x.#foo : Symbol(C.#foo, Decl(privateNamesInGenericClasses.ts, 0, 12)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 3, 8)) - quux(x: C) { return x.#foo; } // OK ->quux : Symbol(C.quux, Decl(privateNamesInGenericClasses.ts, 5, 38)) ->x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 6, 7)) + quux(x: C) { return x.#foo; } // OK +>quux : Symbol(C.quux, Decl(privateNamesInGenericClasses.ts, 3, 40)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 4, 9)) >C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) ->x.#foo : Symbol(C.#foo, Decl(privateNamesInGenericClasses.ts, 2, 12)) ->x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 6, 7)) +>x.#foo : Symbol(C.#foo, Decl(privateNamesInGenericClasses.ts, 0, 12)) +>x : Symbol(x, Decl(privateNamesInGenericClasses.ts, 4, 9)) } declare let a: C; ->a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 9, 11)) +>a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 7, 11)) >C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) declare let b: C; ->b : Symbol(b, Decl(privateNamesInGenericClasses.ts, 10, 11)) +>b : Symbol(b, Decl(privateNamesInGenericClasses.ts, 8, 11)) >C : Symbol(C, Decl(privateNamesInGenericClasses.ts, 0, 0)) -a.#foo; // OK ->a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 9, 11)) +a.#foo; // Error +>a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 7, 11)) a = b; // Error ->a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 9, 11)) ->b : Symbol(b, Decl(privateNamesInGenericClasses.ts, 10, 11)) +>a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 7, 11)) +>b : Symbol(b, Decl(privateNamesInGenericClasses.ts, 8, 11)) b = a; // Error ->b : Symbol(b, Decl(privateNamesInGenericClasses.ts, 10, 11)) ->a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 9, 11)) +>b : Symbol(b, Decl(privateNamesInGenericClasses.ts, 8, 11)) +>a : Symbol(a, Decl(privateNamesInGenericClasses.ts, 7, 11)) diff --git a/tests/baselines/reference/privateNamesInGenericClasses.types b/tests/baselines/reference/privateNamesInGenericClasses.types index 63fc9cce473f9..e0a29a45492c1 100644 --- a/tests/baselines/reference/privateNamesInGenericClasses.types +++ b/tests/baselines/reference/privateNamesInGenericClasses.types @@ -1,25 +1,23 @@ === tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts === -// @target es6 - class C { >C : C - #foo: T; + #foo: T; >#foo : T - bar(x: C) { return x.#foo; } // OK + bar(x: C) { return x.#foo; } // OK >bar : (x: C) => T >x : C >x.#foo : T >x : C - baz(x: C) { return x.#foo; } // OK + baz(x: C) { return x.#foo; } // OK >baz : (x: C) => number >x : C >x.#foo : number >x : C - quux(x: C) { return x.#foo; } // OK + quux(x: C) { return x.#foo; } // OK >quux : (x: C) => string >x : C >x.#foo : string @@ -32,7 +30,7 @@ declare let a: C; declare let b: C; >b : C -a.#foo; // OK +a.#foo; // Error >a.#foo : any >a : C diff --git a/tests/baselines/reference/privateNamesUnique.errors.txt b/tests/baselines/reference/privateNamesUnique.errors.txt index 799a580eb502a..0c3b1ef188c17 100644 --- a/tests/baselines/reference/privateNamesUnique.errors.txt +++ b/tests/baselines/reference/privateNamesUnique.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts(11,7): error TS2322: Type 'B' is not assignable to type 'A'. - Property '#foo' is missing in type 'B'. While type 'B' has a private member with the same spelling, its declaration and accessibility are distinct + Property '#foo' is missing in type 'B'. While type 'B' has a private member with the same spelling, its declaration and accessibility are distinct. ==== tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts (1 errors) ==== @@ -16,5 +16,5 @@ tests/cases/conformance/classes/members/privateNames/privateNamesUnique.ts(11,7) const b: A = new B(); // Error: Property #foo is missing ~ !!! error TS2322: Type 'B' is not assignable to type 'A'. -!!! error TS2322: Property '#foo' is missing in type 'B'. While type 'B' has a private member with the same spelling, its declaration and accessibility are distinct +!!! error TS2322: Property '#foo' is missing in type 'B'. While type 'B' has a private member with the same spelling, its declaration and accessibility are distinct. \ No newline at end of file diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-1.ts b/tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-1.ts new file mode 100644 index 0000000000000..04c75fda5f841 --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-1.ts @@ -0,0 +1,3 @@ +const obj = { + #foo: 1 +}; diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-2.ts b/tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-2.ts new file mode 100644 index 0000000000000..3356e7a957b1f --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNameInObjectLiteral-2.ts @@ -0,0 +1,5 @@ +const obj = { + #foo() { + + } +}; diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesAndGenericClasses-2.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesAndGenericClasses-2.ts new file mode 100644 index 0000000000000..fb515e4bb023a --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesAndGenericClasses-2.ts @@ -0,0 +1,29 @@ +// @strict: true +// @target: es6 + +class C { + #foo: T; + #bar(): T { + return this.#foo; + } + constructor(t: T) { + this.#foo = t; + t = this.#bar(); + } + set baz(t: T) { + this.#foo = t; + + } + get baz(): T { + return this.#foo; + } +} + +let a = new C(3); +let b = new C("hello"); + +a.baz = 5 // OK +const x: number = a.baz // OK +a.#foo; // Error +a = b; // Error +b = a; // Error diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesAndIndexedAccess.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesAndIndexedAccess.ts new file mode 100644 index 0000000000000..0673430ce272c --- /dev/null +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesAndIndexedAccess.ts @@ -0,0 +1,14 @@ +// @strict: true +// @target: es6 + +class C { + foo = 3; + #bar = 3; + constructor () { + const ok: C["foo"] = 3; + // not supported yet, could support in future: + const badForNow: C[#bar] = 3; // Error + // will never use this syntax, already taken: + const badAlways: C["#bar"] = 3; // Error + } +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts index be79278580cc4..fbf667d82f921 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesInGenericClasses.ts @@ -1,15 +1,15 @@ // @strict: true -// @target es6 +// @target: es6 class C { - #foo: T; - bar(x: C) { return x.#foo; } // OK - baz(x: C) { return x.#foo; } // OK - quux(x: C) { return x.#foo; } // OK + #foo: T; + bar(x: C) { return x.#foo; } // OK + baz(x: C) { return x.#foo; } // OK + quux(x: C) { return x.#foo; } // OK } declare let a: C; declare let b: C; -a.#foo; // OK +a.#foo; // Error a = b; // Error b = a; // Error