Add parser types emitter and pass the build

microsoft · Oct 8, 2020 · 4968b81 · 4968b81
1 parent 197ac80
commit 4968b81
Show file tree

Hide file tree

Showing 11 changed files with 142 additions and 29 deletions.
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
@@ -2560,6 +2560,8 @@ namespace ts {
                     return bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.Property, SymbolFlags.PropertyExcludes);
                 case SyntaxKind.EnumMember:
                     return bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.EnumMember, SymbolFlags.EnumMemberExcludes);
+                case SyntaxKind.SpreadEnumMember:
+                    return undefined;
 
                 case SyntaxKind.CallSignature:
                 case SyntaxKind.ConstructSignature:

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -9432,7 +9432,7 @@ namespace ts {
             for (const declaration of symbol.declarations) {
                 if (declaration.kind === SyntaxKind.EnumDeclaration) {
                     for (const member of (<EnumDeclaration>declaration).members) {
-                        if (member.initializer && isStringLiteralLike(member.initializer)) {
+                        if (isSpreadEnumMember(member) || member.initializer && isStringLiteralLike(member.initializer)) {
                             return links.enumKind = EnumKind.Literal;
                         }
                         if (!isLiteralEnumMember(member)) {
@@ -9448,24 +9448,39 @@ namespace ts {
             return type.flags & TypeFlags.EnumLiteral && !(type.flags & TypeFlags.Union) ? getDeclaredTypeOfSymbol(getParentOfSymbol(type.symbol)!) : type;
         }
 
-        function getDeclaredTypeOfEnum(symbol: Symbol): Type {
-            const links = getSymbolLinks(symbol);
-            if (links.declaredType) {
-                return links.declaredType;
-            }
-            if (getEnumKind(symbol) === EnumKind.Literal) {
-                enumCount++;
-                const memberTypeList: Type[] = [];
-                for (const declaration of symbol.declarations) {
-                    if (declaration.kind === SyntaxKind.EnumDeclaration) {
-                        for (const member of (<EnumDeclaration>declaration).members) {
+        function getEnumMemberTypeList(symbol: Symbol): Type[] {
+            const memberTypeList: Type[] = [];
+            for (const declaration of symbol.declarations) {
+                if (declaration.kind === SyntaxKind.EnumDeclaration) {
+                    for (const member of (<EnumDeclaration>declaration).members) {
+                        if (isEnumMember(member)) {
                             const value = getEnumMemberValue(member);
                             const memberType = getFreshTypeOfLiteralType(getLiteralType(value !== undefined ? value : 0, enumCount, getSymbolOfNode(member)));
                             getSymbolLinks(getSymbolOfNode(member)).declaredType = memberType;
                             memberTypeList.push(getRegularTypeOfLiteralType(memberType));
                         }
+                        else {
+                            const referencedEnumDeclaration = getSymbolOfNode(member.name);
+                            if (referencedEnumDeclaration) {
+                                const declaredType = getDeclaredTypeOfEnum(referencedEnumDeclaration);
+                                const types = declaredType.flags & TypeFlags.Union ? (<UnionType>declaredType).types : [declaredType];
+                                memberTypeList.push(...types);
+                            }
+                        }
                     }
                 }
+            }
+            return memberTypeList
+        }
+
+        function getDeclaredTypeOfEnum(symbol: Symbol): Type {
+            const links = getSymbolLinks(symbol);
+            if (links.declaredType) {
+                return links.declaredType;
+            }
+            if (getEnumKind(symbol) === EnumKind.Literal) {
+                enumCount++;
+                const memberTypeList = getEnumMemberTypeList(symbol);
                 if (memberTypeList.length) {
                     const enumType = getUnionType(memberTypeList, UnionReduction.Literal, symbol, /*aliasTypeArguments*/ undefined);
                     if (enumType.flags & TypeFlags.Union) {
@@ -35674,9 +35689,11 @@ namespace ts {
                 nodeLinks.flags |= NodeCheckFlags.EnumValuesComputed;
                 let autoValue: number | undefined = 0;
                 for (const member of node.members) {
-                    const value = computeMemberValue(member, autoValue);
-                    getNodeLinks(member).enumMemberValue = value;
-                    autoValue = typeof value === "number" ? value + 1 : undefined;
+                    if (isEnumMember(member)) {
+                        const value = computeMemberValue(member, autoValue);
+                        getNodeLinks(member).enumMemberValue = value;
+                        autoValue = typeof value === "number" ? value + 1 : undefined;
+                    }
                 }
             }
         }
@@ -35888,7 +35905,7 @@ namespace ts {
                     }
 
                     const firstEnumMember = enumDeclaration.members[0];
-                    if (!firstEnumMember.initializer) {
+                    if (!isSpreadEnumMember(firstEnumMember) && !firstEnumMember.initializer) {
                         if (seenEnumMissingInitialInitializer) {
                             error(firstEnumMember.name, Diagnostics.In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element);
                         }

diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
@@ -1534,6 +1534,8 @@ namespace ts {
                     // Enum
                     case SyntaxKind.EnumMember:
                         return emitEnumMember(<EnumMember>node);
+                    case SyntaxKind.SpreadEnumMember:
+                        return emitSpreadEnumMember(<SpreadEnumMember>node);
 
                     // JSDoc nodes (only used in codefixes currently)
                     case SyntaxKind.JSDocParameterTag:
@@ -3501,6 +3503,11 @@ namespace ts {
             emitInitializer(node.initializer, node.name.end, node);
         }
 
+        function emitSpreadEnumMember(node: SpreadEnumMember) {
+            emit(node.dotDotDotToken);
+            emitEntityName(node.name);
+        }
+
         //
         // JSDoc
         //

diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts
@@ -410,6 +410,8 @@ namespace ts {
             updateSpreadAssignment,
             createEnumMember,
             updateEnumMember,
+            createSpreadEnumMember,
+            updateSpreadEnumMember,
             createSourceFile,
             updateSourceFile,
             createBundle,
@@ -3624,7 +3626,7 @@ namespace ts {
             decorators: readonly Decorator[] | undefined,
             modifiers: readonly Modifier[] | undefined,
             name: string | Identifier,
-            members: readonly EnumMember[]
+            members: readonly EnumMemberLike[]
         ) {
             const node = createBaseNamedDeclaration<EnumDeclaration>(
                 SyntaxKind.EnumDeclaration,
@@ -3646,7 +3648,7 @@ namespace ts {
             decorators: readonly Decorator[] | undefined,
             modifiers: readonly Modifier[] | undefined,
             name: Identifier,
-            members: readonly EnumMember[]) {
+            members: readonly EnumMemberLike[]) {
             return node.decorators !== decorators
                 || node.modifiers !== modifiers
                 || node.name !== name
@@ -4848,6 +4850,26 @@ namespace ts {
                 : node;
         }
 
+        // @api
+        function createSpreadEnumMember(dotDotDotToken: DotDotDotToken, name: EntityName) {
+            const node = createBaseNode<SpreadEnumMember>(SyntaxKind.SpreadEnumMember);
+            node.dotDotDotToken = dotDotDotToken;
+            node.name = name;
+            node.transformFlags |=
+                propagateChildFlags(node.dotDotDotToken) |
+                propagateChildFlags(node.name) |
+                TransformFlags.ContainsTypeScript;
+            return node;
+        }
+
+        // @api
+        function updateSpreadEnumMember(node: SpreadEnumMember, dotDotDotToken: DotDotDotToken, name: EntityName) {
+            return node.dotDotDotToken !== dotDotDotToken
+                || node.name !== name
+                ? update(createSpreadEnumMember(dotDotDotToken, name), node)
+                : node;
+        }
+
         //
         // Top-level nodes
         //

diff --git a/src/compiler/factory/nodeTests.ts b/src/compiler/factory/nodeTests.ts
@@ -666,6 +666,10 @@ namespace ts {
         return node.kind === SyntaxKind.EnumMember;
     }
 
+    export function isSpreadEnumMember(node: Node): node is SpreadEnumMember {
+        return node.kind === SyntaxKind.SpreadEnumMember;
+    }
+
     // Unparsed
 
     // TODO(rbuckton): isUnparsedPrologue

diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -380,6 +380,9 @@ namespace ts {
             case SyntaxKind.EnumMember:
                 return visitNode(cbNode, (<EnumMember>node).name) ||
                     visitNode(cbNode, (<EnumMember>node).initializer);
+            case SyntaxKind.SpreadEnumMember:
+                return visitNode(cbNode, (<SpreadEnumMember>node).dotDotDotToken) ||
+                    visitNode(cbNode, (<EnumMemberLike>node).name);
             case SyntaxKind.ModuleDeclaration:
                 return visitNodes(cbNode, cbNodes, node.decorators) ||
                     visitNodes(cbNode, cbNodes, node.modifiers) ||
@@ -1839,7 +1842,7 @@ namespace ts {
                 case ParsingContext.EnumMembers:
                     // Include open bracket computed properties. This technically also lets in indexers,
                     // which would be a candidate for improved error reporting.
-                    return token() === SyntaxKind.OpenBracketToken || isLiteralPropertyName();
+                    return token() === SyntaxKind.OpenBracketToken || token() === SyntaxKind.DotDotDotToken || isLiteralPropertyName();
                 case ParsingContext.ObjectLiteralMembers:
                     switch (token()) {
                         case SyntaxKind.OpenBracketToken:
@@ -6752,9 +6755,15 @@ namespace ts {
         // In a non-ambient declaration, the grammar allows uninitialized members only in a
         // ConstantEnumMemberSection, which starts at the beginning of an enum declaration
         // or any time an integer literal initializer is encountered.
-        function parseEnumMember(): EnumMember {
+        function parseEnumMember(): EnumMemberLike {
             const pos = getNodePos();
             const hasJSDoc = hasPrecedingJSDocComment();
+            const dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken);
+            if (dotDotDotToken) {
+                const name = parseEntityName(/*allowReservedWords*/ false);
+                return withJSDoc(finishNode(factory.createSpreadEnumMember(dotDotDotToken, name), pos), hasJSDoc);
+            }
+
             const name = parsePropertyName();
             const initializer = allowInAnd(parseInitializer);
             return withJSDoc(finishNode(factory.createEnumMember(name, initializer), pos), hasJSDoc);
@@ -6763,13 +6772,13 @@ namespace ts {
         function parseEnumDeclaration(pos: number, hasJSDoc: boolean, decorators: NodeArray<Decorator> | undefined, modifiers: NodeArray<Modifier> | undefined): EnumDeclaration {
             parseExpected(SyntaxKind.EnumKeyword);
             const name = parseIdentifier();
-            let members;
+            let members: NodeArray<EnumMemberLike> | undefined;
             if (parseExpected(SyntaxKind.OpenBraceToken)) {
                 members = doOutsideOfYieldAndAwaitContext(() => parseDelimitedList(ParsingContext.EnumMembers, parseEnumMember));
                 parseExpected(SyntaxKind.CloseBraceToken);
             }
             else {
-                members = createMissingList<EnumMember>();
+                members = createMissingList<EnumMemberLike>();
             }
             const node = factory.createEnumDeclaration(decorators, modifiers, name, members);
             return withJSDoc(finishNode(node, pos), hasJSDoc);

diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts
@@ -1437,9 +1437,13 @@ namespace ts {
                 case SyntaxKind.EnumDeclaration: {
                     return cleanup(factory.updateEnumDeclaration(input, /*decorators*/ undefined, factory.createNodeArray(ensureModifiers(input)), input.name, factory.createNodeArray(mapDefined(input.members, m => {
                         if (shouldStripInternal(m)) return;
-                        // Rewrite enum values to their constants, if available
-                        const constValue = resolver.getConstantValue(m);
-                        return preserveJsDoc(factory.updateEnumMember(m, m.name, constValue !== undefined ? typeof constValue === "string" ? factory.createStringLiteral(constValue) : factory.createNumericLiteral(constValue) : undefined), m);
+
+                        if (isEnumMember(m)) {
+                            // Rewrite enum values to their constants, if available
+                            const constValue = resolver.getConstantValue(m);
+                            return preserveJsDoc(factory.updateEnumMember(m, m.name, constValue !== undefined ? typeof constValue === "string" ? factory.createStringLiteral(constValue) : factory.createNumericLiteral(constValue) : undefined), m);
+                        }
+                        return m;
                     }))));
                 }
             }

diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -345,6 +345,7 @@ namespace ts {
 
         // Enum
         EnumMember,
+        SpreadEnumMember,
         // Unparsed
         UnparsedPrologue,
         UnparsedPrepend,
@@ -883,6 +884,7 @@ namespace ts {
         | InterfaceDeclaration
         | TypeAliasDeclaration
         | EnumMember
+        | SpreadEnumMember
         | EnumDeclaration
         | ModuleDeclaration
         | ImportEqualsDeclaration
@@ -1355,6 +1357,7 @@ namespace ts {
         | JsxAttribute
         | ShorthandPropertyAssignment
         | EnumMember
+        | SpreadEnumMember
         | JSDocPropertyTag
         | JSDocParameterTag;
 
@@ -2857,10 +2860,19 @@ namespace ts {
         readonly initializer?: Expression;
     }
 
+    export interface SpreadEnumMember extends Declaration, JSDocContainer {
+        readonly kind: SyntaxKind.SpreadEnumMember;
+        readonly parent: EnumDeclaration;
+        readonly dotDotDotToken: DotDotDotToken;
+        readonly name: EntityName;
+    }
+
+    export type EnumMemberLike = EnumMember | SpreadEnumMember;
+
     export interface EnumDeclaration extends DeclarationStatement, JSDocContainer {
         readonly kind: SyntaxKind.EnumDeclaration;
         readonly name: Identifier;
-        readonly members: NodeArray<EnumMember>;
+        readonly members: NodeArray<EnumMemberLike>;
     }
 
     export type ModuleName =
@@ -6977,8 +6989,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, members: readonly EnumMemberLike[]): EnumDeclaration;
+        updateEnumDeclaration(node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMemberLike[]): 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;
@@ -7144,6 +7156,8 @@ namespace ts {
 
         createEnumMember(name: string | PropertyName, initializer?: Expression): EnumMember;
         updateEnumMember(node: EnumMember, name: PropertyName, initializer: Expression | undefined): EnumMember;
+        createSpreadEnumMember(dotDotDotToken: DotDotDotToken, name: EntityName): SpreadEnumMember;
+        updateSpreadEnumMember(node: SpreadEnumMember, dotDotDotToken: DotDotDotToken, name: EntityName): SpreadEnumMember;
 
         //
         // Top-level nodes

diff --git a/src/compiler/visitorPublic.ts b/src/compiler/visitorPublic.ts
@@ -1083,6 +1083,11 @@ namespace ts {
                 return factory.updateEnumMember(<EnumMember>node,
                     nodeVisitor((<EnumMember>node).name, visitor, isPropertyName),
                     nodeVisitor((<EnumMember>node).initializer, visitor, isExpression));
+            case SyntaxKind.SpreadEnumMember:
+                return factory.updateSpreadEnumMember(<SpreadEnumMember>node,
+                    nodeVisitor((<SpreadEnumMember>node).dotDotDotToken, tokenVisitor, isToken),
+                    nodeVisitor((<SpreadEnumMember>node).name, visitor, isEntityName)
+                );
 
             // Top-level nodes
             case SyntaxKind.SourceFile:

diff --git a/src/services/navigationBar.ts b/src/services/navigationBar.ts
@@ -287,7 +287,7 @@ namespace ts.NavigationBar {
             case SyntaxKind.EnumDeclaration:
                 startNode(node);
                 for (const member of (<EnumDeclaration>node).members) {
-                    if (!isComputedProperty(member)) {
+                    if (isEnumMember(member) && !isComputedProperty(member)) {
                         addLeafNode(member);
                     }
                 }

diff --git a/tests/cases/conformance/enums/spreadEnum1.ts b/tests/cases/conformance/enums/spreadEnum1.ts
@@ -0,0 +1,29 @@
+// @declaration: true
+
+enum BasicEvents {
+    Start = "Start",
+    Finish = "Finish"
+}
+
+enum AdvEvents {
+    ...BasicEvents,
+    Pause = "Pause",
+    Resume = "Resume"
+}
+
+declare let basic: BasicEvents;
+
+declare let adv: AdvEvents;
+
+adv = basic;
+
+basic = BasicEvents.Start;
+basic = BasicEvents.Finish;
+
+adv = AdvEvents.Start;
+adv = AdvEvents.Finish;
+adv = AdvEvents.Pause;
+adv = AdvEvents.Resume;
+
+adv = BasicEvents.Start;
+adv = BasicEvents.Finish;