Reduce template literal types with a single placeholder and no extra texts

src/compiler/checker.ts

@@ -22051,6 +22051,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     // For example, `foo-${number}` is related to `foo-${string}` even though number isn't related to string.
                     instantiateType(source, reportUnreliableMapper);
                 }
+                if (isTemplateLiteralTypeWithSinglePlaceholderAndNoExtraTexts(target) && isTypeAssignableTo(source, stringType) && isTypeAssignableTo(target.types[0], stringType)) {
+                    return isRelatedTo(source, target.types[0], RecursionFlags.Both, reportErrors);
+                }
                 if (isTypeMatchedByTemplateLiteralType(source, target as TemplateLiteralType)) {
                     return Ternary.True;
                 }
@@ -22094,6 +22097,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             }
             else if (sourceFlags & TypeFlags.TemplateLiteral && !(targetFlags & TypeFlags.Object)) {
                 if (!(targetFlags & TypeFlags.TemplateLiteral)) {
+                    if (isTemplateLiteralTypeWithSinglePlaceholderAndNoExtraTexts(source) && isTypeAssignableTo(source.types[0], stringType) && isTypeAssignableTo(target, stringType)) {
+                        return isRelatedTo(source.types[0], target, RecursionFlags.Both, reportErrors);
+                    }
                     const constraint = getBaseConstraintOfType(source);
                     if (constraint && constraint !== source && (result = isRelatedTo(constraint, target, RecursionFlags.Source, reportErrors))) {
                         return result;
@@ -24701,6 +24707,14 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return false;
     }
 
+    function isTemplateLiteralTypeWithSinglePlaceholderAndNoExtraTexts(type: Type): type is TemplateLiteralType {
+        if (!(type.flags & TypeFlags.TemplateLiteral)) {
+            return false;
+        }
+        const texts = (type as TemplateLiteralType).texts;
+        return texts.length === 2 && texts[0] === "" && texts[1] === "";
+    }
+
     function isValidTypeForTemplateLiteralPlaceholder(source: Type, target: Type): boolean {
         if (source === target || target.flags & (TypeFlags.Any | TypeFlags.String)) {
             return true;
@@ -24716,9 +24730,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 target.flags & TypeFlags.StringMapping && isMemberOfStringMapping(getStringLiteralType(value), target) ||
                 target.flags & TypeFlags.TemplateLiteral && isTypeMatchedByTemplateLiteralType(source, target as TemplateLiteralType));
         }
-        if (source.flags & TypeFlags.TemplateLiteral) {
-            const texts = (source as TemplateLiteralType).texts;
-            return texts.length === 2 && texts[0] === "" && texts[1] === "" && isTypeAssignableTo((source as TemplateLiteralType).types[0], target);
+        if (isTemplateLiteralTypeWithSinglePlaceholderAndNoExtraTexts(source)) {
+            return isTypeAssignableTo(source.types[0], target);
         }
         return isTypeAssignableTo(source, target);
     }

tests/baselines/reference/templateLiteralTypes5.symbols

@@ -0,0 +1,64 @@
+//// [tests/cases/conformance/types/literal/templateLiteralTypes5.ts] ////
+
+=== templateLiteralTypes5.ts ===
+// https://github.com/microsoft/TypeScript/issues/55364
+interface TypeMap {
+>TypeMap : Symbol(TypeMap, Decl(templateLiteralTypes5.ts, 0, 0))
+
+  a: "A";
+>a : Symbol(TypeMap.a, Decl(templateLiteralTypes5.ts, 1, 19))
+
+  b: "B";
+>b : Symbol(TypeMap.b, Decl(templateLiteralTypes5.ts, 2, 9))
+}
+declare const f: <T0 extends "a" | "b">(x: `${T0}`) => TypeMap[T0];
+>f : Symbol(f, Decl(templateLiteralTypes5.ts, 5, 13))
+>T0 : Symbol(T0, Decl(templateLiteralTypes5.ts, 5, 18))
+>x : Symbol(x, Decl(templateLiteralTypes5.ts, 5, 40))
+>T0 : Symbol(T0, Decl(templateLiteralTypes5.ts, 5, 18))
+>TypeMap : Symbol(TypeMap, Decl(templateLiteralTypes5.ts, 0, 0))
+>T0 : Symbol(T0, Decl(templateLiteralTypes5.ts, 5, 18))
+
+type F1 = <T1 extends "a" | "b">(x: `${T1}`) => TypeMap[T1];
+>F1 : Symbol(F1, Decl(templateLiteralTypes5.ts, 5, 67))
+>T1 : Symbol(T1, Decl(templateLiteralTypes5.ts, 6, 11))
+>x : Symbol(x, Decl(templateLiteralTypes5.ts, 6, 33))
+>T1 : Symbol(T1, Decl(templateLiteralTypes5.ts, 6, 11))
+>TypeMap : Symbol(TypeMap, Decl(templateLiteralTypes5.ts, 0, 0))
+>T1 : Symbol(T1, Decl(templateLiteralTypes5.ts, 6, 11))
+
+const f1: F1 = f; 
+>f1 : Symbol(f1, Decl(templateLiteralTypes5.ts, 7, 5))
+>F1 : Symbol(F1, Decl(templateLiteralTypes5.ts, 5, 67))
+>f : Symbol(f, Decl(templateLiteralTypes5.ts, 5, 13))
+
+type F2 = <T2 extends 'a' | 'b'>(x: `${T2}`) => TypeMap[`${T2}`]
+>F2 : Symbol(F2, Decl(templateLiteralTypes5.ts, 7, 17))
+>T2 : Symbol(T2, Decl(templateLiteralTypes5.ts, 8, 11))
+>x : Symbol(x, Decl(templateLiteralTypes5.ts, 8, 33))
+>T2 : Symbol(T2, Decl(templateLiteralTypes5.ts, 8, 11))
+>TypeMap : Symbol(TypeMap, Decl(templateLiteralTypes5.ts, 0, 0))
+>T2 : Symbol(T2, Decl(templateLiteralTypes5.ts, 8, 11))
+
+const f2: F2 = f
+>f2 : Symbol(f2, Decl(templateLiteralTypes5.ts, 9, 5))
+>F2 : Symbol(F2, Decl(templateLiteralTypes5.ts, 7, 17))
+>f : Symbol(f, Decl(templateLiteralTypes5.ts, 5, 13))
+
+function f3<T3 extends "a" | "b">(x: T3) {
+>f3 : Symbol(f3, Decl(templateLiteralTypes5.ts, 9, 16))
+>T3 : Symbol(T3, Decl(templateLiteralTypes5.ts, 11, 12))
+>x : Symbol(x, Decl(templateLiteralTypes5.ts, 11, 34))
+>T3 : Symbol(T3, Decl(templateLiteralTypes5.ts, 11, 12))
+
+    const test1: `${T3}` = x    
+>test1 : Symbol(test1, Decl(templateLiteralTypes5.ts, 12, 9))
+>T3 : Symbol(T3, Decl(templateLiteralTypes5.ts, 11, 12))
+>x : Symbol(x, Decl(templateLiteralTypes5.ts, 11, 34))
+
+    const test2: T3 = "" as `${T3}`;    
+>test2 : Symbol(test2, Decl(templateLiteralTypes5.ts, 13, 9))
+>T3 : Symbol(T3, Decl(templateLiteralTypes5.ts, 11, 12))
+>T3 : Symbol(T3, Decl(templateLiteralTypes5.ts, 11, 12))
+}
+

tests/baselines/reference/templateLiteralTypes5.types

@@ -0,0 +1,45 @@
+//// [tests/cases/conformance/types/literal/templateLiteralTypes5.ts] ////
+
+=== templateLiteralTypes5.ts ===
+// https://github.com/microsoft/TypeScript/issues/55364
+interface TypeMap {
+  a: "A";
+>a : "A"
+
+  b: "B";
+>b : "B"
+}
+declare const f: <T0 extends "a" | "b">(x: `${T0}`) => TypeMap[T0];
+>f : <T0 extends "a" | "b">(x: `${T0}`) => TypeMap[T0]
+>x : `${T0}`
+
+type F1 = <T1 extends "a" | "b">(x: `${T1}`) => TypeMap[T1];
+>F1 : <T1 extends "a" | "b">(x: `${T1}`) => TypeMap[T1]
+>x : `${T1}`
+
+const f1: F1 = f; 
+>f1 : F1
+>f : <T0 extends "a" | "b">(x: `${T0}`) => TypeMap[T0]
+
+type F2 = <T2 extends 'a' | 'b'>(x: `${T2}`) => TypeMap[`${T2}`]
+>F2 : <T2 extends "a" | "b">(x: `${T2}`) => TypeMap[`${T2}`]
+>x : `${T2}`
+
+const f2: F2 = f
+>f2 : F2
+>f : <T0 extends "a" | "b">(x: `${T0}`) => TypeMap[T0]
+
+function f3<T3 extends "a" | "b">(x: T3) {
+>f3 : <T3 extends "a" | "b">(x: T3) => void
+>x : T3
+
+    const test1: `${T3}` = x    
+>test1 : `${T3}`
+>x : T3
+
+    const test2: T3 = "" as `${T3}`;    
+>test2 : T3
+>"" as `${T3}` : `${T3}`
+>"" : ""
+}
+

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

@@ -0,0 +1,19 @@
+// @strict: true
+// @target: esnext
+// @noEmit: true
+
+// https://github.com/microsoft/TypeScript/issues/55364
+interface TypeMap {
+  a: "A";
+  b: "B";
+}
+declare const f: <T0 extends "a" | "b">(x: `${T0}`) => TypeMap[T0];
+type F1 = <T1 extends "a" | "b">(x: `${T1}`) => TypeMap[T1];
+const f1: F1 = f; 
+type F2 = <T2 extends 'a' | 'b'>(x: `${T2}`) => TypeMap[`${T2}`]
+const f2: F2 = f
+
+function f3<T3 extends "a" | "b">(x: T3) {
+    const test1: `${T3}` = x    
+    const test2: T3 = "" as `${T3}`;    
+}