Apply template string mappings on generic template literal types in a safe way for (Un)Capitalize

Co-authored-by: Devansh Jethmalani <[email protected]>

Author: Andarist

src/compiler/checker.ts

@@ -16720,7 +16720,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     function getStringMappingType(symbol: Symbol, type: Type): Type {
         return type.flags & (TypeFlags.Union | TypeFlags.Never) ? mapType(type, t => getStringMappingType(symbol, t)) :
             type.flags & TypeFlags.StringLiteral ? getStringLiteralType(applyStringMapping(symbol, (type as StringLiteralType).value)) :
-            type.flags & TypeFlags.TemplateLiteral && !isGenericType(type) ? getTemplateLiteralType(...applyTemplateStringMapping(symbol, (type as TemplateLiteralType).texts, (type as TemplateLiteralType).types)) :
+            type.flags & TypeFlags.TemplateLiteral ? applyTemplateStringMapping(symbol, type as TemplateLiteralType) :
             // Mapping<Mapping<T>> === Mapping<T>
             type.flags & TypeFlags.StringMapping && symbol === type.symbol ? type :
             type.flags & (TypeFlags.Any | TypeFlags.String | TypeFlags.StringMapping) || isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) :
@@ -16739,14 +16739,23 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return str;
     }
 
-    function applyTemplateStringMapping(symbol: Symbol, texts: readonly string[], types: readonly Type[]): [texts: readonly string[], types: readonly Type[]] {
+    function applyTemplateStringMapping(symbol: Symbol, type: TemplateLiteralType): Type {
+        const { texts, types } = type;
         switch (intrinsicTypeKinds.get(symbol.escapedName as string)) {
-            case IntrinsicTypeKind.Uppercase: return [texts.map(t => t.toUpperCase()), types.map(t => getStringMappingType(symbol, t))];
-            case IntrinsicTypeKind.Lowercase: return [texts.map(t => t.toLowerCase()), types.map(t => getStringMappingType(symbol, t))];
-            case IntrinsicTypeKind.Capitalize: return [texts[0] === "" ? texts : [texts[0].charAt(0).toUpperCase() + texts[0].slice(1), ...texts.slice(1)], texts[0] === "" ? [getStringMappingType(symbol, types[0]), ...types.slice(1)] : types];
-            case IntrinsicTypeKind.Uncapitalize: return [texts[0] === "" ? texts : [texts[0].charAt(0).toLowerCase() + texts[0].slice(1), ...texts.slice(1)], texts[0] === "" ? [getStringMappingType(symbol, types[0]), ...types.slice(1)] : types];
+            case IntrinsicTypeKind.Uppercase: return getTemplateLiteralType(texts.map(t => t.toUpperCase()), types.map(t => getStringMappingType(symbol, t)));
+            case IntrinsicTypeKind.Lowercase: return getTemplateLiteralType(texts.map(t => t.toLowerCase()), types.map(t => getStringMappingType(symbol, t)));
+            case IntrinsicTypeKind.Capitalize:
+            case IntrinsicTypeKind.Uncapitalize:
+                return texts[0] === "" && types.length
+                    ? types.length === 1 && texts[1] === ""
+                        ? getStringMappingType(symbol, types[0])
+                        : getStringMappingTypeForGenericType(symbol, type)
+                    : getTemplateLiteralType(
+                        [applyStringMapping(symbol, texts[0]), ...texts.slice(1)],
+                        types
+                    );
         }
-        return [texts, types];
+        return getTemplateLiteralType(texts, types);
     }
 
     function getStringMappingTypeForGenericType(symbol: Symbol, type: Type): Type {

tests/baselines/reference/intrinsicTypes.types

@@ -72,13 +72,13 @@ type TN6 = Uncapitalize<42>;  // Error
 >TN6 : 42
 
 type TX1<S extends string> = Uppercase<`aB${S}`>;
->TX1 : Uppercase<`aB${S}`>
+>TX1 : `AB${Uppercase<S>}`
 
 type TX2 = TX1<'xYz'>;  // "ABXYZ"
 >TX2 : "ABXYZ"
 
 type TX3<S extends string> = Lowercase<`aB${S}`>;
->TX3 : Lowercase<`aB${S}`>
+>TX3 : `ab${Lowercase<S>}`
 
 type TX4 = TX3<'xYz'>;  // "abxyz"
 >TX4 : "abxyz"

tests/baselines/reference/numericStringLiteralTypes.types

@@ -12,7 +12,7 @@ type T3<T extends string> = string & `${T}`;  // `${T}
 >T3 : `${T}`
 
 type T4<T extends string> = string & `${Capitalize<`${T}`>}`;  // `${Capitalize<T>}`
->T4 : `${Capitalize<`${T}`>}`
+>T4 : `${Capitalize<T>}`
 
 function f1(a: boolean[], x: `${number}`) {
 >f1 : (a: boolean[], x: `${number}`) => void

tests/baselines/reference/templateLiteralTypes3.types

@@ -568,8 +568,8 @@ function ft1<T extends string>(t: T, u: Uppercase<T>, u1: Uppercase<`1.${T}.3`>,
 >ft1 : <T extends string>(t: T, u: Uppercase<T>, u1: Uppercase<`1.${T}.3`>, u2: Uppercase<`1.${T}.4`>) => void
 >t : T
 >u : Uppercase<T>
->u1 : Uppercase<`1.${T}.3`>
->u2 : Uppercase<`1.${T}.4`>
+>u1 : `1.${Uppercase<T>}.3`
+>u2 : `1.${Uppercase<T>}.4`
 
     spread(`1.${t}.3`, `1.${t}.4`);
 >spread(`1.${t}.3`, `1.${t}.4`) : `1.${T}.3` | `1.${T}.4`
@@ -588,9 +588,9 @@ function ft1<T extends string>(t: T, u: Uppercase<T>, u1: Uppercase<`1.${T}.3`>,
 >u : Uppercase<T>
 
     spread(u1, u2);
->spread(u1, u2) : Uppercase<`1.${T}.3`> | Uppercase<`1.${T}.4`>
+>spread(u1, u2) : `1.${Uppercase<T>}.3` | `1.${Uppercase<T>}.4`
 >spread : <P extends `${string}.${string}.${string}`>(...args: P[]) => P
->u1 : Uppercase<`1.${T}.3`>
->u2 : Uppercase<`1.${T}.4`>
+>u1 : `1.${Uppercase<T>}.3`
+>u2 : `1.${Uppercase<T>}.4`
 }