Fix incorrect type declarations for constants inside namespaces merged with enums

src/compiler/checker.ts

@@ -50962,9 +50962,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return false;
     }
 
-    function literalTypeToNode(type: FreshableType, enclosing: Node, tracker: SymbolTracker): Expression {
-        const enumResult = type.flags & TypeFlags.EnumLike ? nodeBuilder.symbolToExpression(type.symbol, SymbolFlags.Value, enclosing, /*flags*/ undefined, /*internalFlags*/ undefined, tracker)
-            : type === trueType ? factory.createTrue() : type === falseType && factory.createFalse();
+    function literalTypeToNode(type: FreshableType, enclosing: Node, tracker: SymbolTracker): Expression {
+        const enumResult = type.flags & TypeFlags.EnumLike ? nodeBuilder.symbolToExpression(type.symbol, SymbolFlags.Value, /*enclosing*/ undefined, NodeBuilderFlags.UseFullyQualifiedType, /*internalFlags*/ undefined, tracker)
+            : type === trueType ? factory.createTrue() : type === falseType && factory.createFalse();
         if (enumResult) return enumResult;
         const literalValue = (type as LiteralType).value;
         return typeof literalValue === "object" ? factory.createBigIntLiteral(literalValue) :

src/compiler/transformers/declarations.ts

@@ -103,7 +103,8 @@ import {
     isExpandoPropertyDeclaration,
     isExportAssignment,
     isExportDeclaration,
-    isExpressionWithTypeArguments,
+    isExpressionWithTypeArguments,
+    isExpression,
     isExternalModule,
     isExternalModuleAugmentation,
     isExternalModuleIndicator,
@@ -128,8 +129,9 @@ import {
     isObjectLiteralExpression,
     isOmittedExpression,
     isParameter,
-    isPrimitiveLiteralValue,
-    isPrivateIdentifier,
+    isPrimitiveLiteralValue,
+    isPrivateIdentifier,
+    isPropertyAccessExpression,
     isSemicolonClassElement,
     isSetAccessorDeclaration,
     isSourceFile,
@@ -200,8 +202,8 @@ import {
     TransformationContext,
     Transformer,
     transformNodes,
-    tryCast,
-    TypeAliasDeclaration,
+    tryCast,
+    TypeAliasDeclaration,
     TypeNode,
     TypeParameterDeclaration,
     TypeReferenceNode,
@@ -654,21 +656,21 @@ export function transformDeclarations(context: TransformationContext): Transform
         return newParam;
     }
 
-    function shouldPrintWithInitializer(node: Node): node is CanHaveLiteralInitializer & { initializer: Expression; } {
-        return canHaveLiteralInitializer(node)
-            && !!node.initializer
-            && resolver.isLiteralConstDeclaration(getParseTreeNode(node) as CanHaveLiteralInitializer); // TODO: Make safea
+    function shouldPrintWithInitializer(node: Node): node is CanHaveLiteralInitializer & { initializer: Expression; } {
+        return canHaveLiteralInitializer(node)
+            && !!node.initializer
+            && resolver.isLiteralConstDeclaration(getParseTreeNode(node) as CanHaveLiteralInitializer); // TODO: Make safea
     }
 
-    function ensureNoInitializer(node: CanHaveLiteralInitializer) {
-        if (shouldPrintWithInitializer(node)) {
-            const unwrappedInitializer = unwrapParenthesizedExpression(node.initializer);
-            if (!isPrimitiveLiteralValue(unwrappedInitializer)) {
-                reportInferenceFallback(node);
-            }
-            return resolver.createLiteralConstValue(getParseTreeNode(node, canHaveLiteralInitializer)!, symbolTracker);
-        }
-        return undefined;
+    function ensureNoInitializer(node: CanHaveLiteralInitializer) {
+        if (shouldPrintWithInitializer(node)) {
+            const unwrappedInitializer = unwrapParenthesizedExpression(node.initializer);
+            if (!isPrimitiveLiteralValue(unwrappedInitializer)) {
+                reportInferenceFallback(node);
+            }
+            return resolver.createLiteralConstValue(getParseTreeNode(node, canHaveLiteralInitializer)!, symbolTracker);
+        }
+        return undefined;
     }
     function ensureType(node: VariableDeclaration | ParameterDeclaration | BindingElement | PropertyDeclaration | PropertySignature | ExportAssignment | SignatureDeclaration, ignorePrivate?: boolean): TypeNode | undefined {
         if (!ignorePrivate && hasEffectiveModifier(node, ModifierFlags.Private)) {
@@ -1049,12 +1051,12 @@ export function transformDeclarations(context: TransformationContext): Transform
         const oldWithinObjectLiteralType = suppressNewDiagnosticContexts;
         let shouldEnterSuppressNewDiagnosticsContextContext = (input.kind === SyntaxKind.TypeLiteral || input.kind === SyntaxKind.MappedType) && input.parent.kind !== SyntaxKind.TypeAliasDeclaration;
 
-        // Emit methods which are private as properties with no type information
-        if (isMethodDeclaration(input) || isMethodSignature(input)) {
-            if (hasEffectiveModifier(input, ModifierFlags.Private)) {
-                if (input.symbol && input.symbol.declarations && input.symbol.declarations[0] !== input) return; // Elide all but the first overload
-                return cleanup(factory.createPropertyDeclaration(ensureModifiers(input), input.name, /*questionOrExclamationToken*/ undefined, /*type*/ undefined, /*initializer*/ undefined));
-            }
+        // Emit methods which are private as properties with no type information
+        if (isMethodDeclaration(input) || isMethodSignature(input)) {
+            if (hasEffectiveModifier(input, ModifierFlags.Private)) {
+                if (input.symbol && input.symbol.declarations && input.symbol.declarations[0] !== input) return; // Elide all but the first overload
+                return cleanup(factory.createPropertyDeclaration(ensureModifiers(input), input.name, /*questionOrExclamationToken*/ undefined, /*type*/ undefined, /*initializer*/ undefined));
+            }
         }
 
         if (canProduceDiagnostic && !suppressNewDiagnosticContexts) {

tests/baselines/reference/enumNamespaceConstantsDeclaration.js

@@ -0,0 +1,97 @@
+//// [tests/cases/compiler/enumNamespaceConstantsDeclaration.ts] ////
+
+//// [enumNamespaceConstantsDeclaration.ts]
+// Test for constant declarations inside namespace merged with enum
+enum Foo {
+    bar
+}
+namespace Foo {
+    export const baz = Foo.bar;
+}
+
+// Multiple enum members
+enum MyEnum {
+    First = 1,
+    Second = 2
+}
+namespace MyEnum {
+    export const value1 = MyEnum.First;
+    export const value2 = MyEnum.Second;
+}
+
+// String enum
+enum StringEnum {
+    Option1 = "option1",
+    Option2 = "option2"
+}
+namespace StringEnum {
+    export const selected = StringEnum.Option1;
+}
+
+//// [enumNamespaceConstantsDeclaration.js]
+// Test for constant declarations inside namespace merged with enum
+var Foo;
+(function (Foo) {
+    Foo[Foo["bar"] = 0] = "bar";
+})(Foo || (Foo = {}));
+(function (Foo) {
+    Foo.baz = Foo.bar;
+})(Foo || (Foo = {}));
+// Multiple enum members
+var MyEnum;
+(function (MyEnum) {
+    MyEnum[MyEnum["First"] = 1] = "First";
+    MyEnum[MyEnum["Second"] = 2] = "Second";
+})(MyEnum || (MyEnum = {}));
+(function (MyEnum) {
+    MyEnum.value1 = MyEnum.First;
+    MyEnum.value2 = MyEnum.Second;
+})(MyEnum || (MyEnum = {}));
+// String enum
+var StringEnum;
+(function (StringEnum) {
+    StringEnum["Option1"] = "option1";
+    StringEnum["Option2"] = "option2";
+})(StringEnum || (StringEnum = {}));
+(function (StringEnum) {
+    StringEnum.selected = StringEnum.Option1;
+})(StringEnum || (StringEnum = {}));
+
+
+//// [enumNamespaceConstantsDeclaration.d.ts]
+declare enum Foo {
+    bar = 0
+}
+declare namespace Foo {
+    const baz = Foo.bar;
+}
+declare enum MyEnum {
+    First = 1,
+    Second = 2
+}
+declare namespace MyEnum {
+    const value1 = MyEnum.First;
+    const value2 = MyEnum.Second;
+}
+declare enum StringEnum {
+    Option1 = "option1",
+    Option2 = "option2"
+}
+declare namespace StringEnum {
+    const selected: any;
+}
+
+
+!!!! File enumNamespaceConstantsDeclaration.d.ts differs from original emit in noCheck emit
+//// [enumNamespaceConstantsDeclaration.d.ts]
+===================================================================
+--- Expected	The full check baseline
++++ Actual	with noCheck set
+@@ -16,6 +16,6 @@
+     Option1 = "option1",
+     Option2 = "option2"
+ }
+ declare namespace StringEnum {
+-    const selected: any;
++    const selected = StringEnum.Option1;
+ }

tests/baselines/reference/enumNamespaceConstantsDeclaration.symbols

@@ -0,0 +1,65 @@
+//// [tests/cases/compiler/enumNamespaceConstantsDeclaration.ts] ////
+
+=== enumNamespaceConstantsDeclaration.ts ===
+// Test for constant declarations inside namespace merged with enum
+enum Foo {
+>Foo : Symbol(Foo, Decl(enumNamespaceConstantsDeclaration.ts, 0, 0), Decl(enumNamespaceConstantsDeclaration.ts, 3, 1))
+
+    bar
+>bar : Symbol(Foo.bar, Decl(enumNamespaceConstantsDeclaration.ts, 1, 10))
+}
+namespace Foo {
+>Foo : Symbol(Foo, Decl(enumNamespaceConstantsDeclaration.ts, 0, 0), Decl(enumNamespaceConstantsDeclaration.ts, 3, 1))
+
+    export const baz = Foo.bar;
+>baz : Symbol(baz, Decl(enumNamespaceConstantsDeclaration.ts, 5, 16))
+>Foo.bar : Symbol(bar, Decl(enumNamespaceConstantsDeclaration.ts, 1, 10))
+>Foo : Symbol(Foo, Decl(enumNamespaceConstantsDeclaration.ts, 0, 0), Decl(enumNamespaceConstantsDeclaration.ts, 3, 1))
+>bar : Symbol(bar, Decl(enumNamespaceConstantsDeclaration.ts, 1, 10))
+}
+
+// Multiple enum members
+enum MyEnum {
+>MyEnum : Symbol(MyEnum, Decl(enumNamespaceConstantsDeclaration.ts, 6, 1), Decl(enumNamespaceConstantsDeclaration.ts, 12, 1))
+
+    First = 1,
+>First : Symbol(MyEnum.First, Decl(enumNamespaceConstantsDeclaration.ts, 9, 13))
+
+    Second = 2
+>Second : Symbol(MyEnum.Second, Decl(enumNamespaceConstantsDeclaration.ts, 10, 14))
+}
+namespace MyEnum {
+>MyEnum : Symbol(MyEnum, Decl(enumNamespaceConstantsDeclaration.ts, 6, 1), Decl(enumNamespaceConstantsDeclaration.ts, 12, 1))
+
+    export const value1 = MyEnum.First;
+>value1 : Symbol(value1, Decl(enumNamespaceConstantsDeclaration.ts, 14, 16))
+>MyEnum.First : Symbol(First, Decl(enumNamespaceConstantsDeclaration.ts, 9, 13))
+>MyEnum : Symbol(MyEnum, Decl(enumNamespaceConstantsDeclaration.ts, 6, 1), Decl(enumNamespaceConstantsDeclaration.ts, 12, 1))
+>First : Symbol(First, Decl(enumNamespaceConstantsDeclaration.ts, 9, 13))
+
+    export const value2 = MyEnum.Second;
+>value2 : Symbol(value2, Decl(enumNamespaceConstantsDeclaration.ts, 15, 16))
+>MyEnum.Second : Symbol(Second, Decl(enumNamespaceConstantsDeclaration.ts, 10, 14))
+>MyEnum : Symbol(MyEnum, Decl(enumNamespaceConstantsDeclaration.ts, 6, 1), Decl(enumNamespaceConstantsDeclaration.ts, 12, 1))
+>Second : Symbol(Second, Decl(enumNamespaceConstantsDeclaration.ts, 10, 14))
+}
+
+// String enum
+enum StringEnum {
+>StringEnum : Symbol(StringEnum, Decl(enumNamespaceConstantsDeclaration.ts, 16, 1), Decl(enumNamespaceConstantsDeclaration.ts, 22, 1))
+
+    Option1 = "option1",
+>Option1 : Symbol(StringEnum.Option1, Decl(enumNamespaceConstantsDeclaration.ts, 19, 17))
+
+    Option2 = "option2"
+>Option2 : Symbol(StringEnum.Option2, Decl(enumNamespaceConstantsDeclaration.ts, 20, 24))
+}
+namespace StringEnum {
+>StringEnum : Symbol(StringEnum, Decl(enumNamespaceConstantsDeclaration.ts, 16, 1), Decl(enumNamespaceConstantsDeclaration.ts, 22, 1))
+
+    export const selected = StringEnum.Option1;
+>selected : Symbol(selected, Decl(enumNamespaceConstantsDeclaration.ts, 24, 16))
+>StringEnum.Option1 : Symbol(Option1, Decl(enumNamespaceConstantsDeclaration.ts, 19, 17))
+>StringEnum : Symbol(StringEnum, Decl(enumNamespaceConstantsDeclaration.ts, 16, 1), Decl(enumNamespaceConstantsDeclaration.ts, 22, 1))
+>Option1 : Symbol(Option1, Decl(enumNamespaceConstantsDeclaration.ts, 19, 17))
+}

tests/baselines/reference/enumNamespaceConstantsDeclaration.types

@@ -0,0 +1,99 @@
+//// [tests/cases/compiler/enumNamespaceConstantsDeclaration.ts] ////
+
+=== enumNamespaceConstantsDeclaration.ts ===
+// Test for constant declarations inside namespace merged with enum
+enum Foo {
+>Foo : Foo
+>    : ^^^
+
+    bar
+>bar : Foo.bar
+>    : ^^^^^^^
+}
+namespace Foo {
+>Foo : typeof Foo
+>    : ^^^^^^^^^^
+
+    export const baz = Foo.bar;
+>baz : Foo.bar
+>    : ^^^^^^^
+>Foo.bar : Foo
+>        : ^^^
+>Foo : typeof Foo
+>    : ^^^^^^^^^^
+>bar : Foo
+>    : ^^^
+}
+
+// Multiple enum members
+enum MyEnum {
+>MyEnum : MyEnum
+>       : ^^^^^^
+
+    First = 1,
+>First : MyEnum.First
+>      : ^^^^^^^^^^^^
+>1 : 1
+>  : ^
+
+    Second = 2
+>Second : MyEnum.Second
+>       : ^^^^^^^^^^^^^
+>2 : 2
+>  : ^
+}
+namespace MyEnum {
+>MyEnum : typeof MyEnum
+>       : ^^^^^^^^^^^^^
+
+    export const value1 = MyEnum.First;
+>value1 : MyEnum.First
+>       : ^^^^^^^^^^^^
+>MyEnum.First : MyEnum.First
+>             : ^^^^^^^^^^^^
+>MyEnum : typeof MyEnum
+>       : ^^^^^^^^^^^^^
+>First : MyEnum.First
+>      : ^^^^^^^^^^^^
+
+    export const value2 = MyEnum.Second;
+>value2 : MyEnum.Second
+>       : ^^^^^^^^^^^^^
+>MyEnum.Second : MyEnum.Second
+>              : ^^^^^^^^^^^^^
+>MyEnum : typeof MyEnum
+>       : ^^^^^^^^^^^^^
+>Second : MyEnum.Second
+>       : ^^^^^^^^^^^^^
+}
+
+// String enum
+enum StringEnum {
+>StringEnum : StringEnum
+>           : ^^^^^^^^^^
+
+    Option1 = "option1",
+>Option1 : StringEnum.Option1
+>        : ^^^^^^^^^^^^^^^^^^
+>"option1" : "option1"
+>          : ^^^^^^^^^
+
+    Option2 = "option2"
+>Option2 : StringEnum.Option2
+>        : ^^^^^^^^^^^^^^^^^^
+>"option2" : "option2"
+>          : ^^^^^^^^^
+}
+namespace StringEnum {
+>StringEnum : typeof StringEnum
+>           : ^^^^^^^^^^^^^^^^^
+
+    export const selected = StringEnum.Option1;
+>selected : any
+>StringEnum.Option1 : StringEnum.Option1
+>                   : ^^^^^^^^^^^^^^^^^^
+>StringEnum : typeof StringEnum
+>           : ^^^^^^^^^^^^^^^^^
+>Option1 : StringEnum.Option1
+>        : ^^^^^^^^^^^^^^^^^^
+}

tests/cases/compiler/enumNamespaceConstantsDeclaration.d.ts

@@ -0,0 +1,21 @@
+declare enum Foo {
+    bar = 0
+}
+declare namespace Foo {
+    const baz = bar;
+}
+declare enum MyEnum {
+    First = 1,
+    Second = 2
+}
+declare namespace MyEnum {
+    const value1 = First;
+    const value2 = Second;
+}
+declare enum StringEnum {
+    Option1 = "option1",
+    Option2 = "option2"
+}
+declare namespace StringEnum {
+    const selected: any;
+}