Infer string literals at comparison locations

src/compiler/checker.ts

@@ -7337,11 +7337,13 @@ namespace ts {
         function getContextualTypeForBinaryOperand(node: Expression): 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 ||
@@ -7352,6 +7354,7 @@ namespace ts {
                 }
                 return type;
             }
+
             return undefined;
         }
 
@@ -7509,6 +7512,7 @@ namespace ts {
          * @returns the contextual type of an expression.
          */
         function getContextualType(node: Expression): Type {
+
             if (isInsideWithStatementBody(node)) {
                 // We cannot answer semantic questions within a with block, do not proceed any further
                 return undefined;
@@ -7555,6 +7559,62 @@ namespace ts {
             return undefined;
         }
 
+        function shouldAcquireLiteralType(literalNode: StringLiteral) {
+
+            let current: Node = literalNode;
+            while (true) {
+                const { parent } = current;
+                switch (parent.kind) {
+                    // The operand of a 'switch' should get a literal type.
+                    case SyntaxKind.SwitchStatement:
+                        return current === (parent as SwitchStatement).expression;
+
+                    // The tested expression of a 'case' clause should get a literal type.
+                    case SyntaxKind.CaseClause:
+                        return current === (parent as CaseClause).expression;
+
+                    case SyntaxKind.BinaryExpression:
+                        const binaryExpr = parent as BinaryExpression;
+                        switch (binaryExpr.operatorToken.kind) {
+                            // Either operand of an equality/inequality comparison
+                            // should get a literal type.
+                            case SyntaxKind.EqualsEqualsEqualsToken:
+                            case SyntaxKind.ExclamationEqualsEqualsToken:
+                            case SyntaxKind.EqualsEqualsToken:
+                            case SyntaxKind.ExclamationEqualsToken:
+                                return current === binaryExpr.left || current === binaryExpr.right;
+
+                            case SyntaxKind.BarBarToken:
+                                current = parent;
+                                continue;
+
+                        }
+                        break;
+
+                    case SyntaxKind.ConditionalExpression:
+                    case SyntaxKind.ParenthesizedExpression:
+                        current = parent;
+                        continue;
+                }
+
+                // This is not a node we can account for.
+                // Let contextual typing take over.
+                break;
+            }
+
+            // We haven't found a "literal match location" (i.e. a location that signals
+            // a literal should get a literal type). Check whether the contextual type
+            // has a literal type in it.
+            //
+            // We could perform our walk, check if 'current' is an expression when we get to a
+            // a node that isn't a match location, and then get the contextual type of that.
+            // That would save a few steps but the checks in 'isExpression' seem so involved
+            // that it would probably be better to simply grab the contextual type if we didn't.
+            const contextualType = getContextualType(literalNode);
+            return !!contextualType && contextualTypeIsStringLiteralType(contextualType);
+        }
+
+
         // If the given type is an object or union type, if that type has a single signature, and if
         // that signature is non-generic, return the signature. Otherwise return undefined.
         function getNonGenericSignature(type: Type): Signature {
@@ -9869,11 +9929,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 +10779,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,8 +10918,7 @@ namespace ts {
         }
 
         function checkStringLiteralExpression(node: StringLiteral): Type {
-            const contextualType = getContextualType(node);
-            if (contextualType && contextualTypeIsStringLiteralType(contextualType)) {
+            if (shouldAcquireLiteralType(node)) {
                 return getStringLiteralTypeForText(node.text);
             }
 
@@ -13249,7 +13300,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 +13321,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:

tests/baselines/reference/stringLiteralTypeAssertion01.errors.txt

@@ -0,0 +1,55 @@
+tests/cases/conformance/types/stringLiteral/stringLiteralTypeAssertion01.ts(22,5): error TS2352: Neither type 'string' nor type '("a" | "b")[] | "a" | "b"' is assignable to the other.
+  Type 'string' is not assignable to type '"b"'.
+tests/cases/conformance/types/stringLiteral/stringLiteralTypeAssertion01.ts(23,5): error TS2352: Neither type 'string' nor type '("a" | "b")[] | "a" | "b"' is assignable to the other.
+  Type 'string' is not assignable to type '"b"'.
+tests/cases/conformance/types/stringLiteral/stringLiteralTypeAssertion01.ts(30,7): error TS2352: Neither type '("a" | "b")[] | "a" | "b"' nor type 'string' is assignable to the other.
+  Type '("a" | "b")[]' is not assignable to type 'string'.
+tests/cases/conformance/types/stringLiteral/stringLiteralTypeAssertion01.ts(31,7): error TS2352: Neither type '("a" | "b")[] | "a" | "b"' nor type 'string' is assignable to the other.
+  Type '("a" | "b")[]' is not assignable to type 'string'.
+
+
+==== tests/cases/conformance/types/stringLiteral/stringLiteralTypeAssertion01.ts (4 errors) ====
+
+    type S = "a" | "b";
+    type T = S[] | S;
+
+    var s: S;
+    var t: T;
+    var str: string;
+
+    ////////////////
+
+    s = <S>t;
+    s = t as S;
+
+    s = <S>str;
+    s = str as S;
+
+    ////////////////
+
+    t = <T>s;
+    t = s as T;
+
+    t = <T>str;
+        ~~~~~~
+!!! error TS2352: Neither type 'string' nor type '("a" | "b")[] | "a" | "b"' is assignable to the other.
+!!! error TS2352:   Type 'string' is not assignable to type '"b"'.
+    t = str as T;
+        ~~~~~~~~
+!!! error TS2352: Neither type 'string' nor type '("a" | "b")[] | "a" | "b"' is assignable to the other.
+!!! error TS2352:   Type 'string' is not assignable to type '"b"'.
+
+    ////////////////
+
+    str = <string>s;
+    str = s as string;
+
+    str = <string>t;
+          ~~~~~~~~~
+!!! error TS2352: Neither type '("a" | "b")[] | "a" | "b"' nor type 'string' is assignable to the other.
+!!! error TS2352:   Type '("a" | "b")[]' is not assignable to type 'string'.
+    str = t as string;
+          ~~~~~~~~~~~
+!!! error TS2352: Neither type '("a" | "b")[] | "a" | "b"' nor type 'string' is assignable to the other.
+!!! error TS2352:   Type '("a" | "b")[]' is not assignable to type 'string'.
+