Add test

tests/baselines/reference/literalTypesAndTypeAssertions.js

@@ -0,0 +1,28 @@
+//// [literalTypesAndTypeAssertions.ts]
+const obj = {
+    a: "foo" as "foo",
+    b: <"foo">"foo",
+    c: "foo"
+};
+
+let x1 = 1 as (0 | 1);
+let x2 = 1;
+
+let { a = "foo" } = { a: "foo" };
+let { b = "foo" as "foo" } = { b: "bar" };
+let { c = "foo" } = { c: "bar" as "bar" };
+let { d = "foo" as "foo" } = { d: "bar" as "bar" };
+
+
+//// [literalTypesAndTypeAssertions.js]
+var obj = {
+    a: "foo",
+    b: "foo",
+    c: "foo"
+};
+var x1 = 1;
+var x2 = 1;
+var _a = { a: "foo" }.a, a = _a === void 0 ? "foo" : _a;
+var _b = { b: "bar" }.b, b = _b === void 0 ? "foo" : _b;
+var _c = { c: "bar" }.c, c = _c === void 0 ? "foo" : _c;
+var _d = { d: "bar" }.d, d = _d === void 0 ? "foo" : _d;

tests/baselines/reference/literalTypesAndTypeAssertions.symbols

@@ -0,0 +1,37 @@
+=== tests/cases/conformance/types/literal/literalTypesAndTypeAssertions.ts ===
+const obj = {
+>obj : Symbol(obj, Decl(literalTypesAndTypeAssertions.ts, 0, 5))
+
+    a: "foo" as "foo",
+>a : Symbol(a, Decl(literalTypesAndTypeAssertions.ts, 0, 13))
+
+    b: <"foo">"foo",
+>b : Symbol(b, Decl(literalTypesAndTypeAssertions.ts, 1, 22))
+
+    c: "foo"
+>c : Symbol(c, Decl(literalTypesAndTypeAssertions.ts, 2, 20))
+
+};
+
+let x1 = 1 as (0 | 1);
+>x1 : Symbol(x1, Decl(literalTypesAndTypeAssertions.ts, 6, 3))
+
+let x2 = 1;
+>x2 : Symbol(x2, Decl(literalTypesAndTypeAssertions.ts, 7, 3))
+
+let { a = "foo" } = { a: "foo" };
+>a : Symbol(a, Decl(literalTypesAndTypeAssertions.ts, 9, 5))
+>a : Symbol(a, Decl(literalTypesAndTypeAssertions.ts, 9, 21))
+
+let { b = "foo" as "foo" } = { b: "bar" };
+>b : Symbol(b, Decl(literalTypesAndTypeAssertions.ts, 10, 5))
+>b : Symbol(b, Decl(literalTypesAndTypeAssertions.ts, 10, 30))
+
+let { c = "foo" } = { c: "bar" as "bar" };
+>c : Symbol(c, Decl(literalTypesAndTypeAssertions.ts, 11, 5))
+>c : Symbol(c, Decl(literalTypesAndTypeAssertions.ts, 11, 21))
+
+let { d = "foo" as "foo" } = { d: "bar" as "bar" };
+>d : Symbol(d, Decl(literalTypesAndTypeAssertions.ts, 12, 5))
+>d : Symbol(d, Decl(literalTypesAndTypeAssertions.ts, 12, 30))
+

tests/baselines/reference/literalTypesAndTypeAssertions.types

@@ -0,0 +1,62 @@
+=== tests/cases/conformance/types/literal/literalTypesAndTypeAssertions.ts ===
+const obj = {
+>obj : { a: "foo"; b: "foo"; c: string; }
+>{    a: "foo" as "foo",    b: <"foo">"foo",    c: "foo"} : { a: "foo"; b: "foo"; c: string; }
+
+    a: "foo" as "foo",
+>a : "foo"
+>"foo" as "foo" : "foo"
+>"foo" : "foo"
+
+    b: <"foo">"foo",
+>b : "foo"
+><"foo">"foo" : "foo"
+>"foo" : "foo"
+
+    c: "foo"
+>c : string
+>"foo" : "foo"
+
+};
+
+let x1 = 1 as (0 | 1);
+>x1 : 0 | 1
+>1 as (0 | 1) : 0 | 1
+>1 : 1
+
+let x2 = 1;
+>x2 : number
+>1 : 1
+
+let { a = "foo" } = { a: "foo" };
+>a : string
+>"foo" : "foo"
+>{ a: "foo" } : { a?: string; }
+>a : string
+>"foo" : "foo"
+
+let { b = "foo" as "foo" } = { b: "bar" };
+>b : "foo" | "bar"
+>"foo" as "foo" : "foo"
+>"foo" : "foo"
+>{ b: "bar" } : { b?: "bar"; }
+>b : string
+>"bar" : "bar"
+
+let { c = "foo" } = { c: "bar" as "bar" };
+>c : "foo" | "bar"
+>"foo" : "foo"
+>{ c: "bar" as "bar" } : { c?: "bar"; }
+>c : "bar"
+>"bar" as "bar" : "bar"
+>"bar" : "bar"
+
+let { d = "foo" as "foo" } = { d: "bar" as "bar" };
+>d : "foo" | "bar"
+>"foo" as "foo" : "foo"
+>"foo" : "foo"
+>{ d: "bar" as "bar" } : { d?: "bar"; }
+>d : "bar"
+>"bar" as "bar" : "bar"
+>"bar" : "bar"
+

tests/cases/conformance/types/literal/literalTypesAndTypeAssertions.ts

@@ -0,0 +1,13 @@
+const obj = {
+    a: "foo" as "foo",
+    b: <"foo">"foo",
+    c: "foo"
+};
+
+let x1 = 1 as (0 | 1);
+let x2 = 1;
+
+let { a = "foo" } = { a: "foo" };
+let { b = "foo" as "foo" } = { b: "bar" };
+let { c = "foo" } = { c: "bar" as "bar" };
+let { d = "foo" as "foo" } = { d: "bar" as "bar" };