Test that enum literal is assignable to an enum in a union

tests/baselines/reference/enumLiteralAssignableToEnumInsideUnion.js

@@ -0,0 +1,32 @@
+//// [enumLiteralAssignableToEnumInsideUnion.ts]
+module X {
+    export enum Foo {
+        A, B
+    }
+}
+module Y {
+    export enum Foo {
+        A, B
+    }
+}
+const y: X.Foo | boolean = Y.Foo.A;
+
+
+//// [enumLiteralAssignableToEnumInsideUnion.js]
+var X;
+(function (X) {
+    (function (Foo) {
+        Foo[Foo["A"] = 0] = "A";
+        Foo[Foo["B"] = 1] = "B";
+    })(X.Foo || (X.Foo = {}));
+    var Foo = X.Foo;
+})(X || (X = {}));
+var Y;
+(function (Y) {
+    (function (Foo) {
+        Foo[Foo["A"] = 0] = "A";
+        Foo[Foo["B"] = 1] = "B";
+    })(Y.Foo || (Y.Foo = {}));
+    var Foo = Y.Foo;
+})(Y || (Y = {}));
+var y = Y.Foo.A;

tests/baselines/reference/enumLiteralAssignableToEnumInsideUnion.symbols

@@ -0,0 +1,33 @@
+=== tests/cases/compiler/enumLiteralAssignableToEnumInsideUnion.ts ===
+module X {
+>X : Symbol(X, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 0, 0))
+
+    export enum Foo {
+>Foo : Symbol(Foo, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 0, 10))
+
+        A, B
+>A : Symbol(Foo.A, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 1, 21))
+>B : Symbol(Foo.B, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 2, 10))
+    }
+}
+module Y {
+>Y : Symbol(Y, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 4, 1))
+
+    export enum Foo {
+>Foo : Symbol(Foo, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 5, 10))
+
+        A, B
+>A : Symbol(Foo.A, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 6, 21))
+>B : Symbol(Foo.B, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 7, 10))
+    }
+}
+const y: X.Foo | boolean = Y.Foo.A;
+>y : Symbol(y, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 10, 5))
+>X : Symbol(X, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 0, 0))
+>Foo : Symbol(X.Foo, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 0, 10))
+>Y.Foo.A : Symbol(Y.Foo.A, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 6, 21))
+>Y.Foo : Symbol(Y.Foo, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 5, 10))
+>Y : Symbol(Y, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 4, 1))
+>Foo : Symbol(Y.Foo, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 5, 10))
+>A : Symbol(Y.Foo.A, Decl(enumLiteralAssignableToEnumInsideUnion.ts, 6, 21))
+

tests/baselines/reference/enumLiteralAssignableToEnumInsideUnion.types

@@ -0,0 +1,33 @@
+=== tests/cases/compiler/enumLiteralAssignableToEnumInsideUnion.ts ===
+module X {
+>X : typeof X
+
+    export enum Foo {
+>Foo : Foo
+
+        A, B
+>A : Foo
+>B : Foo
+    }
+}
+module Y {
+>Y : typeof Y
+
+    export enum Foo {
+>Foo : Foo
+
+        A, B
+>A : Foo
+>B : Foo
+    }
+}
+const y: X.Foo | boolean = Y.Foo.A;
+>y : boolean | X.Foo
+>X : any
+>Foo : X.Foo
+>Y.Foo.A : Y.Foo
+>Y.Foo : typeof Y.Foo
+>Y : typeof Y
+>Foo : typeof Y.Foo
+>A : Y.Foo
+

tests/cases/compiler/enumLiteralAssignableToEnumInsideUnion.ts

@@ -0,0 +1,11 @@
+module X {
+    export enum Foo {
+        A, B
+    }
+}
+module Y {
+    export enum Foo {
+        A, B
+    }
+}
+const y: X.Foo | boolean = Y.Foo.A;