Add inference priority for template type placeholders

Author: rbuckton

src/compiler/checker.ts

@@ -22771,9 +22771,12 @@ namespace ts {
                         }
 
                         if (sourceTypes) {
+                            const savedPriority = priority;
+                            priority |= InferencePriority.TemplateLiteralPlaceholder;
                             for (const source of sourceTypes) {
                                 inferFromTypes(source, target);
                             }
+                            priority = savedPriority;
                         }
                         else {
                             inferFromTypes(source, target);

src/compiler/types.ts

@@ -5858,19 +5858,20 @@ namespace ts {
 
     export const enum InferencePriority {
         NakedTypeVariable            = 1 << 0,  // Naked type variable in union or intersection type
-        SpeculativeTuple             = 1 << 1,  // Speculative tuple inference
-        SubstituteSource             = 1 << 2,  // Source of inference originated within a substitution type's substitute
-        HomomorphicMappedType        = 1 << 3,  // Reverse inference for homomorphic mapped type
-        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
-        NoConstraints                = 1 << 9,  // Don't infer from constraints of instantiable types
-        AlwaysStrict                 = 1 << 10,  // Always use strict rules for contravariant inferences
-        MaxValue                     = 1 << 11, // Seed for inference priority tracking
-
-        PriorityImpliesCombination = ReturnType | MappedTypeConstraint | LiteralKeyof,  // These priorities imply that the resulting type should be a combination of all candidates
+        TemplateLiteralPlaceholder   = 1 << 1,  // Inference to a template literal type placeholder
+        SpeculativeTuple             = 1 << 2,  // Speculative tuple inference
+        SubstituteSource             = 1 << 3,  // Source of inference originated within a substitution type's substitute
+        HomomorphicMappedType        = 1 << 4,  // Reverse inference for homomorphic mapped type
+        PartialHomomorphicMappedType = 1 << 5,  // Partial reverse inference for homomorphic mapped type
+        MappedTypeConstraint         = 1 << 6,  // Reverse inference for mapped type
+        ContravariantConditional     = 1 << 7,  // Conditional type in contravariant position
+        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
+
+        PriorityImpliesCombination = ReturnType | MappedTypeConstraint | LiteralKeyof | TemplateLiteralPlaceholder, // These priorities imply that the resulting type should be a combination of all candidates
         Circularity = -1,  // Inference circularity (value less than all other priorities)
     }
 

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

@@ -2823,18 +2823,19 @@ declare namespace ts {
     }
     export enum InferencePriority {
         NakedTypeVariable = 1,
-        SpeculativeTuple = 2,
-        SubstituteSource = 4,
-        HomomorphicMappedType = 8,
-        PartialHomomorphicMappedType = 16,
-        MappedTypeConstraint = 32,
-        ContravariantConditional = 64,
-        ReturnType = 128,
-        LiteralKeyof = 256,
-        NoConstraints = 512,
-        AlwaysStrict = 1024,
-        MaxValue = 2048,
-        PriorityImpliesCombination = 416,
+        TemplateLiteralPlaceholder = 2,
+        SpeculativeTuple = 4,
+        SubstituteSource = 8,
+        HomomorphicMappedType = 16,
+        PartialHomomorphicMappedType = 32,
+        MappedTypeConstraint = 64,
+        ContravariantConditional = 128,
+        ReturnType = 256,
+        LiteralKeyof = 512,
+        NoConstraints = 1024,
+        AlwaysStrict = 2048,
+        MaxValue = 4096,
+        PriorityImpliesCombination = 834,
         Circularity = -1
     }
     /** @deprecated Use FileExtensionInfo instead. */

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

@@ -2823,18 +2823,19 @@ declare namespace ts {
     }
     export enum InferencePriority {
         NakedTypeVariable = 1,
-        SpeculativeTuple = 2,
-        SubstituteSource = 4,
-        HomomorphicMappedType = 8,
-        PartialHomomorphicMappedType = 16,
-        MappedTypeConstraint = 32,
-        ContravariantConditional = 64,
-        ReturnType = 128,
-        LiteralKeyof = 256,
-        NoConstraints = 512,
-        AlwaysStrict = 1024,
-        MaxValue = 2048,
-        PriorityImpliesCombination = 416,
+        TemplateLiteralPlaceholder = 2,
+        SpeculativeTuple = 4,
+        SubstituteSource = 8,
+        HomomorphicMappedType = 16,
+        PartialHomomorphicMappedType = 32,
+        MappedTypeConstraint = 64,
+        ContravariantConditional = 128,
+        ReturnType = 256,
+        LiteralKeyof = 512,
+        NoConstraints = 1024,
+        AlwaysStrict = 2048,
+        MaxValue = 4096,
+        PriorityImpliesCombination = 834,
         Circularity = -1
     }
     /** @deprecated Use FileExtensionInfo instead. */

tests/baselines/reference/templateLiteralTypes4.errors.txt

@@ -104,4 +104,14 @@ tests/cases/conformance/types/literal/templateLiteralTypes4.ts(97,12): error TS2
     p.setIndex(2, 3); // error, 2 is not a valid index
                ~
 !!! error TS2345: Argument of type '2' is not assignable to parameter of type '0 | 1'.
+    
+    declare function f1<T extends string | number>(s: `**${T}**`): T;
+    f1("**123**"); // "123" | 123
+    
+    declare function f2<T extends string | bigint>(s: `**${T}**`): T;
+    f2("**123**"); // "123" | 123n
+    
+    declare function f3<T extends string | boolean>(s: `**${T}**`): T;
+    f3("**true**"); // true | "true"
+    f3("**false**"); // false | "false"
 

tests/baselines/reference/templateLiteralTypes4.js

@@ -96,6 +96,16 @@ p.getIndex(2); // error, 2 is not a valid index
 p.setIndex(0, 0); // ok, 0 is a valid index
 p.setIndex(1, 0); // ok, 1 is a valid index
 p.setIndex(2, 3); // error, 2 is not a valid index
+
+declare function f1<T extends string | number>(s: `**${T}**`): T;
+f1("**123**"); // "123" | 123
+
+declare function f2<T extends string | bigint>(s: `**${T}**`): T;
+f2("**123**"); // "123" | 123n
+
+declare function f3<T extends string | boolean>(s: `**${T}**`): T;
+f3("**true**"); // true | "true"
+f3("**false**"); // false | "false"
 
 
 //// [templateLiteralTypes4.js]
@@ -106,6 +116,10 @@ p.getIndex(2); // error, 2 is not a valid index
 p.setIndex(0, 0); // ok, 0 is a valid index
 p.setIndex(1, 0); // ok, 1 is a valid index
 p.setIndex(2, 3); // error, 2 is not a valid index
+f1("**123**"); // "123" | 123
+f2("**123**"); // "123" | 123n
+f3("**true**"); // true | "true"
+f3("**false**"); // false | "false"
 
 
 //// [templateLiteralTypes4.d.ts]
@@ -180,3 +194,6 @@ declare type Point = TypedObject<[
     }
 ]>;
 declare const p: Point;
+declare function f1<T extends string | number>(s: `**${T}**`): T;
+declare function f2<T extends string | bigint>(s: `**${T}**`): T;
+declare function f3<T extends string | boolean>(s: `**${T}**`): T;

tests/baselines/reference/templateLiteralTypes4.symbols

@@ -400,3 +400,36 @@ p.setIndex(2, 3); // error, 2 is not a valid index
 >p : Symbol(p, Decl(templateLiteralTypes4.ts, 89, 13))
 >setIndex : Symbol(TypedObjectMembers.setIndex, Decl(templateLiteralTypes4.ts, 71, 104))
 
+declare function f1<T extends string | number>(s: `**${T}**`): T;
+>f1 : Symbol(f1, Decl(templateLiteralTypes4.ts, 96, 17))
+>T : Symbol(T, Decl(templateLiteralTypes4.ts, 98, 20))
+>s : Symbol(s, Decl(templateLiteralTypes4.ts, 98, 47))
+>T : Symbol(T, Decl(templateLiteralTypes4.ts, 98, 20))
+>T : Symbol(T, Decl(templateLiteralTypes4.ts, 98, 20))
+
+f1("**123**"); // "123" | 123
+>f1 : Symbol(f1, Decl(templateLiteralTypes4.ts, 96, 17))
+
+declare function f2<T extends string | bigint>(s: `**${T}**`): T;
+>f2 : Symbol(f2, Decl(templateLiteralTypes4.ts, 99, 14))
+>T : Symbol(T, Decl(templateLiteralTypes4.ts, 101, 20))
+>s : Symbol(s, Decl(templateLiteralTypes4.ts, 101, 47))
+>T : Symbol(T, Decl(templateLiteralTypes4.ts, 101, 20))
+>T : Symbol(T, Decl(templateLiteralTypes4.ts, 101, 20))
+
+f2("**123**"); // "123" | 123n
+>f2 : Symbol(f2, Decl(templateLiteralTypes4.ts, 99, 14))
+
+declare function f3<T extends string | boolean>(s: `**${T}**`): T;
+>f3 : Symbol(f3, Decl(templateLiteralTypes4.ts, 102, 14))
+>T : Symbol(T, Decl(templateLiteralTypes4.ts, 104, 20))
+>s : Symbol(s, Decl(templateLiteralTypes4.ts, 104, 48))
+>T : Symbol(T, Decl(templateLiteralTypes4.ts, 104, 20))
+>T : Symbol(T, Decl(templateLiteralTypes4.ts, 104, 20))
+
+f3("**true**"); // true | "true"
+>f3 : Symbol(f3, Decl(templateLiteralTypes4.ts, 102, 14))
+
+f3("**false**"); // false | "false"
+>f3 : Symbol(f3, Decl(templateLiteralTypes4.ts, 102, 14))
+

tests/baselines/reference/templateLiteralTypes4.types

@@ -242,3 +242,35 @@ p.setIndex(2, 3); // error, 2 is not a valid index
 >2 : 2
 >3 : 3
 
+declare function f1<T extends string | number>(s: `**${T}**`): T;
+>f1 : <T extends string | number>(s: `**${T}**`) => T
+>s : `**${T}**`
+
+f1("**123**"); // "123" | 123
+>f1("**123**") : "123" | 123
+>f1 : <T extends string | number>(s: `**${T}**`) => T
+>"**123**" : "**123**"
+
+declare function f2<T extends string | bigint>(s: `**${T}**`): T;
+>f2 : <T extends string | bigint>(s: `**${T}**`) => T
+>s : `**${T}**`
+
+f2("**123**"); // "123" | 123n
+>f2("**123**") : "123" | 123n
+>f2 : <T extends string | bigint>(s: `**${T}**`) => T
+>"**123**" : "**123**"
+
+declare function f3<T extends string | boolean>(s: `**${T}**`): T;
+>f3 : <T extends string | boolean>(s: `**${T}**`) => T
+>s : `**${T}**`
+
+f3("**true**"); // true | "true"
+>f3("**true**") : true | "true"
+>f3 : <T extends string | boolean>(s: `**${T}**`) => T
+>"**true**" : "**true**"
+
+f3("**false**"); // false | "false"
+>f3("**false**") : false | "false"
+>f3 : <T extends string | boolean>(s: `**${T}**`) => T
+>"**false**" : "**false**"
+

tests/cases/conformance/types/literal/templateLiteralTypes4.ts

@@ -98,3 +98,13 @@ p.getIndex(2); // error, 2 is not a valid index
 p.setIndex(0, 0); // ok, 0 is a valid index
 p.setIndex(1, 0); // ok, 1 is a valid index
 p.setIndex(2, 3); // error, 2 is not a valid index
+
+declare function f1<T extends string | number>(s: `**${T}**`): T;
+f1("**123**"); // "123" | 123
+
+declare function f2<T extends string | bigint>(s: `**${T}**`): T;
+f2("**123**"); // "123" | 123n
+
+declare function f3<T extends string | boolean>(s: `**${T}**`): T;
+f3("**true**"); // true | "true"
+f3("**false**"); // false | "false"