Refactor isEnumLiteralDeclaration() to allow assumptions about members

Author: caitp

src/compiler/checker.ts

@@ -16712,7 +16712,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             }
             // `var MyEnum: enum = { FirstValue: 1, SecondValue: 2 }` should resolve to a union of the enum values.
             if (node.parent && isEnumLiteralDeclaration(node.parent)) {
-                return links.resolvedType = checkExpressionCached((node.parent as VariableDeclaration).initializer as Expression);
+                return links.resolvedType = checkExpressionCached(node.parent.initializer);
             }
             let symbol: Symbol | undefined;
             let type: Type | undefined;

src/compiler/types.ts

@@ -1883,6 +1883,14 @@ export interface VariableDeclaration extends NamedDeclaration, JSDocContainer {
     readonly initializer?: Expression;             // Optional initializer
 }
 
+export interface EnumLiteralDeclaration extends VariableDeclaration {
+    readonly kind: SyntaxKind.VariableDeclaration;
+    readonly parent: VariableDeclarationList;
+    readonly name: BindingName;
+    readonly type: TypeReferenceNode;
+    readonly initializer: EnumLiteralExpression;
+}
+
 /** @internal */
 export type InitializedVariableDeclaration = VariableDeclaration & { readonly initializer: Expression; };
 

src/compiler/utilitiesPublic.ts

@@ -56,6 +56,7 @@ import {
     EntityName,
     entityNameToString,
     EnumDeclaration,
+    EnumLiteralDeclaration,
     every,
     ExportAssignment,
     ExportDeclaration,
@@ -1431,7 +1432,7 @@ export function isEnumTypeReference(node: Node): boolean {
     return isTypeReferenceNode(node) && isIdentifier(node.typeName) &&
         node.typeName.escapedText === "enum" && !node.typeArguments;
 }
-export function isEnumLiteralDeclaration(node: Node): boolean {
+export function isEnumLiteralDeclaration(node: Node): node is EnumLiteralDeclaration {
     return isVariableDeclaration(node) && hasType(node) && isEnumTypeReference(node.type!) && hasInitializer(node) && isEnumLiteralExpression(node.initializer!);
 }
 

tests/baselines/reference/api/typescript.d.ts

@@ -4529,6 +4529,13 @@ declare namespace ts {
         readonly type?: TypeNode;
         readonly initializer?: Expression;
     }
+    interface EnumLiteralDeclaration extends VariableDeclaration {
+        readonly kind: SyntaxKind.VariableDeclaration;
+        readonly parent: VariableDeclarationList;
+        readonly name: BindingName;
+        readonly type: TypeReferenceNode;
+        readonly initializer: EnumLiteralExpression;
+    }
     interface VariableDeclarationList extends Node {
         readonly kind: SyntaxKind.VariableDeclarationList;
         readonly parent: VariableStatement | ForStatement | ForOfStatement | ForInStatement;
@@ -8740,7 +8747,7 @@ declare namespace ts {
     function isNullishCoalesce(node: Node): boolean;
     function isConstTypeReference(node: Node): boolean;
     function isEnumTypeReference(node: Node): boolean;
-    function isEnumLiteralDeclaration(node: Node): boolean;
+    function isEnumLiteralDeclaration(node: Node): node is EnumLiteralDeclaration;
     function isEnumTypeAnnotation(node: Node): boolean;
     function skipPartiallyEmittedExpressions(node: Expression): Expression;
     function skipPartiallyEmittedExpressions(node: Node): Node;