From f07513d98fce62e57980f76b63722474f22a724a Mon Sep 17 00:00:00 2001 From: kingwl Date: Thu, 15 Oct 2020 14:27:15 +0800 Subject: [PATCH 1/3] make linter happy --- src/compiler/checker.ts | 32 ++++++--- src/compiler/diagnosticMessages.json | 8 +++ src/compiler/emitter.ts | 6 ++ src/compiler/factory/nodeFactory.ts | 8 ++- src/compiler/parser.ts | 8 ++- src/compiler/transformers/declarations.ts | 2 +- src/compiler/types.ts | 5 +- src/compiler/visitorPublic.ts | 1 + src/services/codefixes/fixAddMissingMember.ts | 1 + src/services/refactors/moveToNewFile.ts | 2 +- .../enumStringAnnotation1.errors.txt | 30 +++++++++ .../reference/enumStringAnnotation1.js | 67 +++++++++++++++++++ .../reference/enumStringAnnotation1.symbols | 46 +++++++++++++ .../reference/enumStringAnnotation1.types | 53 +++++++++++++++ .../enums/enumStringAnnotation1.ts | 23 +++++++ 15 files changed, 277 insertions(+), 15 deletions(-) create mode 100644 tests/baselines/reference/enumStringAnnotation1.errors.txt create mode 100644 tests/baselines/reference/enumStringAnnotation1.js create mode 100644 tests/baselines/reference/enumStringAnnotation1.symbols create mode 100644 tests/baselines/reference/enumStringAnnotation1.types create mode 100644 tests/cases/conformance/enums/enumStringAnnotation1.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 65cbfed68a6eb..ff2c7f1b35cf9 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6603,6 +6603,7 @@ namespace ts { /*decorators*/ undefined, factory.createModifiersFromModifierFlags(isConstEnumSymbol(symbol) ? ModifierFlags.Const : 0), getInternalSymbolName(symbol, symbolName), + /*type*/ undefined, map(filter(getPropertiesOfType(getTypeOfSymbol(symbol)), p => !!(p.flags & SymbolFlags.EnumMember)), p => { // TODO: Handle computed names // I hate that to get the initialized value we need to walk back to the declarations here; but there's no @@ -35696,14 +35697,14 @@ namespace ts { nodeLinks.flags |= NodeCheckFlags.EnumValuesComputed; let autoValue: number | undefined = 0; for (const member of node.members) { - const value = computeMemberValue(member, autoValue); + const value = computeMemberValue(node, member, autoValue); getNodeLinks(member).enumMemberValue = value; autoValue = typeof value === "number" ? value + 1 : undefined; } } } - function computeMemberValue(member: EnumMember, autoValue: number | undefined) { + function computeMemberValue(node: EnumDeclaration, member: EnumMember, autoValue: number | undefined) { if (isComputedNonLiteralName(member.name)) { error(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums); } @@ -35712,9 +35713,12 @@ namespace ts { if (isNumericLiteralName(text) && !isInfinityOrNaNString(text)) { error(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name); } + if (node.type && !member.initializer) { + return text as string; + } } if (member.initializer) { - return computeConstantValue(member); + return computeConstantValue(node, member); } // In ambient non-const numeric enum declarations, enum members without initializers are // considered computed members (as opposed to having auto-incremented values). @@ -35732,16 +35736,21 @@ namespace ts { return undefined; } - function computeConstantValue(member: EnumMember): string | number | undefined { + function computeConstantValue(node: EnumDeclaration, member: EnumMember): string | number | undefined { const enumKind = getEnumKind(getSymbolOfNode(member.parent)); const isConstEnum = isEnumConst(member.parent); const initializer = member.initializer!; const value = enumKind === EnumKind.Literal && !isLiteralEnumMember(member) ? undefined : evaluate(initializer); if (value !== undefined) { - if (isConstEnum && typeof value === "number" && !isFinite(value)) { - error(initializer, isNaN(value) ? - Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN : - Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value); + if (typeof value === "number") { + if (node.type) { + error(initializer, Diagnostics.Cannot_use_non_string_initializer_in_enum_with_string_annotation); + } + if (isConstEnum && !isFinite(value)) { + error(initializer, isNaN(value) ? + Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN : + Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value); + } } } else if (enumKind === EnumKind.Literal) { @@ -35862,6 +35871,12 @@ namespace ts { isStringLiteralLike((node).argumentExpression); } + function checkGrammarEnumTypeAnnotation(node: EnumDeclaration) { + if (node.type && node.type.originalKeywordKind !== SyntaxKind.StringKeyword) { + error(node.type, Diagnostics.Enum_annotation_is_support_string_only); + } + } + function checkEnumDeclaration(node: EnumDeclaration) { if (!produceDiagnostics) { return; @@ -35869,6 +35884,7 @@ namespace ts { // Grammar checking checkGrammarDecoratorsAndModifiers(node); + checkGrammarEnumTypeAnnotation(node); checkTypeNameIsReserved(node.name, Diagnostics.Enum_name_cannot_be_0); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index cab3de0e1bab0..3f2ef42edea3b 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1224,6 +1224,14 @@ "code": 2205, "elidedInCompatabilityPyramid": true }, + "Enum annotation is support 'string' only.": { + "category": "Error", + "code": 2206 + }, + "Cannot use non-string initializer in enum with 'string' annotation.": { + "category": "Error", + "code": 2207 + }, "Duplicate identifier '{0}'.": { "category": "Error", diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 237d3fee9cdc5..536f3d1b8a0e4 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -3110,6 +3110,12 @@ namespace ts { writeKeyword("enum"); writeSpace(); emit(node.name); + if (node.type) { + writeSpace(); + writePunctuation(":"); + writeSpace(); + emit(node.type); + } writeSpace(); writePunctuation("{"); diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts index 3d1b6fdb9a7d3..0d295a9020df7 100644 --- a/src/compiler/factory/nodeFactory.ts +++ b/src/compiler/factory/nodeFactory.ts @@ -3624,6 +3624,7 @@ namespace ts { decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, + type: Identifier | undefined, members: readonly EnumMember[] ) { const node = createBaseNamedDeclaration( @@ -3632,6 +3633,7 @@ namespace ts { modifiers, name ); + node.type = type; node.members = createNodeArray(members); node.transformFlags |= propagateChildrenFlags(node.members) | @@ -3646,12 +3648,14 @@ namespace ts { decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, + type: Identifier | undefined, members: readonly EnumMember[]) { return node.decorators !== decorators || node.modifiers !== modifiers || node.name !== name + || node.type !== type || node.members !== members - ? update(createEnumDeclaration(decorators, modifiers, name, members), node) + ? update(createEnumDeclaration(decorators, modifiers, name, type, members), node) : node; } @@ -5773,7 +5777,7 @@ namespace ts { isClassDeclaration(node) ? updateClassDeclaration(node, node.decorators, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members) : isInterfaceDeclaration(node) ? updateInterfaceDeclaration(node, node.decorators, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members) : isTypeAliasDeclaration(node) ? updateTypeAliasDeclaration(node, node.decorators, modifiers, node.name, node.typeParameters, node.type) : - isEnumDeclaration(node) ? updateEnumDeclaration(node, node.decorators, modifiers, node.name, node.members) : + isEnumDeclaration(node) ? updateEnumDeclaration(node, node.decorators, modifiers, node.name, node.type, node.members) : isModuleDeclaration(node) ? updateModuleDeclaration(node, node.decorators, modifiers, node.name, node.body) : isImportEqualsDeclaration(node) ? updateImportEqualsDeclaration(node, node.decorators, modifiers, node.name, node.moduleReference) : isImportDeclaration(node) ? updateImportDeclaration(node, node.decorators, modifiers, node.importClause, node.moduleSpecifier) : diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index a815a12db9a53..e5ad0a2d061fa 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -376,6 +376,7 @@ namespace ts { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, (node).name) || + visitNode(cbNode, (node).type) || visitNodes(cbNode, cbNodes, (node).members); case SyntaxKind.EnumMember: return visitNode(cbNode, (node).name) || @@ -6763,6 +6764,11 @@ namespace ts { function parseEnumDeclaration(pos: number, hasJSDoc: boolean, decorators: NodeArray | undefined, modifiers: NodeArray | undefined): EnumDeclaration { parseExpected(SyntaxKind.EnumKeyword); const name = parseIdentifier(); + let type: Identifier | undefined; + if (parseOptionalToken(SyntaxKind.ColonToken)) { + type = parseIdentifierName(); + } + let members; if (parseExpected(SyntaxKind.OpenBraceToken)) { members = doOutsideOfYieldAndAwaitContext(() => parseDelimitedList(ParsingContext.EnumMembers, parseEnumMember)); @@ -6771,7 +6777,7 @@ namespace ts { else { members = createMissingList(); } - const node = factory.createEnumDeclaration(decorators, modifiers, name, members); + const node = factory.createEnumDeclaration(decorators, modifiers, name, type, members); return withJSDoc(finishNode(node, pos), hasJSDoc); } diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts index 43539cb06ad71..8847f6969c590 100644 --- a/src/compiler/transformers/declarations.ts +++ b/src/compiler/transformers/declarations.ts @@ -1435,7 +1435,7 @@ namespace ts { return cleanup(transformVariableStatement(input)); } case SyntaxKind.EnumDeclaration: { - return cleanup(factory.updateEnumDeclaration(input, /*decorators*/ undefined, factory.createNodeArray(ensureModifiers(input)), input.name, factory.createNodeArray(mapDefined(input.members, m => { + return cleanup(factory.updateEnumDeclaration(input, /*decorators*/ undefined, factory.createNodeArray(ensureModifiers(input)), input.name, /*type*/ undefined, factory.createNodeArray(mapDefined(input.members, m => { if (shouldStripInternal(m)) return; // Rewrite enum values to their constants, if available const constValue = resolver.getConstantValue(m); diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 0ce9c2afa7539..a5034d340e557 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -2861,6 +2861,7 @@ namespace ts { readonly kind: SyntaxKind.EnumDeclaration; readonly name: Identifier; readonly members: NodeArray; + readonly type?: Identifier } export type ModuleName = @@ -6980,8 +6981,8 @@ namespace ts { updateInterfaceDeclaration(node: InterfaceDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration; createTypeAliasDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration; updateTypeAliasDeclaration(node: TypeAliasDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration; - createEnumDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration; - updateEnumDeclaration(node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration; + createEnumDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, type: Identifier | undefined, members: readonly EnumMember[]): EnumDeclaration; + updateEnumDeclaration(node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, type: Identifier | undefined, members: readonly EnumMember[]): EnumDeclaration; createModuleDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration; updateModuleDeclaration(node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration; createModuleBlock(statements: readonly Statement[]): ModuleBlock; diff --git a/src/compiler/visitorPublic.ts b/src/compiler/visitorPublic.ts index 8a06e110552dc..be43670f0bbf2 100644 --- a/src/compiler/visitorPublic.ts +++ b/src/compiler/visitorPublic.ts @@ -912,6 +912,7 @@ namespace ts { nodesVisitor((node).decorators, visitor, isDecorator), nodesVisitor((node).modifiers, visitor, isModifier), nodeVisitor((node).name, visitor, isIdentifier), + nodeVisitor((node).type, visitor, isIdentifier), nodesVisitor((node).members, visitor, isEnumMember)); case SyntaxKind.ModuleDeclaration: diff --git a/src/services/codefixes/fixAddMissingMember.ts b/src/services/codefixes/fixAddMissingMember.ts index 28bc1da2d6bdc..daf724d1f2303 100644 --- a/src/services/codefixes/fixAddMissingMember.ts +++ b/src/services/codefixes/fixAddMissingMember.ts @@ -344,6 +344,7 @@ namespace ts.codefix { enumDeclaration.decorators, enumDeclaration.modifiers, enumDeclaration.name, + enumDeclaration.type, concatenate(enumDeclaration.members, singleElementArray(enumMember)) ), { leadingTriviaOption: textChanges.LeadingTriviaOption.IncludeAll, diff --git a/src/services/refactors/moveToNewFile.ts b/src/services/refactors/moveToNewFile.ts index 8c3f4504925c1..98d34b823640e 100644 --- a/src/services/refactors/moveToNewFile.ts +++ b/src/services/refactors/moveToNewFile.ts @@ -776,7 +776,7 @@ namespace ts.refactor { case SyntaxKind.ModuleDeclaration: return factory.updateModuleDeclaration(d, d.decorators, modifiers, d.name, d.body); case SyntaxKind.EnumDeclaration: - return factory.updateEnumDeclaration(d, d.decorators, modifiers, d.name, d.members); + return factory.updateEnumDeclaration(d, d.decorators, modifiers, d.name, d.type, d.members); case SyntaxKind.TypeAliasDeclaration: return factory.updateTypeAliasDeclaration(d, d.decorators, modifiers, d.name, d.typeParameters, d.type); case SyntaxKind.InterfaceDeclaration: diff --git a/tests/baselines/reference/enumStringAnnotation1.errors.txt b/tests/baselines/reference/enumStringAnnotation1.errors.txt new file mode 100644 index 0000000000000..34d349a4f92c6 --- /dev/null +++ b/tests/baselines/reference/enumStringAnnotation1.errors.txt @@ -0,0 +1,30 @@ +tests/cases/conformance/enums/enumStringAnnotation1.ts(13,9): error TS2207: Cannot use non-string initializer in enum with 'string' annotation. +tests/cases/conformance/enums/enumStringAnnotation1.ts(18,9): error TS2206: Enum annotation is support 'string' only. + + +==== tests/cases/conformance/enums/enumStringAnnotation1.ts (2 errors) ==== + enum A: string { + A, + B + } + + enum B: string { + A, + B = '1', + C, + } + + enum C: string { + A = 1, + ~ +!!! error TS2207: Cannot use non-string initializer in enum with 'string' annotation. + B = '2', + C + } + + enum D: number { + ~~~~~~ +!!! error TS2206: Enum annotation is support 'string' only. + A, + B + } \ No newline at end of file diff --git a/tests/baselines/reference/enumStringAnnotation1.js b/tests/baselines/reference/enumStringAnnotation1.js new file mode 100644 index 0000000000000..82539a0a86ddf --- /dev/null +++ b/tests/baselines/reference/enumStringAnnotation1.js @@ -0,0 +1,67 @@ +//// [enumStringAnnotation1.ts] +enum A: string { + A, + B +} + +enum B: string { + A, + B = '1', + C, +} + +enum C: string { + A = 1, + B = '2', + C +} + +enum D: number { + A, + B +} + +//// [enumStringAnnotation1.js] +var A; +(function (A) { + A["A"] = "A"; + A["B"] = "B"; +})(A || (A = {})); +var B; +(function (B) { + B["A"] = "A"; + B["B"] = "1"; + B["C"] = "C"; +})(B || (B = {})); +var C; +(function (C) { + C[C["A"] = 1] = "A"; + C["B"] = "2"; + C["C"] = "C"; +})(C || (C = {})); +var D; +(function (D) { + D["A"] = "A"; + D["B"] = "B"; +})(D || (D = {})); + + +//// [enumStringAnnotation1.d.ts] +declare enum A { + A = "A", + B = "B" +} +declare enum B { + A = "A", + B = "1", + C = "C" +} +declare enum C { + A = 1, + B = "2", + C = "C" +} +declare enum D { + A = "A", + B = "B" +} diff --git a/tests/baselines/reference/enumStringAnnotation1.symbols b/tests/baselines/reference/enumStringAnnotation1.symbols new file mode 100644 index 0000000000000..e10a7b53ed687 --- /dev/null +++ b/tests/baselines/reference/enumStringAnnotation1.symbols @@ -0,0 +1,46 @@ +=== tests/cases/conformance/enums/enumStringAnnotation1.ts === +enum A: string { +>A : Symbol(A, Decl(enumStringAnnotation1.ts, 0, 0)) + + A, +>A : Symbol(A.A, Decl(enumStringAnnotation1.ts, 0, 16)) + + B +>B : Symbol(A.B, Decl(enumStringAnnotation1.ts, 1, 6)) +} + +enum B: string { +>B : Symbol(B, Decl(enumStringAnnotation1.ts, 3, 1)) + + A, +>A : Symbol(B.A, Decl(enumStringAnnotation1.ts, 5, 16)) + + B = '1', +>B : Symbol(B.B, Decl(enumStringAnnotation1.ts, 6, 6)) + + C, +>C : Symbol(B.C, Decl(enumStringAnnotation1.ts, 7, 12)) +} + +enum C: string { +>C : Symbol(C, Decl(enumStringAnnotation1.ts, 9, 1)) + + A = 1, +>A : Symbol(C.A, Decl(enumStringAnnotation1.ts, 11, 16)) + + B = '2', +>B : Symbol(C.B, Decl(enumStringAnnotation1.ts, 12, 10)) + + C +>C : Symbol(C.C, Decl(enumStringAnnotation1.ts, 13, 12)) +} + +enum D: number { +>D : Symbol(D, Decl(enumStringAnnotation1.ts, 15, 1)) + + A, +>A : Symbol(D.A, Decl(enumStringAnnotation1.ts, 17, 16)) + + B +>B : Symbol(D.B, Decl(enumStringAnnotation1.ts, 18, 6)) +} diff --git a/tests/baselines/reference/enumStringAnnotation1.types b/tests/baselines/reference/enumStringAnnotation1.types new file mode 100644 index 0000000000000..66fdd2160de9a --- /dev/null +++ b/tests/baselines/reference/enumStringAnnotation1.types @@ -0,0 +1,53 @@ +=== tests/cases/conformance/enums/enumStringAnnotation1.ts === +enum A: string { +>A : A +>string : any + + A, +>A : A.A + + B +>B : A.B +} + +enum B: string { +>B : B +>string : any + + A, +>A : B.A + + B = '1', +>B : B.B +>'1' : "1" + + C, +>C : B.C +} + +enum C: string { +>C : C +>string : any + + A = 1, +>A : C.A +>1 : 1 + + B = '2', +>B : C.B +>'2' : "2" + + C +>C : C.C +} + +enum D: number { +>D : D +>number : any + + A, +>A : D.A + + B +>B : D.B +} diff --git a/tests/cases/conformance/enums/enumStringAnnotation1.ts b/tests/cases/conformance/enums/enumStringAnnotation1.ts new file mode 100644 index 0000000000000..246a1083a22df --- /dev/null +++ b/tests/cases/conformance/enums/enumStringAnnotation1.ts @@ -0,0 +1,23 @@ +// @declaration: true + +enum A: string { + A, + B +} + +enum B: string { + A, + B = '1', + C, +} + +enum C: string { + A = 1, + B = '2', + C +} + +enum D: number { + A, + B +} \ No newline at end of file From aadd9cdac4a6774f9dd85268238707122cad513a Mon Sep 17 00:00:00 2001 From: kingwl Date: Thu, 15 Oct 2020 14:35:13 +0800 Subject: [PATCH 2/3] accept baseline --- tests/baselines/reference/api/tsserverlibrary.d.ts | 9 +++++---- tests/baselines/reference/api/typescript.d.ts | 9 +++++---- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index 15653ecacf258..984446923bcc0 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -1564,6 +1564,7 @@ declare namespace ts { readonly kind: SyntaxKind.EnumDeclaration; readonly name: Identifier; readonly members: NodeArray; + readonly type?: Identifier; } export type ModuleName = Identifier | StringLiteral; export type ModuleBody = NamespaceBody | JSDocNamespaceBody; @@ -3396,8 +3397,8 @@ declare namespace ts { updateInterfaceDeclaration(node: InterfaceDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration; createTypeAliasDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration; updateTypeAliasDeclaration(node: TypeAliasDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration; - createEnumDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration; - updateEnumDeclaration(node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration; + createEnumDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, type: Identifier | undefined, members: readonly EnumMember[]): EnumDeclaration; + updateEnumDeclaration(node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, type: Identifier | undefined, members: readonly EnumMember[]): EnumDeclaration; createModuleDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration; updateModuleDeclaration(node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration; createModuleBlock(statements: readonly Statement[]): ModuleBlock; @@ -10466,9 +10467,9 @@ declare namespace ts { /** @deprecated Use `factory.updateTypeAliasDeclaration` or the factory supplied by your transformation context instead. */ const updateTypeAliasDeclaration: (node: TypeAliasDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode) => TypeAliasDeclaration; /** @deprecated Use `factory.createEnumDeclaration` or the factory supplied by your transformation context instead. */ - const createEnumDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]) => EnumDeclaration; + const createEnumDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, type: Identifier | undefined, members: readonly EnumMember[]) => EnumDeclaration; /** @deprecated Use `factory.updateEnumDeclaration` or the factory supplied by your transformation context instead. */ - const updateEnumDeclaration: (node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]) => EnumDeclaration; + const updateEnumDeclaration: (node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, type: Identifier | undefined, members: readonly EnumMember[]) => EnumDeclaration; /** @deprecated Use `factory.createModuleDeclaration` or the factory supplied by your transformation context instead. */ const createModuleDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: Identifier | ModuleBlock | NamespaceDeclaration | JSDocNamespaceDeclaration | undefined, flags?: NodeFlags | undefined) => ModuleDeclaration; /** @deprecated Use `factory.updateModuleDeclaration` 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 26cdf6ba46056..6857295fdf79c 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -1564,6 +1564,7 @@ declare namespace ts { readonly kind: SyntaxKind.EnumDeclaration; readonly name: Identifier; readonly members: NodeArray; + readonly type?: Identifier; } export type ModuleName = Identifier | StringLiteral; export type ModuleBody = NamespaceBody | JSDocNamespaceBody; @@ -3396,8 +3397,8 @@ declare namespace ts { updateInterfaceDeclaration(node: InterfaceDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration; createTypeAliasDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration; updateTypeAliasDeclaration(node: TypeAliasDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration; - createEnumDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration; - updateEnumDeclaration(node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration; + createEnumDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, type: Identifier | undefined, members: readonly EnumMember[]): EnumDeclaration; + updateEnumDeclaration(node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, type: Identifier | undefined, members: readonly EnumMember[]): EnumDeclaration; createModuleDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration; updateModuleDeclaration(node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration; createModuleBlock(statements: readonly Statement[]): ModuleBlock; @@ -6840,9 +6841,9 @@ declare namespace ts { /** @deprecated Use `factory.updateTypeAliasDeclaration` or the factory supplied by your transformation context instead. */ const updateTypeAliasDeclaration: (node: TypeAliasDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode) => TypeAliasDeclaration; /** @deprecated Use `factory.createEnumDeclaration` or the factory supplied by your transformation context instead. */ - const createEnumDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]) => EnumDeclaration; + const createEnumDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, type: Identifier | undefined, members: readonly EnumMember[]) => EnumDeclaration; /** @deprecated Use `factory.updateEnumDeclaration` or the factory supplied by your transformation context instead. */ - const updateEnumDeclaration: (node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]) => EnumDeclaration; + const updateEnumDeclaration: (node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, type: Identifier | undefined, members: readonly EnumMember[]) => EnumDeclaration; /** @deprecated Use `factory.createModuleDeclaration` or the factory supplied by your transformation context instead. */ const createModuleDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: Identifier | ModuleBlock | NamespaceDeclaration | JSDocNamespaceDeclaration | undefined, flags?: NodeFlags | undefined) => ModuleDeclaration; /** @deprecated Use `factory.updateModuleDeclaration` or the factory supplied by your transformation context instead. */ From 45ee064406ce2d6a0e1bdda8c825f78688b12133 Mon Sep 17 00:00:00 2001 From: Wenlu Wang Date: Tue, 2 Mar 2021 10:21:30 +0800 Subject: [PATCH 3/3] Update src/compiler/diagnosticMessages.json Co-authored-by: Bread <60681223+vBread@users.noreply.github.com> --- src/compiler/diagnosticMessages.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 3f2ef42edea3b..e834abf617a5c 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1224,7 +1224,7 @@ "code": 2205, "elidedInCompatabilityPyramid": true }, - "Enum annotation is support 'string' only.": { + "Enum annotation supports 'string' only.": { "category": "Error", "code": 2206 },