Infer string literals at comparison locations

src/compiler/checker.ts

@@ -7334,24 +7334,37 @@ namespace ts {
             return undefined;
         }
 
-        function getContextualTypeForBinaryOperand(node: Expression): Type {
+        function getContextualTypeForBinaryOperand(node: Expression, literalNode: StringLiteral): Type {
             const binaryExpression = <BinaryExpression>node.parent;
             const operator = binaryExpression.operatorToken.kind;
-            if (operator >= SyntaxKind.FirstAssignment && operator <= SyntaxKind.LastAssignment) {
+
+            if (SyntaxKind.FirstAssignment <= operator && operator <= SyntaxKind.LastAssignment) {
                 // In an assignment expression, the right operand is contextually typed by the type of the left operand.
                 if (node === binaryExpression.right) {
                     return checkExpression(binaryExpression.left);
                 }
+                return undefined;
             }
-            else if (operator === SyntaxKind.BarBarToken) {
-                // When an || expression has a contextual type, the operands are contextually typed by that type. When an ||
-                // expression has no contextual type, the right operand is contextually typed by the type of the left operand.
-                let type = getContextualType(binaryExpression);
-                if (!type && node === binaryExpression.right) {
-                    type = checkExpression(binaryExpression.left);
-                }
-                return type;
+
+            switch (operator) {
+                case SyntaxKind.BarBarToken:
+                    // When an || expression has a contextual type, the operands are contextually typed by that type. When an ||
+                    // expression has no contextual type, the right operand is contextually typed by the type of the left operand.
+                    let type = getContextualTypeWorker(binaryExpression, literalNode);
+                    if (!type && node === binaryExpression.right) {
+                        type = checkExpression(binaryExpression.left);
+                    }
+                    return type;
+                case SyntaxKind.EqualsEqualsEqualsToken:
+                case SyntaxKind.ExclamationEqualsEqualsToken:
+                case SyntaxKind.EqualsEqualsToken:
+                case SyntaxKind.ExclamationEqualsToken:
+                    if (literalNode) {
+                        return getStringLiteralTypeForText(literalNode.text);
+                    }
+                    break;
             }
+
             return undefined;
         }
 
@@ -7459,9 +7472,9 @@ namespace ts {
         }
 
         // In a contextually typed conditional expression, the true/false expressions are contextually typed by the same type.
-        function getContextualTypeForConditionalOperand(node: Expression): Type {
+        function getContextualTypeForConditionalOperand(node: Expression, literalNode: StringLiteral): Type {
             const conditional = <ConditionalExpression>node.parent;
-            return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional) : undefined;
+            return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualTypeWorker(conditional, literalNode) : undefined;
         }
 
         function getContextualTypeForJsxExpression(expr: JsxExpression | JsxSpreadAttribute): Type {
@@ -7509,6 +7522,14 @@ namespace ts {
          * @returns the contextual type of an expression.
          */
         function getContextualType(node: Expression): Type {
+            return getContextualTypeWorker(node, /*literalNode*/ undefined);
+        }
+
+        function getLiteralContextualType(literalNode: StringLiteral) {
+            return getContextualTypeWorker(literalNode, literalNode);
+        }
+
+        function getContextualTypeWorker(node: Expression, literalNode: StringLiteral): Type {
             if (isInsideWithStatementBody(node)) {
                 // We cannot answer semantic questions within a with block, do not proceed any further
                 return undefined;
@@ -7536,21 +7557,27 @@ namespace ts {
                 case SyntaxKind.AsExpression:
                     return getTypeFromTypeNode((<AssertionExpression>parent).type);
                 case SyntaxKind.BinaryExpression:
-                    return getContextualTypeForBinaryOperand(node);
+                    return getContextualTypeForBinaryOperand(node, literalNode);
                 case SyntaxKind.PropertyAssignment:
                     return getContextualTypeForObjectLiteralElement(<ObjectLiteralElement>parent);
                 case SyntaxKind.ArrayLiteralExpression:
                     return getContextualTypeForElementExpression(node);
                 case SyntaxKind.ConditionalExpression:
-                    return getContextualTypeForConditionalOperand(node);
+                    return getContextualTypeForConditionalOperand(node, literalNode);
                 case SyntaxKind.TemplateSpan:
                     Debug.assert(parent.parent.kind === SyntaxKind.TemplateExpression);
                     return getContextualTypeForSubstitutionExpression(<TemplateExpression>parent.parent, node);
                 case SyntaxKind.ParenthesizedExpression:
-                    return getContextualType(<ParenthesizedExpression>parent);
+                    return getContextualTypeWorker(<ParenthesizedExpression>parent, literalNode);
                 case SyntaxKind.JsxExpression:
                 case SyntaxKind.JsxSpreadAttribute:
                     return getContextualTypeForJsxExpression(<JsxExpression>parent);
+                case SyntaxKind.SwitchStatement:
+                case SyntaxKind.CaseClause:
+                    if (literalNode) {
+                        return getStringLiteralTypeForText(literalNode.text);
+                    }
+                    break;
             }
             return undefined;
         }
@@ -9869,11 +9896,7 @@ namespace ts {
             if (produceDiagnostics && targetType !== unknownType) {
                 const widenedType = getWidenedType(exprType);
 
-                // Permit 'number[] | "foo"' to be asserted to 'string'.
-                const bothAreStringLike =
-                    someConstituentTypeHasKind(targetType, TypeFlags.StringLike) &&
-                        someConstituentTypeHasKind(widenedType, TypeFlags.StringLike);
-                if (!bothAreStringLike && !(isTypeAssignableTo(targetType, widenedType))) {
+                if (!isTypeAssignableTo(targetType, widenedType)) {
                     checkTypeAssignableTo(exprType, targetType, node, Diagnostics.Neither_type_0_nor_type_1_is_assignable_to_the_other);
                 }
             }
@@ -10723,10 +10746,6 @@ namespace ts {
                 case SyntaxKind.ExclamationEqualsToken:
                 case SyntaxKind.EqualsEqualsEqualsToken:
                 case SyntaxKind.ExclamationEqualsEqualsToken:
-                    // Permit 'number[] | "foo"' to be asserted to 'string'.
-                    if (someConstituentTypeHasKind(leftType, TypeFlags.StringLike) && someConstituentTypeHasKind(rightType, TypeFlags.StringLike)) {
-                        return booleanType;
-                    }
                     if (!isTypeAssignableTo(leftType, rightType) && !isTypeAssignableTo(rightType, leftType)) {
                         reportOperatorError();
                     }
@@ -10866,7 +10885,7 @@ namespace ts {
         }
 
         function checkStringLiteralExpression(node: StringLiteral): Type {
-            const contextualType = getContextualType(node);
+            const contextualType = getLiteralContextualType(node);
             if (contextualType && contextualTypeIsStringLiteralType(contextualType)) {
                 return getStringLiteralTypeForText(node.text);
             }
@@ -13249,7 +13268,6 @@ namespace ts {
             let hasDuplicateDefaultClause = false;
 
             const expressionType = checkExpression(node.expression);
-            const expressionTypeIsStringLike = someConstituentTypeHasKind(expressionType, TypeFlags.StringLike);
             forEach(node.caseBlock.clauses, clause => {
                 // Grammar check for duplicate default clauses, skip if we already report duplicate default clause
                 if (clause.kind === SyntaxKind.DefaultClause && !hasDuplicateDefaultClause) {
@@ -13271,12 +13289,7 @@ namespace ts {
                     // In a 'switch' statement, each 'case' expression must be of a type that is assignable to or from the type of the 'switch' expression.
                     const caseType = checkExpression(caseClause.expression);
 
-                    const expressionTypeIsAssignableToCaseType =
-                        // Permit 'number[] | "foo"' to be asserted to 'string'.
-                        (expressionTypeIsStringLike && someConstituentTypeHasKind(caseType, TypeFlags.StringLike)) ||
-                        isTypeAssignableTo(expressionType, caseType);
-
-                    if (!expressionTypeIsAssignableToCaseType) {
+                    if (!isTypeAssignableTo(expressionType, caseType)) {
                         // 'expressionType is not assignable to caseType', try the reversed check and report errors if it fails
                         checkTypeAssignableTo(caseType, expressionType, caseClause.expression, /*headMessage*/ undefined);
                     }

tests/baselines/reference/TypeGuardWithEnumUnion.types

@@ -14,7 +14,7 @@ function f1(x: Color | string) {
 >typeof x === "number" : boolean
 >typeof x : string
 >x : Color | string
->"number" : string
+>"number" : "number"
 
         var y = x;
 >y : Color
@@ -43,7 +43,7 @@ function f2(x: Color | string | string[]) {
 >typeof x === "object" : boolean
 >typeof x : string
 >x : Color | string | string[]
->"object" : string
+>"object" : "object"
 
         var y = x;
 >y : string[]
@@ -56,7 +56,7 @@ function f2(x: Color | string | string[]) {
 >typeof x === "number" : boolean
 >typeof x : string
 >x : Color | string | string[]
->"number" : string
+>"number" : "number"
 
         var z = x;
 >z : Color
@@ -78,7 +78,7 @@ function f2(x: Color | string | string[]) {
 >typeof x === "string" : boolean
 >typeof x : string
 >x : Color | string | string[]
->"string" : string
+>"string" : "string"
 
         var a = x;
 >a : string

tests/baselines/reference/anonymousClassExpression1.types

@@ -6,5 +6,5 @@ function f() {
 >typeof class {} === "function" : boolean
 >typeof class {} : string
 >class {} : typeof (Anonymous class)
->"function" : string
+>"function" : "function"
 }

tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.types

@@ -23,7 +23,7 @@ class A {
 >v : string
 
                 case "test": use(this);
->"test" : string
+>"test" : "test"
 >use(this) : void
 >use : (a: any) => void
 >this : this

tests/baselines/reference/classDoesNotDependOnBaseTypes.types

@@ -7,7 +7,7 @@ if (typeof x !== "string") {
 >typeof x !== "string" : boolean
 >typeof x : string
 >x : string | StringTreeCollection
->"string" : string
+>"string" : "string"
 
     x[0] = "";
 >x[0] = "" : string

tests/baselines/reference/conditionalOperatorConditionIsBooleanType.types

@@ -122,7 +122,7 @@ typeof "123" == "string" ? exprBoolean1 : exprBoolean2;
 >typeof "123" == "string" : boolean
 >typeof "123" : string
 >"123" : string
->"string" : string
+>"string" : "string"
 >exprBoolean1 : boolean
 >exprBoolean2 : boolean
 
@@ -264,7 +264,7 @@ var resultIsBoolean3 = typeof "123" == "string" ? exprBoolean1 : exprBoolean2;
 >typeof "123" == "string" : boolean
 >typeof "123" : string
 >"123" : string
->"string" : string
+>"string" : "string"
 >exprBoolean1 : boolean
 >exprBoolean2 : boolean
 
@@ -301,7 +301,7 @@ var resultIsStringOrBoolean4 = typeof "123" === "string" ? exprString1 : exprBoo
 >typeof "123" === "string" : boolean
 >typeof "123" : string
 >"123" : string
->"string" : string
+>"string" : "string"
 >exprString1 : string
 >exprBoolean1 : boolean
 

tests/baselines/reference/declFileTypeAnnotationStringLiteral.types

@@ -19,7 +19,7 @@ function foo(a: string): string | number {
     if (a === "hello") {
 >a === "hello" : boolean
 >a : string
->"hello" : string
+>"hello" : "hello"
 
         return a.length;
 >a.length : number

tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.types

@@ -31,7 +31,7 @@ class Wat {
 >() => test == 'abc' : () => boolean
 >test == 'abc' : boolean
 >test : string
->'abc' : string
+>'abc' : "abc"
 
     static whatever() {
 >whatever : () => void

tests/baselines/reference/es3defaultAliasIsQuoted.types

@@ -33,5 +33,5 @@ assert(Foo.CONSTANT === "Foo");
 >Foo.CONSTANT : string
 >Foo : typeof Foo
 >CONSTANT : string
->"Foo" : string
+>"Foo" : "Foo"
 

tests/baselines/reference/interfaceDoesNotDependOnBaseTypes.types

@@ -7,7 +7,7 @@ if (typeof x !== "string") {
 >typeof x !== "string" : boolean
 >typeof x : string
 >x : string | StringTreeArray
->"string" : string
+>"string" : "string"
 
     x.push("");
 >x.push("") : number

tests/baselines/reference/objectLiteralArraySpecialization.types

@@ -52,5 +52,5 @@ thing.doSomething((x, y) => x.name === "bob"); // should not error
 >x.name : string
 >x : { name: string; id: number; }
 >name : string
->"bob" : string
+>"bob" : "bob"
 

tests/baselines/reference/overloadResolutionOverNonCTLambdas.types

@@ -36,7 +36,7 @@ module Bugs {
 >args[index] : any
 >args : any[]
 >index : any
->'undefined' : string
+>'undefined' : "undefined"
 
         ? args[index]
 >args[index] : any

tests/baselines/reference/overloadReturnTypes.types

@@ -28,7 +28,7 @@ function attr(nameOrMap: any, value?: string): any {
 >typeof nameOrMap === "object" : boolean
 >typeof nameOrMap : string
 >nameOrMap : any
->"object" : string
+>"object" : "object"
 
         // handle map case
         return new Accessor;

tests/baselines/reference/stringLiteralCheckedInIf01.types

@@ -16,15 +16,15 @@ function f(foo: T) {
     if (foo === "a") {
 >foo === "a" : boolean
 >foo : ("a" | "b")[] | "a" | "b"
->"a" : string
+>"a" : "a"
 
         return foo;
 >foo : ("a" | "b")[] | "a" | "b"
     }
     else if (foo === "b") {
 >foo === "b" : boolean
 >foo : ("a" | "b")[] | "a" | "b"
->"b" : string
+>"b" : "b"
 
         return foo;
 >foo : ("a" | "b")[] | "a" | "b"

tests/baselines/reference/stringLiteralCheckedInIf02.types

@@ -19,10 +19,10 @@ function isS(t: T): t is S {
 >t === "a" || t === "b" : boolean
 >t === "a" : boolean
 >t : ("a" | "b")[] | "a" | "b"
->"a" : string
+>"a" : "a"
 >t === "b" : boolean
 >t : ("a" | "b")[] | "a" | "b"
->"b" : string
+>"b" : "b"
 }
 
 function f(foo: T) {

tests/baselines/reference/stringLiteralMatchedInSwitch01.types

@@ -16,10 +16,10 @@ switch (foo) {
 >foo : ("a" | "b")[] | "a" | "b"
 
     case "a":
->"a" : string
+>"a" : "a"
 
     case "b":
->"b" : string
+>"b" : "b"
 
         break;
     default: