Properly handle JS enum symbols (microsoft#26893)

Andy · web-flow · commit 06774962eda2 · 2018-09-05T11:19:32.000-07:00
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
@@ -1731,10 +1731,6 @@ namespace ts {
             }
         }
 
-        function bindBlockScopedVariableDeclaration(node: Declaration) {
-            bindBlockScopedDeclaration(node, SymbolFlags.BlockScopedVariable, SymbolFlags.BlockScopedVariableExcludes);
-        }
-
         function delayedBindJSDocTypedefTag() {
             if (!delayedTypeAliases) {
                 return;
@@ -2659,8 +2655,11 @@ namespace ts {
             }
 
             if (!isBindingPattern(node.name)) {
+                const isEnum = !!getJSDocEnumTag(node);
+                const enumFlags = (isEnum ? SymbolFlags.RegularEnum : SymbolFlags.None);
+                const enumExcludes = (isEnum ? SymbolFlags.RegularEnumExcludes : SymbolFlags.None);
                 if (isBlockOrCatchScoped(node)) {
-                    bindBlockScopedVariableDeclaration(node);
+                    bindBlockScopedDeclaration(node, SymbolFlags.BlockScopedVariable | enumFlags, SymbolFlags.BlockScopedVariableExcludes | enumExcludes);
                 }
                 else if (isParameterDeclaration(node)) {
                     // It is safe to walk up parent chain to find whether the node is a destructuring parameter declaration
@@ -2675,7 +2674,7 @@ namespace ts {
                     declareSymbolAndAddToSymbolTable(node, SymbolFlags.FunctionScopedVariable, SymbolFlags.ParameterExcludes);
                 }
                 else {
-                    declareSymbolAndAddToSymbolTable(node, SymbolFlags.FunctionScopedVariable, SymbolFlags.FunctionScopedVariableExcludes);
+                    declareSymbolAndAddToSymbolTable(node, SymbolFlags.FunctionScopedVariable | enumFlags, SymbolFlags.FunctionScopedVariableExcludes | enumExcludes);
                 }
             }
         }
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -8208,6 +8208,12 @@ namespace ts {
                 return type;
             }
 
+            // JS are 'string' or 'number', not an enum type.
+            const enumTag = symbol.valueDeclaration && getJSDocEnumTag(symbol.valueDeclaration);
+            if (enumTag) {
+                return enumTag.typeExpression ? getTypeFromTypeNode(enumTag.typeExpression) : errorType;
+            }
+
             // Get type from reference to named type that cannot be generic (enum or type parameter)
             const res = tryGetDeclaredTypeOfSymbol(symbol);
             if (res) {
@@ -8243,10 +8249,6 @@ namespace ts {
                 // TODO: GH#18217 (should the `|| assignedType` be at a lower precedence?)
                 return (referenceType && assignedType ? getIntersectionType([assignedType, referenceType]) : referenceType || assignedType)!;
             }
-            const enumTag = getJSDocEnumTag(symbol.valueDeclaration);
-            if (enumTag && enumTag.typeExpression) {
-                return getTypeFromTypeNode(enumTag.typeExpression);
-            }
         }
 
         function getTypeReferenceTypeWorker(node: NodeWithTypeArguments, symbol: Symbol, typeArguments: Type[] | undefined): Type | undefined {
diff --git a/tests/cases/fourslash/quickInfoJsdocEnum.ts b/tests/cases/fourslash/quickInfoJsdocEnum.ts
@@ -0,0 +1,25 @@
+/// <reference path="./fourslash.ts"/>
+
+// @allowJs: true
+// @noLib: true
+
+// @Filename: /a.js
+/////**
+//// * Doc
+//// * @enum {number}
+//// */
+////const E = {
+////    A: 0,
+////}
+////
+/////** @type {/**/E} */
+////const x = E.A;
+
+verify.noErrors();
+
+verify.quickInfoAt("",
+`enum E
+const E: {
+    A: number;
+}`,
+"Doc");

Original file line number	Diff line number	Diff line change
`@@ -1731,10 +1731,6 @@ namespace ts {`
`1731`	`1731`	`}`
`1732`	`1732`	`}`
`1733`	`1733`
`1734`		`- function bindBlockScopedVariableDeclaration(node: Declaration) {`
`1735`		`- bindBlockScopedDeclaration(node, SymbolFlags.BlockScopedVariable, SymbolFlags.BlockScopedVariableExcludes);`
`1736`		`- }`
`1737`		`-`
`1738`	`1734`	`function delayedBindJSDocTypedefTag() {`
`1739`	`1735`	`if (!delayedTypeAliases) {`
`1740`	`1736`	`return;`
`@@ -2659,8 +2655,11 @@ namespace ts {`
`2659`	`2655`	`}`
`2660`	`2656`
`2661`	`2657`	`if (!isBindingPattern(node.name)) {`
	`2658`	`+ const isEnum = !!getJSDocEnumTag(node);`
	`2659`	`+ const enumFlags = (isEnum ? SymbolFlags.RegularEnum : SymbolFlags.None);`
	`2660`	`+ const enumExcludes = (isEnum ? SymbolFlags.RegularEnumExcludes : SymbolFlags.None);`
`2662`	`2661`	`if (isBlockOrCatchScoped(node)) {`
`2663`		`- bindBlockScopedVariableDeclaration(node);`
	`2662`	`+ bindBlockScopedDeclaration(node, SymbolFlags.BlockScopedVariable \| enumFlags, SymbolFlags.BlockScopedVariableExcludes \| enumExcludes);`
`2664`	`2663`	`}`
`2665`	`2664`	`else if (isParameterDeclaration(node)) {`
`2666`	`2665`	`// It is safe to walk up parent chain to find whether the node is a destructuring parameter declaration`
`@@ -2675,7 +2674,7 @@ namespace ts {`
`2675`	`2674`	`declareSymbolAndAddToSymbolTable(node, SymbolFlags.FunctionScopedVariable, SymbolFlags.ParameterExcludes);`
`2676`	`2675`	`}`
`2677`	`2676`	`else {`
`2678`		`- declareSymbolAndAddToSymbolTable(node, SymbolFlags.FunctionScopedVariable, SymbolFlags.FunctionScopedVariableExcludes);`
	`2677`	`+ declareSymbolAndAddToSymbolTable(node, SymbolFlags.FunctionScopedVariable \| enumFlags, SymbolFlags.FunctionScopedVariableExcludes \| enumExcludes);`
`2679`	`2678`	`}`
`2680`	`2679`	`}`
`2681`	`2680`	`}`