allow const-assertion on aliased enum symbol (#32110)

Fixes: #32087

src/compiler/checker.ts

@@ -22510,7 +22510,10 @@ namespace ts {
                 case SyntaxKind.ElementAccessExpression:
                     const expr = (<PropertyAccessExpression | ElementAccessExpression>node).expression;
                     if (isIdentifier(expr)) {
-                        const symbol = getSymbolAtLocation(expr);
+                        let symbol = getSymbolAtLocation(expr);
+                        if (symbol && symbol.flags & SymbolFlags.Alias) {
+                            symbol = resolveAlias(symbol);
+                        }
                         return !!(symbol && (symbol.flags & SymbolFlags.Enum) && getEnumKind(symbol) === EnumKind.Literal);
                     }
             }

tests/baselines/reference/constAssertionOnEnum.js

@@ -0,0 +1,33 @@
+//// [tests/cases/conformance/expressions/typeAssertions/constAssertionOnEnum.ts] ////
+
+//// [enum.ts]
+export enum Foo {
+    A,
+    B,
+}
+
+//// [test.ts]
+import {Foo} from './enum';
+
+enum Bar {
+    A,
+    B,
+}
+let foo = Foo.A as const;
+let bar = Bar.A as const;
+
+//// [enum.js]
+export var Foo;
+(function (Foo) {
+    Foo[Foo["A"] = 0] = "A";
+    Foo[Foo["B"] = 1] = "B";
+})(Foo || (Foo = {}));
+//// [test.js]
+import { Foo } from './enum';
+var Bar;
+(function (Bar) {
+    Bar[Bar["A"] = 0] = "A";
+    Bar[Bar["B"] = 1] = "B";
+})(Bar || (Bar = {}));
+let foo = Foo.A;
+let bar = Bar.A;

tests/baselines/reference/constAssertionOnEnum.symbols

@@ -0,0 +1,36 @@
+=== tests/cases/conformance/expressions/typeAssertions/enum.ts ===
+export enum Foo {
+>Foo : Symbol(Foo, Decl(enum.ts, 0, 0))
+
+    A,
+>A : Symbol(Foo.A, Decl(enum.ts, 0, 17))
+
+    B,
+>B : Symbol(Foo.B, Decl(enum.ts, 1, 6))
+}
+
+=== tests/cases/conformance/expressions/typeAssertions/test.ts ===
+import {Foo} from './enum';
+>Foo : Symbol(Foo, Decl(test.ts, 0, 8))
+
+enum Bar {
+>Bar : Symbol(Bar, Decl(test.ts, 0, 27))
+
+    A,
+>A : Symbol(Bar.A, Decl(test.ts, 2, 10))
+
+    B,
+>B : Symbol(Bar.B, Decl(test.ts, 3, 6))
+}
+let foo = Foo.A as const;
+>foo : Symbol(foo, Decl(test.ts, 6, 3))
+>Foo.A : Symbol(Foo.A, Decl(enum.ts, 0, 17))
+>Foo : Symbol(Foo, Decl(test.ts, 0, 8))
+>A : Symbol(Foo.A, Decl(enum.ts, 0, 17))
+
+let bar = Bar.A as const;
+>bar : Symbol(bar, Decl(test.ts, 7, 3))
+>Bar.A : Symbol(Bar.A, Decl(test.ts, 2, 10))
+>Bar : Symbol(Bar, Decl(test.ts, 0, 27))
+>A : Symbol(Bar.A, Decl(test.ts, 2, 10))
+

tests/baselines/reference/constAssertionOnEnum.types

@@ -0,0 +1,38 @@
+=== tests/cases/conformance/expressions/typeAssertions/enum.ts ===
+export enum Foo {
+>Foo : Foo
+
+    A,
+>A : Foo.A
+
+    B,
+>B : Foo.B
+}
+
+=== tests/cases/conformance/expressions/typeAssertions/test.ts ===
+import {Foo} from './enum';
+>Foo : typeof Foo
+
+enum Bar {
+>Bar : Bar
+
+    A,
+>A : Bar.A
+
+    B,
+>B : Bar.B
+}
+let foo = Foo.A as const;
+>foo : Foo.A
+>Foo.A as const : Foo.A
+>Foo.A : Foo.A
+>Foo : typeof Foo
+>A : Foo.A
+
+let bar = Bar.A as const;
+>bar : Bar.A
+>Bar.A as const : Bar.A
+>Bar.A : Bar.A
+>Bar : typeof Bar
+>A : Bar.A
+

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

@@ -0,0 +1,18 @@
+// @strict: true
+// @target: esnext
+
+// @filename: enum.ts
+export enum Foo {
+    A,
+    B,
+}
+
+// @filename: test.ts
+import {Foo} from './enum';
+
+enum Bar {
+    A,
+    B,
+}
+let foo = Foo.A as const;
+let bar = Bar.A as const;