Fix conformance tests, add additional test cases to enumLiteralBaiscs.ts for individual members as types

Author: caitp

src/compiler/factory/nodeFactory.ts

@@ -4546,15 +4546,14 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
     // @api
     function createEnumLiteralExpression(
         modifiers: readonly ModifierLike[] | undefined,
-        name: string | Identifier,
+        name: __String,
         members: readonly EnumMember[],
     ) {
         const node = createBaseDeclaration<EnumLiteralExpression>(SyntaxKind.EnumLiteralExpression);
         node.modifiers = asNodeArray(modifiers);
-        node.name = asName(name);
+        node.name = name;
         node.members = createNodeArray(members);
         node.transformFlags |= propagateChildrenFlags(node.modifiers) |
-            propagateChildFlags(node.name) |
             propagateChildrenFlags(node.members) |
             TransformFlags.ContainsTypeScript;
         node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // Enum declarations cannot contain `await`
@@ -4567,7 +4566,7 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
     function updateEnumLiteralExpression(
         node: EnumLiteralExpression,
         modifiers: readonly ModifierLike[] | undefined,
-        name: Identifier,
+        name: __String,
         members: readonly EnumMember[],
     ) {
         return node.modifiers !== modifiers

src/compiler/parser.ts

@@ -110,6 +110,7 @@ import {
     getLeadingCommentRanges,
     getSpellingSuggestion,
     getTextOfNodeFromSourceText,
+    getTokenPosOfNode,
     HasJSDoc,
     hasJSDocNodes,
     HasModifiers,
@@ -923,8 +924,9 @@ const forEachChildTable: ForEachChildTable = {
             visitNode(cbNode, node.initializer);
     },
     [SyntaxKind.EnumLiteralExpression]: function forEachChildInEnumLiteralExpression<T>(node: EnumLiteralExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        // For EnumLiteralExpression, the name is not visited or emitted. It is a reference to the binding name of a Declaration for which
+        // the EnumLiteralExpression is an initializer, and is used to permit diagnostic code for EnumDeclarations to be used.
         return visitNodes(cbNode, cbNodes, node.modifiers) ||
-            visitNode(cbNode, node.name) ||
             visitNodes(cbNode, cbNodes, node.members);
     },
     [SyntaxKind.ModuleDeclaration]: function forEachChildInModuleDeclaration<T>(node: ModuleDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
@@ -7645,7 +7647,7 @@ namespace Parser {
         }
         const type = parseTypeAnnotation();
         if (allowEnumType && type && isEnumTypeReference(type) && name.kind === SyntaxKind.Identifier) {
-            const initializer = parseInitializerAsEnumLiteralExpression(name, pos);
+            const initializer = parseInitializerAsEnumLiteralExpression(name);
             const node = factoryCreateVariableDeclaration(name, exclamationToken, type, initializer);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
@@ -8293,16 +8295,17 @@ namespace Parser {
         return withJSDoc(finishNode(node, pos), hasJSDoc);
     }
 
-    function parseInitializerAsEnumLiteralExpression(name: Identifier, pos: number) {
+    function parseInitializerAsEnumLiteralExpression(name: Identifier) {
         // A VariableDeclaration with a declared type `enum` expects the initializer to be in a format like an ObjectLiteralExpression,
         // with only constant keys and property assignments, which are treated as EnumMembers.
+        const pos = getNodePos();
         parseExpected(SyntaxKind.EqualsToken);
         parseExpected(SyntaxKind.OpenBraceToken);
         const members = parseDelimitedList(ParsingContext.ObjectLiteralMembers, parseObjectLiteralEnumMember);
         parseExpected(SyntaxKind.CloseBraceToken);
 
         // Should the variable have the jsdoc, or the enum literal, or both?
-        return finishNode(factory.createEnumLiteralExpression(/*modifiers*/ undefined, name, members), pos);
+        return finishNode(factory.createEnumLiteralExpression(/*modifiers*/ undefined, name.escapedText, members), pos);
     }
 
     function parseModuleBlock(): ModuleBlock {

src/compiler/types.ts

@@ -3616,7 +3616,7 @@ export interface EnumLiteralExpression extends PrimaryExpression, Declaration, J
     readonly kind: SyntaxKind.EnumLiteralExpression;
     readonly parent: VariableDeclaration;
     readonly modifiers?: NodeArray<ModifierLike>;
-    readonly name: Identifier; // For compatibility with EnumDeclaration -- however this must be equal to the BindingName in the VariableDeclaration.
+    readonly name: __String; // For compatibility with EnumDeclaration -- however this must be equal to the BindingName in the VariableDeclaration.
     readonly members: NodeArray<EnumMember>;
 }
 
@@ -9025,8 +9025,8 @@ export interface NodeFactory {
     updateTypeAliasDeclaration(node: TypeAliasDeclaration, modifiers: readonly ModifierLike[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
     createEnumDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration;
     updateEnumDeclaration(node: EnumDeclaration, modifiers: readonly ModifierLike[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration;
-    createEnumLiteralExpression(modifiers: readonly ModifierLike[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumLiteralExpression;
-    updateEnumLiteralExpression(node: EnumLiteralExpression, modifiers: readonly ModifierLike[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumLiteralExpression;
+    createEnumLiteralExpression(modifiers: readonly ModifierLike[] | undefined, name: __String, members: readonly EnumMember[]): EnumLiteralExpression;
+    updateEnumLiteralExpression(node: EnumLiteralExpression, modifiers: readonly ModifierLike[] | undefined, name: __String, members: readonly EnumMember[]): EnumLiteralExpression;
     createModuleDeclaration(modifiers: readonly ModifierLike[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration;
     updateModuleDeclaration(node: ModuleDeclaration, modifiers: readonly ModifierLike[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration;
     createModuleBlock(statements: readonly Statement[]): ModuleBlock;

tests/baselines/reference/enumLiteralBasics.errors.txt

@@ -1,12 +1,18 @@
 enumLiteralBasics.ts(6,5): error TS1061: Enum member must have initializer.
 enumLiteralBasics.ts(7,5): error TS1061: Enum member must have initializer.
-enumLiteralBasics.ts(21,7): error TS2322: Type '"exists"' is not assignable to type 'E1'.
-enumLiteralBasics.ts(23,7): error TS2322: Type '"string"' is not assignable to type 'E1'.
-enumLiteralBasics.ts(33,33): error TS2345: Argument of type '"exists"' is not assignable to parameter of type 'E1'.
-enumLiteralBasics.ts(38,32): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'E1'.
+enumLiteralBasics.ts(22,1): error TS2322: Type 'E1.Flag' is not assignable to type 'E1.Int'.
+enumLiteralBasics.ts(27,7): error TS2322: Type '"exists"' is not assignable to type 'E1'.
+enumLiteralBasics.ts(29,7): error TS2322: Type '"string"' is not assignable to type 'E1'.
+enumLiteralBasics.ts(39,33): error TS2345: Argument of type '"exists"' is not assignable to parameter of type 'E1'.
+enumLiteralBasics.ts(44,32): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'E1'.
+enumLiteralBasics.ts(52,38): error TS2345: Argument of type '"exists"' is not assignable to parameter of type 'E1.Int'.
+enumLiteralBasics.ts(54,38): error TS2345: Argument of type '4' is not assignable to parameter of type 'E1.Int'.
+enumLiteralBasics.ts(56,38): error TS2345: Argument of type 'E1.String' is not assignable to parameter of type 'E1.Int'.
+enumLiteralBasics.ts(57,7): error TS2322: Type 'E1.Int' is not assignable to type 'E1.Flag'.
+enumLiteralBasics.ts(57,38): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'E1.Int'.
 
 
-==== enumLiteralBasics.ts (6 errors) ====
+==== enumLiteralBasics.ts (12 errors) ====
     // Enum without initializers have first member = 0 and successive members = N + 1
 
     // Enum literal syntax does not implement auto-incrementing behaviour.
@@ -28,6 +34,14 @@ enumLiteralBasics.ts(38,32): error TS2345: Argument of type '"string"' is not as
     const exist: E1 = E1.ExistingShorthand; // ok
     const ival: E1 = E1.Int; // ok
     const sval: E1 = E1.String; // ok
+    let p_int: E1.Int = E1.Int; // ok
+    const p_nonexist: E1.NonexistingShorthand = E1.NonexistingShorthand; // ok
+    const p_exist: E1.ExistingShorthand = E1.ExistingShorthand; // ok
+    const p_string: E1.String = E1.String; // ok
+    p_int = E1.Flag; // Type 'E1.Flag' is not assignable to type 'E1.Int'.
+    ~~~~~
+!!! error TS2322: Type 'E1.Flag' is not assignable to type 'E1.Int'.
+    p_int = E1.Int | E1.Flag;
 
     // Assigning values which are not part of the enum despite being present in the enum
     const nonexist_bad: E1 = undefined; // error
@@ -57,4 +71,26 @@ enumLiteralBasics.ts(38,32): error TS2345: Argument of type '"string"' is not as
     const sval_bad2: E1 = functest("string"); // error
                                    ~~~~~~~~
 !!! error TS2345: Argument of type '"string"' is not assignable to parameter of type 'E1'.
-    
+    
+    function functest2(value: E1.Int) {
+        console.log(value);
+        return value;
+    }
+    
+    const nonexist_bad3: E1.Int = functest2(undefined);
+    const exist_bad3: E1.Int = functest2("exists"); // error
+                                         ~~~~~~~~
+!!! error TS2345: Argument of type '"exists"' is not assignable to parameter of type 'E1.Int'.
+    const ival_good5: E1.Int = functest2(1); // ok
+    const ival_good6: E1.Int = functest2(4); // ok
+                                         ~
+!!! error TS2345: Argument of type '4' is not assignable to parameter of type 'E1.Int'.
+    const ival_good7: E1.Int = functest2(E1.Int | E1.Flag); // ok
+    const sval_good3: E1.Int = functest2(E1.String);
+                                         ~~~~~~~~~
+!!! error TS2345: Argument of type 'E1.String' is not assignable to parameter of type 'E1.Int'.
+    const sval_bad3: E1.Flag = functest2("string"); // error
+          ~~~~~~~~~
+!!! error TS2322: Type 'E1.Int' is not assignable to type 'E1.Flag'.
+                                         ~~~~~~~~
+!!! error TS2345: Argument of type '"string"' is not assignable to parameter of type 'E1.Int'.

tests/baselines/reference/enumLiteralBasics.js

@@ -18,6 +18,12 @@ const nonexist: E1 = E1.NonexistingShorthand; // ok
 const exist: E1 = E1.ExistingShorthand; // ok
 const ival: E1 = E1.Int; // ok
 const sval: E1 = E1.String; // ok
+let p_int: E1.Int = E1.Int; // ok
+const p_nonexist: E1.NonexistingShorthand = E1.NonexistingShorthand; // ok
+const p_exist: E1.ExistingShorthand = E1.ExistingShorthand; // ok
+const p_string: E1.String = E1.String; // ok
+p_int = E1.Flag; // Type 'E1.Flag' is not assignable to type 'E1.Int'.
+p_int = E1.Int | E1.Flag;
 
 // Assigning values which are not part of the enum despite being present in the enum
 const nonexist_bad: E1 = undefined; // error
@@ -39,7 +45,19 @@ const ival_good3: E1 = functest(4); // ok
 const ival_good4: E1 = functest(E1.Int | E1.Flag); // ok
 const sval_good2: E1 = functest(E1.String);
 const sval_bad2: E1 = functest("string"); // error
-
+
+function functest2(value: E1.Int) {
+    console.log(value);
+    return value;
+}
+
+const nonexist_bad3: E1.Int = functest2(undefined);
+const exist_bad3: E1.Int = functest2("exists"); // error
+const ival_good5: E1.Int = functest2(1); // ok
+const ival_good6: E1.Int = functest2(4); // ok
+const ival_good7: E1.Int = functest2(E1.Int | E1.Flag); // ok
+const sval_good3: E1.Int = functest2(E1.String);
+const sval_bad3: E1.Flag = functest2("string"); // error
 
 //// [enumLiteralBasics.js]
 // Enum without initializers have first member = 0 and successive members = N + 1
@@ -57,6 +75,12 @@ var nonexist = E1.NonexistingShorthand; // ok
 var exist = E1.ExistingShorthand; // ok
 var ival = E1.Int; // ok
 var sval = E1.String; // ok
+var p_int = E1.Int; // ok
+var p_nonexist = E1.NonexistingShorthand; // ok
+var p_exist = E1.ExistingShorthand; // ok
+var p_string = E1.String; // ok
+p_int = E1.Flag; // Type 'E1.Flag' is not assignable to type 'E1.Int'.
+p_int = E1.Int | E1.Flag;
 // Assigning values which are not part of the enum despite being present in the enum
 var nonexist_bad = undefined; // error
 var exist_bad = "exists"; // error
@@ -74,3 +98,14 @@ var ival_good3 = functest(4); // ok
 var ival_good4 = functest(E1.Int | E1.Flag); // ok
 var sval_good2 = functest(E1.String);
 var sval_bad2 = functest("string"); // error
+function functest2(value) {
+    console.log(value);
+    return value;
+}
+var nonexist_bad3 = functest2(undefined);
+var exist_bad3 = functest2("exists"); // error
+var ival_good5 = functest2(1); // ok
+var ival_good6 = functest2(4); // ok
+var ival_good7 = functest2(E1.Int | E1.Flag); // ok
+var sval_good3 = functest2(E1.String);
+var sval_bad3 = functest2("string"); // error