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

ajafff · RyanCavanaugh · commit 392d7750956b · 2019-06-26T14:42:06.000-07:00
Fixes: microsoft#32087
diff --git a/src/compiler/checker.ts b/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);
                     }
             }
diff --git a/tests/baselines/reference/constAssertionOnEnum.js b/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;
diff --git a/tests/baselines/reference/constAssertionOnEnum.symbols b/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))
+
diff --git a/tests/baselines/reference/constAssertionOnEnum.types b/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
+
diff --git a/tests/cases/conformance/expressions/typeAssertions/constAssertionOnEnum.ts b/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;

Original file line number	Diff line number	Diff line change
`@@ -22510,7 +22510,10 @@ namespace ts {`
`22510`	`22510`	`case SyntaxKind.ElementAccessExpression:`
`22511`	`22511`	`const expr = (<PropertyAccessExpression \| ElementAccessExpression>node).expression;`
`22512`	`22512`	`if (isIdentifier(expr)) {`
`22513`		`- const symbol = getSymbolAtLocation(expr);`
	`22513`	`+ let symbol = getSymbolAtLocation(expr);`
	`22514`	`+ if (symbol && symbol.flags & SymbolFlags.Alias) {`
	`22515`	`+ symbol = resolveAlias(symbol);`
	`22516`	`+ }`
`22514`	`22517`	`return !!(symbol && (symbol.flags & SymbolFlags.Enum) && getEnumKind(symbol) === EnumKind.Literal);`
`22515`	`22518`	`}`
`22516`	`22519`	`}`