Support @enum tag post-merge

Author: weswigham

src/compiler/checker.ts

@@ -5213,40 +5213,19 @@ namespace ts {
                         }
                     }
                     if (symbol.flags & SymbolFlags.Enum) {
-                        if (symbol.flags & SymbolFlags.Variable) {
-                            // Oh boy, this symbol really refers to an `@enum`'d variable declaration. We already emitted the variable
-                            // declaration part above, but we can't just emit `export const Foo = {}; export enum Foo {}` - that's
-                            // a symbol merge error. To get the same behavior without a bad merge, we'll do this:
-                            //    export const Foo = {
-                            //        MEMBER: string;
-                            //    };
-                            //    export type Foo = string;
-                            // Make sense? Yes - the @enum tag does nothing nominal and looks nothing like a real enum.
-                            // TODO: the @enum tag has nothing to do with enums and is a glorified @typedef - it should bind that way, too
-                            const typeExpr = getJSDocEnumTag(symbol.valueDeclaration)!.typeExpression;
-                            addResult(createTypeAliasDeclaration(
-                                /*decorators*/ undefined,
-                                /*modifiers*/ undefined,
-                                localName,
-                                /*modifiers*/ undefined,
-                                typeToTypeNodeHelper(typeExpr ? getTypeFromTypeNode(typeExpr) : errorType, context)
-                            ), modifierFlags);
-                        }
-                        else {
-                            addResult(createEnumDeclaration(
-                                /*decorators*/ undefined,
-                                createModifiersFromModifierFlags(isConstEnumSymbol(symbol) ? ModifierFlags.Const : 0),
-                                localName,
-                                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
-                                    // other way to get the possible const value of an enum member that I'm aware of, as the value is cached
-                                    // _on the declaration_, not on the declaration's symbol...
-                                    const initializedValue = p.declarations && p.declarations[0] && isEnumMember(p.declarations[0]) && getConstantValue(p.declarations[0] as EnumMember);
-                                    return createEnumMember(unescapeLeadingUnderscores(p.escapedName), initializedValue === undefined ? undefined : createLiteral(initializedValue));
-                                })
-                            ), modifierFlags);
-                        }
+                        addResult(createEnumDeclaration(
+                            /*decorators*/ undefined,
+                            createModifiersFromModifierFlags(isConstEnumSymbol(symbol) ? ModifierFlags.Const : 0),
+                            localName,
+                            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
+                                // other way to get the possible const value of an enum member that I'm aware of, as the value is cached
+                                // _on the declaration_, not on the declaration's symbol...
+                                const initializedValue = p.declarations && p.declarations[0] && isEnumMember(p.declarations[0]) && getConstantValue(p.declarations[0] as EnumMember);
+                                return createEnumMember(unescapeLeadingUnderscores(p.escapedName), initializedValue === undefined ? undefined : createLiteral(initializedValue));
+                            })
+                        ), modifierFlags);
                     }
                     if (symbol.flags & SymbolFlags.Class) {
                         if (symbol.flags & SymbolFlags.Property) {

tests/baselines/reference/jsDeclarationsEnumTag.js

@@ -104,23 +104,23 @@ exports.ff = ff;
 //// [index.d.ts]
 export function consume(t: string, s: number, f: (arg0: number) => number): void;
 export function ff(s: string): any;
+export type Target = string;
 export const Target: {
     START: string;
     MIDDLE: string;
     END: string;
     /** @type {number} */
     OK_I_GUESS: number;
 };
-export type Target = string;
+export type Second = number;
 export const Second: {
     OK: number;
     /** @type {number} */
     FINE: number;
 };
-export type Second = number;
+export type Fs = (arg0: number) => number;
 export const Fs: {
     ADD1: (n: any) => any;
     ID: (n: any) => any;
     SUB1: (n: any) => number;
 };
-export type Fs = (arg0: number) => number;

tests/baselines/reference/jsDeclarationsEnumTag.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/jsdoc/declarations/index.js ===
 /** @enum {string} */
 export const Target = {
->Target : Symbol(Target, Decl(index.js, 1, 12))
+>Target : Symbol(Target, Decl(index.js, 1, 12), Decl(index.js, 0, 4))
 
     START: "start",
 >START : Symbol(START, Decl(index.js, 1, 23))
@@ -18,7 +18,7 @@ export const Target = {
 }
 /** @enum number */
 export const Second = {
->Second : Symbol(Second, Decl(index.js, 9, 12))
+>Second : Symbol(Second, Decl(index.js, 9, 12), Decl(index.js, 8, 4))
 
     OK: 1,
 >OK : Symbol(OK, Decl(index.js, 9, 23))
@@ -29,7 +29,7 @@ export const Second = {
 }
 /** @enum {function(number): number} */
 export const Fs = {
->Fs : Symbol(Fs, Decl(index.js, 15, 12))
+>Fs : Symbol(Fs, Decl(index.js, 15, 12), Decl(index.js, 14, 4))
 
     ADD1: n => n + 1,
 >ADD1 : Symbol(ADD1, Decl(index.js, 15, 19))
@@ -77,7 +77,7 @@ export function consume(t,s,f) {
     var v = Target.START
 >v : Symbol(v, Decl(index.js, 34, 7))
 >Target.START : Symbol(START, Decl(index.js, 1, 23))
->Target : Symbol(Target, Decl(index.js, 1, 12))
+>Target : Symbol(Target, Decl(index.js, 1, 12), Decl(index.js, 0, 4))
 >START : Symbol(START, Decl(index.js, 1, 23))
 
     v = 'something else' // allowed, like Typescript's classic enums and unlike its string enums
@@ -90,14 +90,14 @@ export function ff(s) {
 
     // element access with arbitrary string is an error only with noImplicitAny
     if (!Target[s]) {
->Target : Symbol(Target, Decl(index.js, 1, 12))
+>Target : Symbol(Target, Decl(index.js, 1, 12), Decl(index.js, 0, 4))
 >s : Symbol(s, Decl(index.js, 38, 19))
 
         return null
     }
     else {
         return Target[s]
->Target : Symbol(Target, Decl(index.js, 1, 12))
+>Target : Symbol(Target, Decl(index.js, 1, 12), Decl(index.js, 0, 4))
 >s : Symbol(s, Decl(index.js, 38, 19))
     }
 }