Update for newer literal types

Author: weswigham

src/compiler/checker.ts

@@ -264,22 +264,15 @@ namespace ts {
             getESSymbolType: () => esSymbolType,
             getNeverType: () => neverType,
             getUnknownType: () => unknownType,
-            getStringLiteralType: (text: string) => {
+            getLiteralType: (literal: string | number) => {
                 /* tslint:disable:no-null-keyword */
-                Debug.assert(text !== undefined && text !== null);
+                Debug.assert(literal !== undefined && literal !== null);
                 /* tslint:enable:no-null-keyword */
-                return getLiteralTypeForText(TypeFlags.StringLiteral, "" + text);
-            },
-            getNumberLiteralType: (text: string) => {
-                /* tslint:disable:no-null-keyword */
-                Debug.assert(text !== undefined && text !== null);
-                /* tslint:enable:no-null-keyword */
-                Debug.assert(typeof text === "string" || typeof text === "number"); // While not formally part of the function signature, allow coercions from numbers
-                return getLiteralTypeForText(TypeFlags.NumberLiteral, "" + text);
+                Debug.assert(typeof literal === "string" || typeof literal === "number");
+                return getLiteralType(literal);
             },
             getFalseType: () => falseType,
             getTrueType: () => trueType,
->>>>>>> Add type relationship functions to checker api
         };
 
         const tupleTypes: GenericType[] = [];

src/compiler/types.ts

@@ -2718,8 +2718,7 @@ namespace ts {
         getESSymbolType(): Type;
         getNeverType(): Type;
         getUnknownType(): Type;
-        getStringLiteralType(text: string): LiteralType;
-        getNumberLiteralType(text: string): LiteralType;
+        getLiteralType(content: string | number): LiteralType;
         getFalseType(): Type;
         getTrueType(): Type;
 

src/harness/unittests/checkerPublicRelationships.ts

@@ -23,7 +23,7 @@ namespace ts {
                 }
                 const xs: number[] = [1,2,3];
                 `
-            }], () => void 0, ScriptTarget.ES3, /*useCaseSensitiveFileNames*/true, "", NewLineKind.CarriageReturnLineFeed);
+            }], () => void 0, ScriptTarget.ES3, /*useCaseSensitiveFileNames*/ true, "", NewLineKind.CarriageReturnLineFeed);
             program = ts.createProgram(["test.ts"], ts.defaultInitCompilerOptions, host);
             const diag = ts.getPreEmitDiagnostics(program);
             if (diag.length) {
@@ -87,42 +87,42 @@ namespace ts {
         });
 
         it("can get string literal types", () => {
-            assert((checker.getStringLiteralType("foobar") as LiteralType).text === "foobar");
+            assert((checker.getLiteralType("foobar") as LiteralType).value === "foobar");
         });
 
         it("can get numeber literal types", () => {
-            assert((checker.getNumberLiteralType("42") as LiteralType).text === "42");
+            assert((checker.getLiteralType(42) as LiteralType).value === "42");
         });
 
         it("doesn't choke on exceptional input to literal type getters", () => {
-            assert.equal((checker.getStringLiteralType("") as LiteralType).text, "");
-            assert.throws(() => checker.getStringLiteralType(undefined), Error, "Debug Failure. False expression:");
+            assert.equal((checker.getLiteralType("") as LiteralType).value, "");
+            assert.throws(() => checker.getLiteralType(/*content*/ undefined), Error, "Debug Failure. False expression:");
             /* tslint:disable:no-null-keyword */
-            assert.throws(() => checker.getStringLiteralType(null), Error, "Debug Failure. False expression:");
+            assert.throws(() => checker.getLiteralType(/*content*/ null), Error, "Debug Failure. False expression:");
             /* tslint:enable:no-null-keyword */
             let hugeStringLiteral = map(new Array(2 ** 16 - 1), () => "a").join();
-            assert.equal((checker.getStringLiteralType(hugeStringLiteral) as LiteralType).text, hugeStringLiteral);
+            assert.equal((checker.getLiteralType(hugeStringLiteral) as LiteralType).value, hugeStringLiteral);
             hugeStringLiteral = undefined;
 
 
-            assert.throws(() => checker.getNumberLiteralType(undefined), Error, "Debug Failure. False expression:");
+            assert.throws(() => checker.getLiteralType(/*content*/ undefined), Error, "Debug Failure. False expression:");
             /* tslint:disable:no-null-keyword */
-            assert.throws(() => checker.getNumberLiteralType(null), Error, "Debug Failure. False expression:");
+            assert.throws(() => checker.getLiteralType(/*content*/ null), Error, "Debug Failure. False expression:");
             /* tslint:enable:no-null-keyword */
 
             const sanityChecks = ["000", "0b0", "0x0", "0.0", "0e-0", "-010", "-0b10", "-0x10", "-0o10", "-10.0", "-1e-1", "NaN", "Infinity", "-Infinity"];
             forEach(sanityChecks, num => {
-                assert.equal((checker.getNumberLiteralType(num) as LiteralType).text, num, `${num} did not match.`);
+                assert.equal((checker.getLiteralType(num) as LiteralType).value, num, `${num} did not match.`);
             });
 
             const insanityChecks = [[0, "0"], [0b0, "0"], [-10, "-10"], [NaN, "NaN"], [Infinity, "Infinity"], [-Infinity, "-Infinity"]];
             forEach(insanityChecks, ([num, expected]) => {
-                assert.equal((checker.getNumberLiteralType(num as any) as LiteralType).text, expected, `${JSON.stringify(num)} should be ${expected}`);
+                assert.equal((checker.getLiteralType(num as any) as LiteralType).value, expected, `${JSON.stringify(num)} should be ${expected}`);
             });
 
             const instabilityChecks = [{ foo: 42 }, new Date(42), [42], new Number(42), new String("42")];
             forEach(instabilityChecks, (bad) => {
-                assert.throws(() => checker.getNumberLiteralType(bad as any));
+                assert.throws(() => checker.getLiteralType(bad as any));
             });
         });
 
@@ -152,7 +152,7 @@ namespace ts {
             assert.notEqual(checker.lookupGlobalType("Function"), innerFunction, "Inner function type should be different than global");
             const brandNameType = checker.getTypeOfSymbol(innerFunction.getProperty("myBrand"));
             assert.notEqual(brandNameType, checker.getUnknownType(), "Brand type on inner function should not be unknown");
-            assert.equal(brandNameType, checker.getNumberLiteralType("42"), "Brand type should be 42");
+            assert.equal(brandNameType, checker.getLiteralType(42), "Brand type should be 42");
 
             let skipped = false;
             const functionBody2 = forEachChild(program.getSourceFile("test.ts"), node => node.kind === SyntaxKind.FunctionDeclaration ? skipped ? (node as FunctionDeclaration) : (skipped = true, undefined) : undefined).body;