Cherrypick non-comparability related changes from prolific literals PR

Author: weswigham

src/compiler/checker.ts

@@ -4265,9 +4265,10 @@ namespace ts {
             if (strictNullChecks && declaration.initializer && !(getFalsyFlags(checkExpressionCached(declaration.initializer)) & TypeFlags.Undefined)) {
                 type = getTypeWithFacts(type, TypeFacts.NEUndefined);
             }
-            return declaration.initializer ?
+            type = declaration.initializer ?
                 getUnionType([type, checkExpressionCached(declaration.initializer)], /*subtypeReduction*/ true) :
                 type;
+            return shouldUseLiteralType(declaration) ? type : getWidenedLiteralType(type);
         }
 
         function getTypeForDeclarationFromJSDocComment(declaration: Node) {
@@ -17403,6 +17404,7 @@ namespace ts {
             if (isUnitType(type) &&
                 !(contextualSignature &&
                     isLiteralContextualType(
+                        type,
                         contextualSignature === getSignatureFromDeclaration(func) ? type : getReturnTypeOfSignature(contextualSignature)))) {
                 type = getWidenedLiteralType(type);
             }
@@ -18487,24 +18489,27 @@ namespace ts {
 
         function checkDeclarationInitializer(declaration: VariableLikeDeclaration) {
             const type = getTypeOfExpression(declaration.initializer, /*cache*/ true);
+            return shouldUseLiteralType(declaration) ? type : getWidenedLiteralType(type);
+        }
+        function shouldUseLiteralType(declaration: VariableLikeDeclaration) {
             return getCombinedNodeFlags(declaration) & NodeFlags.Const ||
                 getCombinedModifierFlags(declaration) & ModifierFlags.Readonly && !isParameterPropertyDeclaration(declaration) ||
-                isTypeAssertion(declaration.initializer) ? type : getWidenedLiteralType(type);
+                (declaration.initializer && isTypeAssertion(declaration.initializer));
         }
 
-        function isLiteralContextualType(contextualType: Type) {
+        function isLiteralContextualType(candidateLiteral: Type, contextualType: Type): boolean {
             if (contextualType) {
+                if (contextualType.flags & TypeFlags.UnionOrIntersection) {
+                    return some((contextualType as UnionOrIntersectionType).types, t => isLiteralContextualType(candidateLiteral, t));
+                }
                 if (contextualType.flags & TypeFlags.TypeVariable) {
                     const constraint = getBaseConstraintOfType(contextualType) || emptyObjectType;
-                    // If the type parameter is constrained to the base primitive type we're checking for,
-                    // consider this a literal context. For example, given a type parameter 'T extends string',
-                    // this causes us to infer string literal types for T.
-                    if (constraint.flags & (TypeFlags.String | TypeFlags.Number | TypeFlags.Boolean | TypeFlags.Enum)) {
-                        return true;
-                    }
-                    contextualType = constraint;
+                    return isLiteralContextualType(candidateLiteral, constraint);
                 }
-                return maybeTypeOfKind(contextualType, (TypeFlags.Literal | TypeFlags.Index));
+                // No need to `maybeTypeOfKind` on the contextual type, as it can't be a union, _however_, `candidateLiteral` might still be one!
+                return !!(((contextualType.flags & TypeFlags.StringLike) && maybeTypeOfKind(candidateLiteral, TypeFlags.StringLike)) ||
+                    ((contextualType.flags & TypeFlags.NumberLike) && maybeTypeOfKind(candidateLiteral, TypeFlags.NumberLike)) ||
+                    ((contextualType.flags & TypeFlags.BooleanLike) && maybeTypeOfKind(candidateLiteral, TypeFlags.BooleanLike)));
             }
             return false;
         }
@@ -18514,8 +18519,8 @@ namespace ts {
                 contextualType = getContextualType(node);
             }
             const type = checkExpression(node, checkMode);
-            const shouldWiden = isTypeAssertion(node) || isLiteralContextualType(contextualType);
-            return shouldWiden ? type : getWidenedLiteralType(type);
+            const shouldNotWiden = isTypeAssertion(node) || isLiteralContextualType(type, contextualType);
+            return shouldNotWiden ? type : getWidenedLiteralType(type);
         }
 
         function checkPropertyAssignment(node: PropertyAssignment, checkMode?: CheckMode): Type {

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.types

@@ -9,7 +9,7 @@ class Point {
     static Origin(): Point { return { x: 0, y: 0 }; } // unexpected error here bug 840246
 >Origin : () => Point
 >Point : Point
->{ x: 0, y: 0 } : { x: number; y: number; }
+>{ x: 0, y: 0 } : { x: 0; y: 0; }
 >x : number
 >0 : 0
 >y : number
@@ -38,7 +38,7 @@ module A {
         static Origin(): Point { return { x: 0, y: 0 }; } // unexpected error here bug 840246
 >Origin : () => Point
 >Point : Point
->{ x: 0, y: 0 } : { x: number; y: number; }
+>{ x: 0, y: 0 } : { x: 0; y: 0; }
 >x : number
 >0 : 0
 >y : number

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.types

@@ -9,7 +9,7 @@ class Point {
     static Origin(): Point { return { x: 0, y: 0 }; }
 >Origin : () => Point
 >Point : Point
->{ x: 0, y: 0 } : { x: number; y: number; }
+>{ x: 0, y: 0 } : { x: 0; y: 0; }
 >x : number
 >0 : 0
 >y : number
@@ -38,7 +38,7 @@ module A {
         static Origin(): Point { return { x: 0, y: 0 }; }
 >Origin : () => Point
 >Point : Point
->{ x: 0, y: 0 } : { x: number; y: number; }
+>{ x: 0, y: 0 } : { x: 0; y: 0; }
 >x : number
 >0 : 0
 >y : number

tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.types

@@ -9,7 +9,7 @@ class Point {
     static Origin: Point = { x: 0, y: 0 };
 >Origin : Point
 >Point : Point
->{ x: 0, y: 0 } : { x: number; y: number; }
+>{ x: 0, y: 0 } : { x: 0; y: 0; }
 >x : number
 >0 : 0
 >y : number
@@ -38,7 +38,7 @@ module A {
         static Origin: Point = { x: 0, y: 0 };
 >Origin : Point
 >Point : Point
->{ x: 0, y: 0 } : { x: number; y: number; }
+>{ x: 0, y: 0 } : { x: 0; y: 0; }
 >x : number
 >0 : 0
 >y : number

tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.types

@@ -9,7 +9,7 @@ class Point {
     static Origin: Point = { x: 0, y: 0 };
 >Origin : Point
 >Point : Point
->{ x: 0, y: 0 } : { x: number; y: number; }
+>{ x: 0, y: 0 } : { x: 0; y: 0; }
 >x : number
 >0 : 0
 >y : number
@@ -38,7 +38,7 @@ module A {
         static Origin: Point = { x: 0, y: 0 };
 >Origin : Point
 >Point : Point
->{ x: 0, y: 0 } : { x: number; y: number; }
+>{ x: 0, y: 0 } : { x: 0; y: 0; }
 >x : number
 >0 : 0
 >y : number

tests/baselines/reference/ES5For-of30.types

@@ -5,7 +5,7 @@ var a: string, b: number;
 
 var tuple: [number, string] = [2, "3"];
 >tuple : [number, string]
->[2, "3"] : [number, string]
+>[2, "3"] : [2, "3"]
 >2 : 2
 >"3" : "3"
 

tests/baselines/reference/ES5For-ofTypeCheck3.types

@@ -1,7 +1,7 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck3.ts ===
 var tuple: [string, number] = ["", 0];
 >tuple : [string, number]
->["", 0] : [string, number]
+>["", 0] : ["", 0]
 >"" : ""
 >0 : 0
 

tests/baselines/reference/ES5for-of32.types

@@ -20,9 +20,9 @@ for (let num of array) {
 >0 : 0
 
         array = [4,5,6]
->array = [4,5,6] : number[]
+>array = [4,5,6] : (4 | 5 | 6)[]
 >array : number[]
->[4,5,6] : number[]
+>[4,5,6] : (4 | 5 | 6)[]
 >4 : 4
 >5 : 5
 >6 : 6

tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types

@@ -15,7 +15,7 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Point
 >Point : Point
->{ x: 0, y: 0 } : { x: number; y: number; }
+>{ x: 0, y: 0 } : { x: 0; y: 0; }
 >x : number
 >0 : 0
 >y : number
@@ -32,7 +32,7 @@ module A {
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Point3d
 >Point3d : Point3d
->{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
+>{ x: 0, y: 0, z: 0 } : { x: 0; y: 0; z: 0; }
 >x : number
 >0 : 0
 >y : number

tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.types

@@ -15,7 +15,7 @@ module A {
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Point
 >Point : Point
->{ x: 0, y: 0 } : { x: number; y: number; }
+>{ x: 0, y: 0 } : { x: 0; y: 0; }
 >x : number
 >0 : 0
 >y : number
@@ -32,7 +32,7 @@ module A {
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Point3d
 >Point3d : Point3d
->{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
+>{ x: 0, y: 0, z: 0 } : { x: 0; y: 0; z: 0; }
 >x : number
 >0 : 0
 >y : number