Avoid the double-symbol trick for enums

src/compiler/binder.ts

@@ -541,7 +541,7 @@ namespace ts {
         }
 
         function declareModuleMember(node: Declaration, symbolFlags: SymbolFlags, symbolExcludes: SymbolFlags): Symbol {
-            const hasExportModifier = getCombinedModifierFlags(node) & ModifierFlags.Export;
+            const hasExportModifier = !!(getCombinedModifierFlags(node) & ModifierFlags.Export) || jsdocTreatAsExported(node);
             if (symbolFlags & SymbolFlags.Alias) {
                 if (node.kind === SyntaxKind.ExportSpecifier || (node.kind === SyntaxKind.ImportEqualsDeclaration && hasExportModifier)) {
                     return declareSymbol(container.symbol.exports!, container.symbol, node, symbolFlags, symbolExcludes);
@@ -567,7 +567,7 @@ namespace ts {
                 //       and this case is specially handled. Module augmentations should only be merged with original module definition
                 //       and should never be merged directly with other augmentation, and the latter case would be possible if automatic merge is allowed.
                 if (isJSDocTypeAlias(node)) Debug.assert(isInJSFile(node)); // We shouldn't add symbols for JSDoc nodes if not in a JS file.
-                if ((!isAmbientModule(node) && (hasExportModifier || container.flags & NodeFlags.ExportContext)) || isJSDocTypeAlias(node)) {
+                if (!isAmbientModule(node) && (hasExportModifier || container.flags & NodeFlags.ExportContext)) {
                     if (!container.locals || (hasSyntacticModifier(node, ModifierFlags.Default) && !getDeclarationName(node))) {
                         return declareSymbol(container.symbol.exports!, container.symbol, node, symbolFlags, symbolExcludes); // No local symbol for an unnamed default!
                     }
@@ -583,6 +583,21 @@ namespace ts {
             }
         }
 
+        function jsdocTreatAsExported(node: Node) {
+            if (!isJSDocTypeAlias(node)) return false;
+            // jsdoc typedef handling is a bit of a doozy, but to summarize, treat the typedef as exported if:
+            // 1. It has an explicit name (since by default typedefs are always directly exported, either at the top level or in a container), or
+            if (!isJSDocEnumTag(node) && !!node.fullName) return true;
+            // 2. The thing a nameless typedef pulls its name from is implicitly a direct export (either by assignment or actual export flag).
+            const declName = getNameOfDeclaration(node);
+            if (!declName) return false;
+            if (isPropertyAccessEntityNameExpression(declName.parent) && isTopLevelNamespaceAssignment(declName.parent)) return true;
+            if (isDeclaration(declName.parent) && getCombinedModifierFlags(declName.parent) & ModifierFlags.Export) return true;
+            // This could potentially be simplified by having `delayedBindJSDocTypedefTag` pass in an override for `hasExportModifier`, since it should
+            // already have calculated and branched on most of this.
+            return false;
+        }
+
         // All container nodes are kept on a linked list in declaration order. This list is used by
         // the getLocalNameOfContainer function in the type checker to validate that the local name
         // used for a container is unique.

tests/baselines/reference/exportedEnumTypeAndValue.symbols

@@ -0,0 +1,26 @@
+=== tests/cases/conformance/jsdoc/def.js ===
+/** @enum {number} */
+const MyEnum = {
+>MyEnum : Symbol(MyEnum, Decl(def.js, 1, 5), Decl(def.js, 0, 4))
+
+  a: 1,
+>a : Symbol(a, Decl(def.js, 1, 16))
+
+  b: 2
+>b : Symbol(b, Decl(def.js, 2, 7))
+
+};
+export default MyEnum;
+>MyEnum : Symbol(MyEnum, Decl(def.js, 1, 5), Decl(def.js, 0, 4))
+
+=== tests/cases/conformance/jsdoc/use.js ===
+import MyEnum from "./def";
+>MyEnum : Symbol(MyEnum, Decl(use.js, 0, 6))
+
+/** @type {MyEnum} */
+const v = MyEnum.b;
+>v : Symbol(v, Decl(use.js, 3, 5))
+>MyEnum.b : Symbol(b, Decl(def.js, 2, 7))
+>MyEnum : Symbol(MyEnum, Decl(use.js, 0, 6))
+>b : Symbol(b, Decl(def.js, 2, 7))
+

tests/baselines/reference/exportedEnumTypeAndValue.types

@@ -0,0 +1,29 @@
+=== tests/cases/conformance/jsdoc/def.js ===
+/** @enum {number} */
+const MyEnum = {
+>MyEnum : { a: number; b: number; }
+>{  a: 1,  b: 2} : { a: number; b: number; }
+
+  a: 1,
+>a : number
+>1 : 1
+
+  b: 2
+>b : number
+>2 : 2
+
+};
+export default MyEnum;
+>MyEnum : number
+
+=== tests/cases/conformance/jsdoc/use.js ===
+import MyEnum from "./def";
+>MyEnum : { a: number; b: number; }
+
+/** @type {MyEnum} */
+const v = MyEnum.b;
+>v : number
+>MyEnum.b : number
+>MyEnum : { a: number; b: number; }
+>b : number
+

tests/baselines/reference/jsEnumTagOnObjectFrozen.symbols

@@ -55,9 +55,9 @@ const Thing = Object.freeze({
 });
 
 exports.Thing = Thing;
->exports.Thing : Symbol(Thing, Decl(index.js, 4, 3), Decl(index.js, 0, 4))
->exports : Symbol(Thing, Decl(index.js, 4, 3), Decl(index.js, 0, 4))
->Thing : Symbol(Thing, Decl(index.js, 4, 3), Decl(index.js, 0, 4))
+>exports.Thing : Symbol(Thing, Decl(index.js, 4, 3))
+>exports : Symbol(Thing, Decl(index.js, 4, 3))
+>Thing : Symbol(Thing, Decl(index.js, 4, 3))
 >Thing : Symbol(Thing, Decl(index.js, 1, 5), Decl(index.js, 0, 4))
 
 /**

tests/cases/conformance/jsdoc/exportedEnumTypeAndValue.ts

@@ -0,0 +1,17 @@
+// @noEmit: true
+// @allowJs: true
+// @checkJs: true
+
+// @Filename: def.js
+/** @enum {number} */
+const MyEnum = {
+  a: 1,
+  b: 2
+};
+export default MyEnum;
+
+// @Filename: use.js
+import MyEnum from "./def";
+
+/** @type {MyEnum} */
+const v = MyEnum.b;

tests/cases/fourslash/quickInfoJSExport.ts

@@ -15,8 +15,7 @@
 //// export { test/**/String };
 
 verify.quickInfoAt("",
-`type testString = string
-(alias) type testString = any
+`(alias) type testString = string
 (alias) const testString: {
     one: string;
     two: string;