Fix enum const initializer visibility painting (#28415)

src/compiler/checker.ts

@@ -28799,15 +28799,15 @@ namespace ts {
             return false;
         }
 
-        function literalTypeToNode(type: FreshableType, enclosing: Node): Expression {
-            const enumResult = type.flags & TypeFlags.EnumLiteral ? nodeBuilder.symbolToExpression(type.symbol, SymbolFlags.Value, enclosing)
+        function literalTypeToNode(type: FreshableType, enclosing: Node, tracker: SymbolTracker): Expression {
+            const enumResult = type.flags & TypeFlags.EnumLiteral ? nodeBuilder.symbolToExpression(type.symbol, SymbolFlags.Value, enclosing, /*flags*/ undefined, tracker)
                 : type === trueType ? createTrue() : type === falseType && createFalse();
             return enumResult || createLiteral((type as LiteralType).value);
         }
 
-        function createLiteralConstValue(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration) {
+        function createLiteralConstValue(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration, tracker: SymbolTracker) {
             const type = getTypeOfSymbol(getSymbolOfNode(node));
-            return literalTypeToNode(<FreshableType>type, node);
+            return literalTypeToNode(<FreshableType>type, node, tracker);
         }
 
         function createResolver(): EmitResolver {

src/compiler/transformers/declarations.ts

@@ -373,7 +373,7 @@ namespace ts {
 
         function ensureNoInitializer(node: CanHaveLiteralInitializer) {
             if (shouldPrintWithInitializer(node)) {
-                return resolver.createLiteralConstValue(getParseTreeNode(node) as CanHaveLiteralInitializer); // TODO: Make safe
+                return resolver.createLiteralConstValue(getParseTreeNode(node) as CanHaveLiteralInitializer, symbolTracker); // TODO: Make safe
             }
             return undefined;
         }

src/compiler/types.ts

@@ -3500,7 +3500,7 @@ namespace ts {
         createTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration | PropertyAccessExpression, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker, addUndefined?: boolean): TypeNode | undefined;
         createReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;
         createTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;
-        createLiteralConstValue(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration): Expression;
+        createLiteralConstValue(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration, tracker: SymbolTracker): Expression;
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags | undefined, shouldComputeAliasToMarkVisible: boolean): SymbolAccessibilityResult;
         isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult;
         // Returns the constant value this property access resolves to, or 'undefined' for a non-constant

tests/baselines/reference/enumDeclarationEmitInitializerHasImport.js

@@ -0,0 +1,35 @@
+//// [tests/cases/compiler/enumDeclarationEmitInitializerHasImport.ts] ////
+
+//// [provider.ts]
+export enum Enum {
+    Value1,
+    Value2,
+}
+//// [consumer.ts]
+import provider = require('./provider');
+
+export const value = provider.Enum.Value1;
+
+//// [provider.js]
+"use strict";
+exports.__esModule = true;
+var Enum;
+(function (Enum) {
+    Enum[Enum["Value1"] = 0] = "Value1";
+    Enum[Enum["Value2"] = 1] = "Value2";
+})(Enum = exports.Enum || (exports.Enum = {}));
+//// [consumer.js]
+"use strict";
+exports.__esModule = true;
+var provider = require("./provider");
+exports.value = provider.Enum.Value1;
+
+
+//// [provider.d.ts]
+export declare enum Enum {
+    Value1 = 0,
+    Value2 = 1
+}
+//// [consumer.d.ts]
+import provider = require('./provider');
+export declare const value = provider.Enum.Value1;

tests/baselines/reference/enumDeclarationEmitInitializerHasImport.symbols

@@ -0,0 +1,22 @@
+=== tests/cases/compiler/consumer.ts ===
+import provider = require('./provider');
+>provider : Symbol(provider, Decl(consumer.ts, 0, 0))
+
+export const value = provider.Enum.Value1;
+>value : Symbol(value, Decl(consumer.ts, 2, 12))
+>provider.Enum.Value1 : Symbol(provider.Enum.Value1, Decl(provider.ts, 0, 18))
+>provider.Enum : Symbol(provider.Enum, Decl(provider.ts, 0, 0))
+>provider : Symbol(provider, Decl(consumer.ts, 0, 0))
+>Enum : Symbol(provider.Enum, Decl(provider.ts, 0, 0))
+>Value1 : Symbol(provider.Enum.Value1, Decl(provider.ts, 0, 18))
+
+=== tests/cases/compiler/provider.ts ===
+export enum Enum {
+>Enum : Symbol(Enum, Decl(provider.ts, 0, 0))
+
+    Value1,
+>Value1 : Symbol(Enum.Value1, Decl(provider.ts, 0, 18))
+
+    Value2,
+>Value2 : Symbol(Enum.Value2, Decl(provider.ts, 1, 11))
+}

tests/baselines/reference/enumDeclarationEmitInitializerHasImport.types

@@ -0,0 +1,22 @@
+=== tests/cases/compiler/consumer.ts ===
+import provider = require('./provider');
+>provider : typeof provider
+
+export const value = provider.Enum.Value1;
+>value : provider.Enum.Value1
+>provider.Enum.Value1 : provider.Enum.Value1
+>provider.Enum : typeof provider.Enum
+>provider : typeof provider
+>Enum : typeof provider.Enum
+>Value1 : provider.Enum.Value1
+
+=== tests/cases/compiler/provider.ts ===
+export enum Enum {
+>Enum : Enum
+
+    Value1,
+>Value1 : Enum.Value1
+
+    Value2,
+>Value2 : Enum.Value2
+}

tests/cases/compiler/enumDeclarationEmitInitializerHasImport.ts

@@ -0,0 +1,10 @@
+// @declaration: true
+// @filename: provider.ts
+export enum Enum {
+    Value1,
+    Value2,
+}
+// @filename: consumer.ts
+import provider = require('./provider');
+
+export const value = provider.Enum.Value1;