Fix const assertions on enums

Fixes #45977

Author: elibarzilay

src/compiler/checker.ts

@@ -30741,13 +30741,11 @@ namespace ts {
                 case SyntaxKind.PropertyAccessExpression:
                 case SyntaxKind.ElementAccessExpression:
                     const expr = (node as PropertyAccessExpression | ElementAccessExpression).expression;
-                    if (isIdentifier(expr)) {
-                        let symbol = getSymbolAtLocation(expr);
-                        if (symbol && symbol.flags & SymbolFlags.Alias) {
-                            symbol = resolveAlias(symbol);
-                        }
-                        return !!(symbol && (symbol.flags & SymbolFlags.Enum) && getEnumKind(symbol) === EnumKind.Literal);
+                    let symbol = getTypeOfNode(expr).symbol;
+                    if (symbol && symbol.flags & SymbolFlags.Alias) {
+                        symbol = resolveAlias(symbol);
                     }
+                    return !!(symbol && (symbol.flags & SymbolFlags.Enum) && getEnumKind(symbol) === EnumKind.Literal);
             }
             return false;
         }

tests/baselines/reference/constAssertionOnEnum.js

@@ -14,7 +14,18 @@ enum Bar {
     B,
 }
 let foo = Foo.A as const;
-let bar = Bar.A as const;
+let bar = Bar.A as const;
+
+//// [ns.ts]
+namespace ns {
+    export enum Foo { X }
+    ns.Foo.X as const;
+}
+
+//// [more.ts]
+export enum Foo { X }
+(Foo).X as const;
+
 
 //// [enum.js]
 export var Foo;
@@ -31,3 +42,19 @@ var Bar;
 })(Bar || (Bar = {}));
 let foo = Foo.A;
 let bar = Bar.A;
+//// [ns.js]
+"use strict";
+var ns;
+(function (ns) {
+    let Foo;
+    (function (Foo) {
+        Foo[Foo["X"] = 0] = "X";
+    })(Foo = ns.Foo || (ns.Foo = {}));
+    ns.Foo.X;
+})(ns || (ns = {}));
+//// [more.js]
+export var Foo;
+(function (Foo) {
+    Foo[Foo["X"] = 0] = "X";
+})(Foo || (Foo = {}));
+(Foo).X;

tests/baselines/reference/constAssertionOnEnum.symbols

@@ -34,3 +34,29 @@ let bar = Bar.A as const;
 >Bar : Symbol(Bar, Decl(test.ts, 0, 27))
 >A : Symbol(Bar.A, Decl(test.ts, 2, 10))
 
+=== tests/cases/conformance/expressions/typeAssertions/ns.ts ===
+namespace ns {
+>ns : Symbol(ns, Decl(ns.ts, 0, 0))
+
+    export enum Foo { X }
+>Foo : Symbol(Foo, Decl(ns.ts, 0, 14))
+>X : Symbol(Foo.X, Decl(ns.ts, 1, 21))
+
+    ns.Foo.X as const;
+>ns.Foo.X : Symbol(Foo.X, Decl(ns.ts, 1, 21))
+>ns.Foo : Symbol(Foo, Decl(ns.ts, 0, 14))
+>ns : Symbol(ns, Decl(ns.ts, 0, 0))
+>Foo : Symbol(Foo, Decl(ns.ts, 0, 14))
+>X : Symbol(Foo.X, Decl(ns.ts, 1, 21))
+}
+
+=== tests/cases/conformance/expressions/typeAssertions/more.ts ===
+export enum Foo { X }
+>Foo : Symbol(Foo, Decl(more.ts, 0, 0))
+>X : Symbol(Foo.X, Decl(more.ts, 0, 17))
+
+(Foo).X as const;
+>(Foo).X : Symbol(Foo.X, Decl(more.ts, 0, 17))
+>Foo : Symbol(Foo, Decl(more.ts, 0, 0))
+>X : Symbol(Foo.X, Decl(more.ts, 0, 17))
+

tests/baselines/reference/constAssertionOnEnum.types

@@ -36,3 +36,32 @@ let bar = Bar.A as const;
 >Bar : typeof Bar
 >A : Bar.A
 
+=== tests/cases/conformance/expressions/typeAssertions/ns.ts ===
+namespace ns {
+>ns : typeof ns
+
+    export enum Foo { X }
+>Foo : Foo
+>X : Foo.X
+
+    ns.Foo.X as const;
+>ns.Foo.X as const : Foo
+>ns.Foo.X : Foo
+>ns.Foo : typeof Foo
+>ns : typeof ns
+>Foo : typeof Foo
+>X : Foo
+}
+
+=== tests/cases/conformance/expressions/typeAssertions/more.ts ===
+export enum Foo { X }
+>Foo : Foo
+>X : Foo.X
+
+(Foo).X as const;
+>(Foo).X as const : Foo
+>(Foo).X : Foo
+>(Foo) : typeof Foo
+>Foo : typeof Foo
+>X : Foo
+

tests/cases/conformance/expressions/typeAssertions/constAssertionOnEnum.ts

@@ -15,4 +15,14 @@ enum Bar {
     B,
 }
 let foo = Foo.A as const;
-let bar = Bar.A as const;
+let bar = Bar.A as const;
+
+// @filename: ns.ts
+namespace ns {
+    export enum Foo { X }
+    ns.Foo.X as const;
+}
+
+// @filename: more.ts
+export enum Foo { X }
+(Foo).X as const;