Bump the InferencePriority.EmptyLiteral

Author: Andarist

src/compiler/types.ts

@@ -6817,9 +6817,9 @@ export const enum InferencePriority {
     PartialHomomorphicMappedType = 1 << 4,  // Partial reverse inference for homomorphic mapped type
     MappedTypeConstraint         = 1 << 5,  // Reverse inference for mapped type
     ContravariantConditional     = 1 << 6,  // Conditional type in contravariant position
-    ReturnType                   = 1 << 7,  // Inference made from return type of generic function
-    LiteralKeyof                 = 1 << 8,  // Inference made from a string literal to a keyof T
-    EmptyLiteral                 = 1 << 9,  // Inference made from an empty literal type
+    EmptyLiteral                 = 1 << 7,  // Inference made from an empty literal type
+    ReturnType                   = 1 << 8,  // Inference made from return type of generic function
+    LiteralKeyof                 = 1 << 9,  // Inference made from a string literal to a keyof T
     NoConstraints                = 1 << 10, // Don't infer from constraints of instantiable types
     AlwaysStrict                 = 1 << 11, // Always use strict rules for contravariant inferences
     MaxValue                     = 1 << 12, // Seed for inference priority tracking

tests/baselines/reference/api/typescript.d.ts

@@ -7360,13 +7360,13 @@ declare namespace ts {
         PartialHomomorphicMappedType = 16,
         MappedTypeConstraint = 32,
         ContravariantConditional = 64,
-        ReturnType = 128,
-        LiteralKeyof = 256,
-        EmptyLiteral = 512,
+        EmptyLiteral = 128,
+        ReturnType = 256,
+        LiteralKeyof = 512,
         NoConstraints = 1024,
         AlwaysStrict = 2048,
         MaxValue = 4096,
-        PriorityImpliesCombination = 416,
+        PriorityImpliesCombination = 800,
         Circularity = -1,
     }
     interface FileExtensionInfo {

tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.types

@@ -47,7 +47,7 @@ function fn2() { return undefined; }
 
 var d1: Date = fn2 `${ 0 }${ undefined }`; // contextually typed
 >d1 : Date
->fn2 `${ 0 }${ undefined }` : Date
+>fn2 `${ 0 }${ undefined }` : any
 >fn2 : { (strs: TemplateStringsArray, s: string, n: number): number; <T>(strs: TemplateStringsArray, n: number, t: T): T; }
 >`${ 0 }${ undefined }` : string
 >0 : 0

tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.types

@@ -47,7 +47,7 @@ function fn2() { return undefined; }
 
 var d1: Date = fn2 `${ 0 }${ undefined }`; // contextually typed
 >d1 : Date
->fn2 `${ 0 }${ undefined }` : Date
+>fn2 `${ 0 }${ undefined }` : any
 >fn2 : { (strs: TemplateStringsArray, s: string, n: number): number; <T>(strs: TemplateStringsArray, n: number, t: T): T; }
 >`${ 0 }${ undefined }` : string
 >0 : 0

tests/baselines/reference/tupleTypes.types

@@ -155,9 +155,9 @@ var tt2: number | string;
 >tt2 : undefined
 
 tt = tuple2(1, undefined);
->tt = tuple2(1, undefined) : [number, string]
+>tt = tuple2(1, undefined) : [number, any]
 >tt : [number, string]
->tuple2(1, undefined) : [number, string]
+>tuple2(1, undefined) : [number, any]
 >tuple2 : <T0, T1>(item0: T0, item1: T1) => [T0, T1]
 >1 : 1
 >undefined : undefined

tests/baselines/reference/widenToAny1.errors.txt

@@ -1,12 +1,11 @@
-widenToAny1.ts(4,39): error TS2322: Type 'string' is not assignable to type 'number'.
+widenToAny1.ts(4,5): error TS2322: Type 'string' is not assignable to type 'number'.
 
 
 ==== widenToAny1.ts (1 errors) ====
     function foo1<T>(f1: { x: T; y: T }): T {
         return undefined;
     }
     var z1: number = foo1({ x: undefined, y: "def" });  // Best common type is any
-                                          ~
+        ~~
 !!! error TS2322: Type 'string' is not assignable to type 'number'.
-!!! related TS6500 widenToAny1.ts:1:30: The expected type comes from property 'y' which is declared here on type '{ x: number; y: number; }'
 

tests/baselines/reference/widenToAny1.types

@@ -12,7 +12,7 @@ function foo1<T>(f1: { x: T; y: T }): T {
 }
 var z1: number = foo1({ x: undefined, y: "def" });  // Best common type is any
 >z1 : number
->foo1({ x: undefined, y: "def" }) : number
+>foo1({ x: undefined, y: "def" }) : string
 >foo1 : <T>(f1: { x: T; y: T; }) => T
 >{ x: undefined, y: "def" } : { x: undefined; y: string; }
 >x : undefined