diff --git a/scripts/eslint/rules/debug-assert.ts b/scripts/eslint/rules/debug-assert.ts index 0e8769f1fe5b1..f3fbce0d37582 100644 --- a/scripts/eslint/rules/debug-assert.ts +++ b/scripts/eslint/rules/debug-assert.ts @@ -43,7 +43,7 @@ export = createRule({ context.report({ messageId: "secondArgumentDebugAssertError", node: message1Node }); } - if (argsLen < 3) { + if (argsLen < 3 || argsLen > 3) { return; } diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 2bd96fe334e8d..712b1f1a8acf4 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -2744,7 +2744,10 @@ namespace ts { } function bindPropertyWorker(node: PropertyDeclaration | PropertySignature) { - return bindPropertyOrMethodOrAccessor(node, SymbolFlags.Property | (node.questionToken ? SymbolFlags.Optional : SymbolFlags.None), SymbolFlags.PropertyExcludes); + const isAutoAccessor = isAutoAccessorPropertyDeclaration(node); + const includes = isAutoAccessor ? SymbolFlags.Accessor : SymbolFlags.Property; + const excludes = isAutoAccessor ? SymbolFlags.AccessorExcludes : SymbolFlags.PropertyExcludes; + return bindPropertyOrMethodOrAccessor(node, includes | (node.questionToken ? SymbolFlags.Optional : SymbolFlags.None), excludes); } function bindAnonymousTypeWorker(node: TypeLiteralNode | MappedTypeNode | JSDocTypeLiteral) { diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index c2f5d4862f0f2..666efd8874a35 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -9658,21 +9658,25 @@ namespace ts { return type; } - function getAnnotatedAccessorTypeNode(accessor: AccessorDeclaration | undefined): TypeNode | undefined { + function getAnnotatedAccessorTypeNode(accessor: AccessorDeclaration | PropertyDeclaration | undefined): TypeNode | undefined { if (accessor) { - if (accessor.kind === SyntaxKind.GetAccessor) { - const getterTypeAnnotation = getEffectiveReturnTypeNode(accessor); - return getterTypeAnnotation; - } - else { - const setterTypeAnnotation = getEffectiveSetAccessorTypeAnnotationNode(accessor); - return setterTypeAnnotation; + switch (accessor.kind) { + case SyntaxKind.GetAccessor: + const getterTypeAnnotation = getEffectiveReturnTypeNode(accessor); + return getterTypeAnnotation; + case SyntaxKind.SetAccessor: + const setterTypeAnnotation = getEffectiveSetAccessorTypeAnnotationNode(accessor); + return setterTypeAnnotation; + case SyntaxKind.PropertyDeclaration: + Debug.assert(hasAccessorModifier(accessor)); + const accessorTypeAnnotation = getEffectiveTypeAnnotationNode(accessor); + return accessorTypeAnnotation; } } return undefined; } - function getAnnotatedAccessorType(accessor: AccessorDeclaration | undefined): Type | undefined { + function getAnnotatedAccessorType(accessor: AccessorDeclaration | PropertyDeclaration | undefined): Type | undefined { const node = getAnnotatedAccessorTypeNode(accessor); return node && getTypeFromTypeNode(node); } @@ -9694,12 +9698,16 @@ namespace ts { } const getter = getDeclarationOfKind(symbol, SyntaxKind.GetAccessor); const setter = getDeclarationOfKind(symbol, SyntaxKind.SetAccessor); + const accessor = tryCast(getDeclarationOfKind(symbol, SyntaxKind.PropertyDeclaration), isAutoAccessorPropertyDeclaration); + // We try to resolve a getter type annotation, a setter type annotation, or a getter function // body return type inference, in that order. let type = getter && isInJSFile(getter) && getTypeForDeclarationFromJSDocComment(getter) || getAnnotatedAccessorType(getter) || getAnnotatedAccessorType(setter) || - getter && getter.body && getReturnTypeFromBody(getter); + getAnnotatedAccessorType(accessor) || + getter && getter.body && getReturnTypeFromBody(getter) || + accessor && accessor.initializer && getWidenedTypeForVariableLikeDeclaration(accessor, /*includeOptionality*/ true); if (!type) { if (setter && !isPrivateWithinAmbient(setter)) { errorOrSuggestion(noImplicitAny, setter, Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation, symbolToString(symbol)); @@ -9707,6 +9715,9 @@ namespace ts { else if (getter && !isPrivateWithinAmbient(getter)) { errorOrSuggestion(noImplicitAny, getter, Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation, symbolToString(symbol)); } + else if (accessor && !isPrivateWithinAmbient(accessor)) { + errorOrSuggestion(noImplicitAny, accessor, Diagnostics.Member_0_implicitly_has_an_1_type, symbolToString(symbol), "any"); + } type = anyType; } if (!popTypeResolution()) { @@ -9716,6 +9727,9 @@ namespace ts { else if (getAnnotatedAccessorTypeNode(setter)) { error(setter, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol)); } + else if (getAnnotatedAccessorTypeNode(accessor)) { + error(setter, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol)); + } else if (getter && noImplicitAny) { error(getter, Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol)); } @@ -9732,7 +9746,9 @@ namespace ts { if (!pushTypeResolution(symbol, TypeSystemPropertyName.WriteType)) { return errorType; } - const setter = getDeclarationOfKind(symbol, SyntaxKind.SetAccessor); + + const setter = getDeclarationOfKind(symbol, SyntaxKind.SetAccessor) + ?? tryCast(getDeclarationOfKind(symbol, SyntaxKind.PropertyDeclaration), isAutoAccessorPropertyDeclaration); let writeType = getAnnotatedAccessorType(setter); if (!popTypeResolution()) { if (getAnnotatedAccessorTypeNode(setter)) { @@ -10890,8 +10906,10 @@ namespace ts { const members = getMembersOfDeclaration(decl); if (members) { for (const member of members) { - if (isStatic === hasStaticModifier(member) && hasLateBindableName(member)) { - lateBindMember(symbol, earlySymbols, lateSymbols, member); + if (isStatic === hasStaticModifier(member)) { + if (hasLateBindableName(member)) { + lateBindMember(symbol, earlySymbols, lateSymbols, member); + } } } } @@ -10905,8 +10923,10 @@ namespace ts { || isBinaryExpression(member) && isPossiblyAliasedThisProperty(member, assignmentKind) || assignmentKind === AssignmentDeclarationKind.ObjectDefinePrototypeProperty || assignmentKind === AssignmentDeclarationKind.Prototype; // A straight `Prototype` assignment probably can never have a computed name - if (isStatic === !isInstanceMember && hasLateBindableName(member)) { - lateBindMember(symbol, earlySymbols, lateSymbols, member); + if (isStatic === !isInstanceMember) { + if (hasLateBindableName(member)) { + lateBindMember(symbol, earlySymbols, lateSymbols, member); + } } } } @@ -43572,6 +43592,9 @@ namespace ts { else if (flags & ModifierFlags.Readonly) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "override", "readonly"); } + else if (flags & ModifierFlags.Accessor) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "override", "accessor"); + } else if (flags & ModifierFlags.Async) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "override", "async"); } @@ -43593,6 +43616,9 @@ namespace ts { else if (flags & ModifierFlags.Static) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "static"); } + else if (flags & ModifierFlags.Accessor) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "accessor"); + } else if (flags & ModifierFlags.Readonly) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "readonly"); } @@ -43626,6 +43652,9 @@ namespace ts { else if (flags & ModifierFlags.Async) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "async"); } + else if (flags & ModifierFlags.Accessor) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "accessor"); + } else if (node.parent.kind === SyntaxKind.ModuleBlock || node.parent.kind === SyntaxKind.SourceFile) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, "static"); } @@ -43642,6 +43671,23 @@ namespace ts { lastStatic = modifier; break; + case SyntaxKind.AccessorKeyword: + if (flags & ModifierFlags.Accessor) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "accessor"); + } + else if (flags & ModifierFlags.Readonly) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "accessor", "readonly"); + } + else if (flags & ModifierFlags.Ambient) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "accessor", "declare"); + } + else if (node.kind !== SyntaxKind.PropertyDeclaration) { + return grammarErrorOnNode(modifier, Diagnostics.accessor_modifier_can_only_appear_on_a_property_declaration); + } + + flags |= ModifierFlags.Accessor; + break; + case SyntaxKind.ReadonlyKeyword: if (flags & ModifierFlags.Readonly) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "readonly"); @@ -43738,6 +43784,9 @@ namespace ts { if (flags & ModifierFlags.Override) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "abstract", "override"); } + if (flags & ModifierFlags.Accessor) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "abstract", "accessor"); + } } if (isNamedDeclaration(node) && node.name.kind === SyntaxKind.PrivateIdentifier) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "abstract"); @@ -44939,6 +44988,9 @@ namespace ts { if (languageVersion < ScriptTarget.ES2015 && isPrivateIdentifier(node.name)) { return grammarErrorOnNode(node.name, Diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher); } + if (languageVersion < ScriptTarget.ES2015 && hasAccessorModifier(node)) { + return grammarErrorOnNode(node.name, Diagnostics.Properties_with_the_accessor_modifier_are_only_available_when_targeting_ECMAScript_2015_and_higher); + } } else if (node.parent.kind === SyntaxKind.InterfaceDeclaration) { if (checkGrammarForInvalidDynamicName(node.name, Diagnostics.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) { diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index fc6f142c76ee4..4ccd0d1118b9b 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -899,6 +899,10 @@ "category": "Error", "code": 1274 }, + "'accessor' modifier can only appear on a property declaration.": { + "category": "Error", + "code": 1275 + }, "'with' statements are not allowed in an async function block.": { "category": "Error", @@ -7380,5 +7384,9 @@ "A 'return' statement cannot be used inside a class static block.": { "category": "Error", "code": 18041 + }, + "Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher.": { + "category": "Error", + "code": 18042 } } diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 6759e51ef1f29..876bb91c1bcbe 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -911,6 +911,10 @@ namespace ts { let nodeIdToGeneratedName: string[]; // Map of generated names for specific nodes. let autoGeneratedIdToGeneratedName: string[]; // Map of generated names for temp and loop variables. let generatedNames: Set; // Set of names generated by the NameGenerator. + let formattedNameTempFlagsStack: (ESMap | undefined)[]; + let formattedNameTempFlags: ESMap | undefined; + let privateNameTempFlagsStack: TempFlags[]; // Stack of enclosing name generation scopes. + let privateNameTempFlags: TempFlags; // TempFlags for the current name generation scope. let tempFlagsStack: TempFlags[]; // Stack of enclosing name generation scopes. let tempFlags: TempFlags; // TempFlags for the current name generation scope. let reservedNamesStack: Set[]; // Stack of TempFlags reserved in enclosing name generation scopes. @@ -1199,6 +1203,10 @@ namespace ts { nodeIdToGeneratedName = []; autoGeneratedIdToGeneratedName = []; generatedNames = new Set(); + formattedNameTempFlagsStack = []; + formattedNameTempFlags = new Map(); + privateNameTempFlagsStack = []; + privateNameTempFlags = TempFlags.Auto; tempFlagsStack = []; tempFlags = TempFlags.Auto; reservedNamesStack = []; @@ -4950,7 +4958,7 @@ namespace ts { } function getTextOfNode(node: Identifier | PrivateIdentifier | LiteralExpression, includeTrivia?: boolean): string { - if (isGeneratedIdentifier(node)) { + if (isGeneratedIdentifier(node) || isGeneratedPrivateIdentifier(node)) { return generateName(node); } if (isStringLiteral(node) && node.textSourceNode) { @@ -4975,7 +4983,7 @@ namespace ts { function getLiteralTextOfNode(node: LiteralLikeNode, neverAsciiEscape: boolean | undefined, jsxAttributeEscape: boolean): string { if (node.kind === SyntaxKind.StringLiteral && (node as StringLiteral).textSourceNode) { const textSourceNode = (node as StringLiteral).textSourceNode!; - if (isIdentifier(textSourceNode) || isNumericLiteral(textSourceNode)) { + if (isIdentifier(textSourceNode) || isPrivateIdentifier(textSourceNode) || isNumericLiteral(textSourceNode)) { const text = isNumericLiteral(textSourceNode) ? textSourceNode.text : getTextOfNode(textSourceNode); return jsxAttributeEscape ? `"${escapeJsxAttributeString(text)}"` : neverAsciiEscape || (getEmitFlags(node) & EmitFlags.NoAsciiEscaping) ? `"${escapeString(text)}"` : @@ -5002,7 +5010,11 @@ namespace ts { return; } tempFlagsStack.push(tempFlags); - tempFlags = 0; + tempFlags = TempFlags.Auto; + privateNameTempFlagsStack.push(privateNameTempFlags); + privateNameTempFlags = TempFlags.Auto; + formattedNameTempFlagsStack.push(formattedNameTempFlags); + formattedNameTempFlags = undefined; reservedNamesStack.push(reservedNames); } @@ -5014,6 +5026,8 @@ namespace ts { return; } tempFlags = tempFlagsStack.pop()!; + privateNameTempFlags = privateNameTempFlagsStack.pop()!; + formattedNameTempFlags = formattedNameTempFlagsStack.pop(); reservedNames = reservedNamesStack.pop()!; } @@ -5126,7 +5140,7 @@ namespace ts { function generateNameIfNeeded(name: DeclarationName | undefined) { if (name) { - if (isGeneratedIdentifier(name)) { + if (isGeneratedIdentifier(name) || isGeneratedPrivateIdentifier(name)) { generateName(name); } else if (isBindingPattern(name)) { @@ -5138,11 +5152,11 @@ namespace ts { /** * Generate the text for a generated identifier. */ - function generateName(name: GeneratedIdentifier) { + function generateName(name: GeneratedIdentifier | GeneratedPrivateIdentifier) { if ((name.autoGenerateFlags & GeneratedIdentifierFlags.KindMask) === GeneratedIdentifierFlags.Node) { // Node names generate unique names based on their original node // and are cached based on that node's id. - return generateNameCached(getNodeForGeneratedName(name), name.autoGenerateFlags); + return generateNameCached(getNodeForGeneratedName(name), isPrivateIdentifier(name), name.autoGenerateFlags, name.autoGeneratePrefix, name.autoGenerateSuffix); } else { // Auto, Loop, and Unique names are cached based on their unique @@ -5152,9 +5166,9 @@ namespace ts { } } - function generateNameCached(node: Node, flags?: GeneratedIdentifierFlags) { + function generateNameCached(node: Node, privateName: boolean, flags?: GeneratedIdentifierFlags, prefix?: string | GeneratedNamePart, suffix?: string) { const nodeId = getNodeId(node); - return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = generateNameForNode(node, flags)); + return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = generateNameForNode(node, privateName, flags ?? GeneratedIdentifierFlags.None, formatGeneratedNamePart(prefix, generateName), formatGeneratedNamePart(suffix))); } /** @@ -5190,22 +5204,59 @@ namespace ts { return true; } + function getTempFlags(formattedNameKey: string) { + switch (formattedNameKey) { + case "": + return tempFlags; + case "#": + return privateNameTempFlags; + default: + return formattedNameTempFlags?.get(formattedNameKey) ?? TempFlags.Auto; + } + } + + function setTempFlags(formattedNameKey: string, flags: TempFlags) { + switch (formattedNameKey) { + case "": + tempFlags = flags; + break; + case "#": + privateNameTempFlags = flags; + break; + default: + formattedNameTempFlags ??= new Map(); + formattedNameTempFlags.set(formattedNameKey, flags); + break; + } + } + /** * Return the next available name in the pattern _a ... _z, _0, _1, ... * TempFlags._i or TempFlags._n may be used to express a preference for that dedicated name. * Note that names generated by makeTempVariableName and makeUniqueName will never conflict. */ - function makeTempVariableName(flags: TempFlags, reservedInNestedScopes?: boolean): string { + function makeTempVariableName(flags: TempFlags, reservedInNestedScopes: boolean, privateName: boolean, prefix: string, suffix: string): string { + if (prefix.length > 0 && prefix.charCodeAt(0) === CharacterCodes.hash) { + prefix = prefix.slice(1); + } + + // Generate a key to use to acquire a TempFlags counter based on the fixed portions of the generated name. + const key = formatGeneratedName(privateName, prefix, "", suffix); + let tempFlags = getTempFlags(key); + if (flags && !(tempFlags & flags)) { const name = flags === TempFlags._i ? "_i" : "_n"; - if (isUniqueName(name)) { + const fullName = formatGeneratedName(privateName, prefix, name, suffix); + if (isUniqueName(fullName)) { tempFlags |= flags; if (reservedInNestedScopes) { - reserveNameInNestedScopes(name); + reserveNameInNestedScopes(fullName); } - return name; + setTempFlags(key, tempFlags); + return fullName; } } + while (true) { const count = tempFlags & TempFlags.CountMask; tempFlags++; @@ -5214,11 +5265,13 @@ namespace ts { const name = count < 26 ? "_" + String.fromCharCode(CharacterCodes.a + count) : "_" + (count - 26); - if (isUniqueName(name)) { + const fullName = formatGeneratedName(privateName, prefix, name, suffix); + if (isUniqueName(fullName)) { if (reservedInNestedScopes) { - reserveNameInNestedScopes(name); + reserveNameInNestedScopes(fullName); } - return name; + setTempFlags(key, tempFlags); + return fullName; } } } @@ -5231,16 +5284,23 @@ namespace ts { * makeUniqueName are guaranteed to never conflict. * If `optimistic` is set, the first instance will use 'baseName' verbatim instead of 'baseName_1' */ - function makeUniqueName(baseName: string, checkFn: (name: string) => boolean = isUniqueName, optimistic?: boolean, scoped?: boolean): string { + function makeUniqueName(baseName: string, checkFn: (name: string) => boolean = isUniqueName, optimistic: boolean, scoped: boolean, privateName: boolean, prefix: string, suffix: string): string { + if (baseName.length > 0 && baseName.charCodeAt(0) === CharacterCodes.hash) { + baseName = baseName.slice(1); + } + if (prefix.length > 0 && prefix.charCodeAt(0) === CharacterCodes.hash) { + prefix = prefix.slice(1); + } if (optimistic) { - if (checkFn(baseName)) { + const fullName = formatGeneratedName(privateName, prefix, baseName, suffix); + if (checkFn(fullName)) { if (scoped) { - reserveNameInNestedScopes(baseName); + reserveNameInNestedScopes(fullName); } else { - generatedNames.add(baseName); + generatedNames.add(fullName); } - return baseName; + return fullName; } } // Find the first unique 'name_n', where n is a positive number @@ -5249,22 +5309,22 @@ namespace ts { } let i = 1; while (true) { - const generatedName = baseName + i; - if (checkFn(generatedName)) { + const fullName = formatGeneratedName(privateName, prefix, baseName + i, suffix); + if (checkFn(fullName)) { if (scoped) { - reserveNameInNestedScopes(generatedName); + reserveNameInNestedScopes(fullName); } else { - generatedNames.add(generatedName); + generatedNames.add(fullName); } - return generatedName; + return fullName; } i++; } } function makeFileLevelOptimisticUniqueName(name: string) { - return makeUniqueName(name, isFileLevelUniqueName, /*optimistic*/ true); + return makeUniqueName(name, isFileLevelUniqueName, /*optimistic*/ true, /*scoped*/ false, /*privateName*/ false, /*prefix*/ "", /*suffix*/ ""); } /** @@ -5273,7 +5333,7 @@ namespace ts { function generateNameForModuleOrEnum(node: ModuleDeclaration | EnumDeclaration) { const name = getTextOfNode(node.name); // Use module/enum name itself if it is unique, otherwise make a unique variation - return isUniqueLocalName(name, node) ? name : makeUniqueName(name); + return isUniqueLocalName(name, node) ? name : makeUniqueName(name, isUniqueName, /*optimistic*/ false, /*scoped*/ false, /*privateName*/ false, /*prefix*/ "", /*suffix*/ ""); } /** @@ -5283,109 +5343,98 @@ namespace ts { const expr = getExternalModuleName(node)!; // TODO: GH#18217 const baseName = isStringLiteral(expr) ? makeIdentifierFromModuleName(expr.text) : "module"; - return makeUniqueName(baseName); + return makeUniqueName(baseName, isUniqueName, /*optimistic*/ false, /*scoped*/ false, /*privateName*/ false, /*prefix*/ "", /*suffix*/ ""); } /** * Generates a unique name for a default export. */ function generateNameForExportDefault() { - return makeUniqueName("default"); + return makeUniqueName("default", isUniqueName, /*optimistic*/ false, /*scoped*/ false, /*privateName*/ false, /*prefix*/ "", /*suffix*/ ""); } /** * Generates a unique name for a class expression. */ function generateNameForClassExpression() { - return makeUniqueName("class"); + return makeUniqueName("class", isUniqueName, /*optimistic*/ false, /*scoped*/ false, /*privateName*/ false, /*prefix*/ "", /*suffix*/ ""); } - function generateNameForMethodOrAccessor(node: MethodDeclaration | AccessorDeclaration) { + function generateNameForMethodOrAccessor(node: MethodDeclaration | AccessorDeclaration, privateName: boolean, prefix: string, suffix: string) { if (isIdentifier(node.name)) { - return generateNameCached(node.name); + return generateNameCached(node.name, privateName); } - return makeTempVariableName(TempFlags.Auto); + return makeTempVariableName(TempFlags.Auto, /*reservedInNestedScopes*/ false, privateName, prefix, suffix); } /** * Generates a unique name from a node. */ - function generateNameForNode(node: Node, flags?: GeneratedIdentifierFlags): string { + function generateNameForNode(node: Node, privateName: boolean, flags: GeneratedIdentifierFlags, prefix: string, suffix: string): string { switch (node.kind) { case SyntaxKind.Identifier: + case SyntaxKind.PrivateIdentifier: return makeUniqueName( getTextOfNode(node as Identifier), isUniqueName, - !!(flags! & GeneratedIdentifierFlags.Optimistic), - !!(flags! & GeneratedIdentifierFlags.ReservedInNestedScopes) + !!(flags & GeneratedIdentifierFlags.Optimistic), + !!(flags & GeneratedIdentifierFlags.ReservedInNestedScopes), + privateName, + prefix, + suffix ); case SyntaxKind.ModuleDeclaration: case SyntaxKind.EnumDeclaration: + Debug.assert(!prefix && !suffix && !privateName); return generateNameForModuleOrEnum(node as ModuleDeclaration | EnumDeclaration); case SyntaxKind.ImportDeclaration: case SyntaxKind.ExportDeclaration: + Debug.assert(!prefix && !suffix && !privateName); return generateNameForImportOrExportDeclaration(node as ImportDeclaration | ExportDeclaration); case SyntaxKind.FunctionDeclaration: case SyntaxKind.ClassDeclaration: case SyntaxKind.ExportAssignment: + Debug.assert(!prefix && !suffix && !privateName); return generateNameForExportDefault(); case SyntaxKind.ClassExpression: + Debug.assert(!prefix && !suffix && !privateName); return generateNameForClassExpression(); case SyntaxKind.MethodDeclaration: case SyntaxKind.GetAccessor: case SyntaxKind.SetAccessor: - return generateNameForMethodOrAccessor(node as MethodDeclaration | AccessorDeclaration); + return generateNameForMethodOrAccessor(node as MethodDeclaration | AccessorDeclaration, privateName, prefix, suffix); case SyntaxKind.ComputedPropertyName: - return makeTempVariableName(TempFlags.Auto, /*reserveInNestedScopes*/ true); + return makeTempVariableName(TempFlags.Auto, /*reserveInNestedScopes*/ true, privateName, prefix, suffix); default: - return makeTempVariableName(TempFlags.Auto); + return makeTempVariableName(TempFlags.Auto, /*reserveInNestedScopes*/ false, privateName, prefix, suffix); } } /** * Generates a unique identifier for a node. */ - function makeName(name: GeneratedIdentifier) { + function makeName(name: GeneratedIdentifier | GeneratedPrivateIdentifier) { + const prefix = formatGeneratedNamePart(name.autoGeneratePrefix, generateName); + const suffix = formatGeneratedNamePart (name.autoGenerateSuffix); switch (name.autoGenerateFlags & GeneratedIdentifierFlags.KindMask) { case GeneratedIdentifierFlags.Auto: - return makeTempVariableName(TempFlags.Auto, !!(name.autoGenerateFlags & GeneratedIdentifierFlags.ReservedInNestedScopes)); + return makeTempVariableName(TempFlags.Auto, !!(name.autoGenerateFlags & GeneratedIdentifierFlags.ReservedInNestedScopes), isPrivateIdentifier(name), prefix, suffix); case GeneratedIdentifierFlags.Loop: - return makeTempVariableName(TempFlags._i, !!(name.autoGenerateFlags & GeneratedIdentifierFlags.ReservedInNestedScopes)); + Debug.assertNode(name, isIdentifier); + return makeTempVariableName(TempFlags._i, !!(name.autoGenerateFlags & GeneratedIdentifierFlags.ReservedInNestedScopes), /*privateName*/ false, prefix, suffix); case GeneratedIdentifierFlags.Unique: return makeUniqueName( idText(name), (name.autoGenerateFlags & GeneratedIdentifierFlags.FileLevel) ? isFileLevelUniqueName : isUniqueName, !!(name.autoGenerateFlags & GeneratedIdentifierFlags.Optimistic), - !!(name.autoGenerateFlags & GeneratedIdentifierFlags.ReservedInNestedScopes) + !!(name.autoGenerateFlags & GeneratedIdentifierFlags.ReservedInNestedScopes), + isPrivateIdentifier(name), + prefix, + suffix ); } - return Debug.fail("Unsupported GeneratedIdentifierKind."); - } - - /** - * Gets the node from which a name should be generated. - */ - function getNodeForGeneratedName(name: GeneratedIdentifier) { - const autoGenerateId = name.autoGenerateId; - let node = name as Node; - let original = node.original; - while (original) { - node = original; - - // if "node" is a different generated name (having a different - // "autoGenerateId"), use it and stop traversing. - if (isIdentifier(node) - && !!(node.autoGenerateFlags! & GeneratedIdentifierFlags.Node) - && node.autoGenerateId !== autoGenerateId) { - break; - } - - original = node.original; - } - - // otherwise, return the original node for the source; - return node; + return Debug.fail(`Unsupported GeneratedIdentifierKind: ${Debug.formatEnum(name.autoGenerateFlags & GeneratedIdentifierFlags.KindMask, (ts as any).GeneratedIdentifierFlags, /*isFlags*/ true)}.`); } // Comments diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts index 76a8c405d722b..93edb4f760466 100644 --- a/src/compiler/factory/nodeFactory.ts +++ b/src/compiler/factory/nodeFactory.ts @@ -60,6 +60,8 @@ namespace ts { createUniqueName, getGeneratedNameForNode, createPrivateIdentifier, + createUniquePrivateName, + getGeneratedPrivateNameForNode, createToken, createSuper, createThis, @@ -817,7 +819,7 @@ namespace ts { } // @api - function createStringLiteralFromNode(sourceNode: PropertyNameLiteral): StringLiteral { + function createStringLiteralFromNode(sourceNode: PropertyNameLiteral | PrivateIdentifier): StringLiteral { const node = createBaseStringLiteral(getTextOfIdentifierOrLiteral(sourceNode), /*isSingleQuote*/ undefined); node.textSourceNode = sourceNode; return node; @@ -859,10 +861,12 @@ namespace ts { return node; } - function createBaseGeneratedIdentifier(text: string, autoGenerateFlags: GeneratedIdentifierFlags) { + function createBaseGeneratedIdentifier(text: string, autoGenerateFlags: GeneratedIdentifierFlags, prefix: string | GeneratedNamePart | undefined, suffix: string | undefined) { const node = createBaseIdentifier(text, /*originalKeywordKind*/ undefined) as Mutable; node.autoGenerateFlags = autoGenerateFlags; node.autoGenerateId = nextAutoGenerateId; + node.autoGeneratePrefix = prefix; + node.autoGenerateSuffix = suffix; nextAutoGenerateId++; return node; } @@ -888,10 +892,10 @@ namespace ts { } // @api - function createTempVariable(recordTempVariable: ((node: Identifier) => void) | undefined, reservedInNestedScopes?: boolean): GeneratedIdentifier { + function createTempVariable(recordTempVariable: ((node: Identifier) => void) | undefined, reservedInNestedScopes?: boolean, prefix?: string | GeneratedNamePart, suffix?: string): GeneratedIdentifier { let flags = GeneratedIdentifierFlags.Auto; if (reservedInNestedScopes) flags |= GeneratedIdentifierFlags.ReservedInNestedScopes; - const name = createBaseGeneratedIdentifier("", flags); + const name = createBaseGeneratedIdentifier("", flags, prefix, suffix); if (recordTempVariable) { recordTempVariable(name); } @@ -903,35 +907,72 @@ namespace ts { function createLoopVariable(reservedInNestedScopes?: boolean): Identifier { let flags = GeneratedIdentifierFlags.Loop; if (reservedInNestedScopes) flags |= GeneratedIdentifierFlags.ReservedInNestedScopes; - return createBaseGeneratedIdentifier("", flags); + return createBaseGeneratedIdentifier("", flags, /*prefix*/ undefined, /*suffix*/ undefined); } /** Create a unique name based on the supplied text. */ // @api - function createUniqueName(text: string, flags: GeneratedIdentifierFlags = GeneratedIdentifierFlags.None): Identifier { + function createUniqueName(text: string, flags: GeneratedIdentifierFlags = GeneratedIdentifierFlags.None, prefix?: string | GeneratedNamePart, suffix?: string): Identifier { Debug.assert(!(flags & GeneratedIdentifierFlags.KindMask), "Argument out of range: flags"); Debug.assert((flags & (GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel)) !== GeneratedIdentifierFlags.FileLevel, "GeneratedIdentifierFlags.FileLevel cannot be set without also setting GeneratedIdentifierFlags.Optimistic"); - return createBaseGeneratedIdentifier(text, GeneratedIdentifierFlags.Unique | flags); + return createBaseGeneratedIdentifier(text, GeneratedIdentifierFlags.Unique | flags, prefix, suffix); } /** Create a unique name generated for a node. */ // @api - function getGeneratedNameForNode(node: Node | undefined, flags: GeneratedIdentifierFlags = 0): Identifier { + function getGeneratedNameForNode(node: Node | undefined, flags: GeneratedIdentifierFlags = 0, prefix?: string | GeneratedNamePart, suffix?: string): Identifier { Debug.assert(!(flags & GeneratedIdentifierFlags.KindMask), "Argument out of range: flags"); - const name = createBaseGeneratedIdentifier(node && isIdentifier(node) ? idText(node) : "", GeneratedIdentifierFlags.Node | flags); + const text = !node ? "" : + isMemberName(node) ? formatGeneratedName(/*privateName*/ false, prefix, node, suffix, idText) : + `generated@${getNodeId(node)}`; + if (prefix || suffix) flags |= GeneratedIdentifierFlags.Optimistic; + const name = createBaseGeneratedIdentifier(text, GeneratedIdentifierFlags.Node | flags, prefix, suffix); name.original = node; return name; } - // @api - function createPrivateIdentifier(text: string): PrivateIdentifier { - if (!startsWith(text, "#")) Debug.fail("First character of private identifier must be #: " + text); + function createBasePrivateIdentifier(text: string) { const node = baseFactory.createBasePrivateIdentifierNode(SyntaxKind.PrivateIdentifier) as Mutable; node.escapedText = escapeLeadingUnderscores(text); node.transformFlags |= TransformFlags.ContainsClassFields; return node; } + // @api + function createPrivateIdentifier(text: string): PrivateIdentifier { + if (!startsWith(text, "#")) Debug.fail("First character of private identifier must be #: " + text); + return createBasePrivateIdentifier(text); + } + + function createBaseGeneratedPrivateIdentifier(text: string, autoGenerateFlags: GeneratedIdentifierFlags, prefix: string | GeneratedNamePart | undefined, suffix: string | undefined) { + const node = createBasePrivateIdentifier(text); + node.autoGenerateFlags = autoGenerateFlags; + node.autoGenerateId = nextAutoGenerateId; + node.autoGeneratePrefix = prefix; + node.autoGenerateSuffix = suffix; + nextAutoGenerateId++; + return node; + } + + /** Create a unique name based on the supplied text. */ + // @api + function createUniquePrivateName(text?: string, prefix?: string | GeneratedNamePart, suffix?: string): PrivateIdentifier { + if (text && !startsWith(text, "#")) Debug.fail("First character of private identifier must be #: " + text); + const autoGenerateFlags = GeneratedIdentifierFlags.ReservedInNestedScopes | + (text ? GeneratedIdentifierFlags.Unique : GeneratedIdentifierFlags.Auto); + return createBaseGeneratedPrivateIdentifier(text ?? "", autoGenerateFlags, prefix, suffix); + } + + // @api + function getGeneratedPrivateNameForNode(node: Node, prefix?: string | GeneratedNamePart, suffix?: string): PrivateIdentifier { + const text = isMemberName(node) ? formatGeneratedName(/*privateName*/ true, prefix, node, suffix, idText) : + `#generated@${getNodeId(node)}`; + const flags = prefix || suffix ? GeneratedIdentifierFlags.Optimistic : GeneratedIdentifierFlags.None; + const name = createBaseGeneratedPrivateIdentifier(text, GeneratedIdentifierFlags.Node | flags, prefix, suffix); + name.original = node; + return name; + } + // // Punctuation // @@ -996,6 +1037,9 @@ namespace ts { case SyntaxKind.StaticKeyword: transformFlags = TransformFlags.ContainsES2015; break; + case SyntaxKind.AccessorKeyword: + transformFlags = TransformFlags.ContainsDecorators; + break; case SyntaxKind.ThisKeyword: // 'this' indicates a lexical 'this' transformFlags = TransformFlags.ContainsLexicalThis; @@ -1056,6 +1100,7 @@ namespace ts { if (flags & ModifierFlags.Private) result.push(createModifier(SyntaxKind.PrivateKeyword)); if (flags & ModifierFlags.Protected) result.push(createModifier(SyntaxKind.ProtectedKeyword)); if (flags & ModifierFlags.Abstract) result.push(createModifier(SyntaxKind.AbstractKeyword)); + if (flags & ModifierFlags.Accessor) result.push(createModifier(SyntaxKind.AccessorKeyword)); if (flags & ModifierFlags.Static) result.push(createModifier(SyntaxKind.StaticKeyword)); if (flags & ModifierFlags.Override) result.push(createModifier(SyntaxKind.OverrideKeyword)); if (flags & ModifierFlags.Readonly) result.push(createModifier(SyntaxKind.ReadonlyKeyword)); diff --git a/src/compiler/factory/nodeTests.ts b/src/compiler/factory/nodeTests.ts index 903dea149a191..88fcd65b079d8 100644 --- a/src/compiler/factory/nodeTests.ts +++ b/src/compiler/factory/nodeTests.ts @@ -139,6 +139,11 @@ namespace ts { return node.kind === SyntaxKind.OverrideKeyword; } + /* @internal */ + export function isAccessorModifier(node: Node): node is AccessorKeyword { + return node.kind === SyntaxKind.AccessorKeyword; + } + /*@internal*/ export function isSuperKeyword(node: Node): node is SuperExpression { return node.kind === SyntaxKind.SuperKeyword; diff --git a/src/compiler/factory/parenthesizerRules.ts b/src/compiler/factory/parenthesizerRules.ts index c824c13fd1629..cdf26077cdf8a 100644 --- a/src/compiler/factory/parenthesizerRules.ts +++ b/src/compiler/factory/parenthesizerRules.ts @@ -177,13 +177,15 @@ namespace ts { // (a|b)|c -> a|(b|c) -> a|b|c // (a&b)&c -> a&(b&c) -> a&b&c // (a^b)^c -> a^(b^c) -> a^b^c + // (a,b),c -> a,(b,c) -> a,b,c // // While addition is associative in mathematics, JavaScript's `+` is not // guaranteed to be associative as it is overloaded with string concatenation. return binaryOperator === SyntaxKind.AsteriskToken || binaryOperator === SyntaxKind.BarToken || binaryOperator === SyntaxKind.AmpersandToken - || binaryOperator === SyntaxKind.CaretToken; + || binaryOperator === SyntaxKind.CaretToken + || binaryOperator === SyntaxKind.CommaToken; } /** diff --git a/src/compiler/factory/utilities.ts b/src/compiler/factory/utilities.ts index 9a02483f07dc1..adb5821a9ad08 100644 --- a/src/compiler/factory/utilities.ts +++ b/src/compiler/factory/utilities.ts @@ -1283,4 +1283,141 @@ namespace ts { if (nodes.length === 0) return nodes; return setTextRange(factory.createNodeArray([], nodes.hasTrailingComma), nodes); } + + /** + * Gets the node from which a name should be generated. + */ + export function getNodeForGeneratedName(name: GeneratedIdentifier | GeneratedPrivateIdentifier) { + if (name.autoGenerateFlags & GeneratedIdentifierFlags.Node) { + const autoGenerateId = name.autoGenerateId; + let node = name as Node; + let original = node.original; + while (original) { + node = original; + + // if "node" is a different generated name (having a different "autoGenerateId"), use it and stop traversing. + if (isMemberName(node) + && !!(node.autoGenerateFlags! & GeneratedIdentifierFlags.Node) + && node.autoGenerateId !== autoGenerateId) { + break; + } + + original = node.original; + } + // otherwise, return the original node for the source + return node; + } + return name; + } + + /** + * Formats a prefix or suffix of a generated name. + */ + export function formatGeneratedNamePart(part: string | undefined): string; + /** + * Formats a prefix or suffix of a generated name. If the part is a {@link GeneratedNamePart}, calls {@link generateName} to format the source node. + */ + export function formatGeneratedNamePart(part: string | GeneratedNamePart | undefined, generateName: (name: GeneratedIdentifier | GeneratedPrivateIdentifier) => string): string; + export function formatGeneratedNamePart(part: string | GeneratedNamePart | undefined, generateName?: (name: GeneratedIdentifier | GeneratedPrivateIdentifier) => string): string { + return typeof part === "object" ? formatGeneratedName(/*privateName*/ false, part.prefix, part.node, part.suffix, generateName!) : + typeof part === "string" ? part.length > 0 && part.charCodeAt(0) === CharacterCodes.hash ? part.slice(1) : part : + ""; + } + + function formatIdentifier(name: string | Identifier | PrivateIdentifier, generateName?: (name: GeneratedIdentifier | GeneratedPrivateIdentifier) => string) { + return typeof name === "string" ? name : + formatIdentifierWorker(name, Debug.checkDefined(generateName)); + } + + function formatIdentifierWorker(node: Identifier | PrivateIdentifier, generateName: (name: GeneratedIdentifier | GeneratedPrivateIdentifier) => string) { + return isGeneratedPrivateIdentifier(node) ? generateName(node).slice(1) : + isGeneratedIdentifier(node) ? generateName(node) : + isPrivateIdentifier(node) ? (node.escapedText as string).slice(1) : + idText(node); + } + + /** + * Formats a generated name. + * @param privateName When `true`, inserts a `#` character at the start of the result. + * @param prefix The prefix (if any) to include before the base name. + * @param baseName The base name for the generated name. + * @param suffix The suffix (if any) to include after the base name. + */ + export function formatGeneratedName(privateName: boolean, prefix: string | undefined, baseName: string, suffix: string | undefined): string; + /** + * Formats a generated name. + * @param privateName When `true`, inserts a `#` character at the start of the result. + * @param prefix The prefix (if any) to include before the base name. + * @param baseName The base name for the generated name. + * @param suffix The suffix (if any) to include after the base name. + * @param generateName Called to format the source node of {@link prefix} when it is a {@link GeneratedNamePart}. + */ + export function formatGeneratedName(privateName: boolean, prefix: string | GeneratedNamePart | undefined, baseName: string | Identifier | PrivateIdentifier, suffix: string | GeneratedNamePart | undefined, generateName: (name: GeneratedIdentifier | GeneratedPrivateIdentifier) => string): string; + export function formatGeneratedName(privateName: boolean, prefix: string | GeneratedNamePart | undefined, baseName: string | Identifier | PrivateIdentifier, suffix: string | GeneratedNamePart | undefined, generateName?: (name: GeneratedIdentifier | GeneratedPrivateIdentifier) => string) { + prefix = formatGeneratedNamePart(prefix, generateName!); + suffix = formatGeneratedNamePart(suffix, generateName!); + baseName = formatIdentifier(baseName, generateName); + return `${privateName ? "#" : ""}${prefix}${baseName}${suffix}`; + } + + + /** + * Creates a private backing field for an `accesor` {@link PropertyDeclaration}. + */ + export function createAccessorPropertyBackingField(factory: NodeFactory, node: PropertyDeclaration, modifiers: ModifiersArray | undefined, initializer: Expression | undefined) { + return factory.updatePropertyDeclaration( + node, + modifiers, + factory.getGeneratedPrivateNameForNode(node.name, /*prefix*/ undefined, "_accessor_storage"), + /*questionOrExclamationToken*/ undefined, + /*type*/ undefined, + initializer + ); + } + + /** + * Creates a {@link GetAccessorDeclaration} that reads from a private backing field. + */ + export function createAccessorPropertyGetRedirector(factory: NodeFactory, node: PropertyDeclaration, modifiers: ModifiersArray | undefined, name: PropertyName) { + return factory.createGetAccessorDeclaration( + modifiers, + name, + [], + /*type*/ undefined, + factory.createBlock([ + factory.createReturnStatement( + factory.createPropertyAccessExpression( + factory.createThis(), + factory.getGeneratedPrivateNameForNode(node.name, /*prefix*/ undefined, "_accessor_storage") + ) + ) + ]) + ); + } + + /** + * Creates a {@link SetAccessorDeclaration} that writes to a private backing field. + */ + export function createAccessorPropertySetRedirector(factory: NodeFactory, node: PropertyDeclaration, modifiers: ModifiersArray | undefined, name: PropertyName) { + return factory.createSetAccessorDeclaration( + modifiers, + name, + [factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotdotDotToken*/ undefined, + "value" + )], + factory.createBlock([ + factory.createExpressionStatement( + factory.createAssignment( + factory.createPropertyAccessExpression( + factory.createThis(), + factory.getGeneratedPrivateNameForNode(node.name, /*prefix*/ undefined, "_accessor_storage") + ), + factory.createIdentifier("value") + ) + ) + ]) + ); + } } diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 76e2fe0e351f7..70fb8e90819b3 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -2132,6 +2132,7 @@ namespace ts { return canFollowExportModifier(); case SyntaxKind.DefaultKeyword: return nextTokenCanFollowDefaultKeyword(); + case SyntaxKind.AccessorKeyword: case SyntaxKind.StaticKeyword: case SyntaxKind.GetKeyword: case SyntaxKind.SetKeyword: @@ -6388,6 +6389,7 @@ namespace ts { case SyntaxKind.NamespaceKeyword: return nextTokenIsIdentifierOrStringLiteralOnSameLine(); case SyntaxKind.AbstractKeyword: + case SyntaxKind.AccessorKeyword: case SyntaxKind.AsyncKeyword: case SyntaxKind.DeclareKeyword: case SyntaxKind.PrivateKeyword: @@ -6480,6 +6482,7 @@ namespace ts { // When these don't start a declaration, they're an identifier in an expression statement return true; + case SyntaxKind.AccessorKeyword: case SyntaxKind.PublicKeyword: case SyntaxKind.PrivateKeyword: case SyntaxKind.ProtectedKeyword: @@ -6566,6 +6569,7 @@ namespace ts { case SyntaxKind.ProtectedKeyword: case SyntaxKind.PublicKeyword: case SyntaxKind.AbstractKeyword: + case SyntaxKind.AccessorKeyword: case SyntaxKind.StaticKeyword: case SyntaxKind.ReadonlyKeyword: case SyntaxKind.GlobalKeyword: diff --git a/src/compiler/program.ts b/src/compiler/program.ts index 04aa9a3c782b0..716bebbe7dbf4 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -2391,7 +2391,9 @@ namespace ts { // Check modifiers of property declaration if (nodes === (parent as PropertyDeclaration).modifiers) { for (const modifier of nodes as NodeArray) { - if (isModifier(modifier) && modifier.kind !== SyntaxKind.StaticKeyword) { + if (isModifier(modifier) + && modifier.kind !== SyntaxKind.StaticKeyword + && modifier.kind !== SyntaxKind.AccessorKeyword) { diagnostics.push(createDiagnosticForNode(modifier, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, tokenToString(modifier.kind))); } } @@ -2445,6 +2447,7 @@ namespace ts { case SyntaxKind.StaticKeyword: case SyntaxKind.ExportKeyword: case SyntaxKind.DefaultKeyword: + case SyntaxKind.AccessorKeyword: } } } diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index 107ff3a143efa..7212b4d445f39 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -80,6 +80,7 @@ namespace ts { /** @internal */ export const textToKeywordObj: MapLike = { abstract: SyntaxKind.AbstractKeyword, + accessor: SyntaxKind.AccessorKeyword, any: SyntaxKind.AnyKeyword, as: SyntaxKind.AsKeyword, asserts: SyntaxKind.AssertsKeyword, diff --git a/src/compiler/transformers/classFields.ts b/src/compiler/transformers/classFields.ts index 7e9f7639264dd..77c491c8be0d2 100644 --- a/src/compiler/transformers/classFields.ts +++ b/src/compiler/transformers/classFields.ts @@ -12,11 +12,13 @@ namespace ts { */ ClassStaticThisOrSuperReference = 1 << 1, } + export const enum PrivateIdentifierKind { Field = "f", Method = "m", Accessor = "a" } + interface PrivateIdentifierInfoBase { /** * brandCheckIdentifier can contain: @@ -35,6 +37,7 @@ namespace ts { */ isValid: boolean; } + interface PrivateIdentifierAccessorInfo extends PrivateIdentifierInfoBase { kind: PrivateIdentifierKind.Accessor; /** @@ -46,6 +49,7 @@ namespace ts { */ setterName?: Identifier; } + interface PrivateIdentifierMethodInfo extends PrivateIdentifierInfoBase { kind: PrivateIdentifierKind.Method; /** @@ -53,6 +57,7 @@ namespace ts { */ methodName: Identifier; } + interface PrivateIdentifierInstanceFieldInfo extends PrivateIdentifierInfoBase { kind: PrivateIdentifierKind.Field; isStatic: false; @@ -61,11 +66,12 @@ namespace ts { */ variableName: undefined; } + interface PrivateIdentifierStaticFieldInfo extends PrivateIdentifierInfoBase { kind: PrivateIdentifierKind.Field; isStatic: true; /** - * Contains the variable that will server as the storage for the field. + * Contains the variable that will serve as the storage for the field. */ variableName: Identifier; } @@ -80,7 +86,7 @@ namespace ts { /** * Used for prefixing generated variable names. */ - className: string; + className?: Identifier; /** * Used for brand check on private methods. */ @@ -88,7 +94,11 @@ namespace ts { /** * A mapping of private names to information needed for transformation. */ - identifiers: UnderscoreEscapedMap + identifiers?: UnderscoreEscapedMap; + /** + * A mapping of generated private names to information needed for transformation. + */ + generatedIdentifiers?: ESMap; } interface ClassLexicalEnvironment { @@ -133,6 +143,14 @@ namespace ts { const languageVersion = getEmitScriptTarget(compilerOptions); const useDefineForClassFields = getUseDefineForClassFields(compilerOptions); + // We need to transform class field initializers when not using Define, or when using + // Define and targeting < ES2022. + const shouldTransformInitializers = !useDefineForClassFields || languageVersion < ScriptTarget.ES2022; + + // We need to transform `accessor` fields when targeting < ESNext + const shouldTransformAutoAccessors = languageVersion < ScriptTarget.ESNext; + + // We need to transform private members and class static blocks when targeting < ES2022. const shouldTransformPrivateElementsOrClassStaticBlocks = languageVersion < ScriptTarget.ES2022; // We need to transform `this` in a static initializer into a reference to the class @@ -143,6 +161,8 @@ namespace ts { // the es2015 transformation handles those. const shouldTransformSuperInStaticInitializers = shouldTransformThisInStaticInitializers && languageVersion >= ScriptTarget.ES2015; + const shouldTransformAnything = shouldTransformInitializers || shouldTransformAutoAccessors; + const previousOnSubstituteNode = context.onSubstituteNode; context.onSubstituteNode = onSubstituteNode; const previousOnEmitNode = context.onEmitNode; @@ -166,6 +186,7 @@ namespace ts { const classLexicalEnvironmentStack: (ClassLexicalEnvironment | undefined)[] = []; const classLexicalEnvironmentMap = new Map(); + let currentClassLexicalEnvironment: ClassLexicalEnvironment | undefined; let currentComputedPropertyNameClassLexicalEnvironment: ClassLexicalEnvironment | undefined; let currentStaticPropertyDeclarationOrStaticBlock: PropertyDeclaration | ClassStaticBlockDeclaration | undefined; @@ -173,78 +194,98 @@ namespace ts { return chainBundle(context, transformSourceFile); function transformSourceFile(node: SourceFile) { - const options = context.getCompilerOptions(); - if (node.isDeclarationFile - || useDefineForClassFields && getEmitScriptTarget(options) >= ScriptTarget.ES2022) { + if (node.isDeclarationFile || !shouldTransformAnything) { return node; } + const visited = visitEachChild(node, visitor, context); addEmitHelpers(visited, context.readEmitHelpers()); return visited; } + function visitor(node: Node): VisitResult { + return visitorWorker(node, /*valueIsDiscarded*/ false); + } + + function discardedValueVisitor(node: Node): VisitResult { + return visitorWorker(node, /*valueIsDiscarded*/ true); + } + function visitorWorker(node: Node, valueIsDiscarded: boolean): VisitResult { - if (node.transformFlags & TransformFlags.ContainsClassFields) { - switch (node.kind) { - case SyntaxKind.ClassExpression: - case SyntaxKind.ClassDeclaration: - return visitClassLike(node as ClassLikeDeclaration); - case SyntaxKind.PropertyDeclaration: - return visitPropertyDeclaration(node as PropertyDeclaration); - case SyntaxKind.VariableStatement: - return visitVariableStatement(node as VariableStatement); - case SyntaxKind.PrivateIdentifier: - return visitPrivateIdentifier(node as PrivateIdentifier); - case SyntaxKind.ClassStaticBlockDeclaration: - return visitClassStaticBlockDeclaration(node as ClassStaticBlockDeclaration); + switch (node.kind) { + case SyntaxKind.ClassExpression: + case SyntaxKind.ClassDeclaration: + return visitClassLikeDeclaration(node as ClassLikeDeclaration); + } + + if (shouldTransformInitializers) { + if (node.transformFlags & TransformFlags.ContainsClassFields) { + switch (node.kind) { + case SyntaxKind.PropertyDeclaration: + return visitPropertyDeclaration(node as PropertyDeclaration); + case SyntaxKind.VariableStatement: + return visitVariableStatement(node as VariableStatement); + case SyntaxKind.PrivateIdentifier: + return visitPrivateIdentifier(node as PrivateIdentifier); + case SyntaxKind.ClassStaticBlockDeclaration: + return visitClassStaticBlockDeclaration(node as ClassStaticBlockDeclaration); + } + } + + if (node.transformFlags & TransformFlags.ContainsClassFields || + node.transformFlags & TransformFlags.ContainsLexicalSuper && + shouldTransformSuperInStaticInitializers && + currentStaticPropertyDeclarationOrStaticBlock && + currentClassLexicalEnvironment) { + switch (node.kind) { + case SyntaxKind.PrefixUnaryExpression: + case SyntaxKind.PostfixUnaryExpression: + return visitPreOrPostfixUnaryExpression(node as PrefixUnaryExpression | PostfixUnaryExpression, valueIsDiscarded); + case SyntaxKind.BinaryExpression: + return visitBinaryExpression(node as BinaryExpression, valueIsDiscarded); + case SyntaxKind.CallExpression: + return visitCallExpression(node as CallExpression); + case SyntaxKind.TaggedTemplateExpression: + return visitTaggedTemplateExpression(node as TaggedTemplateExpression); + case SyntaxKind.PropertyAccessExpression: + return visitPropertyAccessExpression(node as PropertyAccessExpression); + case SyntaxKind.ElementAccessExpression: + return visitElementAccessExpression(node as ElementAccessExpression); + case SyntaxKind.ExpressionStatement: + return visitExpressionStatement(node as ExpressionStatement); + case SyntaxKind.ForStatement: + return visitForStatement(node as ForStatement); + case SyntaxKind.FunctionDeclaration: + case SyntaxKind.FunctionExpression: + case SyntaxKind.Constructor: + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: { + const savedCurrentStaticPropertyDeclarationOrStaticBlock = currentStaticPropertyDeclarationOrStaticBlock; + currentStaticPropertyDeclarationOrStaticBlock = undefined; + const result = visitEachChild(node, visitor, context); + currentStaticPropertyDeclarationOrStaticBlock = savedCurrentStaticPropertyDeclarationOrStaticBlock; + return result; + } + } } } - if (node.transformFlags & TransformFlags.ContainsClassFields || - node.transformFlags & TransformFlags.ContainsLexicalSuper && - shouldTransformSuperInStaticInitializers && - currentStaticPropertyDeclarationOrStaticBlock && - currentClassLexicalEnvironment) { + + if (shouldTransformAutoAccessors) { switch (node.kind) { - case SyntaxKind.PrefixUnaryExpression: - case SyntaxKind.PostfixUnaryExpression: - return visitPreOrPostfixUnaryExpression(node as PrefixUnaryExpression | PostfixUnaryExpression, valueIsDiscarded); - case SyntaxKind.BinaryExpression: - return visitBinaryExpression(node as BinaryExpression, valueIsDiscarded); - case SyntaxKind.CallExpression: - return visitCallExpression(node as CallExpression); - case SyntaxKind.TaggedTemplateExpression: - return visitTaggedTemplateExpression(node as TaggedTemplateExpression); - case SyntaxKind.PropertyAccessExpression: - return visitPropertyAccessExpression(node as PropertyAccessExpression); - case SyntaxKind.ElementAccessExpression: - return visitElementAccessExpression(node as ElementAccessExpression); - case SyntaxKind.ExpressionStatement: - return visitExpressionStatement(node as ExpressionStatement); - case SyntaxKind.ForStatement: - return visitForStatement(node as ForStatement); - case SyntaxKind.FunctionDeclaration: - case SyntaxKind.FunctionExpression: - case SyntaxKind.Constructor: - case SyntaxKind.MethodDeclaration: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: { - const savedCurrentStaticPropertyDeclarationOrStaticBlock = currentStaticPropertyDeclarationOrStaticBlock; - currentStaticPropertyDeclarationOrStaticBlock = undefined; - const result = visitEachChild(node, visitor, context); - currentStaticPropertyDeclarationOrStaticBlock = savedCurrentStaticPropertyDeclarationOrStaticBlock; - return result; + case SyntaxKind.AccessorKeyword: + return undefined; + } + + if (node.transformFlags & TransformFlags.ContainsClassFields) { + switch (node.kind) { + case SyntaxKind.PropertyDeclaration: + return visitPropertyDeclaration(node as PropertyDeclaration); } } } - return visitEachChild(node, visitor, context); - } - function discardedValueVisitor(node: Node): VisitResult { - return visitorWorker(node, /*valueIsDiscarded*/ true); - } - - function visitor(node: Node): VisitResult { - return visitorWorker(node, /*valueIsDiscarded*/ false); + return visitEachChild(node, visitor, context); } function heritageClauseVisitor(node: Node): VisitResult { @@ -257,7 +298,7 @@ namespace ts { return visitor(node); } - function visitorDestructuringTarget(node: Node): VisitResult { + function destructuringTargetVisitor(node: Node): VisitResult { switch (node.kind) { case SyntaxKind.ObjectLiteralExpression: case SyntaxKind.ArrayLiteralExpression: @@ -313,29 +354,48 @@ namespace ts { * @param node The node to visit. */ function classElementVisitor(node: Node): VisitResult { - switch (node.kind) { - case SyntaxKind.Constructor: - // Constructors for classes using class fields are transformed in - // `visitClassDeclaration` or `visitClassExpression`. - return undefined; + if (shouldTransformInitializers) { + switch (node.kind) { + case SyntaxKind.Constructor: + // Constructors for classes using class fields are transformed in + // `visitClassDeclaration` or `visitClassExpression`. + return undefined; - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - case SyntaxKind.MethodDeclaration: - return visitMethodOrAccessorDeclaration(node as MethodDeclaration | AccessorDeclaration); + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + case SyntaxKind.MethodDeclaration: + return visitMethodOrAccessorDeclaration(node as MethodDeclaration | AccessorDeclaration); - case SyntaxKind.PropertyDeclaration: - return visitPropertyDeclaration(node as PropertyDeclaration); + case SyntaxKind.PropertyDeclaration: + return visitPropertyDeclaration(node as PropertyDeclaration); - case SyntaxKind.ComputedPropertyName: - return visitComputedPropertyName(node as ComputedPropertyName); + case SyntaxKind.SemicolonClassElement: + return node; + } + } - case SyntaxKind.SemicolonClassElement: - return node; + if (shouldTransformAutoAccessors) { + switch (node.kind) { + case SyntaxKind.PropertyDeclaration: + return visitPropertyDeclaration(node as PropertyDeclaration); + } + } - default: - return visitor(node); + switch (node.kind) { + case SyntaxKind.PropertyDeclaration: + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + const savedCurrentStaticPropertyDeclarationOrStaticBlock = currentStaticPropertyDeclarationOrStaticBlock; + currentStaticPropertyDeclarationOrStaticBlock = undefined; + const result = visitEachChild(node, classElementVisitor, context); + currentStaticPropertyDeclarationOrStaticBlock = savedCurrentStaticPropertyDeclarationOrStaticBlock; + return result; + case SyntaxKind.ComputedPropertyName: + return visitComputedPropertyName(node as ComputedPropertyName); } + + return visitor(node); } function visitVariableStatement(node: VariableStatement) { @@ -351,18 +411,18 @@ namespace ts { return statement; } - function visitComputedPropertyName(name: ComputedPropertyName) { - let node = visitEachChild(name, visitor, context); + function visitComputedPropertyName(node: ComputedPropertyName) { + let expression = visitNode(node.expression, visitor, isExpression); if (some(pendingExpressions)) { - const expressions = pendingExpressions; - expressions.push(node.expression); - pendingExpressions = []; - node = factory.updateComputedPropertyName( - node, - factory.inlineExpressions(expressions) - ); + if (isParenthesizedExpression(expression)) { + expression = factory.updateParenthesizedExpression(expression, factory.inlineExpressions([...pendingExpressions, expression.expression])); + } + else { + expression = factory.inlineExpressions([...pendingExpressions, expression]); + } + pendingExpressions = undefined; } - return node; + return factory.updateComputedPropertyName(node, expression); } function visitMethodOrAccessorDeclaration(node: MethodDeclaration | AccessorDeclaration) { @@ -420,34 +480,93 @@ namespace ts { } } - function visitPropertyDeclaration(node: PropertyDeclaration) { - Debug.assert(!hasDecorators(node)); + function accessorFieldResultVisitor(node: Node) { + switch (node.kind) { + case SyntaxKind.PropertyDeclaration: + return transformFieldInitializer(node as PropertyDeclaration); + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + return classElementVisitor(node); + default: + Debug.assertMissingNode(node, "Expected node to either be a PropertyDeclaration, GetAccessorDeclaration, or SetAccessorDeclaration"); + break; + } + } - if (isPrivateIdentifier(node.name)) { - if (!shouldTransformPrivateElementsOrClassStaticBlocks) { - if (isStatic(node)) { - // static fields are left as is - return visitEachChild(node, visitor, context); - } + function transformAutoAccessor(node: AutoAccessorPropertyDeclaration): VisitResult { + // transforms: + // accessor x = 1; + // into: + // #x = 1; + // get x() { return this.#x; } + // set x(value) { this.#x = value; } - // Initializer is elided as the field is initialized in transformConstructor. - return factory.updatePropertyDeclaration( - node, - visitNodes(node.modifiers, visitor, isModifierLike), - node.name, - /*questionOrExclamationToken*/ undefined, - /*type*/ undefined, - /*initializer*/ undefined - ); - } + Debug.assertEachNode(node.modifiers, isModifier); - // leave invalid code untransformed - const info = accessPrivateIdentifier(node.name); - Debug.assert(info, "Undeclared private name for property declaration."); - if (!info.isValid) { - return node; + const commentRange = getCommentRange(node); + const sourceMapRange = getSourceMapRange(node); + + // Since we're creating two declarations where there was previously one, cache + // the expression for any computed property names. + const name = node.name; + let getterName = name; + let setterName = name; + if (isComputedPropertyName(name) && !isSimpleInlineableExpression(name.expression)) { + const temp = factory.createTempVariable(hoistVariableDeclaration); + setSourceMapRange(temp, name.expression); + const expression = visitNode(name.expression, visitor, isExpression); + const assignment = factory.createAssignment(temp, expression); + setSourceMapRange(assignment, name.expression); + getterName = factory.updateComputedPropertyName(name, factory.inlineExpressions([assignment, temp])); + setterName = factory.updateComputedPropertyName(name, temp); + } + + const backingField = createAccessorPropertyBackingField(factory, node, node.modifiers, node.initializer); + setOriginalNode(backingField, node); + setEmitFlags(backingField, EmitFlags.NoComments); + setSourceMapRange(backingField, sourceMapRange); + + const getter = createAccessorPropertyGetRedirector(factory, node, node.modifiers, getterName); + setOriginalNode(getter, node); + setCommentRange(getter, commentRange); + setSourceMapRange(getter, sourceMapRange); + + const setter = createAccessorPropertySetRedirector(factory, node, node.modifiers, setterName); + setOriginalNode(setter, node); + setEmitFlags(setter, EmitFlags.NoComments); + setSourceMapRange(setter, sourceMapRange); + + return visitArray([backingField, getter, setter], accessorFieldResultVisitor, isClassElement); + } + + function transformPrivateFieldInitializer(node: PrivateIdentifierPropertyDeclaration) { + if (!shouldTransformPrivateElementsOrClassStaticBlocks) { + if (isStatic(node)) { + // static fields are left as is + return visitEachChild(node, classElementVisitor, context); } + + // Initializer is elided as the field is initialized in transformConstructor. + return factory.updatePropertyDeclaration( + node, + visitNodes(node.modifiers, visitor, isModifierLike), + node.name, + /*questionOrExclamationToken*/ undefined, + /*type*/ undefined, + /*initializer*/ undefined + ); + } + + const info = accessPrivateIdentifier(node.name); + Debug.assert(info, "Undeclared private name for property declaration."); + + // leave invalid code untransformed + if (!info.isValid) { + return node; } + } + + function transformPublicFieldInitializer(node: PropertyDeclaration) { // Create a temporary variable to store a computed property name (if necessary). // If it's not inlineable, then we emit an expression after the class which assigns // the property name to the temporary variable. @@ -478,6 +597,30 @@ namespace ts { return undefined; } + function transformFieldInitializer(node: PropertyDeclaration) { + Debug.assert(!hasDecorators(node)); + + if (!shouldTransformInitializers) { + return visitEachChild(node, classElementVisitor, context); + } + + if (isPrivateIdentifierClassElementDeclaration(node)) { + return transformPrivateFieldInitializer(node); + } + + return transformPublicFieldInitializer(node); + } + + function visitPropertyDeclaration(node: PropertyDeclaration) { + // If this is an accessor field, we defer to `transformAccessorField`. That function + // will in turn call `transformFieldInitializer` as needed. + if (shouldTransformAutoAccessors && isAutoAccessorPropertyDeclaration(node)) { + return transformAutoAccessor(node); + } + + return transformFieldInitializer(node); + } + function createPrivateIdentifierAccess(info: PrivateIdentifierInfo, receiver: Expression): Expression { return createPrivateIdentifierAccessHelper(info, visitNode(receiver, visitor, isExpression)); } @@ -789,7 +932,7 @@ namespace ts { pendingExpressions = undefined; node = factory.updateBinaryExpression( node, - visitNode(node.left, visitorDestructuringTarget), + visitNode(node.left, destructuringTargetVisitor), node.operatorToken, visitNode(node.right, visitor) ); @@ -938,9 +1081,17 @@ namespace ts { /** * Set up the environment for a class. */ - function visitClassLike(node: ClassLikeDeclaration) { - if (!forEach(node.members, doesClassElementNeedTransform)) { - return visitEachChild(node, visitor, context); + function visitClassLikeDeclaration(node: ClassLikeDeclaration) { + const shouldTransform = shouldTransformInitializers + && node.transformFlags & TransformFlags.ContainsClassFields + && forEach(node.members, doesClassElementNeedTransform); + + if (!shouldTransform) { + const savedPendingExpressions = pendingExpressions; + pendingExpressions = undefined; + const result = visitEachChild(node, visitor, context); + pendingExpressions = savedPendingExpressions; + return result; } const savedPendingExpressions = pendingExpressions; @@ -950,7 +1101,7 @@ namespace ts { if (shouldTransformPrivateElementsOrClassStaticBlocks) { const name = getNameOfDeclaration(node); if (name && isIdentifier(name)) { - getPrivateIdentifierEnvironment().className = idText(name); + getPrivateIdentifierEnvironment().className = name; } const privateInstanceMethodsAndAccessors = getPrivateInstanceMethodsAndAccessors(node); @@ -987,7 +1138,7 @@ namespace ts { } for (const member of node.members) { if (!isStatic(member)) continue; - if (member.name && isPrivateIdentifier(member.name) && shouldTransformPrivateElementsOrClassStaticBlocks) { + if (member.name && (isPrivateIdentifier(member.name) || isAutoAccessorPropertyDeclaration(member)) && shouldTransformPrivateElementsOrClassStaticBlocks) { facts |= ClassFacts.NeedsClassConstructorReference; } if (isPropertyDeclaration(member) || isClassStaticBlockDeclaration(member)) { @@ -1185,13 +1336,21 @@ namespace ts { // Declare private names. for (const member of node.members) { if (isPrivateIdentifierClassElementDeclaration(member)) { - addPrivateIdentifierToEnvironment(member); + addPrivateIdentifierToEnvironment(member, member.name); } } if (some(getPrivateInstanceMethodsAndAccessors(node))) { createBrandCheckWeakSetForPrivateMethods(); } + + if (shouldTransformAutoAccessors) { + for (const member of node.members) { + if (isAutoAccessorPropertyDeclaration(member)) { + addPrivateIdentifierToEnvironment(member, factory.getGeneratedPrivateNameForNode(member.name, /*prefix*/ undefined, "_accessor_storage")); + } + } + } } const constructor = transformConstructor(node, isDerivedClass); @@ -1272,7 +1431,7 @@ namespace ts { function transformConstructorBody(node: ClassDeclaration | ClassExpression, constructor: ConstructorDeclaration | undefined, isDerivedClass: boolean) { let properties = getProperties(node, /*requireInitializer*/ false, /*isStatic*/ false); if (!useDefineForClassFields) { - properties = filter(properties, property => !!property.initializer || isPrivateIdentifier(property.name)); + properties = filter(properties, property => !!property.initializer || isPrivateIdentifier(property.name) || hasAccessorModifier(property)); } const privateMethodsAndAccessors = getPrivateInstanceMethodsAndAccessors(node); @@ -1434,9 +1593,10 @@ namespace ts { } const statement = factory.createExpressionStatement(expression); + setOriginalNode(statement, property); + addEmitFlags(statement, getEmitFlags(property) & EmitFlags.NoComments); setSourceMapRange(statement, moveRangePastModifiers(property)); setCommentRange(statement, property); - setOriginalNode(statement, property); // `setOriginalNode` *copies* the `emitNode` from `property`, so now both // `statement` and `expression` have a copy of the synthesized comments. @@ -1461,9 +1621,10 @@ namespace ts { continue; } startOnNewLine(expression); + setOriginalNode(expression, property); + addEmitFlags(expression, getEmitFlags(property) & EmitFlags.NoComments); setSourceMapRange(expression, moveRangePastModifiers(property)); setCommentRange(expression, property); - setOriginalNode(expression, property); expressions.push(expression); } @@ -1492,9 +1653,13 @@ namespace ts { function transformPropertyWorker(property: PropertyDeclaration, receiver: LeftHandSideExpression) { // We generate a name here in order to reuse the value cached by the relocated computed name expression (which uses the same generated name) const emitAssignment = !useDefineForClassFields; - const propertyName = isComputedPropertyName(property.name) && !isSimpleInlineableExpression(property.name.expression) - ? factory.updateComputedPropertyName(property.name, factory.getGeneratedNameForNode(property.name)) - : property.name; + + const propertyName = + hasAccessorModifier(property) ? + factory.getGeneratedPrivateNameForNode(property.name) : + isComputedPropertyName(property.name) && !isSimpleInlineableExpression(property.name.expression) ? + factory.updateComputedPropertyName(property.name, factory.getGeneratedNameForNode(property.name)) : + property.name; if (hasStaticModifier(property)) { currentStaticPropertyDeclarationOrStaticBlock = property; @@ -1801,8 +1966,10 @@ namespace ts { function getPrivateIdentifierEnvironment() { const lex = getClassLexicalEnvironment(); lex.privateIdentifierEnvironment ||= { - className: "", - identifiers: new Map() + className: undefined, + weakSetName: undefined, + identifiers: undefined, + generatedIdentifiers: undefined, }; return lex.privateIdentifierEnvironment; } @@ -1811,69 +1978,62 @@ namespace ts { return pendingExpressions || (pendingExpressions = []); } - function addPrivateIdentifierToEnvironment(node: PrivateClassElementDeclaration) { - const text = getTextOfPropertyName(node.name) as string; + function addPrivateIdentifierToEnvironment(node: PropertyDeclaration | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration, name: PrivateIdentifier) { const lex = getClassLexicalEnvironment(); - const { classConstructor } = lex; - const privateEnv = getPrivateIdentifierEnvironment(); - const { weakSetName } = privateEnv; - + const previousInfo = getPrivateIdentifier(privateEnv, name); + const isValid = !isReservedPrivateName(name) && previousInfo === undefined; const assignmentExpressions: Expression[] = []; - const privateName = node.name.escapedText; - const previousInfo = privateEnv.identifiers.get(privateName); - const isValid = !isReservedPrivateName(node.name) && previousInfo === undefined; - if (hasStaticModifier(node)) { - Debug.assert(classConstructor, "weakSetName should be set in private identifier environment"); + Debug.assert(lex.classConstructor, "weakSetName should be set in private identifier environment"); if (isPropertyDeclaration(node)) { - const variableName = createHoistedVariableForPrivateName(text, node); - privateEnv.identifiers.set(privateName, { + const variableName = createHoistedVariableForPrivateName(name); + setPrivateIdentifier(privateEnv, name, { kind: PrivateIdentifierKind.Field, variableName, - brandCheckIdentifier: classConstructor, + brandCheckIdentifier: lex.classConstructor, isStatic: true, isValid, }); } else if (isMethodDeclaration(node)) { - const functionName = createHoistedVariableForPrivateName(text, node); - privateEnv.identifiers.set(privateName, { + const functionName = createHoistedVariableForPrivateName(name); + setPrivateIdentifier(privateEnv, name, { kind: PrivateIdentifierKind.Method, methodName: functionName, - brandCheckIdentifier: classConstructor, + brandCheckIdentifier: lex.classConstructor, isStatic: true, isValid, }); } else if (isGetAccessorDeclaration(node)) { - const getterName = createHoistedVariableForPrivateName(text + "_get", node); + const getterName = createHoistedVariableForPrivateName(name, "_get"); if (previousInfo?.kind === PrivateIdentifierKind.Accessor && previousInfo.isStatic && !previousInfo.getterName) { previousInfo.getterName = getterName; } else { - privateEnv.identifiers.set(privateName, { + setPrivateIdentifier(privateEnv, name, { kind: PrivateIdentifierKind.Accessor, getterName, setterName: undefined, - brandCheckIdentifier: classConstructor, + brandCheckIdentifier: lex.classConstructor, isStatic: true, isValid, }); } } else if (isSetAccessorDeclaration(node)) { - const setterName = createHoistedVariableForPrivateName(text + "_set", node); + const setterName = createHoistedVariableForPrivateName(name, "_set"); if (previousInfo?.kind === PrivateIdentifierKind.Accessor && previousInfo.isStatic && !previousInfo.setterName) { previousInfo.setterName = setterName; } else { - privateEnv.identifiers.set(privateName, { + setPrivateIdentifier(privateEnv, name, { kind: PrivateIdentifierKind.Accessor, getterName: undefined, setterName, - brandCheckIdentifier: classConstructor, + brandCheckIdentifier: lex.classConstructor, isStatic: true, isValid, }); @@ -1884,8 +2044,8 @@ namespace ts { } } else if (isPropertyDeclaration(node)) { - const weakMapName = createHoistedVariableForPrivateName(text, node); - privateEnv.identifiers.set(privateName, { + const weakMapName = createHoistedVariableForPrivateName(name); + setPrivateIdentifier(privateEnv, name, { kind: PrivateIdentifierKind.Field, brandCheckIdentifier: weakMapName, isStatic: false, @@ -1903,48 +2063,48 @@ namespace ts { )); } else if (isMethodDeclaration(node)) { - Debug.assert(weakSetName, "weakSetName should be set in private identifier environment"); + Debug.assert(privateEnv.weakSetName, "weakSetName should be set in private identifier environment"); - privateEnv.identifiers.set(privateName, { + setPrivateIdentifier(privateEnv, name, { kind: PrivateIdentifierKind.Method, - methodName: createHoistedVariableForPrivateName(text, node), - brandCheckIdentifier: weakSetName, + methodName: createHoistedVariableForPrivateName(name), + brandCheckIdentifier: privateEnv.weakSetName, isStatic: false, isValid, }); } else if (isAccessor(node)) { - Debug.assert(weakSetName, "weakSetName should be set in private identifier environment"); + Debug.assert(privateEnv.weakSetName, "weakSetName should be set in private identifier environment"); if (isGetAccessor(node)) { - const getterName = createHoistedVariableForPrivateName(text + "_get", node); + const getterName = createHoistedVariableForPrivateName(name, "_get"); if (previousInfo?.kind === PrivateIdentifierKind.Accessor && !previousInfo.isStatic && !previousInfo.getterName) { previousInfo.getterName = getterName; } else { - privateEnv.identifiers.set(privateName, { + setPrivateIdentifier(privateEnv, name, { kind: PrivateIdentifierKind.Accessor, getterName, setterName: undefined, - brandCheckIdentifier: weakSetName, + brandCheckIdentifier: privateEnv.weakSetName, isStatic: false, isValid, }); } } else { - const setterName = createHoistedVariableForPrivateName(text + "_set", node); + const setterName = createHoistedVariableForPrivateName(name, "_set"); if (previousInfo?.kind === PrivateIdentifierKind.Accessor && !previousInfo.isStatic && !previousInfo.setterName) { previousInfo.setterName = setterName; } else { - privateEnv.identifiers.set(privateName, { + setPrivateIdentifier(privateEnv, name, { kind: PrivateIdentifierKind.Accessor, getterName: undefined, setterName, - brandCheckIdentifier: weakSetName, + brandCheckIdentifier: privateEnv.weakSetName, isStatic: false, isValid, }); @@ -1958,10 +2118,13 @@ namespace ts { getPendingExpressions().push(...assignmentExpressions); } - function createHoistedVariableForClass(name: string, node: PrivateIdentifier | ClassStaticBlockDeclaration): Identifier { + function createHoistedVariableForClass(name: string | PrivateIdentifier | undefined, node: PrivateIdentifier | ClassStaticBlockDeclaration, suffix?: string): Identifier { const { className } = getPrivateIdentifierEnvironment(); - const prefix = className ? `_${className}` : ""; - const identifier = factory.createUniqueName(`${prefix}_${name}`, GeneratedIdentifierFlags.Optimistic); + const prefix: GeneratedNamePart | string = className ? { prefix: "_", node: className, suffix: "_" } : "_"; + const identifier = + typeof name === "object" ? factory.getGeneratedNameForNode(name, GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.ReservedInNestedScopes, prefix, suffix) : + typeof name === "string" ? factory.createUniqueName(name, GeneratedIdentifierFlags.Optimistic, prefix, suffix) : + factory.createTempVariable(/*recordTempVariable*/ undefined, /*reserveInNestedScopes*/ true, prefix, suffix); if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.BlockScopedBindingInLoop) { addBlockScopedVariable(identifier); @@ -1973,13 +2136,34 @@ namespace ts { return identifier; } - function createHoistedVariableForPrivateName(privateName: string, node: PrivateClassElementDeclaration): Identifier { - return createHoistedVariableForClass(privateName.substring(1), node.name); + function createHoistedVariableForPrivateName(name: PrivateIdentifier, suffix?: string): Identifier { + const text = tryGetTextOfPropertyName(name) as string | undefined; + return createHoistedVariableForClass(text?.substring(1) ?? name, name, suffix); } function accessPrivateIdentifier(name: PrivateIdentifier) { + if (isGeneratedPrivateIdentifier(name)) { + return accessGeneratedPrivateIdentifier(name); + } + else { + return accessPrivateIdentifierByText(name.escapedText); + } + } + + function accessPrivateIdentifierByText(text: __String) { + return accessPrivateIdentifierWorker(getPrivateIdentifierInfo, text); + } + + function accessGeneratedPrivateIdentifier(name: GeneratedPrivateIdentifier) { + return accessPrivateIdentifierWorker(getGeneratedPrivateIdentifierInfo, getNodeForGeneratedName(name)); + } + + function accessPrivateIdentifierWorker( + getPrivateIdentifierInfo: (privateEnv: PrivateIdentifierEnvironment, key: K) => PrivateIdentifierInfo | undefined, + privateIdentifierKey: K + ) { if (currentClassLexicalEnvironment?.privateIdentifierEnvironment) { - const info = currentClassLexicalEnvironment.privateIdentifierEnvironment.identifiers.get(name.escapedText); + const info = getPrivateIdentifierInfo(currentClassLexicalEnvironment.privateIdentifierEnvironment, privateIdentifierKey); if (info) { return info; } @@ -1989,9 +2173,11 @@ namespace ts { if (!env) { continue; } - const info = env.privateIdentifierEnvironment?.identifiers.get(name.escapedText); - if (info) { - return info; + if (env.privateIdentifierEnvironment) { + const info = getPrivateIdentifierInfo(env.privateIdentifierEnvironment, privateIdentifierKey); + if (info) { + return info; + } } } return undefined; @@ -2072,7 +2258,7 @@ namespace ts { } } } - return visitNode(node, visitorDestructuringTarget); + return visitNode(node, destructuringTargetVisitor); } function visitObjectAssignmentTarget(node: ObjectLiteralElementLike) { @@ -2118,13 +2304,13 @@ namespace ts { visitNode(node.name, visitor, isPropertyName), wrapped ? initializer ? factory.createAssignment(wrapped, visitNode(initializer, visitor)) : wrapped : - visitNode(node.initializer, visitorDestructuringTarget, isExpression) + visitNode(node.initializer, destructuringTargetVisitor, isExpression) ); } if (isSpreadAssignment(node)) { return factory.updateSpreadAssignment( node, - wrapped || visitNode(node.expression, visitorDestructuringTarget, isExpression) + wrapped || visitNode(node.expression, destructuringTargetVisitor, isExpression) ); } Debug.assert(wrapped === undefined, "Should not have generated a wrapped target"); @@ -2190,6 +2376,31 @@ namespace ts { } function isReservedPrivateName(node: PrivateIdentifier) { - return node.escapedText === "#constructor"; + return !isGeneratedPrivateIdentifier(node) && node.escapedText === "#constructor"; + } + + function getPrivateIdentifier(privateEnv: PrivateIdentifierEnvironment, name: PrivateIdentifier) { + return isGeneratedPrivateIdentifier(name) ? + getGeneratedPrivateIdentifierInfo(privateEnv, getNodeForGeneratedName(name)) : + getPrivateIdentifierInfo(privateEnv, name.escapedText); + } + + function setPrivateIdentifier(privateEnv: PrivateIdentifierEnvironment, name: PrivateIdentifier, info: PrivateIdentifierInfo) { + if (isGeneratedPrivateIdentifier(name)) { + privateEnv.generatedIdentifiers ??= new Map(); + privateEnv.generatedIdentifiers.set(getNodeForGeneratedName(name), info); + } + else { + privateEnv.identifiers ??= new Map(); + privateEnv.identifiers.set(name.escapedText, info); + } + } + + function getPrivateIdentifierInfo(privateEnv: PrivateIdentifierEnvironment, key: __String) { + return privateEnv.identifiers?.get(key); + } + + function getGeneratedPrivateIdentifierInfo(privateEnv: PrivateIdentifierEnvironment, key: Node) { + return privateEnv.generatedIdentifiers?.get(key); } } diff --git a/src/compiler/transformers/legacyDecorators.ts b/src/compiler/transformers/legacyDecorators.ts index 43a5b1f7a05fe..36c3f65b6757d 100644 --- a/src/compiler/transformers/legacyDecorators.ts +++ b/src/compiler/transformers/legacyDecorators.ts @@ -453,7 +453,7 @@ namespace ts { const prefix = getClassMemberPrefix(node, member); const memberName = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ !hasSyntacticModifier(member, ModifierFlags.Ambient)); const descriptor = languageVersion > ScriptTarget.ES3 - ? member.kind === SyntaxKind.PropertyDeclaration + ? isPropertyDeclaration(member) && !hasAccessorModifier(member) // We emit `void 0` here to indicate to `__decorate` that it can invoke `Object.defineProperty` directly, but that it // should not invoke `Object.getOwnPropertyDescriptor`. ? factory.createVoidZero() diff --git a/src/compiler/types.ts b/src/compiler/types.ts index a6121cddb6096..062bfbd7dd0e5 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -159,6 +159,7 @@ namespace ts { YieldKeyword, // Contextual keywords AbstractKeyword, + AccessorKeyword, AsKeyword, AssertsKeyword, AssertKeyword, @@ -548,6 +549,7 @@ namespace ts { export type KeywordSyntaxKind = | SyntaxKind.AbstractKeyword + | SyntaxKind.AccessorKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword @@ -631,6 +633,7 @@ namespace ts { export type ModifierSyntaxKind = | SyntaxKind.AbstractKeyword + | SyntaxKind.AccessorKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword @@ -814,9 +817,10 @@ namespace ts { Protected = 1 << 4, // Property/Method Static = 1 << 5, // Property/Method Readonly = 1 << 6, // Property/Method - Abstract = 1 << 7, // Class/Method/ConstructSignature - Async = 1 << 8, // Property/Method/Function - Default = 1 << 9, // Function/Class (export default declaration) + Accessor = 1 << 7, // Property + Abstract = 1 << 8, // Class/Method/ConstructSignature + Async = 1 << 9, // Property/Method/Function + Default = 1 << 10, // Function/Class (export default declaration) Const = 1 << 11, // Const enum HasComputedJSDocModifiers = 1 << 12, // Indicates the computed modifier flags include modifiers from JSDoc. @@ -834,7 +838,7 @@ namespace ts { TypeScriptModifier = Ambient | Public | Private | Protected | Readonly | Abstract | Const | Override | In | Out, ExportDefault = Export | Default, - All = Export | Ambient | Public | Private | Protected | Static | Readonly | Abstract | Async | Default | Const | Deprecated | Override | In | Out | Decorator, + All = Export | Ambient | Public | Private | Protected | Static | Readonly | Abstract | Accessor | Async | Default | Const | Deprecated | Override | In | Out | Decorator, Modifier = All & ~Decorator } @@ -1140,6 +1144,7 @@ namespace ts { } export type AbstractKeyword = ModifierToken; + export type AccessorKeyword = ModifierToken; export type AsyncKeyword = ModifierToken; export type ConstKeyword = ModifierToken; export type DeclareKeyword = ModifierToken; @@ -1159,6 +1164,7 @@ namespace ts { export type Modifier = | AbstractKeyword + | AccessorKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword @@ -1191,6 +1197,7 @@ namespace ts { | AccessibilityModifier | ReadonlyKeyword | StaticKeyword + | AccessorKeyword ; export type ModifiersArray = NodeArray; @@ -1221,6 +1228,8 @@ namespace ts { readonly originalKeywordKind?: SyntaxKind; // Original syntaxKind which get set so that we can report an error later /*@internal*/ readonly autoGenerateFlags?: GeneratedIdentifierFlags; // Specifies whether to auto-generate the text for an identifier. /*@internal*/ readonly autoGenerateId?: number; // Ensures unique generated identifiers get unique names, but clones get the same name. + /*@internal*/ readonly autoGeneratePrefix?: string | GeneratedNamePart; + /*@internal*/ readonly autoGenerateSuffix?: string; /*@internal*/ generatedImportReference?: ImportSpecifier; // Reference to the generated import specifier this identifier refers to isInJSDocNamespace?: boolean; // if the node is a member in a JSDoc namespace /*@internal*/ typeArguments?: NodeArray; // Only defined on synthesized nodes. Though not syntactically valid, used in emitting diagnostics, quickinfo, and signature help. @@ -1310,8 +1319,16 @@ namespace ts { // escaping not strictly necessary // avoids gotchas in transforms and utils readonly escapedText: __String; + /*@internal*/ readonly autoGenerateFlags?: GeneratedIdentifierFlags; // Specifies whether to auto-generate the text for an identifier. + /*@internal*/ readonly autoGenerateId?: number; // Ensures unique generated identifiers get unique names, but clones get the same name. + /*@internal*/ readonly autoGeneratePrefix?: string | GeneratedNamePart; + /*@internal*/ readonly autoGenerateSuffix?: string; } + /*@internal*/ + export interface GeneratedPrivateIdentifier extends PrivateIdentifier { + autoGenerateFlags: GeneratedIdentifierFlags; + } /* @internal */ // A name that supports late-binding (used in checker) @@ -1435,6 +1452,10 @@ namespace ts { readonly initializer?: Expression; // Optional initializer } + export interface AutoAccessorPropertyDeclaration extends PropertyDeclaration { + _autoAccessorBrand: any; + } + /*@internal*/ export interface PrivateIdentifierPropertyDeclaration extends PropertyDeclaration { name: PrivateIdentifier; @@ -1859,7 +1880,7 @@ namespace ts { export interface StringLiteral extends LiteralExpression, Declaration { readonly kind: SyntaxKind.StringLiteral; - /* @internal */ readonly textSourceNode?: Identifier | StringLiteralLike | NumericLiteral; // Allows a StringLiteral to get its text from another node (used by transforms). + /* @internal */ readonly textSourceNode?: Identifier | StringLiteralLike | NumericLiteral | PrivateIdentifier; // Allows a StringLiteral to get its text from another node (used by transforms). /** Note: this is only set when synthesizing a node, not during parsing. */ /* @internal */ readonly singleQuote?: boolean; } @@ -5072,6 +5093,7 @@ namespace ts { MethodExcludes = Value & ~Method, GetAccessorExcludes = Value & ~SetAccessor, SetAccessorExcludes = Value & ~GetAccessor, + AccessorExcludes = Value & ~Accessor, TypeParameterExcludes = Type & ~TypeParameter, TypeAliasExcludes = Type, AliasExcludes = Alias, @@ -7373,6 +7395,15 @@ namespace ts { convertToAssignmentElementTarget(node: BindingOrAssignmentElementTarget): Expression; } + /* @internal */ + export interface GeneratedNamePart { + /** an additional prefix to insert before the text sourced from `node` */ + prefix?: string; + node: Identifier | PrivateIdentifier; + /** an additional suffix to insert after the text sourced from `node` */ + suffix?: string; + } + export interface NodeFactory { /* @internal */ readonly parenthesizer: ParenthesizerRules; /* @internal */ readonly converters: NodeConverters; @@ -7388,7 +7419,7 @@ namespace ts { createBigIntLiteral(value: string | PseudoBigInt): BigIntLiteral; createStringLiteral(text: string, isSingleQuote?: boolean): StringLiteral; /* @internal*/ createStringLiteral(text: string, isSingleQuote?: boolean, hasExtendedUnicodeEscape?: boolean): StringLiteral; // eslint-disable-line @typescript-eslint/unified-signatures - createStringLiteralFromNode(sourceNode: PropertyNameLiteral, isSingleQuote?: boolean): StringLiteral; + createStringLiteralFromNode(sourceNode: PropertyNameLiteral | PrivateIdentifier, isSingleQuote?: boolean): StringLiteral; createRegularExpressionLiteral(text: string): RegularExpressionLiteral; // @@ -7409,6 +7440,7 @@ namespace ts { * setting `EmitFlags.ReuseTempVariableScope` on the nested function itself. */ createTempVariable(recordTempVariable: ((node: Identifier) => void) | undefined, reservedInNestedScopes?: boolean): Identifier; + /*@internal*/ createTempVariable(recordTempVariable: ((node: Identifier) => void) | undefined, reservedInNestedScopes?: boolean, prefix?: string | GeneratedNamePart, suffix?: string): Identifier; // eslint-disable-line @typescript-eslint/unified-signatures /** * Create a unique temporary variable for use in a loop. @@ -7420,11 +7452,17 @@ namespace ts { /** Create a unique name based on the supplied text. */ createUniqueName(text: string, flags?: GeneratedIdentifierFlags): Identifier; + /*@internal*/ createUniqueName(text: string, flags?: GeneratedIdentifierFlags, prefix?: string | GeneratedNamePart, suffix?: string): Identifier; // eslint-disable-line @typescript-eslint/unified-signatures /** Create a unique name generated for a node. */ getGeneratedNameForNode(node: Node | undefined, flags?: GeneratedIdentifierFlags): Identifier; + /*@internal*/ getGeneratedNameForNode(node: Node | undefined, flags?: GeneratedIdentifierFlags, prefix?: string | GeneratedNamePart, suffix?: string): Identifier; // eslint-disable-line @typescript-eslint/unified-signatures createPrivateIdentifier(text: string): PrivateIdentifier + createUniquePrivateName(text?: string): PrivateIdentifier; + /*@internal*/ createUniquePrivateName(text?: string, prefix?: string | GeneratedNamePart, suffix?: string): PrivateIdentifier; // eslint-disable-line @typescript-eslint/unified-signatures + getGeneratedPrivateNameForNode(node: Node): PrivateIdentifier; + /*@internal*/ getGeneratedPrivateNameForNode(node: Node, prefix?: string | GeneratedNamePart, suffix?: string): PrivateIdentifier; // eslint-disable-line @typescript-eslint/unified-signatures // // Punctuation @@ -8289,7 +8327,7 @@ namespace ts { (nodes: NodeArray | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray | undefined; } - export type VisitResult = T | T[] | undefined; + export type VisitResult = T | readonly T[] | undefined; export interface Printer { /** diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 0ac57b26fee15..9b3b0b4a5c7b0 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -853,6 +853,10 @@ namespace ts { return false; } + export function isAmbientPropertyDeclaration(node: PropertyDeclaration) { + return !!(node.flags & NodeFlags.Ambient) || hasSyntacticModifier(node, ModifierFlags.Ambient); + } + export function isBlockScope(node: Node, parentNode: Node | undefined): boolean { switch (node.kind) { case SyntaxKind.SourceFile: @@ -996,7 +1000,7 @@ namespace ts { switch (name.kind) { case SyntaxKind.Identifier: case SyntaxKind.PrivateIdentifier: - return name.escapedText; + return name.autoGenerateFlags ? undefined : name.escapedText; case SyntaxKind.StringLiteral: case SyntaxKind.NumericLiteral: case SyntaxKind.NoSubstitutionTemplateLiteral: @@ -3404,7 +3408,7 @@ namespace ts { return false; } } - export function getTextOfIdentifierOrLiteral(node: PropertyNameLiteral): string { + export function getTextOfIdentifierOrLiteral(node: PropertyNameLiteral | PrivateIdentifier): string { return isMemberName(node) ? idText(node) : node.text; } @@ -4917,6 +4921,10 @@ namespace ts { return hasSyntacticModifier(node, ModifierFlags.Ambient); } + export function hasAccessorModifier(node: Node): boolean { + return hasSyntacticModifier(node, ModifierFlags.Accessor); + } + export function hasEffectiveReadonlyModifier(node: Node): boolean { return hasEffectiveModifier(node, ModifierFlags.Readonly); } @@ -5026,6 +5034,7 @@ namespace ts { case SyntaxKind.ProtectedKeyword: return ModifierFlags.Protected; case SyntaxKind.PrivateKeyword: return ModifierFlags.Private; case SyntaxKind.AbstractKeyword: return ModifierFlags.Abstract; + case SyntaxKind.AccessorKeyword: return ModifierFlags.Accessor; case SyntaxKind.ExportKeyword: return ModifierFlags.Export; case SyntaxKind.DeclareKeyword: return ModifierFlags.Ambient; case SyntaxKind.ConstKeyword: return ModifierFlags.Const; @@ -5040,10 +5049,6 @@ namespace ts { return ModifierFlags.None; } - export function createModifiers(modifierFlags: ModifierFlags): ModifiersArray | undefined { - return modifierFlags ? factory.createNodeArray(factory.createModifiersFromModifierFlags(modifierFlags)) : undefined; - } - export function isLogicalOperator(token: SyntaxKind): boolean { return token === SyntaxKind.BarBarToken || token === SyntaxKind.AmpersandAmpersandToken diff --git a/src/compiler/utilitiesPublic.ts b/src/compiler/utilitiesPublic.ts index f2f0c030840f8..44b916b9a0ec8 100644 --- a/src/compiler/utilitiesPublic.ts +++ b/src/compiler/utilitiesPublic.ts @@ -1193,6 +1193,11 @@ namespace ts { return isIdentifier(node) && (node.autoGenerateFlags! & GeneratedIdentifierFlags.KindMask) > GeneratedIdentifierFlags.None; } + /* @internal */ + export function isGeneratedPrivateIdentifier(node: Node): node is GeneratedPrivateIdentifier { + return isPrivateIdentifier(node) && (node.autoGenerateFlags! & GeneratedIdentifierFlags.KindMask) > GeneratedIdentifierFlags.None; + } + // Private Identifiers /*@internal*/ export function isPrivateIdentifierClassElementDeclaration(node: Node): node is PrivateClassElementDeclaration { @@ -1210,6 +1215,7 @@ namespace ts { export function isModifierKind(token: SyntaxKind): token is Modifier["kind"] { switch (token) { case SyntaxKind.AbstractKeyword: + case SyntaxKind.AccessorKeyword: case SyntaxKind.AsyncKeyword: case SyntaxKind.ConstKeyword: case SyntaxKind.DeclareKeyword: @@ -1235,7 +1241,10 @@ namespace ts { /* @internal */ export function isClassMemberModifier(idToken: SyntaxKind): boolean { - return isParameterPropertyModifier(idToken) || idToken === SyntaxKind.StaticKeyword || idToken === SyntaxKind.OverrideKeyword; + return isParameterPropertyModifier(idToken) || + idToken === SyntaxKind.StaticKeyword || + idToken === SyntaxKind.OverrideKeyword || + idToken === SyntaxKind.AccessorKeyword; } export function isModifier(node: Node): node is Modifier { @@ -1343,6 +1352,10 @@ namespace ts { return node && (node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor); } + export function isAutoAccessorPropertyDeclaration(node: Node): node is AutoAccessorPropertyDeclaration { + return isPropertyDeclaration(node) && hasAccessorModifier(node); + } + /* @internal */ export function isMethodOrAccessor(node: Node): node is MethodDeclaration | AccessorDeclaration { switch (node.kind) { @@ -1355,6 +1368,19 @@ namespace ts { } } + /* @internal */ + export function isNamedClassElement(node: Node): node is MethodDeclaration | AccessorDeclaration | PropertyDeclaration { + switch (node.kind) { + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + case SyntaxKind.PropertyDeclaration: + return true; + default: + return false; + } + } + // Type members export function isModifierLike(node: Node): node is ModifierLike { diff --git a/src/compiler/visitorPublic.ts b/src/compiler/visitorPublic.ts index 619348685efbc..e4c41b2bd48d2 100644 --- a/src/compiler/visitorPublic.ts +++ b/src/compiler/visitorPublic.ts @@ -44,6 +44,9 @@ namespace ts { return visitedNode as T; } + /* @internal */ + export function visitNodes(nodes: NodeArray, visitor: Visitor, test: (node: Node) => node is U, start?: number, count?: number): NodeArray; + /** * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place. * @@ -55,6 +58,9 @@ namespace ts { */ export function visitNodes(nodes: NodeArray, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray; + /* @internal */ + export function visitNodes(nodes: NodeArray | undefined, visitor: Visitor, test: (node: Node) => node is U, start?: number, count?: number): NodeArray | undefined; + /** * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place. * @@ -116,7 +122,14 @@ namespace ts { } /* @internal */ - export function visitArray(nodes: readonly T[] | undefined, visitor: Visitor, test: (node: Node) => node is U, start?: number, count?: number): readonly U[] | undefined { + export function visitArray(nodes: T[] | undefined, visitor: Visitor, test: (node: Node) => node is U, start?: number, count?: number): U[] | undefined; + /* @internal */ + export function visitArray(nodes: readonly T[] | undefined, visitor: Visitor, test: (node: Node) => node is U, start?: number, count?: number): readonly U[] | undefined; + /* @internal */ + export function visitArray(nodes: T[] | undefined, visitor: Visitor, test: (node: Node) => node is T, start?: number, count?: number): T[] | undefined; + /* @internal */ + export function visitArray(nodes: readonly T[] | undefined, visitor: Visitor, test: (node: Node) => node is T, start?: number, count?: number): readonly T[] | undefined; + export function visitArray(nodes: readonly T[] | undefined, visitor: Visitor, test: (node: Node) => node is U, start?: number, count?: number) { if (nodes === undefined) { return nodes; } diff --git a/src/deprecatedCompat/4.0/nodeFactoryTopLevelExports.ts b/src/deprecatedCompat/4.0/nodeFactoryTopLevelExports.ts index 07dccb1e1c6a7..330a7f5c01b2a 100644 --- a/src/deprecatedCompat/4.0/nodeFactoryTopLevelExports.ts +++ b/src/deprecatedCompat/4.0/nodeFactoryTopLevelExports.ts @@ -30,7 +30,7 @@ namespace ts { export const createLoopVariable = Debug.deprecate(factory.createLoopVariable, factoryDeprecation); /** @deprecated Use `factory.createUniqueName` or the factory supplied by your transformation context instead. */ - export const createUniqueName = Debug.deprecate(factory.createUniqueName, factoryDeprecation); + export const createUniqueName: (text: string, flags?: GeneratedIdentifierFlags | undefined) => Identifier = Debug.deprecate(factory.createUniqueName, factoryDeprecation); /** @deprecated Use `factory.createPrivateIdentifier` or the factory supplied by your transformation context instead. */ export const createPrivateIdentifier = Debug.deprecate(factory.createPrivateIdentifier, factoryDeprecation); diff --git a/src/harness/fourslashInterfaceImpl.ts b/src/harness/fourslashInterfaceImpl.ts index ab830bb0a5ed7..a281bf14043f7 100644 --- a/src/harness/fourslashInterfaceImpl.ts +++ b/src/harness/fourslashInterfaceImpl.ts @@ -1260,6 +1260,7 @@ namespace FourSlashInterface { export const classElementKeywords: readonly ExpectedCompletionEntryObject[] = [ "abstract", + "accessor", "async", "constructor", "declare", diff --git a/src/services/classifier.ts b/src/services/classifier.ts index ed8445b8f3987..ed87a6284417a 100644 --- a/src/services/classifier.ts +++ b/src/services/classifier.ts @@ -320,6 +320,7 @@ namespace ts { case SyntaxKind.SetKeyword: case SyntaxKind.ConstructorKeyword: case SyntaxKind.StaticKeyword: + case SyntaxKind.AccessorKeyword: return true; // Allow things like "public get", "public constructor" and "public static". default: return false; // Any other keyword following "public" is actually an identifier, not a real keyword. diff --git a/src/services/codefixes/generateAccessors.ts b/src/services/codefixes/generateAccessors.ts index 7486feab0648c..4fe71a352158a 100644 --- a/src/services/codefixes/generateAccessors.ts +++ b/src/services/codefixes/generateAccessors.ts @@ -29,18 +29,18 @@ namespace ts.codefix { suppressLeadingAndTrailingTrivia(declaration); suppressLeadingAndTrailingTrivia(container); - let accessorModifiers: NodeArray | undefined; + let accessorModifiers: readonly ModifierLike[] | undefined; let fieldModifiers: readonly ModifierLike[] | undefined; if (isClassLike(container)) { const modifierFlags = getEffectiveModifierFlags(declaration); if (isSourceFileJS(file)) { - const modifiers = createModifiers(modifierFlags); + const modifiers = factory.createModifiersFromModifierFlags(modifierFlags); accessorModifiers = modifiers; fieldModifiers = modifiers; } else { - accessorModifiers = createModifiers(prepareModifierFlagsForAccessor(modifierFlags)); - fieldModifiers = createModifiers(prepareModifierFlagsForField(modifierFlags)); + accessorModifiers = factory.createModifiersFromModifierFlags(prepareModifierFlagsForAccessor(modifierFlags)); + fieldModifiers = factory.createModifiersFromModifierFlags(prepareModifierFlagsForField(modifierFlags)); } if (canHaveDecorators(declaration)) { fieldModifiers = concatenate(getDecorators(declaration), fieldModifiers); @@ -146,7 +146,7 @@ namespace ts.codefix { }; } - function generateGetAccessor(fieldName: AcceptedNameType, accessorName: AcceptedNameType, type: TypeNode | undefined, modifiers: NodeArray | undefined, isStatic: boolean, container: ContainerDeclaration) { + function generateGetAccessor(fieldName: AcceptedNameType, accessorName: AcceptedNameType, type: TypeNode | undefined, modifiers: readonly ModifierLike[] | undefined, isStatic: boolean, container: ContainerDeclaration) { return factory.createGetAccessorDeclaration( modifiers, accessorName, @@ -160,7 +160,7 @@ namespace ts.codefix { ); } - function generateSetAccessor(fieldName: AcceptedNameType, accessorName: AcceptedNameType, type: TypeNode | undefined, modifiers: NodeArray | undefined, isStatic: boolean, container: ContainerDeclaration) { + function generateSetAccessor(fieldName: AcceptedNameType, accessorName: AcceptedNameType, type: TypeNode | undefined, modifiers: readonly ModifierLike[] | undefined, isStatic: boolean, container: ContainerDeclaration) { return factory.createSetAccessorDeclaration( modifiers, accessorName, diff --git a/src/services/completions.ts b/src/services/completions.ts index 2f6b940f7cf7d..ac998add7f2db 100644 --- a/src/services/completions.ts +++ b/src/services/completions.ts @@ -3970,6 +3970,7 @@ namespace ts.Completions { function isClassMemberCompletionKeyword(kind: SyntaxKind) { switch (kind) { case SyntaxKind.AbstractKeyword: + case SyntaxKind.AccessorKeyword: case SyntaxKind.ConstructorKeyword: case SyntaxKind.GetKeyword: case SyntaxKind.SetKeyword: diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts index 76cd5aa6e4f8e..1c6115aada758 100644 --- a/src/services/formatting/rules.ts +++ b/src/services/formatting/rules.ts @@ -149,6 +149,7 @@ namespace ts.formatting { "SpaceAfterCertainTypeScriptKeywords", [ SyntaxKind.AbstractKeyword, + SyntaxKind.AccessorKeyword, SyntaxKind.ClassKeyword, SyntaxKind.DeclareKeyword, SyntaxKind.DefaultKeyword, diff --git a/src/testRunner/compilerRunner.ts b/src/testRunner/compilerRunner.ts index 1d320d667cf5f..cb5779e579d6e 100644 --- a/src/testRunner/compilerRunner.ts +++ b/src/testRunner/compilerRunner.ts @@ -141,7 +141,8 @@ namespace Harness { "preserveConstEnums", "skipLibCheck", "exactOptionalPropertyTypes", - "useUnknownInCatchVariables" + "useUnknownInCatchVariables", + "useDefineForClassFields" ]; private fileName: string; private justName: string; diff --git a/tests/baselines/reference/accessorField1(target=es2015).js b/tests/baselines/reference/accessorField1(target=es2015).js new file mode 100644 index 0000000000000..e3a8a5baf03ce --- /dev/null +++ b/tests/baselines/reference/accessorField1(target=es2015).js @@ -0,0 +1,39 @@ +//// [accessorField1.ts] +class C1 { + accessor a: any; + accessor b = 1; + static accessor c: any; + static accessor d = 2; +} + + +//// [accessorField1.js] +var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +}; +var _a, _C1_a_accessor_storage, _C1_b_accessor_storage, _C1_c_accessor_storage, _C1_d_accessor_storage; +class C1 { + constructor() { + _C1_a_accessor_storage.set(this, void 0); + _C1_b_accessor_storage.set(this, 1); + } + get a() { return __classPrivateFieldGet(this, _C1_a_accessor_storage, "f"); } + set a(value) { __classPrivateFieldSet(this, _C1_a_accessor_storage, value, "f"); } + get b() { return __classPrivateFieldGet(this, _C1_b_accessor_storage, "f"); } + set b(value) { __classPrivateFieldSet(this, _C1_b_accessor_storage, value, "f"); } + static get c() { return __classPrivateFieldGet(this, _a, "f", _C1_c_accessor_storage); } + static set c(value) { __classPrivateFieldSet(this, _a, value, "f", _C1_c_accessor_storage); } + static get d() { return __classPrivateFieldGet(this, _a, "f", _C1_d_accessor_storage); } + static set d(value) { __classPrivateFieldSet(this, _a, value, "f", _C1_d_accessor_storage); } +} +_a = C1, _C1_a_accessor_storage = new WeakMap(), _C1_b_accessor_storage = new WeakMap(); +_C1_c_accessor_storage = { value: void 0 }; +_C1_d_accessor_storage = { value: 2 }; diff --git a/tests/baselines/reference/accessorField1(target=es2015).symbols b/tests/baselines/reference/accessorField1(target=es2015).symbols new file mode 100644 index 0000000000000..28111d6f8fdaf --- /dev/null +++ b/tests/baselines/reference/accessorField1(target=es2015).symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField1.ts, 0, 0)) + + accessor a: any; +>a : Symbol(C1.a, Decl(accessorField1.ts, 0, 10)) + + accessor b = 1; +>b : Symbol(C1.b, Decl(accessorField1.ts, 1, 20)) + + static accessor c: any; +>c : Symbol(C1.c, Decl(accessorField1.ts, 2, 19)) + + static accessor d = 2; +>d : Symbol(C1.d, Decl(accessorField1.ts, 3, 27)) +} + diff --git a/tests/baselines/reference/accessorField1(target=es2015).types b/tests/baselines/reference/accessorField1(target=es2015).types new file mode 100644 index 0000000000000..de41def82af66 --- /dev/null +++ b/tests/baselines/reference/accessorField1(target=es2015).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts === +class C1 { +>C1 : C1 + + accessor a: any; +>a : any + + accessor b = 1; +>b : number +>1 : 1 + + static accessor c: any; +>c : any + + static accessor d = 2; +>d : number +>2 : 2 +} + diff --git a/tests/baselines/reference/accessorField1(target=es2022).js b/tests/baselines/reference/accessorField1(target=es2022).js new file mode 100644 index 0000000000000..5c481928b48e0 --- /dev/null +++ b/tests/baselines/reference/accessorField1(target=es2022).js @@ -0,0 +1,24 @@ +//// [accessorField1.ts] +class C1 { + accessor a: any; + accessor b = 1; + static accessor c: any; + static accessor d = 2; +} + + +//// [accessorField1.js] +class C1 { + #a_accessor_storage; + get a() { return this.#a_accessor_storage; } + set a(value) { this.#a_accessor_storage = value; } + #b_accessor_storage = 1; + get b() { return this.#b_accessor_storage; } + set b(value) { this.#b_accessor_storage = value; } + static #c_accessor_storage; + static get c() { return this.#c_accessor_storage; } + static set c(value) { this.#c_accessor_storage = value; } + static #d_accessor_storage = 2; + static get d() { return this.#d_accessor_storage; } + static set d(value) { this.#d_accessor_storage = value; } +} diff --git a/tests/baselines/reference/accessorField1(target=es2022).symbols b/tests/baselines/reference/accessorField1(target=es2022).symbols new file mode 100644 index 0000000000000..28111d6f8fdaf --- /dev/null +++ b/tests/baselines/reference/accessorField1(target=es2022).symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField1.ts, 0, 0)) + + accessor a: any; +>a : Symbol(C1.a, Decl(accessorField1.ts, 0, 10)) + + accessor b = 1; +>b : Symbol(C1.b, Decl(accessorField1.ts, 1, 20)) + + static accessor c: any; +>c : Symbol(C1.c, Decl(accessorField1.ts, 2, 19)) + + static accessor d = 2; +>d : Symbol(C1.d, Decl(accessorField1.ts, 3, 27)) +} + diff --git a/tests/baselines/reference/accessorField1(target=es2022).types b/tests/baselines/reference/accessorField1(target=es2022).types new file mode 100644 index 0000000000000..de41def82af66 --- /dev/null +++ b/tests/baselines/reference/accessorField1(target=es2022).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts === +class C1 { +>C1 : C1 + + accessor a: any; +>a : any + + accessor b = 1; +>b : number +>1 : 1 + + static accessor c: any; +>c : any + + static accessor d = 2; +>d : number +>2 : 2 +} + diff --git a/tests/baselines/reference/accessorField1(target=es5).errors.txt b/tests/baselines/reference/accessorField1(target=es5).errors.txt new file mode 100644 index 0000000000000..c26af21198b94 --- /dev/null +++ b/tests/baselines/reference/accessorField1(target=es5).errors.txt @@ -0,0 +1,22 @@ +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts(2,14): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts(3,14): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts(4,21): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts(5,21): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + + +==== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts (4 errors) ==== + class C1 { + accessor a: any; + ~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + accessor b = 1; + ~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + static accessor c: any; + ~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + static accessor d = 2; + ~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + } + \ No newline at end of file diff --git a/tests/baselines/reference/accessorField1(target=es5).symbols b/tests/baselines/reference/accessorField1(target=es5).symbols new file mode 100644 index 0000000000000..28111d6f8fdaf --- /dev/null +++ b/tests/baselines/reference/accessorField1(target=es5).symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField1.ts, 0, 0)) + + accessor a: any; +>a : Symbol(C1.a, Decl(accessorField1.ts, 0, 10)) + + accessor b = 1; +>b : Symbol(C1.b, Decl(accessorField1.ts, 1, 20)) + + static accessor c: any; +>c : Symbol(C1.c, Decl(accessorField1.ts, 2, 19)) + + static accessor d = 2; +>d : Symbol(C1.d, Decl(accessorField1.ts, 3, 27)) +} + diff --git a/tests/baselines/reference/accessorField1(target=es5).types b/tests/baselines/reference/accessorField1(target=es5).types new file mode 100644 index 0000000000000..de41def82af66 --- /dev/null +++ b/tests/baselines/reference/accessorField1(target=es5).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts === +class C1 { +>C1 : C1 + + accessor a: any; +>a : any + + accessor b = 1; +>b : number +>1 : 1 + + static accessor c: any; +>c : any + + static accessor d = 2; +>d : number +>2 : 2 +} + diff --git a/tests/baselines/reference/accessorField1(target=esnext).js b/tests/baselines/reference/accessorField1(target=esnext).js new file mode 100644 index 0000000000000..9d9f7f3db7ccf --- /dev/null +++ b/tests/baselines/reference/accessorField1(target=esnext).js @@ -0,0 +1,16 @@ +//// [accessorField1.ts] +class C1 { + accessor a: any; + accessor b = 1; + static accessor c: any; + static accessor d = 2; +} + + +//// [accessorField1.js] +class C1 { + accessor a; + accessor b = 1; + static accessor c; + static accessor d = 2; +} diff --git a/tests/baselines/reference/accessorField1(target=esnext).symbols b/tests/baselines/reference/accessorField1(target=esnext).symbols new file mode 100644 index 0000000000000..28111d6f8fdaf --- /dev/null +++ b/tests/baselines/reference/accessorField1(target=esnext).symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField1.ts, 0, 0)) + + accessor a: any; +>a : Symbol(C1.a, Decl(accessorField1.ts, 0, 10)) + + accessor b = 1; +>b : Symbol(C1.b, Decl(accessorField1.ts, 1, 20)) + + static accessor c: any; +>c : Symbol(C1.c, Decl(accessorField1.ts, 2, 19)) + + static accessor d = 2; +>d : Symbol(C1.d, Decl(accessorField1.ts, 3, 27)) +} + diff --git a/tests/baselines/reference/accessorField1(target=esnext).types b/tests/baselines/reference/accessorField1(target=esnext).types new file mode 100644 index 0000000000000..de41def82af66 --- /dev/null +++ b/tests/baselines/reference/accessorField1(target=esnext).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts === +class C1 { +>C1 : C1 + + accessor a: any; +>a : any + + accessor b = 1; +>b : number +>1 : 1 + + static accessor c: any; +>c : any + + static accessor d = 2; +>d : number +>2 : 2 +} + diff --git a/tests/baselines/reference/accessorField2(target=es2015).js b/tests/baselines/reference/accessorField2(target=es2015).js new file mode 100644 index 0000000000000..029fdb486f896 --- /dev/null +++ b/tests/baselines/reference/accessorField2(target=es2015).js @@ -0,0 +1,20 @@ +//// [accessorField2.ts] +class C1 { + accessor #a: any; + accessor #b = 1; + static accessor #c: any; + static accessor #d = 2; +} + + +//// [accessorField2.js] +var _a, _C1_a, _C1_b, _C1_c, _C1_d, _C1_a_accessor_storage, _C1_b_accessor_storage, _C1_c_accessor_storage, _C1_d_accessor_storage; +class C1 { + constructor() { + _C1_a_accessor_storage.set(this, void 0); + _C1_b_accessor_storage.set(this, 1); + } +} +_a = C1, _C1_a = new WeakMap(), _C1_b = new WeakMap(), _C1_a_accessor_storage = new WeakMap(), _C1_b_accessor_storage = new WeakMap(); +_C1_c_accessor_storage = { value: void 0 }; +_C1_d_accessor_storage = { value: 2 }; diff --git a/tests/baselines/reference/accessorField2(target=es2015).symbols b/tests/baselines/reference/accessorField2(target=es2015).symbols new file mode 100644 index 0000000000000..383ce4cd0acd4 --- /dev/null +++ b/tests/baselines/reference/accessorField2(target=es2015).symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField2.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField2.ts, 0, 0)) + + accessor #a: any; +>#a : Symbol(C1.#a, Decl(accessorField2.ts, 0, 10)) + + accessor #b = 1; +>#b : Symbol(C1.#b, Decl(accessorField2.ts, 1, 21)) + + static accessor #c: any; +>#c : Symbol(C1.#c, Decl(accessorField2.ts, 2, 20)) + + static accessor #d = 2; +>#d : Symbol(C1.#d, Decl(accessorField2.ts, 3, 28)) +} + diff --git a/tests/baselines/reference/accessorField2(target=es2015).types b/tests/baselines/reference/accessorField2(target=es2015).types new file mode 100644 index 0000000000000..d0a26bbe75da5 --- /dev/null +++ b/tests/baselines/reference/accessorField2(target=es2015).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField2.ts === +class C1 { +>C1 : C1 + + accessor #a: any; +>#a : any + + accessor #b = 1; +>#b : number +>1 : 1 + + static accessor #c: any; +>#c : any + + static accessor #d = 2; +>#d : number +>2 : 2 +} + diff --git a/tests/baselines/reference/accessorField2(target=es2022).js b/tests/baselines/reference/accessorField2(target=es2022).js new file mode 100644 index 0000000000000..0c94a3da6cf5a --- /dev/null +++ b/tests/baselines/reference/accessorField2(target=es2022).js @@ -0,0 +1,24 @@ +//// [accessorField2.ts] +class C1 { + accessor #a: any; + accessor #b = 1; + static accessor #c: any; + static accessor #d = 2; +} + + +//// [accessorField2.js] +class C1 { + #a_accessor_storage; + get #a() { return this.#a_accessor_storage; } + set #a(value) { this.#a_accessor_storage = value; } + #b_accessor_storage = 1; + get #b() { return this.#b_accessor_storage; } + set #b(value) { this.#b_accessor_storage = value; } + static #c_accessor_storage; + static get #c() { return this.#c_accessor_storage; } + static set #c(value) { this.#c_accessor_storage = value; } + static #d_accessor_storage = 2; + static get #d() { return this.#d_accessor_storage; } + static set #d(value) { this.#d_accessor_storage = value; } +} diff --git a/tests/baselines/reference/accessorField2(target=es2022).symbols b/tests/baselines/reference/accessorField2(target=es2022).symbols new file mode 100644 index 0000000000000..383ce4cd0acd4 --- /dev/null +++ b/tests/baselines/reference/accessorField2(target=es2022).symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField2.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField2.ts, 0, 0)) + + accessor #a: any; +>#a : Symbol(C1.#a, Decl(accessorField2.ts, 0, 10)) + + accessor #b = 1; +>#b : Symbol(C1.#b, Decl(accessorField2.ts, 1, 21)) + + static accessor #c: any; +>#c : Symbol(C1.#c, Decl(accessorField2.ts, 2, 20)) + + static accessor #d = 2; +>#d : Symbol(C1.#d, Decl(accessorField2.ts, 3, 28)) +} + diff --git a/tests/baselines/reference/accessorField2(target=es2022).types b/tests/baselines/reference/accessorField2(target=es2022).types new file mode 100644 index 0000000000000..d0a26bbe75da5 --- /dev/null +++ b/tests/baselines/reference/accessorField2(target=es2022).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField2.ts === +class C1 { +>C1 : C1 + + accessor #a: any; +>#a : any + + accessor #b = 1; +>#b : number +>1 : 1 + + static accessor #c: any; +>#c : any + + static accessor #d = 2; +>#d : number +>2 : 2 +} + diff --git a/tests/baselines/reference/accessorField2(target=esnext).js b/tests/baselines/reference/accessorField2(target=esnext).js new file mode 100644 index 0000000000000..0d809686b4397 --- /dev/null +++ b/tests/baselines/reference/accessorField2(target=esnext).js @@ -0,0 +1,16 @@ +//// [accessorField2.ts] +class C1 { + accessor #a: any; + accessor #b = 1; + static accessor #c: any; + static accessor #d = 2; +} + + +//// [accessorField2.js] +class C1 { + accessor #a; + accessor #b = 1; + static accessor #c; + static accessor #d = 2; +} diff --git a/tests/baselines/reference/accessorField2(target=esnext).symbols b/tests/baselines/reference/accessorField2(target=esnext).symbols new file mode 100644 index 0000000000000..383ce4cd0acd4 --- /dev/null +++ b/tests/baselines/reference/accessorField2(target=esnext).symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField2.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField2.ts, 0, 0)) + + accessor #a: any; +>#a : Symbol(C1.#a, Decl(accessorField2.ts, 0, 10)) + + accessor #b = 1; +>#b : Symbol(C1.#b, Decl(accessorField2.ts, 1, 21)) + + static accessor #c: any; +>#c : Symbol(C1.#c, Decl(accessorField2.ts, 2, 20)) + + static accessor #d = 2; +>#d : Symbol(C1.#d, Decl(accessorField2.ts, 3, 28)) +} + diff --git a/tests/baselines/reference/accessorField2(target=esnext).types b/tests/baselines/reference/accessorField2(target=esnext).types new file mode 100644 index 0000000000000..d0a26bbe75da5 --- /dev/null +++ b/tests/baselines/reference/accessorField2(target=esnext).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField2.ts === +class C1 { +>C1 : C1 + + accessor #a: any; +>#a : any + + accessor #b = 1; +>#b : number +>1 : 1 + + static accessor #c: any; +>#c : any + + static accessor #d = 2; +>#d : number +>2 : 2 +} + diff --git a/tests/baselines/reference/accessorField3(target=es2015).js b/tests/baselines/reference/accessorField3(target=es2015).js new file mode 100644 index 0000000000000..302d5fdc600eb --- /dev/null +++ b/tests/baselines/reference/accessorField3(target=es2015).js @@ -0,0 +1,39 @@ +//// [accessorField3.ts] +class C1 { + accessor "w": any; + accessor "x" = 1; + static accessor "y": any; + static accessor "z" = 2; +} + + +//// [accessorField3.js] +var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +}; +var _a, _C1__a_accessor_storage, _C1__b_accessor_storage, _C1__c_accessor_storage, _C1__d_accessor_storage; +class C1 { + constructor() { + _C1__a_accessor_storage.set(this, void 0); + _C1__b_accessor_storage.set(this, 1); + } + get "w"() { return __classPrivateFieldGet(this, _C1__a_accessor_storage, "f"); } + set "w"(value) { __classPrivateFieldSet(this, _C1__a_accessor_storage, value, "f"); } + get "x"() { return __classPrivateFieldGet(this, _C1__b_accessor_storage, "f"); } + set "x"(value) { __classPrivateFieldSet(this, _C1__b_accessor_storage, value, "f"); } + static get "y"() { return __classPrivateFieldGet(this, _a, "f", _C1__c_accessor_storage); } + static set "y"(value) { __classPrivateFieldSet(this, _a, value, "f", _C1__c_accessor_storage); } + static get "z"() { return __classPrivateFieldGet(this, _a, "f", _C1__d_accessor_storage); } + static set "z"(value) { __classPrivateFieldSet(this, _a, value, "f", _C1__d_accessor_storage); } +} +_a = C1, _C1__a_accessor_storage = new WeakMap(), _C1__b_accessor_storage = new WeakMap(); +_C1__c_accessor_storage = { value: void 0 }; +_C1__d_accessor_storage = { value: 2 }; diff --git a/tests/baselines/reference/accessorField3(target=es2015).symbols b/tests/baselines/reference/accessorField3(target=es2015).symbols new file mode 100644 index 0000000000000..0312c5a3cd1a4 --- /dev/null +++ b/tests/baselines/reference/accessorField3(target=es2015).symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField3.ts, 0, 0)) + + accessor "w": any; +>"w" : Symbol(C1["w"], Decl(accessorField3.ts, 0, 10)) + + accessor "x" = 1; +>"x" : Symbol(C1["x"], Decl(accessorField3.ts, 1, 22)) + + static accessor "y": any; +>"y" : Symbol(C1["y"], Decl(accessorField3.ts, 2, 21)) + + static accessor "z" = 2; +>"z" : Symbol(C1["z"], Decl(accessorField3.ts, 3, 29)) +} + diff --git a/tests/baselines/reference/accessorField3(target=es2015).types b/tests/baselines/reference/accessorField3(target=es2015).types new file mode 100644 index 0000000000000..4434ebeda37a4 --- /dev/null +++ b/tests/baselines/reference/accessorField3(target=es2015).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts === +class C1 { +>C1 : C1 + + accessor "w": any; +>"w" : any + + accessor "x" = 1; +>"x" : number +>1 : 1 + + static accessor "y": any; +>"y" : any + + static accessor "z" = 2; +>"z" : number +>2 : 2 +} + diff --git a/tests/baselines/reference/accessorField3(target=es2022).js b/tests/baselines/reference/accessorField3(target=es2022).js new file mode 100644 index 0000000000000..4cb2eed6d7678 --- /dev/null +++ b/tests/baselines/reference/accessorField3(target=es2022).js @@ -0,0 +1,24 @@ +//// [accessorField3.ts] +class C1 { + accessor "w": any; + accessor "x" = 1; + static accessor "y": any; + static accessor "z" = 2; +} + + +//// [accessorField3.js] +class C1 { + #_a_accessor_storage; + get "w"() { return this.#_a_accessor_storage; } + set "w"(value) { this.#_a_accessor_storage = value; } + #_b_accessor_storage = 1; + get "x"() { return this.#_b_accessor_storage; } + set "x"(value) { this.#_b_accessor_storage = value; } + static #_c_accessor_storage; + static get "y"() { return this.#_c_accessor_storage; } + static set "y"(value) { this.#_c_accessor_storage = value; } + static #_d_accessor_storage = 2; + static get "z"() { return this.#_d_accessor_storage; } + static set "z"(value) { this.#_d_accessor_storage = value; } +} diff --git a/tests/baselines/reference/accessorField3(target=es2022).symbols b/tests/baselines/reference/accessorField3(target=es2022).symbols new file mode 100644 index 0000000000000..0312c5a3cd1a4 --- /dev/null +++ b/tests/baselines/reference/accessorField3(target=es2022).symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField3.ts, 0, 0)) + + accessor "w": any; +>"w" : Symbol(C1["w"], Decl(accessorField3.ts, 0, 10)) + + accessor "x" = 1; +>"x" : Symbol(C1["x"], Decl(accessorField3.ts, 1, 22)) + + static accessor "y": any; +>"y" : Symbol(C1["y"], Decl(accessorField3.ts, 2, 21)) + + static accessor "z" = 2; +>"z" : Symbol(C1["z"], Decl(accessorField3.ts, 3, 29)) +} + diff --git a/tests/baselines/reference/accessorField3(target=es2022).types b/tests/baselines/reference/accessorField3(target=es2022).types new file mode 100644 index 0000000000000..4434ebeda37a4 --- /dev/null +++ b/tests/baselines/reference/accessorField3(target=es2022).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts === +class C1 { +>C1 : C1 + + accessor "w": any; +>"w" : any + + accessor "x" = 1; +>"x" : number +>1 : 1 + + static accessor "y": any; +>"y" : any + + static accessor "z" = 2; +>"z" : number +>2 : 2 +} + diff --git a/tests/baselines/reference/accessorField3(target=es5).errors.txt b/tests/baselines/reference/accessorField3(target=es5).errors.txt new file mode 100644 index 0000000000000..8e1c319e6ac77 --- /dev/null +++ b/tests/baselines/reference/accessorField3(target=es5).errors.txt @@ -0,0 +1,22 @@ +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts(2,14): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts(3,14): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts(4,21): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts(5,21): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + + +==== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts (4 errors) ==== + class C1 { + accessor "w": any; + ~~~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + accessor "x" = 1; + ~~~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + static accessor "y": any; + ~~~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + static accessor "z" = 2; + ~~~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + } + \ No newline at end of file diff --git a/tests/baselines/reference/accessorField3(target=es5).symbols b/tests/baselines/reference/accessorField3(target=es5).symbols new file mode 100644 index 0000000000000..0312c5a3cd1a4 --- /dev/null +++ b/tests/baselines/reference/accessorField3(target=es5).symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField3.ts, 0, 0)) + + accessor "w": any; +>"w" : Symbol(C1["w"], Decl(accessorField3.ts, 0, 10)) + + accessor "x" = 1; +>"x" : Symbol(C1["x"], Decl(accessorField3.ts, 1, 22)) + + static accessor "y": any; +>"y" : Symbol(C1["y"], Decl(accessorField3.ts, 2, 21)) + + static accessor "z" = 2; +>"z" : Symbol(C1["z"], Decl(accessorField3.ts, 3, 29)) +} + diff --git a/tests/baselines/reference/accessorField3(target=es5).types b/tests/baselines/reference/accessorField3(target=es5).types new file mode 100644 index 0000000000000..4434ebeda37a4 --- /dev/null +++ b/tests/baselines/reference/accessorField3(target=es5).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts === +class C1 { +>C1 : C1 + + accessor "w": any; +>"w" : any + + accessor "x" = 1; +>"x" : number +>1 : 1 + + static accessor "y": any; +>"y" : any + + static accessor "z" = 2; +>"z" : number +>2 : 2 +} + diff --git a/tests/baselines/reference/accessorField3(target=esnext).js b/tests/baselines/reference/accessorField3(target=esnext).js new file mode 100644 index 0000000000000..6535fef4ac5d9 --- /dev/null +++ b/tests/baselines/reference/accessorField3(target=esnext).js @@ -0,0 +1,16 @@ +//// [accessorField3.ts] +class C1 { + accessor "w": any; + accessor "x" = 1; + static accessor "y": any; + static accessor "z" = 2; +} + + +//// [accessorField3.js] +class C1 { + accessor "w"; + accessor "x" = 1; + static accessor "y"; + static accessor "z" = 2; +} diff --git a/tests/baselines/reference/accessorField3(target=esnext).symbols b/tests/baselines/reference/accessorField3(target=esnext).symbols new file mode 100644 index 0000000000000..0312c5a3cd1a4 --- /dev/null +++ b/tests/baselines/reference/accessorField3(target=esnext).symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField3.ts, 0, 0)) + + accessor "w": any; +>"w" : Symbol(C1["w"], Decl(accessorField3.ts, 0, 10)) + + accessor "x" = 1; +>"x" : Symbol(C1["x"], Decl(accessorField3.ts, 1, 22)) + + static accessor "y": any; +>"y" : Symbol(C1["y"], Decl(accessorField3.ts, 2, 21)) + + static accessor "z" = 2; +>"z" : Symbol(C1["z"], Decl(accessorField3.ts, 3, 29)) +} + diff --git a/tests/baselines/reference/accessorField3(target=esnext).types b/tests/baselines/reference/accessorField3(target=esnext).types new file mode 100644 index 0000000000000..4434ebeda37a4 --- /dev/null +++ b/tests/baselines/reference/accessorField3(target=esnext).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts === +class C1 { +>C1 : C1 + + accessor "w": any; +>"w" : any + + accessor "x" = 1; +>"x" : number +>1 : 1 + + static accessor "y": any; +>"y" : any + + static accessor "z" = 2; +>"z" : number +>2 : 2 +} + diff --git a/tests/baselines/reference/accessorField4(target=es2015).js b/tests/baselines/reference/accessorField4(target=es2015).js new file mode 100644 index 0000000000000..8631dca33e409 --- /dev/null +++ b/tests/baselines/reference/accessorField4(target=es2015).js @@ -0,0 +1,39 @@ +//// [accessorField4.ts] +class C1 { + accessor 0: any; + accessor 1 = 1; + static accessor 2: any; + static accessor 3 = 2; +} + + +//// [accessorField4.js] +var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +}; +var _a, _C1__a_accessor_storage, _C1__b_accessor_storage, _C1__c_accessor_storage, _C1__d_accessor_storage; +class C1 { + constructor() { + _C1__a_accessor_storage.set(this, void 0); + _C1__b_accessor_storage.set(this, 1); + } + get 0() { return __classPrivateFieldGet(this, _C1__a_accessor_storage, "f"); } + set 0(value) { __classPrivateFieldSet(this, _C1__a_accessor_storage, value, "f"); } + get 1() { return __classPrivateFieldGet(this, _C1__b_accessor_storage, "f"); } + set 1(value) { __classPrivateFieldSet(this, _C1__b_accessor_storage, value, "f"); } + static get 2() { return __classPrivateFieldGet(this, _a, "f", _C1__c_accessor_storage); } + static set 2(value) { __classPrivateFieldSet(this, _a, value, "f", _C1__c_accessor_storage); } + static get 3() { return __classPrivateFieldGet(this, _a, "f", _C1__d_accessor_storage); } + static set 3(value) { __classPrivateFieldSet(this, _a, value, "f", _C1__d_accessor_storage); } +} +_a = C1, _C1__a_accessor_storage = new WeakMap(), _C1__b_accessor_storage = new WeakMap(); +_C1__c_accessor_storage = { value: void 0 }; +_C1__d_accessor_storage = { value: 2 }; diff --git a/tests/baselines/reference/accessorField4(target=es2015).symbols b/tests/baselines/reference/accessorField4(target=es2015).symbols new file mode 100644 index 0000000000000..7720dcdf7d897 --- /dev/null +++ b/tests/baselines/reference/accessorField4(target=es2015).symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField4.ts, 0, 0)) + + accessor 0: any; +>0 : Symbol(C1[0], Decl(accessorField4.ts, 0, 10)) + + accessor 1 = 1; +>1 : Symbol(C1[1], Decl(accessorField4.ts, 1, 20)) + + static accessor 2: any; +>2 : Symbol(C1[2], Decl(accessorField4.ts, 2, 19)) + + static accessor 3 = 2; +>3 : Symbol(C1[3], Decl(accessorField4.ts, 3, 27)) +} + diff --git a/tests/baselines/reference/accessorField4(target=es2015).types b/tests/baselines/reference/accessorField4(target=es2015).types new file mode 100644 index 0000000000000..702dc296d9b4c --- /dev/null +++ b/tests/baselines/reference/accessorField4(target=es2015).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts === +class C1 { +>C1 : C1 + + accessor 0: any; +>0 : any + + accessor 1 = 1; +>1 : number +>1 : 1 + + static accessor 2: any; +>2 : any + + static accessor 3 = 2; +>3 : number +>2 : 2 +} + diff --git a/tests/baselines/reference/accessorField4(target=es2022).js b/tests/baselines/reference/accessorField4(target=es2022).js new file mode 100644 index 0000000000000..603b4bd3999b1 --- /dev/null +++ b/tests/baselines/reference/accessorField4(target=es2022).js @@ -0,0 +1,24 @@ +//// [accessorField4.ts] +class C1 { + accessor 0: any; + accessor 1 = 1; + static accessor 2: any; + static accessor 3 = 2; +} + + +//// [accessorField4.js] +class C1 { + #_a_accessor_storage; + get 0() { return this.#_a_accessor_storage; } + set 0(value) { this.#_a_accessor_storage = value; } + #_b_accessor_storage = 1; + get 1() { return this.#_b_accessor_storage; } + set 1(value) { this.#_b_accessor_storage = value; } + static #_c_accessor_storage; + static get 2() { return this.#_c_accessor_storage; } + static set 2(value) { this.#_c_accessor_storage = value; } + static #_d_accessor_storage = 2; + static get 3() { return this.#_d_accessor_storage; } + static set 3(value) { this.#_d_accessor_storage = value; } +} diff --git a/tests/baselines/reference/accessorField4(target=es2022).symbols b/tests/baselines/reference/accessorField4(target=es2022).symbols new file mode 100644 index 0000000000000..7720dcdf7d897 --- /dev/null +++ b/tests/baselines/reference/accessorField4(target=es2022).symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField4.ts, 0, 0)) + + accessor 0: any; +>0 : Symbol(C1[0], Decl(accessorField4.ts, 0, 10)) + + accessor 1 = 1; +>1 : Symbol(C1[1], Decl(accessorField4.ts, 1, 20)) + + static accessor 2: any; +>2 : Symbol(C1[2], Decl(accessorField4.ts, 2, 19)) + + static accessor 3 = 2; +>3 : Symbol(C1[3], Decl(accessorField4.ts, 3, 27)) +} + diff --git a/tests/baselines/reference/accessorField4(target=es2022).types b/tests/baselines/reference/accessorField4(target=es2022).types new file mode 100644 index 0000000000000..702dc296d9b4c --- /dev/null +++ b/tests/baselines/reference/accessorField4(target=es2022).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts === +class C1 { +>C1 : C1 + + accessor 0: any; +>0 : any + + accessor 1 = 1; +>1 : number +>1 : 1 + + static accessor 2: any; +>2 : any + + static accessor 3 = 2; +>3 : number +>2 : 2 +} + diff --git a/tests/baselines/reference/accessorField4(target=es5).errors.txt b/tests/baselines/reference/accessorField4(target=es5).errors.txt new file mode 100644 index 0000000000000..f2475966eeb4b --- /dev/null +++ b/tests/baselines/reference/accessorField4(target=es5).errors.txt @@ -0,0 +1,22 @@ +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts(2,14): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts(3,14): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts(4,21): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts(5,21): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + + +==== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts (4 errors) ==== + class C1 { + accessor 0: any; + ~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + accessor 1 = 1; + ~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + static accessor 2: any; + ~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + static accessor 3 = 2; + ~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + } + \ No newline at end of file diff --git a/tests/baselines/reference/accessorField4(target=es5).symbols b/tests/baselines/reference/accessorField4(target=es5).symbols new file mode 100644 index 0000000000000..7720dcdf7d897 --- /dev/null +++ b/tests/baselines/reference/accessorField4(target=es5).symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField4.ts, 0, 0)) + + accessor 0: any; +>0 : Symbol(C1[0], Decl(accessorField4.ts, 0, 10)) + + accessor 1 = 1; +>1 : Symbol(C1[1], Decl(accessorField4.ts, 1, 20)) + + static accessor 2: any; +>2 : Symbol(C1[2], Decl(accessorField4.ts, 2, 19)) + + static accessor 3 = 2; +>3 : Symbol(C1[3], Decl(accessorField4.ts, 3, 27)) +} + diff --git a/tests/baselines/reference/accessorField4(target=es5).types b/tests/baselines/reference/accessorField4(target=es5).types new file mode 100644 index 0000000000000..702dc296d9b4c --- /dev/null +++ b/tests/baselines/reference/accessorField4(target=es5).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts === +class C1 { +>C1 : C1 + + accessor 0: any; +>0 : any + + accessor 1 = 1; +>1 : number +>1 : 1 + + static accessor 2: any; +>2 : any + + static accessor 3 = 2; +>3 : number +>2 : 2 +} + diff --git a/tests/baselines/reference/accessorField4(target=esnext).js b/tests/baselines/reference/accessorField4(target=esnext).js new file mode 100644 index 0000000000000..b0eafbf87f317 --- /dev/null +++ b/tests/baselines/reference/accessorField4(target=esnext).js @@ -0,0 +1,16 @@ +//// [accessorField4.ts] +class C1 { + accessor 0: any; + accessor 1 = 1; + static accessor 2: any; + static accessor 3 = 2; +} + + +//// [accessorField4.js] +class C1 { + accessor 0; + accessor 1 = 1; + static accessor 2; + static accessor 3 = 2; +} diff --git a/tests/baselines/reference/accessorField4(target=esnext).symbols b/tests/baselines/reference/accessorField4(target=esnext).symbols new file mode 100644 index 0000000000000..7720dcdf7d897 --- /dev/null +++ b/tests/baselines/reference/accessorField4(target=esnext).symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField4.ts, 0, 0)) + + accessor 0: any; +>0 : Symbol(C1[0], Decl(accessorField4.ts, 0, 10)) + + accessor 1 = 1; +>1 : Symbol(C1[1], Decl(accessorField4.ts, 1, 20)) + + static accessor 2: any; +>2 : Symbol(C1[2], Decl(accessorField4.ts, 2, 19)) + + static accessor 3 = 2; +>3 : Symbol(C1[3], Decl(accessorField4.ts, 3, 27)) +} + diff --git a/tests/baselines/reference/accessorField4(target=esnext).types b/tests/baselines/reference/accessorField4(target=esnext).types new file mode 100644 index 0000000000000..702dc296d9b4c --- /dev/null +++ b/tests/baselines/reference/accessorField4(target=esnext).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts === +class C1 { +>C1 : C1 + + accessor 0: any; +>0 : any + + accessor 1 = 1; +>1 : number +>1 : 1 + + static accessor 2: any; +>2 : any + + static accessor 3 = 2; +>3 : number +>2 : 2 +} + diff --git a/tests/baselines/reference/accessorField5(target=es2015).js b/tests/baselines/reference/accessorField5(target=es2015).js new file mode 100644 index 0000000000000..6e5f0cab385aa --- /dev/null +++ b/tests/baselines/reference/accessorField5(target=es2015).js @@ -0,0 +1,53 @@ +//// [accessorField5.ts] +class C1 { + accessor ["w"]: any; + accessor ["x"] = 1; + static accessor ["y"]: any; + static accessor ["z"] = 2; +} + +declare var f: any; +class C2 { + // @ts-ignore + accessor [f()] = 1; +} + +//// [accessorField5.js] +var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +}; +var _a, _C1__a_accessor_storage, _C1__b_accessor_storage, _C1__c_accessor_storage, _C1__d_accessor_storage, _C2__e_accessor_storage, _b; +class C1 { + constructor() { + _C1__a_accessor_storage.set(this, void 0); + _C1__b_accessor_storage.set(this, 1); + } + get [(_C1__a_accessor_storage = new WeakMap(), _C1__b_accessor_storage = new WeakMap(), "w")]() { return __classPrivateFieldGet(this, _C1__a_accessor_storage, "f"); } + set ["w"](value) { __classPrivateFieldSet(this, _C1__a_accessor_storage, value, "f"); } + get ["x"]() { return __classPrivateFieldGet(this, _C1__b_accessor_storage, "f"); } + set ["x"](value) { __classPrivateFieldSet(this, _C1__b_accessor_storage, value, "f"); } + static get ["y"]() { return __classPrivateFieldGet(this, _a, "f", _C1__c_accessor_storage); } + static set ["y"](value) { __classPrivateFieldSet(this, _a, value, "f", _C1__c_accessor_storage); } + static get ["z"]() { return __classPrivateFieldGet(this, _a, "f", _C1__d_accessor_storage); } + static set ["z"](value) { __classPrivateFieldSet(this, _a, value, "f", _C1__d_accessor_storage); } +} +_a = C1; +_C1__c_accessor_storage = { value: void 0 }; +_C1__d_accessor_storage = { value: 2 }; +class C2 { + constructor() { + // @ts-ignore + _C2__e_accessor_storage.set(this, 1); + } + // @ts-ignore + get [(_C2__e_accessor_storage = new WeakMap(), _b = f(), _b)]() { return __classPrivateFieldGet(this, _C2__e_accessor_storage, "f"); } + set [_b](value) { __classPrivateFieldSet(this, _C2__e_accessor_storage, value, "f"); } +} diff --git a/tests/baselines/reference/accessorField5(target=es2015).symbols b/tests/baselines/reference/accessorField5(target=es2015).symbols new file mode 100644 index 0000000000000..e09a9785dc30f --- /dev/null +++ b/tests/baselines/reference/accessorField5(target=es2015).symbols @@ -0,0 +1,32 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField5.ts, 0, 0)) + + accessor ["w"]: any; +>["w"] : Symbol(C1["w"], Decl(accessorField5.ts, 0, 10)) +>"w" : Symbol(C1["w"], Decl(accessorField5.ts, 0, 10)) + + accessor ["x"] = 1; +>["x"] : Symbol(C1["x"], Decl(accessorField5.ts, 1, 24)) +>"x" : Symbol(C1["x"], Decl(accessorField5.ts, 1, 24)) + + static accessor ["y"]: any; +>["y"] : Symbol(C1["y"], Decl(accessorField5.ts, 2, 23)) +>"y" : Symbol(C1["y"], Decl(accessorField5.ts, 2, 23)) + + static accessor ["z"] = 2; +>["z"] : Symbol(C1["z"], Decl(accessorField5.ts, 3, 31)) +>"z" : Symbol(C1["z"], Decl(accessorField5.ts, 3, 31)) +} + +declare var f: any; +>f : Symbol(f, Decl(accessorField5.ts, 7, 11)) + +class C2 { +>C2 : Symbol(C2, Decl(accessorField5.ts, 7, 19)) + + // @ts-ignore + accessor [f()] = 1; +>[f()] : Symbol(C2[f()], Decl(accessorField5.ts, 8, 10)) +>f : Symbol(f, Decl(accessorField5.ts, 7, 11)) +} diff --git a/tests/baselines/reference/accessorField5(target=es2015).types b/tests/baselines/reference/accessorField5(target=es2015).types new file mode 100644 index 0000000000000..60b575def5744 --- /dev/null +++ b/tests/baselines/reference/accessorField5(target=es2015).types @@ -0,0 +1,36 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts === +class C1 { +>C1 : C1 + + accessor ["w"]: any; +>["w"] : any +>"w" : "w" + + accessor ["x"] = 1; +>["x"] : number +>"x" : "x" +>1 : 1 + + static accessor ["y"]: any; +>["y"] : any +>"y" : "y" + + static accessor ["z"] = 2; +>["z"] : number +>"z" : "z" +>2 : 2 +} + +declare var f: any; +>f : any + +class C2 { +>C2 : C2 + + // @ts-ignore + accessor [f()] = 1; +>[f()] : number +>f() : any +>f : any +>1 : 1 +} diff --git a/tests/baselines/reference/accessorField5(target=es2022).js b/tests/baselines/reference/accessorField5(target=es2022).js new file mode 100644 index 0000000000000..2388795f8ac3e --- /dev/null +++ b/tests/baselines/reference/accessorField5(target=es2022).js @@ -0,0 +1,36 @@ +//// [accessorField5.ts] +class C1 { + accessor ["w"]: any; + accessor ["x"] = 1; + static accessor ["y"]: any; + static accessor ["z"] = 2; +} + +declare var f: any; +class C2 { + // @ts-ignore + accessor [f()] = 1; +} + +//// [accessorField5.js] +var _a; +class C1 { + #_a_accessor_storage; + get ["w"]() { return this.#_a_accessor_storage; } + set ["w"](value) { this.#_a_accessor_storage = value; } + #_b_accessor_storage = 1; + get ["x"]() { return this.#_b_accessor_storage; } + set ["x"](value) { this.#_b_accessor_storage = value; } + static #_c_accessor_storage; + static get ["y"]() { return this.#_c_accessor_storage; } + static set ["y"](value) { this.#_c_accessor_storage = value; } + static #_d_accessor_storage = 2; + static get ["z"]() { return this.#_d_accessor_storage; } + static set ["z"](value) { this.#_d_accessor_storage = value; } +} +class C2 { + #_e_accessor_storage = 1; + // @ts-ignore + get [(_a = f(), _a)]() { return this.#_e_accessor_storage; } + set [_a](value) { this.#_e_accessor_storage = value; } +} diff --git a/tests/baselines/reference/accessorField5(target=es2022).symbols b/tests/baselines/reference/accessorField5(target=es2022).symbols new file mode 100644 index 0000000000000..e09a9785dc30f --- /dev/null +++ b/tests/baselines/reference/accessorField5(target=es2022).symbols @@ -0,0 +1,32 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField5.ts, 0, 0)) + + accessor ["w"]: any; +>["w"] : Symbol(C1["w"], Decl(accessorField5.ts, 0, 10)) +>"w" : Symbol(C1["w"], Decl(accessorField5.ts, 0, 10)) + + accessor ["x"] = 1; +>["x"] : Symbol(C1["x"], Decl(accessorField5.ts, 1, 24)) +>"x" : Symbol(C1["x"], Decl(accessorField5.ts, 1, 24)) + + static accessor ["y"]: any; +>["y"] : Symbol(C1["y"], Decl(accessorField5.ts, 2, 23)) +>"y" : Symbol(C1["y"], Decl(accessorField5.ts, 2, 23)) + + static accessor ["z"] = 2; +>["z"] : Symbol(C1["z"], Decl(accessorField5.ts, 3, 31)) +>"z" : Symbol(C1["z"], Decl(accessorField5.ts, 3, 31)) +} + +declare var f: any; +>f : Symbol(f, Decl(accessorField5.ts, 7, 11)) + +class C2 { +>C2 : Symbol(C2, Decl(accessorField5.ts, 7, 19)) + + // @ts-ignore + accessor [f()] = 1; +>[f()] : Symbol(C2[f()], Decl(accessorField5.ts, 8, 10)) +>f : Symbol(f, Decl(accessorField5.ts, 7, 11)) +} diff --git a/tests/baselines/reference/accessorField5(target=es2022).types b/tests/baselines/reference/accessorField5(target=es2022).types new file mode 100644 index 0000000000000..60b575def5744 --- /dev/null +++ b/tests/baselines/reference/accessorField5(target=es2022).types @@ -0,0 +1,36 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts === +class C1 { +>C1 : C1 + + accessor ["w"]: any; +>["w"] : any +>"w" : "w" + + accessor ["x"] = 1; +>["x"] : number +>"x" : "x" +>1 : 1 + + static accessor ["y"]: any; +>["y"] : any +>"y" : "y" + + static accessor ["z"] = 2; +>["z"] : number +>"z" : "z" +>2 : 2 +} + +declare var f: any; +>f : any + +class C2 { +>C2 : C2 + + // @ts-ignore + accessor [f()] = 1; +>[f()] : number +>f() : any +>f : any +>1 : 1 +} diff --git a/tests/baselines/reference/accessorField5(target=es5).errors.txt b/tests/baselines/reference/accessorField5(target=es5).errors.txt new file mode 100644 index 0000000000000..0e791f39a877b --- /dev/null +++ b/tests/baselines/reference/accessorField5(target=es5).errors.txt @@ -0,0 +1,27 @@ +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts(2,14): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts(3,14): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts(4,21): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts(5,21): error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + + +==== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts (4 errors) ==== + class C1 { + accessor ["w"]: any; + ~~~~~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + accessor ["x"] = 1; + ~~~~~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + static accessor ["y"]: any; + ~~~~~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + static accessor ["z"] = 2; + ~~~~~ +!!! error TS18042: Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher. + } + + declare var f: any; + class C2 { + // @ts-ignore + accessor [f()] = 1; + } \ No newline at end of file diff --git a/tests/baselines/reference/accessorField5(target=es5).symbols b/tests/baselines/reference/accessorField5(target=es5).symbols new file mode 100644 index 0000000000000..e09a9785dc30f --- /dev/null +++ b/tests/baselines/reference/accessorField5(target=es5).symbols @@ -0,0 +1,32 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField5.ts, 0, 0)) + + accessor ["w"]: any; +>["w"] : Symbol(C1["w"], Decl(accessorField5.ts, 0, 10)) +>"w" : Symbol(C1["w"], Decl(accessorField5.ts, 0, 10)) + + accessor ["x"] = 1; +>["x"] : Symbol(C1["x"], Decl(accessorField5.ts, 1, 24)) +>"x" : Symbol(C1["x"], Decl(accessorField5.ts, 1, 24)) + + static accessor ["y"]: any; +>["y"] : Symbol(C1["y"], Decl(accessorField5.ts, 2, 23)) +>"y" : Symbol(C1["y"], Decl(accessorField5.ts, 2, 23)) + + static accessor ["z"] = 2; +>["z"] : Symbol(C1["z"], Decl(accessorField5.ts, 3, 31)) +>"z" : Symbol(C1["z"], Decl(accessorField5.ts, 3, 31)) +} + +declare var f: any; +>f : Symbol(f, Decl(accessorField5.ts, 7, 11)) + +class C2 { +>C2 : Symbol(C2, Decl(accessorField5.ts, 7, 19)) + + // @ts-ignore + accessor [f()] = 1; +>[f()] : Symbol(C2[f()], Decl(accessorField5.ts, 8, 10)) +>f : Symbol(f, Decl(accessorField5.ts, 7, 11)) +} diff --git a/tests/baselines/reference/accessorField5(target=es5).types b/tests/baselines/reference/accessorField5(target=es5).types new file mode 100644 index 0000000000000..60b575def5744 --- /dev/null +++ b/tests/baselines/reference/accessorField5(target=es5).types @@ -0,0 +1,36 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts === +class C1 { +>C1 : C1 + + accessor ["w"]: any; +>["w"] : any +>"w" : "w" + + accessor ["x"] = 1; +>["x"] : number +>"x" : "x" +>1 : 1 + + static accessor ["y"]: any; +>["y"] : any +>"y" : "y" + + static accessor ["z"] = 2; +>["z"] : number +>"z" : "z" +>2 : 2 +} + +declare var f: any; +>f : any + +class C2 { +>C2 : C2 + + // @ts-ignore + accessor [f()] = 1; +>[f()] : number +>f() : any +>f : any +>1 : 1 +} diff --git a/tests/baselines/reference/accessorField5(target=esnext).js b/tests/baselines/reference/accessorField5(target=esnext).js new file mode 100644 index 0000000000000..7c84d37e73c3d --- /dev/null +++ b/tests/baselines/reference/accessorField5(target=esnext).js @@ -0,0 +1,25 @@ +//// [accessorField5.ts] +class C1 { + accessor ["w"]: any; + accessor ["x"] = 1; + static accessor ["y"]: any; + static accessor ["z"] = 2; +} + +declare var f: any; +class C2 { + // @ts-ignore + accessor [f()] = 1; +} + +//// [accessorField5.js] +class C1 { + accessor ["w"]; + accessor ["x"] = 1; + static accessor ["y"]; + static accessor ["z"] = 2; +} +class C2 { + // @ts-ignore + accessor [f()] = 1; +} diff --git a/tests/baselines/reference/accessorField5(target=esnext).symbols b/tests/baselines/reference/accessorField5(target=esnext).symbols new file mode 100644 index 0000000000000..e09a9785dc30f --- /dev/null +++ b/tests/baselines/reference/accessorField5(target=esnext).symbols @@ -0,0 +1,32 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField5.ts, 0, 0)) + + accessor ["w"]: any; +>["w"] : Symbol(C1["w"], Decl(accessorField5.ts, 0, 10)) +>"w" : Symbol(C1["w"], Decl(accessorField5.ts, 0, 10)) + + accessor ["x"] = 1; +>["x"] : Symbol(C1["x"], Decl(accessorField5.ts, 1, 24)) +>"x" : Symbol(C1["x"], Decl(accessorField5.ts, 1, 24)) + + static accessor ["y"]: any; +>["y"] : Symbol(C1["y"], Decl(accessorField5.ts, 2, 23)) +>"y" : Symbol(C1["y"], Decl(accessorField5.ts, 2, 23)) + + static accessor ["z"] = 2; +>["z"] : Symbol(C1["z"], Decl(accessorField5.ts, 3, 31)) +>"z" : Symbol(C1["z"], Decl(accessorField5.ts, 3, 31)) +} + +declare var f: any; +>f : Symbol(f, Decl(accessorField5.ts, 7, 11)) + +class C2 { +>C2 : Symbol(C2, Decl(accessorField5.ts, 7, 19)) + + // @ts-ignore + accessor [f()] = 1; +>[f()] : Symbol(C2[f()], Decl(accessorField5.ts, 8, 10)) +>f : Symbol(f, Decl(accessorField5.ts, 7, 11)) +} diff --git a/tests/baselines/reference/accessorField5(target=esnext).types b/tests/baselines/reference/accessorField5(target=esnext).types new file mode 100644 index 0000000000000..60b575def5744 --- /dev/null +++ b/tests/baselines/reference/accessorField5(target=esnext).types @@ -0,0 +1,36 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts === +class C1 { +>C1 : C1 + + accessor ["w"]: any; +>["w"] : any +>"w" : "w" + + accessor ["x"] = 1; +>["x"] : number +>"x" : "x" +>1 : 1 + + static accessor ["y"]: any; +>["y"] : any +>"y" : "y" + + static accessor ["z"] = 2; +>["z"] : number +>"z" : "z" +>2 : 2 +} + +declare var f: any; +>f : any + +class C2 { +>C2 : C2 + + // @ts-ignore + accessor [f()] = 1; +>[f()] : number +>f() : any +>f : any +>1 : 1 +} diff --git a/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=false).errors.txt b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=false).errors.txt new file mode 100644 index 0000000000000..4a63914155538 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=false).errors.txt @@ -0,0 +1,18 @@ +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts(6,5): error TS2610: 'a' is defined as an accessor in class 'C1', but is overridden here in 'C2' as an instance property. + + +==== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts (1 errors) ==== + class C1 { + accessor a: any; + } + + class C2 extends C1 { + a = 1; + ~ +!!! error TS2610: 'a' is defined as an accessor in class 'C1', but is overridden here in 'C2' as an instance property. + } + + class C3 extends C1 { + get a() { return super.a; } + } + \ No newline at end of file diff --git a/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=false).js b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=false).js new file mode 100644 index 0000000000000..b2afea001fa94 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=false).js @@ -0,0 +1,41 @@ +//// [accessorField6.ts] +class C1 { + accessor a: any; +} + +class C2 extends C1 { + a = 1; +} + +class C3 extends C1 { + get a() { return super.a; } +} + + +//// [accessorField6.js] +var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +}; +var _C1_a_accessor_storage; +class C1 { + get a() { return __classPrivateFieldGet(this, _C1_a_accessor_storage, "f"); } + set a(value) { __classPrivateFieldSet(this, _C1_a_accessor_storage, value, "f"); } +} +_C1_a_accessor_storage = new WeakMap(); +class C2 extends C1 { + constructor() { + super(...arguments); + this.a = 1; + } +} +class C3 extends C1 { + get a() { return super.a; } +} diff --git a/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=false).symbols b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=false).symbols new file mode 100644 index 0000000000000..5b0d798ba80d5 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=false).symbols @@ -0,0 +1,27 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + accessor a: any; +>a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +} + +class C2 extends C1 { +>C2 : Symbol(C2, Decl(accessorField6.ts, 2, 1)) +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + a = 1; +>a : Symbol(C2.a, Decl(accessorField6.ts, 4, 21)) +} + +class C3 extends C1 { +>C3 : Symbol(C3, Decl(accessorField6.ts, 6, 1)) +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + get a() { return super.a; } +>a : Symbol(C3.a, Decl(accessorField6.ts, 8, 21)) +>super.a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +>super : Symbol(C1, Decl(accessorField6.ts, 0, 0)) +>a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +} + diff --git a/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=false).types b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=false).types new file mode 100644 index 0000000000000..a6b9efded46a1 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=false).types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts === +class C1 { +>C1 : C1 + + accessor a: any; +>a : any +} + +class C2 extends C1 { +>C2 : C2 +>C1 : C1 + + a = 1; +>a : number +>1 : 1 +} + +class C3 extends C1 { +>C3 : C3 +>C1 : C1 + + get a() { return super.a; } +>a : any +>super.a : any +>super : C1 +>a : any +} + diff --git a/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=true).errors.txt b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=true).errors.txt new file mode 100644 index 0000000000000..4a63914155538 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=true).errors.txt @@ -0,0 +1,18 @@ +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts(6,5): error TS2610: 'a' is defined as an accessor in class 'C1', but is overridden here in 'C2' as an instance property. + + +==== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts (1 errors) ==== + class C1 { + accessor a: any; + } + + class C2 extends C1 { + a = 1; + ~ +!!! error TS2610: 'a' is defined as an accessor in class 'C1', but is overridden here in 'C2' as an instance property. + } + + class C3 extends C1 { + get a() { return super.a; } + } + \ No newline at end of file diff --git a/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=true).js b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=true).js new file mode 100644 index 0000000000000..e217a7d9eb0c6 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=true).js @@ -0,0 +1,49 @@ +//// [accessorField6.ts] +class C1 { + accessor a: any; +} + +class C2 extends C1 { + a = 1; +} + +class C3 extends C1 { + get a() { return super.a; } +} + + +//// [accessorField6.js] +var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +}; +var _C1_a_accessor_storage; +class C1 { + constructor() { + _C1_a_accessor_storage.set(this, void 0); + } + get a() { return __classPrivateFieldGet(this, _C1_a_accessor_storage, "f"); } + set a(value) { __classPrivateFieldSet(this, _C1_a_accessor_storage, value, "f"); } +} +_C1_a_accessor_storage = new WeakMap(); +class C2 extends C1 { + constructor() { + super(...arguments); + Object.defineProperty(this, "a", { + enumerable: true, + configurable: true, + writable: true, + value: 1 + }); + } +} +class C3 extends C1 { + get a() { return super.a; } +} diff --git a/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=true).symbols b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=true).symbols new file mode 100644 index 0000000000000..5b0d798ba80d5 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=true).symbols @@ -0,0 +1,27 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + accessor a: any; +>a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +} + +class C2 extends C1 { +>C2 : Symbol(C2, Decl(accessorField6.ts, 2, 1)) +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + a = 1; +>a : Symbol(C2.a, Decl(accessorField6.ts, 4, 21)) +} + +class C3 extends C1 { +>C3 : Symbol(C3, Decl(accessorField6.ts, 6, 1)) +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + get a() { return super.a; } +>a : Symbol(C3.a, Decl(accessorField6.ts, 8, 21)) +>super.a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +>super : Symbol(C1, Decl(accessorField6.ts, 0, 0)) +>a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +} + diff --git a/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=true).types b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=true).types new file mode 100644 index 0000000000000..a6b9efded46a1 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2015,usedefineforclassfields=true).types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts === +class C1 { +>C1 : C1 + + accessor a: any; +>a : any +} + +class C2 extends C1 { +>C2 : C2 +>C1 : C1 + + a = 1; +>a : number +>1 : 1 +} + +class C3 extends C1 { +>C3 : C3 +>C1 : C1 + + get a() { return super.a; } +>a : any +>super.a : any +>super : C1 +>a : any +} + diff --git a/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=false).errors.txt b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=false).errors.txt new file mode 100644 index 0000000000000..4a63914155538 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=false).errors.txt @@ -0,0 +1,18 @@ +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts(6,5): error TS2610: 'a' is defined as an accessor in class 'C1', but is overridden here in 'C2' as an instance property. + + +==== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts (1 errors) ==== + class C1 { + accessor a: any; + } + + class C2 extends C1 { + a = 1; + ~ +!!! error TS2610: 'a' is defined as an accessor in class 'C1', but is overridden here in 'C2' as an instance property. + } + + class C3 extends C1 { + get a() { return super.a; } + } + \ No newline at end of file diff --git a/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=false).js b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=false).js new file mode 100644 index 0000000000000..27f356be65eef --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=false).js @@ -0,0 +1,29 @@ +//// [accessorField6.ts] +class C1 { + accessor a: any; +} + +class C2 extends C1 { + a = 1; +} + +class C3 extends C1 { + get a() { return super.a; } +} + + +//// [accessorField6.js] +class C1 { + #a_accessor_storage; + get a() { return this.#a_accessor_storage; } + set a(value) { this.#a_accessor_storage = value; } +} +class C2 extends C1 { + constructor() { + super(...arguments); + this.a = 1; + } +} +class C3 extends C1 { + get a() { return super.a; } +} diff --git a/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=false).symbols b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=false).symbols new file mode 100644 index 0000000000000..5b0d798ba80d5 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=false).symbols @@ -0,0 +1,27 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + accessor a: any; +>a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +} + +class C2 extends C1 { +>C2 : Symbol(C2, Decl(accessorField6.ts, 2, 1)) +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + a = 1; +>a : Symbol(C2.a, Decl(accessorField6.ts, 4, 21)) +} + +class C3 extends C1 { +>C3 : Symbol(C3, Decl(accessorField6.ts, 6, 1)) +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + get a() { return super.a; } +>a : Symbol(C3.a, Decl(accessorField6.ts, 8, 21)) +>super.a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +>super : Symbol(C1, Decl(accessorField6.ts, 0, 0)) +>a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +} + diff --git a/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=false).types b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=false).types new file mode 100644 index 0000000000000..a6b9efded46a1 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=false).types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts === +class C1 { +>C1 : C1 + + accessor a: any; +>a : any +} + +class C2 extends C1 { +>C2 : C2 +>C1 : C1 + + a = 1; +>a : number +>1 : 1 +} + +class C3 extends C1 { +>C3 : C3 +>C1 : C1 + + get a() { return super.a; } +>a : any +>super.a : any +>super : C1 +>a : any +} + diff --git a/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=true).errors.txt b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=true).errors.txt new file mode 100644 index 0000000000000..4a63914155538 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=true).errors.txt @@ -0,0 +1,18 @@ +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts(6,5): error TS2610: 'a' is defined as an accessor in class 'C1', but is overridden here in 'C2' as an instance property. + + +==== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts (1 errors) ==== + class C1 { + accessor a: any; + } + + class C2 extends C1 { + a = 1; + ~ +!!! error TS2610: 'a' is defined as an accessor in class 'C1', but is overridden here in 'C2' as an instance property. + } + + class C3 extends C1 { + get a() { return super.a; } + } + \ No newline at end of file diff --git a/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=true).js b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=true).js new file mode 100644 index 0000000000000..a2816090e4614 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=true).js @@ -0,0 +1,26 @@ +//// [accessorField6.ts] +class C1 { + accessor a: any; +} + +class C2 extends C1 { + a = 1; +} + +class C3 extends C1 { + get a() { return super.a; } +} + + +//// [accessorField6.js] +class C1 { + #a_accessor_storage; + get a() { return this.#a_accessor_storage; } + set a(value) { this.#a_accessor_storage = value; } +} +class C2 extends C1 { + a = 1; +} +class C3 extends C1 { + get a() { return super.a; } +} diff --git a/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=true).symbols b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=true).symbols new file mode 100644 index 0000000000000..5b0d798ba80d5 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=true).symbols @@ -0,0 +1,27 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + accessor a: any; +>a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +} + +class C2 extends C1 { +>C2 : Symbol(C2, Decl(accessorField6.ts, 2, 1)) +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + a = 1; +>a : Symbol(C2.a, Decl(accessorField6.ts, 4, 21)) +} + +class C3 extends C1 { +>C3 : Symbol(C3, Decl(accessorField6.ts, 6, 1)) +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + get a() { return super.a; } +>a : Symbol(C3.a, Decl(accessorField6.ts, 8, 21)) +>super.a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +>super : Symbol(C1, Decl(accessorField6.ts, 0, 0)) +>a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +} + diff --git a/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=true).types b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=true).types new file mode 100644 index 0000000000000..a6b9efded46a1 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=es2022,usedefineforclassfields=true).types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts === +class C1 { +>C1 : C1 + + accessor a: any; +>a : any +} + +class C2 extends C1 { +>C2 : C2 +>C1 : C1 + + a = 1; +>a : number +>1 : 1 +} + +class C3 extends C1 { +>C3 : C3 +>C1 : C1 + + get a() { return super.a; } +>a : any +>super.a : any +>super : C1 +>a : any +} + diff --git a/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=false).errors.txt b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=false).errors.txt new file mode 100644 index 0000000000000..4a63914155538 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=false).errors.txt @@ -0,0 +1,18 @@ +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts(6,5): error TS2610: 'a' is defined as an accessor in class 'C1', but is overridden here in 'C2' as an instance property. + + +==== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts (1 errors) ==== + class C1 { + accessor a: any; + } + + class C2 extends C1 { + a = 1; + ~ +!!! error TS2610: 'a' is defined as an accessor in class 'C1', but is overridden here in 'C2' as an instance property. + } + + class C3 extends C1 { + get a() { return super.a; } + } + \ No newline at end of file diff --git a/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=false).js b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=false).js new file mode 100644 index 0000000000000..e38b062084739 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=false).js @@ -0,0 +1,26 @@ +//// [accessorField6.ts] +class C1 { + accessor a: any; +} + +class C2 extends C1 { + a = 1; +} + +class C3 extends C1 { + get a() { return super.a; } +} + + +//// [accessorField6.js] +class C1 { +} +class C2 extends C1 { + constructor() { + super(...arguments); + this.a = 1; + } +} +class C3 extends C1 { + get a() { return super.a; } +} diff --git a/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=false).symbols b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=false).symbols new file mode 100644 index 0000000000000..5b0d798ba80d5 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=false).symbols @@ -0,0 +1,27 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + accessor a: any; +>a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +} + +class C2 extends C1 { +>C2 : Symbol(C2, Decl(accessorField6.ts, 2, 1)) +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + a = 1; +>a : Symbol(C2.a, Decl(accessorField6.ts, 4, 21)) +} + +class C3 extends C1 { +>C3 : Symbol(C3, Decl(accessorField6.ts, 6, 1)) +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + get a() { return super.a; } +>a : Symbol(C3.a, Decl(accessorField6.ts, 8, 21)) +>super.a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +>super : Symbol(C1, Decl(accessorField6.ts, 0, 0)) +>a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +} + diff --git a/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=false).types b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=false).types new file mode 100644 index 0000000000000..a6b9efded46a1 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=false).types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts === +class C1 { +>C1 : C1 + + accessor a: any; +>a : any +} + +class C2 extends C1 { +>C2 : C2 +>C1 : C1 + + a = 1; +>a : number +>1 : 1 +} + +class C3 extends C1 { +>C3 : C3 +>C1 : C1 + + get a() { return super.a; } +>a : any +>super.a : any +>super : C1 +>a : any +} + diff --git a/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=true).errors.txt b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=true).errors.txt new file mode 100644 index 0000000000000..4a63914155538 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=true).errors.txt @@ -0,0 +1,18 @@ +tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts(6,5): error TS2610: 'a' is defined as an accessor in class 'C1', but is overridden here in 'C2' as an instance property. + + +==== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts (1 errors) ==== + class C1 { + accessor a: any; + } + + class C2 extends C1 { + a = 1; + ~ +!!! error TS2610: 'a' is defined as an accessor in class 'C1', but is overridden here in 'C2' as an instance property. + } + + class C3 extends C1 { + get a() { return super.a; } + } + \ No newline at end of file diff --git a/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=true).js b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=true).js new file mode 100644 index 0000000000000..e6550dab6f237 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=true).js @@ -0,0 +1,24 @@ +//// [accessorField6.ts] +class C1 { + accessor a: any; +} + +class C2 extends C1 { + a = 1; +} + +class C3 extends C1 { + get a() { return super.a; } +} + + +//// [accessorField6.js] +class C1 { + accessor a; +} +class C2 extends C1 { + a = 1; +} +class C3 extends C1 { + get a() { return super.a; } +} diff --git a/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=true).symbols b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=true).symbols new file mode 100644 index 0000000000000..5b0d798ba80d5 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=true).symbols @@ -0,0 +1,27 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + accessor a: any; +>a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +} + +class C2 extends C1 { +>C2 : Symbol(C2, Decl(accessorField6.ts, 2, 1)) +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + a = 1; +>a : Symbol(C2.a, Decl(accessorField6.ts, 4, 21)) +} + +class C3 extends C1 { +>C3 : Symbol(C3, Decl(accessorField6.ts, 6, 1)) +>C1 : Symbol(C1, Decl(accessorField6.ts, 0, 0)) + + get a() { return super.a; } +>a : Symbol(C3.a, Decl(accessorField6.ts, 8, 21)) +>super.a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +>super : Symbol(C1, Decl(accessorField6.ts, 0, 0)) +>a : Symbol(C1.a, Decl(accessorField6.ts, 0, 10)) +} + diff --git a/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=true).types b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=true).types new file mode 100644 index 0000000000000..a6b9efded46a1 --- /dev/null +++ b/tests/baselines/reference/accessorField6(target=esnext,usedefineforclassfields=true).types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts === +class C1 { +>C1 : C1 + + accessor a: any; +>a : any +} + +class C2 extends C1 { +>C2 : C2 +>C1 : C1 + + a = 1; +>a : number +>1 : 1 +} + +class C3 extends C1 { +>C3 : C3 +>C1 : C1 + + get a() { return super.a; } +>a : any +>super.a : any +>super : C1 +>a : any +} + diff --git a/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=false).js b/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=false).js new file mode 100644 index 0000000000000..272f35f30706c --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=false).js @@ -0,0 +1,41 @@ +//// [accessorField7.ts] +abstract class C1 { + abstract accessor a: any; +} + +class C2 extends C1 { + accessor a = 1; +} + +class C3 extends C1 { + get a() { return 1; } +} + + +//// [accessorField7.js] +var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +}; +var _C2_a_accessor_storage; +class C1 { +} +class C2 extends C1 { + constructor() { + super(...arguments); + _C2_a_accessor_storage.set(this, 1); + } + get a() { return __classPrivateFieldGet(this, _C2_a_accessor_storage, "f"); } + set a(value) { __classPrivateFieldSet(this, _C2_a_accessor_storage, value, "f"); } +} +_C2_a_accessor_storage = new WeakMap(); +class C3 extends C1 { + get a() { return 1; } +} diff --git a/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=false).symbols b/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=false).symbols new file mode 100644 index 0000000000000..a0bed37bd9bb9 --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=false).symbols @@ -0,0 +1,24 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField7.ts === +abstract class C1 { +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + abstract accessor a: any; +>a : Symbol(C1.a, Decl(accessorField7.ts, 0, 19)) +} + +class C2 extends C1 { +>C2 : Symbol(C2, Decl(accessorField7.ts, 2, 1)) +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + accessor a = 1; +>a : Symbol(C2.a, Decl(accessorField7.ts, 4, 21)) +} + +class C3 extends C1 { +>C3 : Symbol(C3, Decl(accessorField7.ts, 6, 1)) +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + get a() { return 1; } +>a : Symbol(C3.a, Decl(accessorField7.ts, 8, 21)) +} + diff --git a/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=false).types b/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=false).types new file mode 100644 index 0000000000000..a103af877051c --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=false).types @@ -0,0 +1,26 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField7.ts === +abstract class C1 { +>C1 : C1 + + abstract accessor a: any; +>a : any +} + +class C2 extends C1 { +>C2 : C2 +>C1 : C1 + + accessor a = 1; +>a : number +>1 : 1 +} + +class C3 extends C1 { +>C3 : C3 +>C1 : C1 + + get a() { return 1; } +>a : number +>1 : 1 +} + diff --git a/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=true).js b/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=true).js new file mode 100644 index 0000000000000..272f35f30706c --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=true).js @@ -0,0 +1,41 @@ +//// [accessorField7.ts] +abstract class C1 { + abstract accessor a: any; +} + +class C2 extends C1 { + accessor a = 1; +} + +class C3 extends C1 { + get a() { return 1; } +} + + +//// [accessorField7.js] +var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +}; +var _C2_a_accessor_storage; +class C1 { +} +class C2 extends C1 { + constructor() { + super(...arguments); + _C2_a_accessor_storage.set(this, 1); + } + get a() { return __classPrivateFieldGet(this, _C2_a_accessor_storage, "f"); } + set a(value) { __classPrivateFieldSet(this, _C2_a_accessor_storage, value, "f"); } +} +_C2_a_accessor_storage = new WeakMap(); +class C3 extends C1 { + get a() { return 1; } +} diff --git a/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=true).symbols b/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=true).symbols new file mode 100644 index 0000000000000..a0bed37bd9bb9 --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=true).symbols @@ -0,0 +1,24 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField7.ts === +abstract class C1 { +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + abstract accessor a: any; +>a : Symbol(C1.a, Decl(accessorField7.ts, 0, 19)) +} + +class C2 extends C1 { +>C2 : Symbol(C2, Decl(accessorField7.ts, 2, 1)) +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + accessor a = 1; +>a : Symbol(C2.a, Decl(accessorField7.ts, 4, 21)) +} + +class C3 extends C1 { +>C3 : Symbol(C3, Decl(accessorField7.ts, 6, 1)) +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + get a() { return 1; } +>a : Symbol(C3.a, Decl(accessorField7.ts, 8, 21)) +} + diff --git a/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=true).types b/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=true).types new file mode 100644 index 0000000000000..a103af877051c --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=es2015,usedefineforclassfields=true).types @@ -0,0 +1,26 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField7.ts === +abstract class C1 { +>C1 : C1 + + abstract accessor a: any; +>a : any +} + +class C2 extends C1 { +>C2 : C2 +>C1 : C1 + + accessor a = 1; +>a : number +>1 : 1 +} + +class C3 extends C1 { +>C3 : C3 +>C1 : C1 + + get a() { return 1; } +>a : number +>1 : 1 +} + diff --git a/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=false).js b/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=false).js new file mode 100644 index 0000000000000..ff282b347ece2 --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=false).js @@ -0,0 +1,29 @@ +//// [accessorField7.ts] +abstract class C1 { + abstract accessor a: any; +} + +class C2 extends C1 { + accessor a = 1; +} + +class C3 extends C1 { + get a() { return 1; } +} + + +//// [accessorField7.js] +class C1 { +} +class C2 extends C1 { + constructor() { + super(...arguments); + this.#a_accessor_storage = 1; + } + #a_accessor_storage; + get a() { return this.#a_accessor_storage; } + set a(value) { this.#a_accessor_storage = value; } +} +class C3 extends C1 { + get a() { return 1; } +} diff --git a/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=false).symbols b/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=false).symbols new file mode 100644 index 0000000000000..a0bed37bd9bb9 --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=false).symbols @@ -0,0 +1,24 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField7.ts === +abstract class C1 { +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + abstract accessor a: any; +>a : Symbol(C1.a, Decl(accessorField7.ts, 0, 19)) +} + +class C2 extends C1 { +>C2 : Symbol(C2, Decl(accessorField7.ts, 2, 1)) +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + accessor a = 1; +>a : Symbol(C2.a, Decl(accessorField7.ts, 4, 21)) +} + +class C3 extends C1 { +>C3 : Symbol(C3, Decl(accessorField7.ts, 6, 1)) +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + get a() { return 1; } +>a : Symbol(C3.a, Decl(accessorField7.ts, 8, 21)) +} + diff --git a/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=false).types b/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=false).types new file mode 100644 index 0000000000000..a103af877051c --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=false).types @@ -0,0 +1,26 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField7.ts === +abstract class C1 { +>C1 : C1 + + abstract accessor a: any; +>a : any +} + +class C2 extends C1 { +>C2 : C2 +>C1 : C1 + + accessor a = 1; +>a : number +>1 : 1 +} + +class C3 extends C1 { +>C3 : C3 +>C1 : C1 + + get a() { return 1; } +>a : number +>1 : 1 +} + diff --git a/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=true).js b/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=true).js new file mode 100644 index 0000000000000..eb3c26be94053 --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=true).js @@ -0,0 +1,25 @@ +//// [accessorField7.ts] +abstract class C1 { + abstract accessor a: any; +} + +class C2 extends C1 { + accessor a = 1; +} + +class C3 extends C1 { + get a() { return 1; } +} + + +//// [accessorField7.js] +class C1 { +} +class C2 extends C1 { + #a_accessor_storage = 1; + get a() { return this.#a_accessor_storage; } + set a(value) { this.#a_accessor_storage = value; } +} +class C3 extends C1 { + get a() { return 1; } +} diff --git a/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=true).symbols b/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=true).symbols new file mode 100644 index 0000000000000..a0bed37bd9bb9 --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=true).symbols @@ -0,0 +1,24 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField7.ts === +abstract class C1 { +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + abstract accessor a: any; +>a : Symbol(C1.a, Decl(accessorField7.ts, 0, 19)) +} + +class C2 extends C1 { +>C2 : Symbol(C2, Decl(accessorField7.ts, 2, 1)) +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + accessor a = 1; +>a : Symbol(C2.a, Decl(accessorField7.ts, 4, 21)) +} + +class C3 extends C1 { +>C3 : Symbol(C3, Decl(accessorField7.ts, 6, 1)) +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + get a() { return 1; } +>a : Symbol(C3.a, Decl(accessorField7.ts, 8, 21)) +} + diff --git a/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=true).types b/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=true).types new file mode 100644 index 0000000000000..a103af877051c --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=es2022,usedefineforclassfields=true).types @@ -0,0 +1,26 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField7.ts === +abstract class C1 { +>C1 : C1 + + abstract accessor a: any; +>a : any +} + +class C2 extends C1 { +>C2 : C2 +>C1 : C1 + + accessor a = 1; +>a : number +>1 : 1 +} + +class C3 extends C1 { +>C3 : C3 +>C1 : C1 + + get a() { return 1; } +>a : number +>1 : 1 +} + diff --git a/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=false).js b/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=false).js new file mode 100644 index 0000000000000..d84530fda0c48 --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=false).js @@ -0,0 +1,26 @@ +//// [accessorField7.ts] +abstract class C1 { + abstract accessor a: any; +} + +class C2 extends C1 { + accessor a = 1; +} + +class C3 extends C1 { + get a() { return 1; } +} + + +//// [accessorField7.js] +class C1 { +} +class C2 extends C1 { + constructor() { + super(...arguments); + this.#a_1 = 1; + } +} +class C3 extends C1 { + get a() { return 1; } +} diff --git a/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=false).symbols b/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=false).symbols new file mode 100644 index 0000000000000..a0bed37bd9bb9 --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=false).symbols @@ -0,0 +1,24 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField7.ts === +abstract class C1 { +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + abstract accessor a: any; +>a : Symbol(C1.a, Decl(accessorField7.ts, 0, 19)) +} + +class C2 extends C1 { +>C2 : Symbol(C2, Decl(accessorField7.ts, 2, 1)) +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + accessor a = 1; +>a : Symbol(C2.a, Decl(accessorField7.ts, 4, 21)) +} + +class C3 extends C1 { +>C3 : Symbol(C3, Decl(accessorField7.ts, 6, 1)) +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + get a() { return 1; } +>a : Symbol(C3.a, Decl(accessorField7.ts, 8, 21)) +} + diff --git a/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=false).types b/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=false).types new file mode 100644 index 0000000000000..a103af877051c --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=false).types @@ -0,0 +1,26 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField7.ts === +abstract class C1 { +>C1 : C1 + + abstract accessor a: any; +>a : any +} + +class C2 extends C1 { +>C2 : C2 +>C1 : C1 + + accessor a = 1; +>a : number +>1 : 1 +} + +class C3 extends C1 { +>C3 : C3 +>C1 : C1 + + get a() { return 1; } +>a : number +>1 : 1 +} + diff --git a/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=true).js b/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=true).js new file mode 100644 index 0000000000000..7951a92f92ba1 --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=true).js @@ -0,0 +1,23 @@ +//// [accessorField7.ts] +abstract class C1 { + abstract accessor a: any; +} + +class C2 extends C1 { + accessor a = 1; +} + +class C3 extends C1 { + get a() { return 1; } +} + + +//// [accessorField7.js] +class C1 { +} +class C2 extends C1 { + accessor a = 1; +} +class C3 extends C1 { + get a() { return 1; } +} diff --git a/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=true).symbols b/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=true).symbols new file mode 100644 index 0000000000000..a0bed37bd9bb9 --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=true).symbols @@ -0,0 +1,24 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField7.ts === +abstract class C1 { +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + abstract accessor a: any; +>a : Symbol(C1.a, Decl(accessorField7.ts, 0, 19)) +} + +class C2 extends C1 { +>C2 : Symbol(C2, Decl(accessorField7.ts, 2, 1)) +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + accessor a = 1; +>a : Symbol(C2.a, Decl(accessorField7.ts, 4, 21)) +} + +class C3 extends C1 { +>C3 : Symbol(C3, Decl(accessorField7.ts, 6, 1)) +>C1 : Symbol(C1, Decl(accessorField7.ts, 0, 0)) + + get a() { return 1; } +>a : Symbol(C3.a, Decl(accessorField7.ts, 8, 21)) +} + diff --git a/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=true).types b/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=true).types new file mode 100644 index 0000000000000..a103af877051c --- /dev/null +++ b/tests/baselines/reference/accessorField7(target=esnext,usedefineforclassfields=true).types @@ -0,0 +1,26 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField7.ts === +abstract class C1 { +>C1 : C1 + + abstract accessor a: any; +>a : any +} + +class C2 extends C1 { +>C2 : C2 +>C1 : C1 + + accessor a = 1; +>a : number +>1 : 1 +} + +class C3 extends C1 { +>C3 : C3 +>C1 : C1 + + get a() { return 1; } +>a : number +>1 : 1 +} + diff --git a/tests/baselines/reference/accessorField8.js b/tests/baselines/reference/accessorField8.js new file mode 100644 index 0000000000000..b34d65f1f55e4 --- /dev/null +++ b/tests/baselines/reference/accessorField8.js @@ -0,0 +1,49 @@ +//// [accessorField8.ts] +class C1 { + accessor a: any; + static accessor b: any; +} + +declare class C2 { + accessor a: any; + static accessor b: any; +} + +function f() { + class C3 { + accessor a: any; + static accessor b: any; + } + return C3; +} + + +//// [accessorField8.js] +class C1 { + accessor a; + static accessor b; +} +function f() { + class C3 { + accessor a; + static accessor b; + } + return C3; +} + + +//// [accessorField8.d.ts] +declare class C1 { + accessor a: any; + static accessor b: any; +} +declare class C2 { + accessor a: any; + static accessor b: any; +} +declare function f(): { + new (): { + a: any; + }; + b: any; +}; diff --git a/tests/baselines/reference/accessorField8.symbols b/tests/baselines/reference/accessorField8.symbols new file mode 100644 index 0000000000000..77018c3b42ae5 --- /dev/null +++ b/tests/baselines/reference/accessorField8.symbols @@ -0,0 +1,37 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField8.ts === +class C1 { +>C1 : Symbol(C1, Decl(accessorField8.ts, 0, 0)) + + accessor a: any; +>a : Symbol(C1.a, Decl(accessorField8.ts, 0, 10)) + + static accessor b: any; +>b : Symbol(C1.b, Decl(accessorField8.ts, 1, 20)) +} + +declare class C2 { +>C2 : Symbol(C2, Decl(accessorField8.ts, 3, 1)) + + accessor a: any; +>a : Symbol(C2.a, Decl(accessorField8.ts, 5, 18)) + + static accessor b: any; +>b : Symbol(C2.b, Decl(accessorField8.ts, 6, 20)) +} + +function f() { +>f : Symbol(f, Decl(accessorField8.ts, 8, 1)) + + class C3 { +>C3 : Symbol(C3, Decl(accessorField8.ts, 10, 14)) + + accessor a: any; +>a : Symbol(C3.a, Decl(accessorField8.ts, 11, 14)) + + static accessor b: any; +>b : Symbol(C3.b, Decl(accessorField8.ts, 12, 24)) + } + return C3; +>C3 : Symbol(C3, Decl(accessorField8.ts, 10, 14)) +} + diff --git a/tests/baselines/reference/accessorField8.types b/tests/baselines/reference/accessorField8.types new file mode 100644 index 0000000000000..040ad200d7865 --- /dev/null +++ b/tests/baselines/reference/accessorField8.types @@ -0,0 +1,37 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessorField8.ts === +class C1 { +>C1 : C1 + + accessor a: any; +>a : any + + static accessor b: any; +>b : any +} + +declare class C2 { +>C2 : C2 + + accessor a: any; +>a : any + + static accessor b: any; +>b : any +} + +function f() { +>f : () => typeof C3 + + class C3 { +>C3 : C3 + + accessor a: any; +>a : any + + static accessor b: any; +>b : any + } + return C3; +>C3 : typeof C3 +} + diff --git a/tests/baselines/reference/accessorFieldAllowedModifiers.js b/tests/baselines/reference/accessorFieldAllowedModifiers.js new file mode 100644 index 0000000000000..b1806f06426d2 --- /dev/null +++ b/tests/baselines/reference/accessorFieldAllowedModifiers.js @@ -0,0 +1,47 @@ +//// [accessorFieldAllowedModifiers.ts] +abstract class C1 { + accessor a: any; + public accessor b: any; + private accessor c: any; + protected accessor d: any; + abstract accessor e: any; + static accessor f: any; + public static accessor g: any; + private static accessor h: any; + protected static accessor i: any; + accessor #j: any; + accessor "k": any; + accessor 108: any; + accessor ["m"]: any; +} + +class C2 extends C1 { + override accessor e: any; + static override accessor i: any; +} + +declare class C3 { + accessor a: any; +} + + + +//// [accessorFieldAllowedModifiers.js] +class C1 { + accessor a; + accessor b; + accessor c; + accessor d; + static accessor f; + static accessor g; + static accessor h; + static accessor i; + accessor #j; + accessor "k"; + accessor 108; + accessor ["m"]; +} +class C2 extends C1 { + accessor e; + static accessor i; +} diff --git a/tests/baselines/reference/accessorFieldDisallowedModifiers.errors.txt b/tests/baselines/reference/accessorFieldDisallowedModifiers.errors.txt new file mode 100644 index 0000000000000..1b7b9db32fab9 --- /dev/null +++ b/tests/baselines/reference/accessorFieldDisallowedModifiers.errors.txt @@ -0,0 +1,120 @@ +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(2,14): error TS1030: 'accessor' modifier already seen. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(3,14): error TS1243: 'accessor' modifier cannot be used with 'readonly' modifier. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(4,13): error TS1243: 'accessor' modifier cannot be used with 'declare' modifier. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(5,14): error TS1029: 'public' modifier must precede 'accessor' modifier. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(6,14): error TS1029: 'private' modifier must precede 'accessor' modifier. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(7,14): error TS1029: 'protected' modifier must precede 'accessor' modifier. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(8,14): error TS1029: 'abstract' modifier must precede 'accessor' modifier. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(9,14): error TS1029: 'static' modifier must precede 'accessor' modifier. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(10,5): error TS1275: 'accessor' modifier can only appear on a property declaration. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(11,5): error TS1275: 'accessor' modifier can only appear on a property declaration. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(12,5): error TS1275: 'accessor' modifier can only appear on a property declaration. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(13,5): error TS1275: 'accessor' modifier can only appear on a property declaration. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(17,14): error TS1029: 'override' modifier must precede 'accessor' modifier. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(21,5): error TS1070: 'accessor' modifier cannot appear on a type member. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(24,1): error TS1275: 'accessor' modifier can only appear on a property declaration. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(25,1): error TS1275: 'accessor' modifier can only appear on a property declaration. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(26,1): error TS1275: 'accessor' modifier can only appear on a property declaration. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(27,1): error TS1275: 'accessor' modifier can only appear on a property declaration. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(28,1): error TS1275: 'accessor' modifier can only appear on a property declaration. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(29,1): error TS1275: 'accessor' modifier can only appear on a property declaration. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(30,1): error TS1275: 'accessor' modifier can only appear on a property declaration. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(31,1): error TS1275: 'accessor' modifier can only appear on a property declaration. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(32,1): error TS1275: 'accessor' modifier can only appear on a property declaration. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(32,25): error TS2792: Cannot find module 'x'. Did you mean to set the 'moduleResolution' option to 'node', or to add aliases to the 'paths' option? +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(33,1): error TS1275: 'accessor' modifier can only appear on a property declaration. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(34,1): error TS1275: 'accessor' modifier can only appear on a property declaration. +tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts(35,1): error TS1275: 'accessor' modifier can only appear on a property declaration. + + +==== tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts (27 errors) ==== + abstract class C1 { + accessor accessor a: any; + ~~~~~~~~ +!!! error TS1030: 'accessor' modifier already seen. + readonly accessor b: any; + ~~~~~~~~ +!!! error TS1243: 'accessor' modifier cannot be used with 'readonly' modifier. + declare accessor c: any; + ~~~~~~~~ +!!! error TS1243: 'accessor' modifier cannot be used with 'declare' modifier. + accessor public d: any; + ~~~~~~ +!!! error TS1029: 'public' modifier must precede 'accessor' modifier. + accessor private e: any; + ~~~~~~~ +!!! error TS1029: 'private' modifier must precede 'accessor' modifier. + accessor protected f: any; + ~~~~~~~~~ +!!! error TS1029: 'protected' modifier must precede 'accessor' modifier. + accessor abstract g: any; + ~~~~~~~~ +!!! error TS1029: 'abstract' modifier must precede 'accessor' modifier. + accessor static h: any; + ~~~~~~ +!!! error TS1029: 'static' modifier must precede 'accessor' modifier. + accessor i() {} + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + accessor get j() { return false; } + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + accessor set k(v: any) {} + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + accessor constructor() {} + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + } + + class C2 extends C1 { + accessor override g: any; + ~~~~~~~~ +!!! error TS1029: 'override' modifier must precede 'accessor' modifier. + } + + interface I1 { + accessor a: number; + ~~~~~~~~ +!!! error TS1070: 'accessor' modifier cannot appear on a type member. + } + + accessor class C3 {} + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + accessor interface I2 {} + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + accessor namespace N1 {} + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + accessor enum E1 {} + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + accessor var V1: any; + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + accessor type T1 = never; + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + accessor function F1() {} + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + accessor import "x"; + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + accessor import {} from "x"; + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + ~~~ +!!! error TS2792: Cannot find module 'x'. Did you mean to set the 'moduleResolution' option to 'node', or to add aliases to the 'paths' option? + accessor export { V1 }; + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + accessor export default V1; + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + accessor import N2 = N1; + ~~~~~~~~ +!!! error TS1275: 'accessor' modifier can only appear on a property declaration. + \ No newline at end of file diff --git a/tests/baselines/reference/accessorFieldDisallowedModifiers.js b/tests/baselines/reference/accessorFieldDisallowedModifiers.js new file mode 100644 index 0000000000000..7ba066b51d9b8 --- /dev/null +++ b/tests/baselines/reference/accessorFieldDisallowedModifiers.js @@ -0,0 +1,64 @@ +//// [accessorFieldDisallowedModifiers.ts] +abstract class C1 { + accessor accessor a: any; + readonly accessor b: any; + declare accessor c: any; + accessor public d: any; + accessor private e: any; + accessor protected f: any; + accessor abstract g: any; + accessor static h: any; + accessor i() {} + accessor get j() { return false; } + accessor set k(v: any) {} + accessor constructor() {} +} + +class C2 extends C1 { + accessor override g: any; +} + +interface I1 { + accessor a: number; +} + +accessor class C3 {} +accessor interface I2 {} +accessor namespace N1 {} +accessor enum E1 {} +accessor var V1: any; +accessor type T1 = never; +accessor function F1() {} +accessor import "x"; +accessor import {} from "x"; +accessor export { V1 }; +accessor export default V1; +accessor import N2 = N1; + + +//// [accessorFieldDisallowedModifiers.js] +class C1 { + accessor accessor a; + accessor b; + accessor d; + accessor e; + accessor f; + accessor static h; + accessor i() { } + accessor get j() { return false; } + accessor set k(v) { } + constructor() { } +} +class C2 extends C1 { + accessor g; +} +accessor class C3 { +} +accessor var E1; +(function (E1) { +})(E1 || (E1 = {})); +accessor var V1; +accessor function F1() { } +accessor import "x"; +export { V1 }; +export default V1; diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index 9401f57e76edf..c493f41ae8d32 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -232,237 +232,238 @@ declare namespace ts { StaticKeyword = 124, YieldKeyword = 125, AbstractKeyword = 126, - AsKeyword = 127, - AssertsKeyword = 128, - AssertKeyword = 129, - AnyKeyword = 130, - AsyncKeyword = 131, - AwaitKeyword = 132, - BooleanKeyword = 133, - ConstructorKeyword = 134, - DeclareKeyword = 135, - GetKeyword = 136, - InferKeyword = 137, - IntrinsicKeyword = 138, - IsKeyword = 139, - KeyOfKeyword = 140, - ModuleKeyword = 141, - NamespaceKeyword = 142, - NeverKeyword = 143, - OutKeyword = 144, - ReadonlyKeyword = 145, - RequireKeyword = 146, - NumberKeyword = 147, - ObjectKeyword = 148, - SetKeyword = 149, - StringKeyword = 150, - SymbolKeyword = 151, - TypeKeyword = 152, - UndefinedKeyword = 153, - UniqueKeyword = 154, - UnknownKeyword = 155, - FromKeyword = 156, - GlobalKeyword = 157, - BigIntKeyword = 158, - OverrideKeyword = 159, - OfKeyword = 160, - QualifiedName = 161, - ComputedPropertyName = 162, - TypeParameter = 163, - Parameter = 164, - Decorator = 165, - PropertySignature = 166, - PropertyDeclaration = 167, - MethodSignature = 168, - MethodDeclaration = 169, - ClassStaticBlockDeclaration = 170, - Constructor = 171, - GetAccessor = 172, - SetAccessor = 173, - CallSignature = 174, - ConstructSignature = 175, - IndexSignature = 176, - TypePredicate = 177, - TypeReference = 178, - FunctionType = 179, - ConstructorType = 180, - TypeQuery = 181, - TypeLiteral = 182, - ArrayType = 183, - TupleType = 184, - OptionalType = 185, - RestType = 186, - UnionType = 187, - IntersectionType = 188, - ConditionalType = 189, - InferType = 190, - ParenthesizedType = 191, - ThisType = 192, - TypeOperator = 193, - IndexedAccessType = 194, - MappedType = 195, - LiteralType = 196, - NamedTupleMember = 197, - TemplateLiteralType = 198, - TemplateLiteralTypeSpan = 199, - ImportType = 200, - ObjectBindingPattern = 201, - ArrayBindingPattern = 202, - BindingElement = 203, - ArrayLiteralExpression = 204, - ObjectLiteralExpression = 205, - PropertyAccessExpression = 206, - ElementAccessExpression = 207, - CallExpression = 208, - NewExpression = 209, - TaggedTemplateExpression = 210, - TypeAssertionExpression = 211, - ParenthesizedExpression = 212, - FunctionExpression = 213, - ArrowFunction = 214, - DeleteExpression = 215, - TypeOfExpression = 216, - VoidExpression = 217, - AwaitExpression = 218, - PrefixUnaryExpression = 219, - PostfixUnaryExpression = 220, - BinaryExpression = 221, - ConditionalExpression = 222, - TemplateExpression = 223, - YieldExpression = 224, - SpreadElement = 225, - ClassExpression = 226, - OmittedExpression = 227, - ExpressionWithTypeArguments = 228, - AsExpression = 229, - NonNullExpression = 230, - MetaProperty = 231, - SyntheticExpression = 232, - TemplateSpan = 233, - SemicolonClassElement = 234, - Block = 235, - EmptyStatement = 236, - VariableStatement = 237, - ExpressionStatement = 238, - IfStatement = 239, - DoStatement = 240, - WhileStatement = 241, - ForStatement = 242, - ForInStatement = 243, - ForOfStatement = 244, - ContinueStatement = 245, - BreakStatement = 246, - ReturnStatement = 247, - WithStatement = 248, - SwitchStatement = 249, - LabeledStatement = 250, - ThrowStatement = 251, - TryStatement = 252, - DebuggerStatement = 253, - VariableDeclaration = 254, - VariableDeclarationList = 255, - FunctionDeclaration = 256, - ClassDeclaration = 257, - InterfaceDeclaration = 258, - TypeAliasDeclaration = 259, - EnumDeclaration = 260, - ModuleDeclaration = 261, - ModuleBlock = 262, - CaseBlock = 263, - NamespaceExportDeclaration = 264, - ImportEqualsDeclaration = 265, - ImportDeclaration = 266, - ImportClause = 267, - NamespaceImport = 268, - NamedImports = 269, - ImportSpecifier = 270, - ExportAssignment = 271, - ExportDeclaration = 272, - NamedExports = 273, - NamespaceExport = 274, - ExportSpecifier = 275, - MissingDeclaration = 276, - ExternalModuleReference = 277, - JsxElement = 278, - JsxSelfClosingElement = 279, - JsxOpeningElement = 280, - JsxClosingElement = 281, - JsxFragment = 282, - JsxOpeningFragment = 283, - JsxClosingFragment = 284, - JsxAttribute = 285, - JsxAttributes = 286, - JsxSpreadAttribute = 287, - JsxExpression = 288, - CaseClause = 289, - DefaultClause = 290, - HeritageClause = 291, - CatchClause = 292, - AssertClause = 293, - AssertEntry = 294, - ImportTypeAssertionContainer = 295, - PropertyAssignment = 296, - ShorthandPropertyAssignment = 297, - SpreadAssignment = 298, - EnumMember = 299, - UnparsedPrologue = 300, - UnparsedPrepend = 301, - UnparsedText = 302, - UnparsedInternalText = 303, - UnparsedSyntheticReference = 304, - SourceFile = 305, - Bundle = 306, - UnparsedSource = 307, - InputFiles = 308, - JSDocTypeExpression = 309, - JSDocNameReference = 310, - JSDocMemberName = 311, - JSDocAllType = 312, - JSDocUnknownType = 313, - JSDocNullableType = 314, - JSDocNonNullableType = 315, - JSDocOptionalType = 316, - JSDocFunctionType = 317, - JSDocVariadicType = 318, - JSDocNamepathType = 319, - JSDoc = 320, + AccessorKeyword = 127, + AsKeyword = 128, + AssertsKeyword = 129, + AssertKeyword = 130, + AnyKeyword = 131, + AsyncKeyword = 132, + AwaitKeyword = 133, + BooleanKeyword = 134, + ConstructorKeyword = 135, + DeclareKeyword = 136, + GetKeyword = 137, + InferKeyword = 138, + IntrinsicKeyword = 139, + IsKeyword = 140, + KeyOfKeyword = 141, + ModuleKeyword = 142, + NamespaceKeyword = 143, + NeverKeyword = 144, + OutKeyword = 145, + ReadonlyKeyword = 146, + RequireKeyword = 147, + NumberKeyword = 148, + ObjectKeyword = 149, + SetKeyword = 150, + StringKeyword = 151, + SymbolKeyword = 152, + TypeKeyword = 153, + UndefinedKeyword = 154, + UniqueKeyword = 155, + UnknownKeyword = 156, + FromKeyword = 157, + GlobalKeyword = 158, + BigIntKeyword = 159, + OverrideKeyword = 160, + OfKeyword = 161, + QualifiedName = 162, + ComputedPropertyName = 163, + TypeParameter = 164, + Parameter = 165, + Decorator = 166, + PropertySignature = 167, + PropertyDeclaration = 168, + MethodSignature = 169, + MethodDeclaration = 170, + ClassStaticBlockDeclaration = 171, + Constructor = 172, + GetAccessor = 173, + SetAccessor = 174, + CallSignature = 175, + ConstructSignature = 176, + IndexSignature = 177, + TypePredicate = 178, + TypeReference = 179, + FunctionType = 180, + ConstructorType = 181, + TypeQuery = 182, + TypeLiteral = 183, + ArrayType = 184, + TupleType = 185, + OptionalType = 186, + RestType = 187, + UnionType = 188, + IntersectionType = 189, + ConditionalType = 190, + InferType = 191, + ParenthesizedType = 192, + ThisType = 193, + TypeOperator = 194, + IndexedAccessType = 195, + MappedType = 196, + LiteralType = 197, + NamedTupleMember = 198, + TemplateLiteralType = 199, + TemplateLiteralTypeSpan = 200, + ImportType = 201, + ObjectBindingPattern = 202, + ArrayBindingPattern = 203, + BindingElement = 204, + ArrayLiteralExpression = 205, + ObjectLiteralExpression = 206, + PropertyAccessExpression = 207, + ElementAccessExpression = 208, + CallExpression = 209, + NewExpression = 210, + TaggedTemplateExpression = 211, + TypeAssertionExpression = 212, + ParenthesizedExpression = 213, + FunctionExpression = 214, + ArrowFunction = 215, + DeleteExpression = 216, + TypeOfExpression = 217, + VoidExpression = 218, + AwaitExpression = 219, + PrefixUnaryExpression = 220, + PostfixUnaryExpression = 221, + BinaryExpression = 222, + ConditionalExpression = 223, + TemplateExpression = 224, + YieldExpression = 225, + SpreadElement = 226, + ClassExpression = 227, + OmittedExpression = 228, + ExpressionWithTypeArguments = 229, + AsExpression = 230, + NonNullExpression = 231, + MetaProperty = 232, + SyntheticExpression = 233, + TemplateSpan = 234, + SemicolonClassElement = 235, + Block = 236, + EmptyStatement = 237, + VariableStatement = 238, + ExpressionStatement = 239, + IfStatement = 240, + DoStatement = 241, + WhileStatement = 242, + ForStatement = 243, + ForInStatement = 244, + ForOfStatement = 245, + ContinueStatement = 246, + BreakStatement = 247, + ReturnStatement = 248, + WithStatement = 249, + SwitchStatement = 250, + LabeledStatement = 251, + ThrowStatement = 252, + TryStatement = 253, + DebuggerStatement = 254, + VariableDeclaration = 255, + VariableDeclarationList = 256, + FunctionDeclaration = 257, + ClassDeclaration = 258, + InterfaceDeclaration = 259, + TypeAliasDeclaration = 260, + EnumDeclaration = 261, + ModuleDeclaration = 262, + ModuleBlock = 263, + CaseBlock = 264, + NamespaceExportDeclaration = 265, + ImportEqualsDeclaration = 266, + ImportDeclaration = 267, + ImportClause = 268, + NamespaceImport = 269, + NamedImports = 270, + ImportSpecifier = 271, + ExportAssignment = 272, + ExportDeclaration = 273, + NamedExports = 274, + NamespaceExport = 275, + ExportSpecifier = 276, + MissingDeclaration = 277, + ExternalModuleReference = 278, + JsxElement = 279, + JsxSelfClosingElement = 280, + JsxOpeningElement = 281, + JsxClosingElement = 282, + JsxFragment = 283, + JsxOpeningFragment = 284, + JsxClosingFragment = 285, + JsxAttribute = 286, + JsxAttributes = 287, + JsxSpreadAttribute = 288, + JsxExpression = 289, + CaseClause = 290, + DefaultClause = 291, + HeritageClause = 292, + CatchClause = 293, + AssertClause = 294, + AssertEntry = 295, + ImportTypeAssertionContainer = 296, + PropertyAssignment = 297, + ShorthandPropertyAssignment = 298, + SpreadAssignment = 299, + EnumMember = 300, + UnparsedPrologue = 301, + UnparsedPrepend = 302, + UnparsedText = 303, + UnparsedInternalText = 304, + UnparsedSyntheticReference = 305, + SourceFile = 306, + Bundle = 307, + UnparsedSource = 308, + InputFiles = 309, + JSDocTypeExpression = 310, + JSDocNameReference = 311, + JSDocMemberName = 312, + JSDocAllType = 313, + JSDocUnknownType = 314, + JSDocNullableType = 315, + JSDocNonNullableType = 316, + JSDocOptionalType = 317, + JSDocFunctionType = 318, + JSDocVariadicType = 319, + JSDocNamepathType = 320, + JSDoc = 321, /** @deprecated Use SyntaxKind.JSDoc */ - JSDocComment = 320, - JSDocText = 321, - JSDocTypeLiteral = 322, - JSDocSignature = 323, - JSDocLink = 324, - JSDocLinkCode = 325, - JSDocLinkPlain = 326, - JSDocTag = 327, - JSDocAugmentsTag = 328, - JSDocImplementsTag = 329, - JSDocAuthorTag = 330, - JSDocDeprecatedTag = 331, - JSDocClassTag = 332, - JSDocPublicTag = 333, - JSDocPrivateTag = 334, - JSDocProtectedTag = 335, - JSDocReadonlyTag = 336, - JSDocOverrideTag = 337, - JSDocCallbackTag = 338, - JSDocEnumTag = 339, - JSDocParameterTag = 340, - JSDocReturnTag = 341, - JSDocThisTag = 342, - JSDocTypeTag = 343, - JSDocTemplateTag = 344, - JSDocTypedefTag = 345, - JSDocSeeTag = 346, - JSDocPropertyTag = 347, - SyntaxList = 348, - NotEmittedStatement = 349, - PartiallyEmittedExpression = 350, - CommaListExpression = 351, - MergeDeclarationMarker = 352, - EndOfDeclarationMarker = 353, - SyntheticReferenceExpression = 354, - Count = 355, + JSDocComment = 321, + JSDocText = 322, + JSDocTypeLiteral = 323, + JSDocSignature = 324, + JSDocLink = 325, + JSDocLinkCode = 326, + JSDocLinkPlain = 327, + JSDocTag = 328, + JSDocAugmentsTag = 329, + JSDocImplementsTag = 330, + JSDocAuthorTag = 331, + JSDocDeprecatedTag = 332, + JSDocClassTag = 333, + JSDocPublicTag = 334, + JSDocPrivateTag = 335, + JSDocProtectedTag = 336, + JSDocReadonlyTag = 337, + JSDocOverrideTag = 338, + JSDocCallbackTag = 339, + JSDocEnumTag = 340, + JSDocParameterTag = 341, + JSDocReturnTag = 342, + JSDocThisTag = 343, + JSDocTypeTag = 344, + JSDocTemplateTag = 345, + JSDocTypedefTag = 346, + JSDocSeeTag = 347, + JSDocPropertyTag = 348, + SyntaxList = 349, + NotEmittedStatement = 350, + PartiallyEmittedExpression = 351, + CommaListExpression = 352, + MergeDeclarationMarker = 353, + EndOfDeclarationMarker = 354, + SyntheticReferenceExpression = 355, + Count = 356, FirstAssignment = 63, LastAssignment = 78, FirstCompoundAssignment = 64, @@ -470,15 +471,15 @@ declare namespace ts { FirstReservedWord = 81, LastReservedWord = 116, FirstKeyword = 81, - LastKeyword = 160, + LastKeyword = 161, FirstFutureReservedWord = 117, LastFutureReservedWord = 125, - FirstTypeNode = 177, - LastTypeNode = 200, + FirstTypeNode = 178, + LastTypeNode = 201, FirstPunctuation = 18, LastPunctuation = 78, FirstToken = 0, - LastToken = 160, + LastToken = 161, FirstTriviaToken = 2, LastTriviaToken = 7, FirstLiteralToken = 8, @@ -487,20 +488,20 @@ declare namespace ts { LastTemplateToken = 17, FirstBinaryOperator = 29, LastBinaryOperator = 78, - FirstStatement = 237, - LastStatement = 253, - FirstNode = 161, - FirstJSDocNode = 309, - LastJSDocNode = 347, - FirstJSDocTagNode = 327, - LastJSDocTagNode = 347, + FirstStatement = 238, + LastStatement = 254, + FirstNode = 162, + FirstJSDocNode = 310, + LastJSDocNode = 348, + FirstJSDocTagNode = 328, + LastJSDocTagNode = 348, } export type TriviaSyntaxKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia | SyntaxKind.NewLineTrivia | SyntaxKind.WhitespaceTrivia | SyntaxKind.ShebangTrivia | SyntaxKind.ConflictMarkerTrivia; export type LiteralSyntaxKind = SyntaxKind.NumericLiteral | SyntaxKind.BigIntLiteral | SyntaxKind.StringLiteral | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.RegularExpressionLiteral | SyntaxKind.NoSubstitutionTemplateLiteral; export type PseudoLiteralSyntaxKind = SyntaxKind.TemplateHead | SyntaxKind.TemplateMiddle | SyntaxKind.TemplateTail; export type PunctuationSyntaxKind = SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.OpenParenToken | SyntaxKind.CloseParenToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.DotToken | SyntaxKind.DotDotDotToken | SyntaxKind.SemicolonToken | SyntaxKind.CommaToken | SyntaxKind.QuestionDotToken | SyntaxKind.LessThanToken | SyntaxKind.LessThanSlashToken | SyntaxKind.GreaterThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.EqualsEqualsToken | SyntaxKind.ExclamationEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.EqualsGreaterThanToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.AsteriskToken | SyntaxKind.AsteriskAsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken | SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken | SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken | SyntaxKind.ExclamationToken | SyntaxKind.TildeToken | SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken | SyntaxKind.QuestionQuestionToken | SyntaxKind.QuestionToken | SyntaxKind.ColonToken | SyntaxKind.AtToken | SyntaxKind.BacktickToken | SyntaxKind.HashToken | SyntaxKind.EqualsToken | SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.CaretEqualsToken; - export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.AssertKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.OfKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OutKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.RequireKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword; - export type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.ExportKeyword | SyntaxKind.InKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OutKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.StaticKeyword; + export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AccessorKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.AssertKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.OfKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OutKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.RequireKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword; + export type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AccessorKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.ExportKeyword | SyntaxKind.InKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OutKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.StaticKeyword; export type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VoidKeyword; export type TokenSyntaxKind = SyntaxKind.Unknown | SyntaxKind.EndOfFileToken | TriviaSyntaxKind | LiteralSyntaxKind | PseudoLiteralSyntaxKind | PunctuationSyntaxKind | SyntaxKind.Identifier | KeywordSyntaxKind; export type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken; @@ -545,9 +546,10 @@ declare namespace ts { Protected = 16, Static = 32, Readonly = 64, - Abstract = 128, - Async = 256, - Default = 512, + Accessor = 128, + Abstract = 256, + Async = 512, + Default = 1024, Const = 2048, HasComputedJSDocModifiers = 4096, Deprecated = 8192, @@ -559,10 +561,10 @@ declare namespace ts { AccessibilityModifier = 28, ParameterPropertyModifier = 16476, NonPublicAccessibilityModifier = 24, - TypeScriptModifier = 116958, - ExportDefault = 513, - All = 257023, - Modifier = 125951 + TypeScriptModifier = 117086, + ExportDefault = 1025, + All = 258047, + Modifier = 126975 } export enum JsxFlags { None = 0, @@ -618,6 +620,7 @@ declare namespace ts { export interface ModifierToken extends KeywordToken { } export type AbstractKeyword = ModifierToken; + export type AccessorKeyword = ModifierToken; export type AsyncKeyword = ModifierToken; export type ConstKeyword = ModifierToken; export type DeclareKeyword = ModifierToken; @@ -633,11 +636,11 @@ declare namespace ts { export type StaticKeyword = ModifierToken; /** @deprecated Use `ReadonlyKeyword` instead. */ export type ReadonlyToken = ReadonlyKeyword; - export type Modifier = AbstractKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | ExportKeyword | InKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | OutKeyword | OverrideKeyword | ReadonlyKeyword | StaticKeyword; + export type Modifier = AbstractKeyword | AccessorKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | ExportKeyword | InKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | OutKeyword | OverrideKeyword | ReadonlyKeyword | StaticKeyword; export type ModifierLike = Modifier | Decorator; export type AccessibilityModifier = PublicKeyword | PrivateKeyword | ProtectedKeyword; export type ParameterPropertyModifier = AccessibilityModifier | ReadonlyKeyword; - export type ClassMemberModifier = AccessibilityModifier | ReadonlyKeyword | StaticKeyword; + export type ClassMemberModifier = AccessibilityModifier | ReadonlyKeyword | StaticKeyword | AccessorKeyword; export type ModifiersArray = NodeArray; export enum GeneratedIdentifierFlags { None = 0, @@ -764,6 +767,9 @@ declare namespace ts { readonly type?: TypeNode; readonly initializer?: Expression; } + export interface AutoAccessorPropertyDeclaration extends PropertyDeclaration { + _autoAccessorBrand: any; + } export interface ObjectLiteralElement extends NamedDeclaration { _objectLiteralBrand: any; readonly name?: PropertyName; @@ -2554,6 +2560,7 @@ declare namespace ts { MethodExcludes = 103359, GetAccessorExcludes = 46015, SetAccessorExcludes = 78783, + AccessorExcludes = 13247, TypeParameterExcludes = 526824, TypeAliasExcludes = 788968, AliasExcludes = 2097152, @@ -3379,7 +3386,7 @@ declare namespace ts { createNumericLiteral(value: string | number, numericLiteralFlags?: TokenFlags): NumericLiteral; createBigIntLiteral(value: string | PseudoBigInt): BigIntLiteral; createStringLiteral(text: string, isSingleQuote?: boolean): StringLiteral; - createStringLiteralFromNode(sourceNode: PropertyNameLiteral, isSingleQuote?: boolean): StringLiteral; + createStringLiteralFromNode(sourceNode: PropertyNameLiteral | PrivateIdentifier, isSingleQuote?: boolean): StringLiteral; createRegularExpressionLiteral(text: string): RegularExpressionLiteral; createIdentifier(text: string): Identifier; /** @@ -3404,6 +3411,8 @@ declare namespace ts { /** Create a unique name generated for a node. */ getGeneratedNameForNode(node: Node | undefined, flags?: GeneratedIdentifierFlags): Identifier; createPrivateIdentifier(text: string): PrivateIdentifier; + createUniquePrivateName(text?: string): PrivateIdentifier; + getGeneratedPrivateNameForNode(node: Node): PrivateIdentifier; createToken(token: SyntaxKind.SuperKeyword): SuperExpression; createToken(token: SyntaxKind.ThisKeyword): ThisExpression; createToken(token: SyntaxKind.NullKeyword): NullLiteral; @@ -3940,7 +3949,7 @@ declare namespace ts { (nodes: NodeArray, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray; (nodes: NodeArray | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray | undefined; } - export type VisitResult = T | T[] | undefined; + export type VisitResult = T | readonly T[] | undefined; export interface Printer { /** * Print a node and its subtree as-is, without any emit transformations. @@ -4499,6 +4508,7 @@ declare namespace ts { function isClassElement(node: Node): node is ClassElement; function isClassLike(node: Node): node is ClassLikeDeclaration; function isAccessor(node: Node): node is AccessorDeclaration; + function isAutoAccessorPropertyDeclaration(node: Node): node is AutoAccessorPropertyDeclaration; function isModifierLike(node: Node): node is ModifierLike; function isTypeElement(node: Node): node is TypeElement; function isClassOrTypeElement(node: Node): node is ClassElement | TypeElement; @@ -10846,7 +10856,7 @@ declare namespace ts { (text: string, isSingleQuote?: boolean | undefined, hasExtendedUnicodeEscape?: boolean | undefined): StringLiteral; }; /** @deprecated Use `factory.createStringLiteralFromNode` or the factory supplied by your transformation context instead. */ - const createStringLiteralFromNode: (sourceNode: PropertyNameLiteral, isSingleQuote?: boolean | undefined) => StringLiteral; + const createStringLiteralFromNode: (sourceNode: PrivateIdentifier | PropertyNameLiteral, isSingleQuote?: boolean | undefined) => StringLiteral; /** @deprecated Use `factory.createRegularExpressionLiteral` or the factory supplied by your transformation context instead. */ const createRegularExpressionLiteral: (text: string) => RegularExpressionLiteral; /** @deprecated Use `factory.createLoopVariable` or the factory supplied by your transformation context instead. */ diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index aaea770c3efcb..94ab64f153758 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -232,237 +232,238 @@ declare namespace ts { StaticKeyword = 124, YieldKeyword = 125, AbstractKeyword = 126, - AsKeyword = 127, - AssertsKeyword = 128, - AssertKeyword = 129, - AnyKeyword = 130, - AsyncKeyword = 131, - AwaitKeyword = 132, - BooleanKeyword = 133, - ConstructorKeyword = 134, - DeclareKeyword = 135, - GetKeyword = 136, - InferKeyword = 137, - IntrinsicKeyword = 138, - IsKeyword = 139, - KeyOfKeyword = 140, - ModuleKeyword = 141, - NamespaceKeyword = 142, - NeverKeyword = 143, - OutKeyword = 144, - ReadonlyKeyword = 145, - RequireKeyword = 146, - NumberKeyword = 147, - ObjectKeyword = 148, - SetKeyword = 149, - StringKeyword = 150, - SymbolKeyword = 151, - TypeKeyword = 152, - UndefinedKeyword = 153, - UniqueKeyword = 154, - UnknownKeyword = 155, - FromKeyword = 156, - GlobalKeyword = 157, - BigIntKeyword = 158, - OverrideKeyword = 159, - OfKeyword = 160, - QualifiedName = 161, - ComputedPropertyName = 162, - TypeParameter = 163, - Parameter = 164, - Decorator = 165, - PropertySignature = 166, - PropertyDeclaration = 167, - MethodSignature = 168, - MethodDeclaration = 169, - ClassStaticBlockDeclaration = 170, - Constructor = 171, - GetAccessor = 172, - SetAccessor = 173, - CallSignature = 174, - ConstructSignature = 175, - IndexSignature = 176, - TypePredicate = 177, - TypeReference = 178, - FunctionType = 179, - ConstructorType = 180, - TypeQuery = 181, - TypeLiteral = 182, - ArrayType = 183, - TupleType = 184, - OptionalType = 185, - RestType = 186, - UnionType = 187, - IntersectionType = 188, - ConditionalType = 189, - InferType = 190, - ParenthesizedType = 191, - ThisType = 192, - TypeOperator = 193, - IndexedAccessType = 194, - MappedType = 195, - LiteralType = 196, - NamedTupleMember = 197, - TemplateLiteralType = 198, - TemplateLiteralTypeSpan = 199, - ImportType = 200, - ObjectBindingPattern = 201, - ArrayBindingPattern = 202, - BindingElement = 203, - ArrayLiteralExpression = 204, - ObjectLiteralExpression = 205, - PropertyAccessExpression = 206, - ElementAccessExpression = 207, - CallExpression = 208, - NewExpression = 209, - TaggedTemplateExpression = 210, - TypeAssertionExpression = 211, - ParenthesizedExpression = 212, - FunctionExpression = 213, - ArrowFunction = 214, - DeleteExpression = 215, - TypeOfExpression = 216, - VoidExpression = 217, - AwaitExpression = 218, - PrefixUnaryExpression = 219, - PostfixUnaryExpression = 220, - BinaryExpression = 221, - ConditionalExpression = 222, - TemplateExpression = 223, - YieldExpression = 224, - SpreadElement = 225, - ClassExpression = 226, - OmittedExpression = 227, - ExpressionWithTypeArguments = 228, - AsExpression = 229, - NonNullExpression = 230, - MetaProperty = 231, - SyntheticExpression = 232, - TemplateSpan = 233, - SemicolonClassElement = 234, - Block = 235, - EmptyStatement = 236, - VariableStatement = 237, - ExpressionStatement = 238, - IfStatement = 239, - DoStatement = 240, - WhileStatement = 241, - ForStatement = 242, - ForInStatement = 243, - ForOfStatement = 244, - ContinueStatement = 245, - BreakStatement = 246, - ReturnStatement = 247, - WithStatement = 248, - SwitchStatement = 249, - LabeledStatement = 250, - ThrowStatement = 251, - TryStatement = 252, - DebuggerStatement = 253, - VariableDeclaration = 254, - VariableDeclarationList = 255, - FunctionDeclaration = 256, - ClassDeclaration = 257, - InterfaceDeclaration = 258, - TypeAliasDeclaration = 259, - EnumDeclaration = 260, - ModuleDeclaration = 261, - ModuleBlock = 262, - CaseBlock = 263, - NamespaceExportDeclaration = 264, - ImportEqualsDeclaration = 265, - ImportDeclaration = 266, - ImportClause = 267, - NamespaceImport = 268, - NamedImports = 269, - ImportSpecifier = 270, - ExportAssignment = 271, - ExportDeclaration = 272, - NamedExports = 273, - NamespaceExport = 274, - ExportSpecifier = 275, - MissingDeclaration = 276, - ExternalModuleReference = 277, - JsxElement = 278, - JsxSelfClosingElement = 279, - JsxOpeningElement = 280, - JsxClosingElement = 281, - JsxFragment = 282, - JsxOpeningFragment = 283, - JsxClosingFragment = 284, - JsxAttribute = 285, - JsxAttributes = 286, - JsxSpreadAttribute = 287, - JsxExpression = 288, - CaseClause = 289, - DefaultClause = 290, - HeritageClause = 291, - CatchClause = 292, - AssertClause = 293, - AssertEntry = 294, - ImportTypeAssertionContainer = 295, - PropertyAssignment = 296, - ShorthandPropertyAssignment = 297, - SpreadAssignment = 298, - EnumMember = 299, - UnparsedPrologue = 300, - UnparsedPrepend = 301, - UnparsedText = 302, - UnparsedInternalText = 303, - UnparsedSyntheticReference = 304, - SourceFile = 305, - Bundle = 306, - UnparsedSource = 307, - InputFiles = 308, - JSDocTypeExpression = 309, - JSDocNameReference = 310, - JSDocMemberName = 311, - JSDocAllType = 312, - JSDocUnknownType = 313, - JSDocNullableType = 314, - JSDocNonNullableType = 315, - JSDocOptionalType = 316, - JSDocFunctionType = 317, - JSDocVariadicType = 318, - JSDocNamepathType = 319, - JSDoc = 320, + AccessorKeyword = 127, + AsKeyword = 128, + AssertsKeyword = 129, + AssertKeyword = 130, + AnyKeyword = 131, + AsyncKeyword = 132, + AwaitKeyword = 133, + BooleanKeyword = 134, + ConstructorKeyword = 135, + DeclareKeyword = 136, + GetKeyword = 137, + InferKeyword = 138, + IntrinsicKeyword = 139, + IsKeyword = 140, + KeyOfKeyword = 141, + ModuleKeyword = 142, + NamespaceKeyword = 143, + NeverKeyword = 144, + OutKeyword = 145, + ReadonlyKeyword = 146, + RequireKeyword = 147, + NumberKeyword = 148, + ObjectKeyword = 149, + SetKeyword = 150, + StringKeyword = 151, + SymbolKeyword = 152, + TypeKeyword = 153, + UndefinedKeyword = 154, + UniqueKeyword = 155, + UnknownKeyword = 156, + FromKeyword = 157, + GlobalKeyword = 158, + BigIntKeyword = 159, + OverrideKeyword = 160, + OfKeyword = 161, + QualifiedName = 162, + ComputedPropertyName = 163, + TypeParameter = 164, + Parameter = 165, + Decorator = 166, + PropertySignature = 167, + PropertyDeclaration = 168, + MethodSignature = 169, + MethodDeclaration = 170, + ClassStaticBlockDeclaration = 171, + Constructor = 172, + GetAccessor = 173, + SetAccessor = 174, + CallSignature = 175, + ConstructSignature = 176, + IndexSignature = 177, + TypePredicate = 178, + TypeReference = 179, + FunctionType = 180, + ConstructorType = 181, + TypeQuery = 182, + TypeLiteral = 183, + ArrayType = 184, + TupleType = 185, + OptionalType = 186, + RestType = 187, + UnionType = 188, + IntersectionType = 189, + ConditionalType = 190, + InferType = 191, + ParenthesizedType = 192, + ThisType = 193, + TypeOperator = 194, + IndexedAccessType = 195, + MappedType = 196, + LiteralType = 197, + NamedTupleMember = 198, + TemplateLiteralType = 199, + TemplateLiteralTypeSpan = 200, + ImportType = 201, + ObjectBindingPattern = 202, + ArrayBindingPattern = 203, + BindingElement = 204, + ArrayLiteralExpression = 205, + ObjectLiteralExpression = 206, + PropertyAccessExpression = 207, + ElementAccessExpression = 208, + CallExpression = 209, + NewExpression = 210, + TaggedTemplateExpression = 211, + TypeAssertionExpression = 212, + ParenthesizedExpression = 213, + FunctionExpression = 214, + ArrowFunction = 215, + DeleteExpression = 216, + TypeOfExpression = 217, + VoidExpression = 218, + AwaitExpression = 219, + PrefixUnaryExpression = 220, + PostfixUnaryExpression = 221, + BinaryExpression = 222, + ConditionalExpression = 223, + TemplateExpression = 224, + YieldExpression = 225, + SpreadElement = 226, + ClassExpression = 227, + OmittedExpression = 228, + ExpressionWithTypeArguments = 229, + AsExpression = 230, + NonNullExpression = 231, + MetaProperty = 232, + SyntheticExpression = 233, + TemplateSpan = 234, + SemicolonClassElement = 235, + Block = 236, + EmptyStatement = 237, + VariableStatement = 238, + ExpressionStatement = 239, + IfStatement = 240, + DoStatement = 241, + WhileStatement = 242, + ForStatement = 243, + ForInStatement = 244, + ForOfStatement = 245, + ContinueStatement = 246, + BreakStatement = 247, + ReturnStatement = 248, + WithStatement = 249, + SwitchStatement = 250, + LabeledStatement = 251, + ThrowStatement = 252, + TryStatement = 253, + DebuggerStatement = 254, + VariableDeclaration = 255, + VariableDeclarationList = 256, + FunctionDeclaration = 257, + ClassDeclaration = 258, + InterfaceDeclaration = 259, + TypeAliasDeclaration = 260, + EnumDeclaration = 261, + ModuleDeclaration = 262, + ModuleBlock = 263, + CaseBlock = 264, + NamespaceExportDeclaration = 265, + ImportEqualsDeclaration = 266, + ImportDeclaration = 267, + ImportClause = 268, + NamespaceImport = 269, + NamedImports = 270, + ImportSpecifier = 271, + ExportAssignment = 272, + ExportDeclaration = 273, + NamedExports = 274, + NamespaceExport = 275, + ExportSpecifier = 276, + MissingDeclaration = 277, + ExternalModuleReference = 278, + JsxElement = 279, + JsxSelfClosingElement = 280, + JsxOpeningElement = 281, + JsxClosingElement = 282, + JsxFragment = 283, + JsxOpeningFragment = 284, + JsxClosingFragment = 285, + JsxAttribute = 286, + JsxAttributes = 287, + JsxSpreadAttribute = 288, + JsxExpression = 289, + CaseClause = 290, + DefaultClause = 291, + HeritageClause = 292, + CatchClause = 293, + AssertClause = 294, + AssertEntry = 295, + ImportTypeAssertionContainer = 296, + PropertyAssignment = 297, + ShorthandPropertyAssignment = 298, + SpreadAssignment = 299, + EnumMember = 300, + UnparsedPrologue = 301, + UnparsedPrepend = 302, + UnparsedText = 303, + UnparsedInternalText = 304, + UnparsedSyntheticReference = 305, + SourceFile = 306, + Bundle = 307, + UnparsedSource = 308, + InputFiles = 309, + JSDocTypeExpression = 310, + JSDocNameReference = 311, + JSDocMemberName = 312, + JSDocAllType = 313, + JSDocUnknownType = 314, + JSDocNullableType = 315, + JSDocNonNullableType = 316, + JSDocOptionalType = 317, + JSDocFunctionType = 318, + JSDocVariadicType = 319, + JSDocNamepathType = 320, + JSDoc = 321, /** @deprecated Use SyntaxKind.JSDoc */ - JSDocComment = 320, - JSDocText = 321, - JSDocTypeLiteral = 322, - JSDocSignature = 323, - JSDocLink = 324, - JSDocLinkCode = 325, - JSDocLinkPlain = 326, - JSDocTag = 327, - JSDocAugmentsTag = 328, - JSDocImplementsTag = 329, - JSDocAuthorTag = 330, - JSDocDeprecatedTag = 331, - JSDocClassTag = 332, - JSDocPublicTag = 333, - JSDocPrivateTag = 334, - JSDocProtectedTag = 335, - JSDocReadonlyTag = 336, - JSDocOverrideTag = 337, - JSDocCallbackTag = 338, - JSDocEnumTag = 339, - JSDocParameterTag = 340, - JSDocReturnTag = 341, - JSDocThisTag = 342, - JSDocTypeTag = 343, - JSDocTemplateTag = 344, - JSDocTypedefTag = 345, - JSDocSeeTag = 346, - JSDocPropertyTag = 347, - SyntaxList = 348, - NotEmittedStatement = 349, - PartiallyEmittedExpression = 350, - CommaListExpression = 351, - MergeDeclarationMarker = 352, - EndOfDeclarationMarker = 353, - SyntheticReferenceExpression = 354, - Count = 355, + JSDocComment = 321, + JSDocText = 322, + JSDocTypeLiteral = 323, + JSDocSignature = 324, + JSDocLink = 325, + JSDocLinkCode = 326, + JSDocLinkPlain = 327, + JSDocTag = 328, + JSDocAugmentsTag = 329, + JSDocImplementsTag = 330, + JSDocAuthorTag = 331, + JSDocDeprecatedTag = 332, + JSDocClassTag = 333, + JSDocPublicTag = 334, + JSDocPrivateTag = 335, + JSDocProtectedTag = 336, + JSDocReadonlyTag = 337, + JSDocOverrideTag = 338, + JSDocCallbackTag = 339, + JSDocEnumTag = 340, + JSDocParameterTag = 341, + JSDocReturnTag = 342, + JSDocThisTag = 343, + JSDocTypeTag = 344, + JSDocTemplateTag = 345, + JSDocTypedefTag = 346, + JSDocSeeTag = 347, + JSDocPropertyTag = 348, + SyntaxList = 349, + NotEmittedStatement = 350, + PartiallyEmittedExpression = 351, + CommaListExpression = 352, + MergeDeclarationMarker = 353, + EndOfDeclarationMarker = 354, + SyntheticReferenceExpression = 355, + Count = 356, FirstAssignment = 63, LastAssignment = 78, FirstCompoundAssignment = 64, @@ -470,15 +471,15 @@ declare namespace ts { FirstReservedWord = 81, LastReservedWord = 116, FirstKeyword = 81, - LastKeyword = 160, + LastKeyword = 161, FirstFutureReservedWord = 117, LastFutureReservedWord = 125, - FirstTypeNode = 177, - LastTypeNode = 200, + FirstTypeNode = 178, + LastTypeNode = 201, FirstPunctuation = 18, LastPunctuation = 78, FirstToken = 0, - LastToken = 160, + LastToken = 161, FirstTriviaToken = 2, LastTriviaToken = 7, FirstLiteralToken = 8, @@ -487,20 +488,20 @@ declare namespace ts { LastTemplateToken = 17, FirstBinaryOperator = 29, LastBinaryOperator = 78, - FirstStatement = 237, - LastStatement = 253, - FirstNode = 161, - FirstJSDocNode = 309, - LastJSDocNode = 347, - FirstJSDocTagNode = 327, - LastJSDocTagNode = 347, + FirstStatement = 238, + LastStatement = 254, + FirstNode = 162, + FirstJSDocNode = 310, + LastJSDocNode = 348, + FirstJSDocTagNode = 328, + LastJSDocTagNode = 348, } export type TriviaSyntaxKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia | SyntaxKind.NewLineTrivia | SyntaxKind.WhitespaceTrivia | SyntaxKind.ShebangTrivia | SyntaxKind.ConflictMarkerTrivia; export type LiteralSyntaxKind = SyntaxKind.NumericLiteral | SyntaxKind.BigIntLiteral | SyntaxKind.StringLiteral | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.RegularExpressionLiteral | SyntaxKind.NoSubstitutionTemplateLiteral; export type PseudoLiteralSyntaxKind = SyntaxKind.TemplateHead | SyntaxKind.TemplateMiddle | SyntaxKind.TemplateTail; export type PunctuationSyntaxKind = SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.OpenParenToken | SyntaxKind.CloseParenToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.DotToken | SyntaxKind.DotDotDotToken | SyntaxKind.SemicolonToken | SyntaxKind.CommaToken | SyntaxKind.QuestionDotToken | SyntaxKind.LessThanToken | SyntaxKind.LessThanSlashToken | SyntaxKind.GreaterThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.EqualsEqualsToken | SyntaxKind.ExclamationEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.EqualsGreaterThanToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.AsteriskToken | SyntaxKind.AsteriskAsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken | SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken | SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken | SyntaxKind.ExclamationToken | SyntaxKind.TildeToken | SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken | SyntaxKind.QuestionQuestionToken | SyntaxKind.QuestionToken | SyntaxKind.ColonToken | SyntaxKind.AtToken | SyntaxKind.BacktickToken | SyntaxKind.HashToken | SyntaxKind.EqualsToken | SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.CaretEqualsToken; - export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.AssertKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.OfKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OutKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.RequireKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword; - export type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.ExportKeyword | SyntaxKind.InKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OutKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.StaticKeyword; + export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AccessorKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.AssertKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.OfKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OutKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.RequireKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword; + export type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AccessorKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.ExportKeyword | SyntaxKind.InKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OutKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.StaticKeyword; export type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VoidKeyword; export type TokenSyntaxKind = SyntaxKind.Unknown | SyntaxKind.EndOfFileToken | TriviaSyntaxKind | LiteralSyntaxKind | PseudoLiteralSyntaxKind | PunctuationSyntaxKind | SyntaxKind.Identifier | KeywordSyntaxKind; export type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken; @@ -545,9 +546,10 @@ declare namespace ts { Protected = 16, Static = 32, Readonly = 64, - Abstract = 128, - Async = 256, - Default = 512, + Accessor = 128, + Abstract = 256, + Async = 512, + Default = 1024, Const = 2048, HasComputedJSDocModifiers = 4096, Deprecated = 8192, @@ -559,10 +561,10 @@ declare namespace ts { AccessibilityModifier = 28, ParameterPropertyModifier = 16476, NonPublicAccessibilityModifier = 24, - TypeScriptModifier = 116958, - ExportDefault = 513, - All = 257023, - Modifier = 125951 + TypeScriptModifier = 117086, + ExportDefault = 1025, + All = 258047, + Modifier = 126975 } export enum JsxFlags { None = 0, @@ -618,6 +620,7 @@ declare namespace ts { export interface ModifierToken extends KeywordToken { } export type AbstractKeyword = ModifierToken; + export type AccessorKeyword = ModifierToken; export type AsyncKeyword = ModifierToken; export type ConstKeyword = ModifierToken; export type DeclareKeyword = ModifierToken; @@ -633,11 +636,11 @@ declare namespace ts { export type StaticKeyword = ModifierToken; /** @deprecated Use `ReadonlyKeyword` instead. */ export type ReadonlyToken = ReadonlyKeyword; - export type Modifier = AbstractKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | ExportKeyword | InKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | OutKeyword | OverrideKeyword | ReadonlyKeyword | StaticKeyword; + export type Modifier = AbstractKeyword | AccessorKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | ExportKeyword | InKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | OutKeyword | OverrideKeyword | ReadonlyKeyword | StaticKeyword; export type ModifierLike = Modifier | Decorator; export type AccessibilityModifier = PublicKeyword | PrivateKeyword | ProtectedKeyword; export type ParameterPropertyModifier = AccessibilityModifier | ReadonlyKeyword; - export type ClassMemberModifier = AccessibilityModifier | ReadonlyKeyword | StaticKeyword; + export type ClassMemberModifier = AccessibilityModifier | ReadonlyKeyword | StaticKeyword | AccessorKeyword; export type ModifiersArray = NodeArray; export enum GeneratedIdentifierFlags { None = 0, @@ -764,6 +767,9 @@ declare namespace ts { readonly type?: TypeNode; readonly initializer?: Expression; } + export interface AutoAccessorPropertyDeclaration extends PropertyDeclaration { + _autoAccessorBrand: any; + } export interface ObjectLiteralElement extends NamedDeclaration { _objectLiteralBrand: any; readonly name?: PropertyName; @@ -2554,6 +2560,7 @@ declare namespace ts { MethodExcludes = 103359, GetAccessorExcludes = 46015, SetAccessorExcludes = 78783, + AccessorExcludes = 13247, TypeParameterExcludes = 526824, TypeAliasExcludes = 788968, AliasExcludes = 2097152, @@ -3379,7 +3386,7 @@ declare namespace ts { createNumericLiteral(value: string | number, numericLiteralFlags?: TokenFlags): NumericLiteral; createBigIntLiteral(value: string | PseudoBigInt): BigIntLiteral; createStringLiteral(text: string, isSingleQuote?: boolean): StringLiteral; - createStringLiteralFromNode(sourceNode: PropertyNameLiteral, isSingleQuote?: boolean): StringLiteral; + createStringLiteralFromNode(sourceNode: PropertyNameLiteral | PrivateIdentifier, isSingleQuote?: boolean): StringLiteral; createRegularExpressionLiteral(text: string): RegularExpressionLiteral; createIdentifier(text: string): Identifier; /** @@ -3404,6 +3411,8 @@ declare namespace ts { /** Create a unique name generated for a node. */ getGeneratedNameForNode(node: Node | undefined, flags?: GeneratedIdentifierFlags): Identifier; createPrivateIdentifier(text: string): PrivateIdentifier; + createUniquePrivateName(text?: string): PrivateIdentifier; + getGeneratedPrivateNameForNode(node: Node): PrivateIdentifier; createToken(token: SyntaxKind.SuperKeyword): SuperExpression; createToken(token: SyntaxKind.ThisKeyword): ThisExpression; createToken(token: SyntaxKind.NullKeyword): NullLiteral; @@ -3940,7 +3949,7 @@ declare namespace ts { (nodes: NodeArray, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray; (nodes: NodeArray | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray | undefined; } - export type VisitResult = T | T[] | undefined; + export type VisitResult = T | readonly T[] | undefined; export interface Printer { /** * Print a node and its subtree as-is, without any emit transformations. @@ -4499,6 +4508,7 @@ declare namespace ts { function isClassElement(node: Node): node is ClassElement; function isClassLike(node: Node): node is ClassLikeDeclaration; function isAccessor(node: Node): node is AccessorDeclaration; + function isAutoAccessorPropertyDeclaration(node: Node): node is AutoAccessorPropertyDeclaration; function isModifierLike(node: Node): node is ModifierLike; function isTypeElement(node: Node): node is TypeElement; function isClassOrTypeElement(node: Node): node is ClassElement | TypeElement; @@ -6987,7 +6997,7 @@ declare namespace ts { (text: string, isSingleQuote?: boolean | undefined, hasExtendedUnicodeEscape?: boolean | undefined): StringLiteral; }; /** @deprecated Use `factory.createStringLiteralFromNode` or the factory supplied by your transformation context instead. */ - const createStringLiteralFromNode: (sourceNode: PropertyNameLiteral, isSingleQuote?: boolean | undefined) => StringLiteral; + const createStringLiteralFromNode: (sourceNode: PrivateIdentifier | PropertyNameLiteral, isSingleQuote?: boolean | undefined) => StringLiteral; /** @deprecated Use `factory.createRegularExpressionLiteral` or the factory supplied by your transformation context instead. */ const createRegularExpressionLiteral: (text: string) => RegularExpressionLiteral; /** @deprecated Use `factory.createLoopVariable` or the factory supplied by your transformation context instead. */ diff --git a/tests/baselines/reference/decoratorOnClassProperty13.js b/tests/baselines/reference/decoratorOnClassProperty13.js new file mode 100644 index 0000000000000..c914c6be18cf3 --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassProperty13.js @@ -0,0 +1,34 @@ +//// [decoratorOnClassProperty13.ts] +declare function dec(target: any, propertyKey: string): void; + +class C { + @dec accessor prop; +} + +//// [decoratorOnClassProperty13.js] +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +}; +var _C_prop_accessor_storage; +class C { + get prop() { return __classPrivateFieldGet(this, _C_prop_accessor_storage, "f"); } + set prop(value) { __classPrivateFieldSet(this, _C_prop_accessor_storage, value, "f"); } +} +_C_prop_accessor_storage = new WeakMap(); +__decorate([ + dec +], C.prototype, "prop", null); diff --git a/tests/baselines/reference/decoratorOnClassProperty13.symbols b/tests/baselines/reference/decoratorOnClassProperty13.symbols new file mode 100644 index 0000000000000..6dc163ffaed97 --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassProperty13.symbols @@ -0,0 +1,13 @@ +=== tests/cases/conformance/decorators/class/property/decoratorOnClassProperty13.ts === +declare function dec(target: any, propertyKey: string): void; +>dec : Symbol(dec, Decl(decoratorOnClassProperty13.ts, 0, 0)) +>target : Symbol(target, Decl(decoratorOnClassProperty13.ts, 0, 21)) +>propertyKey : Symbol(propertyKey, Decl(decoratorOnClassProperty13.ts, 0, 33)) + +class C { +>C : Symbol(C, Decl(decoratorOnClassProperty13.ts, 0, 61)) + + @dec accessor prop; +>dec : Symbol(dec, Decl(decoratorOnClassProperty13.ts, 0, 0)) +>prop : Symbol(C.prop, Decl(decoratorOnClassProperty13.ts, 2, 9)) +} diff --git a/tests/baselines/reference/decoratorOnClassProperty13.types b/tests/baselines/reference/decoratorOnClassProperty13.types new file mode 100644 index 0000000000000..6a9d7ca61c55e --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassProperty13.types @@ -0,0 +1,13 @@ +=== tests/cases/conformance/decorators/class/property/decoratorOnClassProperty13.ts === +declare function dec(target: any, propertyKey: string): void; +>dec : (target: any, propertyKey: string) => void +>target : any +>propertyKey : string + +class C { +>C : C + + @dec accessor prop; +>dec : (target: any, propertyKey: string) => void +>prop : any +} diff --git a/tests/baselines/reference/privateNameComputedPropertyName2(target=es2015).js b/tests/baselines/reference/privateNameComputedPropertyName2(target=es2015).js index 248d8203636d6..8b84f1973fb88 100644 --- a/tests/baselines/reference/privateNameComputedPropertyName2(target=es2015).js +++ b/tests/baselines/reference/privateNameComputedPropertyName2(target=es2015).js @@ -21,6 +21,6 @@ class A { constructor() { _A_x.set(this, 100); } - [(_A_x = new WeakMap(), (getX = (a) => __classPrivateFieldGet(a, _A_x, "f"), "_"))]() { } + [(_A_x = new WeakMap(), getX = (a) => __classPrivateFieldGet(a, _A_x, "f"), "_")]() { } } console.log(getX(new A)); diff --git a/tests/baselines/reference/privateNameDuplicateField.js b/tests/baselines/reference/privateNameDuplicateField.js index 3b59b74ad8165..1ed7681412e50 100644 --- a/tests/baselines/reference/privateNameDuplicateField.js +++ b/tests/baselines/reference/privateNameDuplicateField.js @@ -557,7 +557,7 @@ function Method() { _d = A_Method_StaticSetter, _A_Method_StaticSetter_instances = new WeakSet(); } function Getter() { - var _A_Getter_Field_instances, _A_Getter_Field_foo_get, _A_Getter_Field_foo, _A_Getter_Method_instances, _A_Getter_Method_foo_get, _A_Getter_Method_foo, _A_Getter_Getter_instances, _A_Getter_Getter_foo_get, _A_Getter_Getter_foo_get_1, _A_Getter_Setter_instances, _A_Getter_Setter_foo_get, _A_Getter_Setter_foo_set, _A_Getter_StaticField_instances, _a, _A_Getter_StaticField_foo_get, _A_Getter_StaticField_foo, _A_Getter_StaticMethod_instances, _b, _A_Getter_StaticMethod_foo_get, _A_Getter_StaticMethod_foo, _A_Getter_StaticGetter_instances, _c, _A_Getter_StaticGetter_foo_get, _A_Getter_StaticGetter_foo_get_1, _A_Getter_StaticSetter_instances, _d, _A_Getter_StaticSetter_foo_get, _A_Getter_StaticSetter_foo_set; + var _A_Getter_Field_instances, _A_Getter_Field_foo_get, _A_Getter_Field_foo, _A_Getter_Method_instances, _A_Getter_Method_foo_get, _A_Getter_Method_foo, _A_Getter_Getter_instances, _A_Getter_Getter_foo_get, _A_Getter_Getter_foo_1_get, _A_Getter_Setter_instances, _A_Getter_Setter_foo_get, _A_Getter_Setter_foo_set, _A_Getter_StaticField_instances, _a, _A_Getter_StaticField_foo_get, _A_Getter_StaticField_foo, _A_Getter_StaticMethod_instances, _b, _A_Getter_StaticMethod_foo_get, _A_Getter_StaticMethod_foo, _A_Getter_StaticGetter_instances, _c, _A_Getter_StaticGetter_foo_get, _A_Getter_StaticGetter_foo_1_get, _A_Getter_StaticSetter_instances, _d, _A_Getter_StaticSetter_foo_get, _A_Getter_StaticSetter_foo_set; // Error class A_Getter_Field { constructor() { @@ -631,7 +631,7 @@ function Getter() { _d = A_Getter_StaticSetter, _A_Getter_StaticSetter_instances = new WeakSet(); } function Setter() { - var _A_Setter_Field_instances, _A_Setter_Field_foo_set, _A_Setter_Field_foo, _A_Setter_Method_instances, _A_Setter_Method_foo_set, _A_Setter_Method_foo, _A_Setter_Getter_instances, _A_Setter_Getter_foo_set, _A_Setter_Getter_foo_get, _A_Setter_Setter_instances, _A_Setter_Setter_foo_set, _A_Setter_Setter_foo_set_1, _A_Setter_StaticField_instances, _a, _A_Setter_StaticField_foo_set, _A_Setter_StaticField_foo, _A_Setter_StaticMethod_instances, _b, _A_Setter_StaticMethod_foo_set, _A_Setter_StaticMethod_foo, _A_Setter_StaticGetter_instances, _c, _A_Setter_StaticGetter_foo_set, _A_Setter_StaticGetter_foo_get, _A_Setter_StaticSetter_instances, _d, _A_Setter_StaticSetter_foo_set, _A_Setter_StaticSetter_foo_set_1; + var _A_Setter_Field_instances, _A_Setter_Field_foo_set, _A_Setter_Field_foo, _A_Setter_Method_instances, _A_Setter_Method_foo_set, _A_Setter_Method_foo, _A_Setter_Getter_instances, _A_Setter_Getter_foo_set, _A_Setter_Getter_foo_get, _A_Setter_Setter_instances, _A_Setter_Setter_foo_set, _A_Setter_Setter_foo_1_set, _A_Setter_StaticField_instances, _a, _A_Setter_StaticField_foo_set, _A_Setter_StaticField_foo, _A_Setter_StaticMethod_instances, _b, _A_Setter_StaticMethod_foo_set, _A_Setter_StaticMethod_foo, _A_Setter_StaticGetter_instances, _c, _A_Setter_StaticGetter_foo_set, _A_Setter_StaticGetter_foo_get, _A_Setter_StaticSetter_instances, _d, _A_Setter_StaticSetter_foo_set, _A_Setter_StaticSetter_foo_1_set; // Error class A_Setter_Field { constructor() { @@ -836,7 +836,7 @@ function StaticMethod() { _h = A_StaticMethod_StaticSetter; } function StaticGetter() { - var _a, _A_StaticGetter_Field_foo_get, _A_StaticGetter_Field_foo, _A_StaticGetter_Method_instances, _b, _A_StaticGetter_Method_foo_get, _A_StaticGetter_Method_foo, _A_StaticGetter_Getter_instances, _c, _A_StaticGetter_Getter_foo_get, _A_StaticGetter_Getter_foo_get_1, _A_StaticGetter_Setter_instances, _d, _A_StaticGetter_Setter_foo_get, _A_StaticGetter_Setter_foo_set, _e, _A_StaticGetter_StaticField_foo_get, _A_StaticGetter_StaticField_foo, _f, _A_StaticGetter_StaticMethod_foo_get, _A_StaticGetter_StaticMethod_foo, _g, _A_StaticGetter_StaticGetter_foo_get, _A_StaticGetter_StaticGetter_foo_get_1, _h, _A_StaticGetter_StaticSetter_foo_get, _A_StaticGetter_StaticSetter_foo_set; + var _a, _A_StaticGetter_Field_foo_get, _A_StaticGetter_Field_foo, _A_StaticGetter_Method_instances, _b, _A_StaticGetter_Method_foo_get, _A_StaticGetter_Method_foo, _A_StaticGetter_Getter_instances, _c, _A_StaticGetter_Getter_foo_get, _A_StaticGetter_Getter_foo_1_get, _A_StaticGetter_Setter_instances, _d, _A_StaticGetter_Setter_foo_get, _A_StaticGetter_Setter_foo_set, _e, _A_StaticGetter_StaticField_foo_get, _A_StaticGetter_StaticField_foo, _f, _A_StaticGetter_StaticMethod_foo_get, _A_StaticGetter_StaticMethod_foo, _g, _A_StaticGetter_StaticGetter_foo_get, _A_StaticGetter_StaticGetter_foo_1_get, _h, _A_StaticGetter_StaticSetter_foo_get, _A_StaticGetter_StaticSetter_foo_set; // Error class A_StaticGetter_Field { constructor() { @@ -897,7 +897,7 @@ function StaticGetter() { _h = A_StaticGetter_StaticSetter, _A_StaticGetter_StaticSetter_foo_get = function _A_StaticGetter_StaticSetter_foo_get() { return ""; }, _A_StaticGetter_StaticSetter_foo_set = function _A_StaticGetter_StaticSetter_foo_set(value) { }; } function StaticSetter() { - var _a, _A_StaticSetter_Field_foo_set, _A_StaticSetter_Field_foo, _A_StaticSetter_Method_instances, _b, _A_StaticSetter_Method_foo_set, _A_StaticSetter_Method_foo, _A_StaticSetter_Getter_instances, _c, _A_StaticSetter_Getter_foo_set, _A_StaticSetter_Getter_foo_get, _A_StaticSetter_Setter_instances, _d, _A_StaticSetter_Setter_foo_set, _A_StaticSetter_Setter_foo_set_1, _e, _A_StaticSetter_StaticField_foo_set, _A_StaticSetter_StaticField_foo, _f, _A_StaticSetter_StaticMethod_foo_set, _A_StaticSetter_StaticMethod_foo, _g, _A_StaticSetter_StaticGetter_foo_set, _A_StaticSetter_StaticGetter_foo_get, _h, _A_StaticSetter_StaticSetter_foo_set, _A_StaticSetter_StaticSetter_foo_set_1; + var _a, _A_StaticSetter_Field_foo_set, _A_StaticSetter_Field_foo, _A_StaticSetter_Method_instances, _b, _A_StaticSetter_Method_foo_set, _A_StaticSetter_Method_foo, _A_StaticSetter_Getter_instances, _c, _A_StaticSetter_Getter_foo_set, _A_StaticSetter_Getter_foo_get, _A_StaticSetter_Setter_instances, _d, _A_StaticSetter_Setter_foo_set, _A_StaticSetter_Setter_foo_1_set, _e, _A_StaticSetter_StaticField_foo_set, _A_StaticSetter_StaticField_foo, _f, _A_StaticSetter_StaticMethod_foo_set, _A_StaticSetter_StaticMethod_foo, _g, _A_StaticSetter_StaticGetter_foo_set, _A_StaticSetter_StaticGetter_foo_get, _h, _A_StaticSetter_StaticSetter_foo_set, _A_StaticSetter_StaticSetter_foo_1_set; // Error class A_StaticSetter_Field { constructor() { diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts new file mode 100644 index 0000000000000..177db89c2eddb --- /dev/null +++ b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField1.ts @@ -0,0 +1,9 @@ +// @target: esnext, es2022, es2015, es5 +// @noEmitOnError: true + +class C1 { + accessor a: any; + accessor b = 1; + static accessor c: any; + static accessor d = 2; +} diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField2.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField2.ts new file mode 100644 index 0000000000000..898bb120600ad --- /dev/null +++ b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField2.ts @@ -0,0 +1,8 @@ +// @target: esnext, es2022, es2015 + +class C1 { + accessor #a: any; + accessor #b = 1; + static accessor #c: any; + static accessor #d = 2; +} diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts new file mode 100644 index 0000000000000..1c74a8be284c9 --- /dev/null +++ b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField3.ts @@ -0,0 +1,9 @@ +// @target: esnext, es2022, es2015, es5 +// @noEmitOnError: true + +class C1 { + accessor "w": any; + accessor "x" = 1; + static accessor "y": any; + static accessor "z" = 2; +} diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts new file mode 100644 index 0000000000000..fcbf1e6f7bd58 --- /dev/null +++ b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField4.ts @@ -0,0 +1,9 @@ +// @target: esnext, es2022, es2015, es5 +// @noEmitOnError: true + +class C1 { + accessor 0: any; + accessor 1 = 1; + static accessor 2: any; + static accessor 3 = 2; +} diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts new file mode 100644 index 0000000000000..99e5cb140ef73 --- /dev/null +++ b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField5.ts @@ -0,0 +1,15 @@ +// @target: esnext, es2022, es2015, es5 +// @noEmitOnError: true + +class C1 { + accessor ["w"]: any; + accessor ["x"] = 1; + static accessor ["y"]: any; + static accessor ["z"] = 2; +} + +declare var f: any; +class C2 { + // @ts-ignore + accessor [f()] = 1; +} \ No newline at end of file diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts new file mode 100644 index 0000000000000..aeb0c28609c25 --- /dev/null +++ b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField6.ts @@ -0,0 +1,14 @@ +// @target: esnext, es2022, es2015 +// @useDefineForClassFields: * + +class C1 { + accessor a: any; +} + +class C2 extends C1 { + a = 1; +} + +class C3 extends C1 { + get a() { return super.a; } +} diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField7.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField7.ts new file mode 100644 index 0000000000000..7993326180d10 --- /dev/null +++ b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField7.ts @@ -0,0 +1,14 @@ +// @target: esnext, es2022, es2015 +// @useDefineForClassFields: * + +abstract class C1 { + abstract accessor a: any; +} + +class C2 extends C1 { + accessor a = 1; +} + +class C3 extends C1 { + get a() { return 1; } +} diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField8.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField8.ts new file mode 100644 index 0000000000000..8e3a19e4d2b9d --- /dev/null +++ b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorField8.ts @@ -0,0 +1,20 @@ +// @target: esnext +// @declaration: true + +class C1 { + accessor a: any; + static accessor b: any; +} + +declare class C2 { + accessor a: any; + static accessor b: any; +} + +function f() { + class C3 { + accessor a: any; + static accessor b: any; + } + return C3; +} diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldAllowedModifiers.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldAllowedModifiers.ts new file mode 100644 index 0000000000000..be8aca8bdfd31 --- /dev/null +++ b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldAllowedModifiers.ts @@ -0,0 +1,28 @@ +// @target: esnext +// @noTypesAndSymbols: true + +abstract class C1 { + accessor a: any; + public accessor b: any; + private accessor c: any; + protected accessor d: any; + abstract accessor e: any; + static accessor f: any; + public static accessor g: any; + private static accessor h: any; + protected static accessor i: any; + accessor #j: any; + accessor "k": any; + accessor 108: any; + accessor ["m"]: any; +} + +class C2 extends C1 { + override accessor e: any; + static override accessor i: any; +} + +declare class C3 { + accessor a: any; +} + diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts new file mode 100644 index 0000000000000..1d4cdba39ba5f --- /dev/null +++ b/tests/cases/conformance/classes/propertyMemberDeclarations/accessorFieldDisallowedModifiers.ts @@ -0,0 +1,38 @@ +// @target: esnext +// @noTypesAndSymbols: true + +abstract class C1 { + accessor accessor a: any; + readonly accessor b: any; + declare accessor c: any; + accessor public d: any; + accessor private e: any; + accessor protected f: any; + accessor abstract g: any; + accessor static h: any; + accessor i() {} + accessor get j() { return false; } + accessor set k(v: any) {} + accessor constructor() {} +} + +class C2 extends C1 { + accessor override g: any; +} + +interface I1 { + accessor a: number; +} + +accessor class C3 {} +accessor interface I2 {} +accessor namespace N1 {} +accessor enum E1 {} +accessor var V1: any; +accessor type T1 = never; +accessor function F1() {} +accessor import "x"; +accessor import {} from "x"; +accessor export { V1 }; +accessor export default V1; +accessor import N2 = N1; diff --git a/tests/cases/conformance/decorators/class/property/decoratorOnClassProperty13.ts b/tests/cases/conformance/decorators/class/property/decoratorOnClassProperty13.ts new file mode 100644 index 0000000000000..2955af4dd771c --- /dev/null +++ b/tests/cases/conformance/decorators/class/property/decoratorOnClassProperty13.ts @@ -0,0 +1,7 @@ +// @target: ES2015 +// @experimentaldecorators: true +declare function dec(target: any, propertyKey: string): void; + +class C { + @dec accessor prop; +} \ No newline at end of file diff --git a/tests/cases/fourslash/completionEntryForClassMembers.ts b/tests/cases/fourslash/completionEntryForClassMembers.ts index 4d691c383abe0..fd148965c55e2 100644 --- a/tests/cases/fourslash/completionEntryForClassMembers.ts +++ b/tests/cases/fourslash/completionEntryForClassMembers.ts @@ -146,9 +146,7 @@ verify.completions( "classThatStartedWritingIdentifierAfterPrivateModifier", "classThatStartedWritingIdentifierAfterPrivateStaticModifier", ], - unsorted: ["private", "protected", "public", "static", "abstract", "async", "constructor", "declare", "get", "readonly", "set", "override"].map( - name => ({ name, sortText: completion.SortText.GlobalsOrKeywords }) - ), + unsorted: completion.classElementKeywords, isNewIdentifierLocation: true, }, { diff --git a/tests/cases/fourslash/completionListInNamedClassExpression.ts b/tests/cases/fourslash/completionListInNamedClassExpression.ts index 1a3068e9d0360..98658ee6888f4 100644 --- a/tests/cases/fourslash/completionListInNamedClassExpression.ts +++ b/tests/cases/fourslash/completionListInNamedClassExpression.ts @@ -11,22 +11,7 @@ verify.completions( { marker: "0", includes: { name: "myClass", text: "(local class) myClass", kind: "local class" } }, { marker: "1", - exact: [ - "abstract", - "async", - "constructor", - "declare", - "get", - "override", - "private", - "protected", - "public", - "readonly", - "set", - "static", - ].map( - name => ({ name, sortText: completion.SortText.GlobalsOrKeywords }) - ), + exact: completion.classElementKeywords, isNewIdentifierLocation: true, } );