More tests of enum assignability

1. Numeric literal <-> enum literal assignability
2. Computed enum <-> union enum assignability
3. Also rebaseline error reporting of existing enum cases.

tests/cases/compiler/enumAssignmentCompat5.ts

@@ -0,0 +1,23 @@
+enum E {
+    A, B, C
+}
+enum Computed {
+    A = 1 << 1,
+    B = 1 << 2,
+    C = 1 << 3,
+}
+let n: number;
+let e: E = n; // ok because it's too inconvenient otherwise
+e = 0; // ok, in range
+e = 4; // ok, out of range, but allowed computed enums don't have all members
+let a: E.A = 0; // ok, A === 0
+a = 2; // error, 2 !== 0
+a = n; // ok
+
+let c: Computed = n; // ok
+c = n; // ok
+c = 4; // ok
+let ca: Computed.A = 1; // error, Computed.A isn't a literal type because Computed has no enum literals
+
+
+

tests/cases/compiler/enumLiteralAssignableToEnumInsideUnion.ts

@@ -8,4 +8,20 @@ module Y {
         A, B
     }
 }
-const y: X.Foo | boolean = Y.Foo.A;
+module Z {
+    export enum Foo {
+        A = 1 << 1,
+        B = 1 << 2,
+    }
+}
+module Ka {
+    export enum Foo {
+        A = 1 << 10,
+        B = 1 << 11,
+    }
+}
+const e1: X.Foo | boolean = Z.Foo.A; // ok
+const e2: X.Foo.A | X.Foo.B | boolean = Z.Foo.A; // ok, X.Foo is equivalent to X.Foo.A | X.Foo.B
+const e3: X.Foo.B | boolean = Z.Foo.A; // not legal
+const e4: X.Foo.A | boolean = Z.Foo.A; // not legal either because Z.Foo is computed and Z.Foo.A is not necessarily assignable to X.Foo.A
+const e5: Ka.Foo | boolean = Z.Foo.A; // ok