Properly check types in template literal placeholders (microsoft#40498)

* Properly check types in template literal placeholders

* Add regression test

* Update test

* Accept new baselines

Author: ahejlsberg

src/compiler/checker.ts

@@ -31548,16 +31548,16 @@ namespace ts {
             registerForUnusedIdentifiersCheck(node);
         }
 
-        function checkTemplateType(node: TemplateLiteralTypeNode) {
-            forEachChild(node, checkSourceElement);
-            getTypeFromTypeNode(node);
+        function checkTemplateLiteralType(node: TemplateLiteralTypeNode) {
             for (const span of node.templateSpans) {
+                checkSourceElement(span.type);
                 const type = getTypeFromTypeNode(span.type);
                 checkTypeAssignableTo(type, templateConstraintType, span.type);
                 if (!everyType(type, t => !!(t.flags & TypeFlags.Literal) || isGenericIndexType(t))) {
                     error(span.type, Diagnostics.Template_literal_type_argument_0_is_not_literal_type_or_a_generic_type, typeToString(type));
                 }
             }
+            getTypeFromTypeNode(node);
         }
 
         function checkImportType(node: ImportTypeNode) {
@@ -36198,7 +36198,7 @@ namespace ts {
                 case SyntaxKind.InferType:
                     return checkInferType(<InferTypeNode>node);
                 case SyntaxKind.TemplateLiteralType:
-                    return checkTemplateType(<TemplateLiteralTypeNode>node);
+                    return checkTemplateLiteralType(<TemplateLiteralTypeNode>node);
                 case SyntaxKind.ImportType:
                     return checkImportType(<ImportTypeNode>node);
                 case SyntaxKind.NamedTupleMember:

tests/baselines/reference/templateLiteralTypes1.errors.txt

@@ -4,12 +4,13 @@ tests/cases/conformance/types/literal/templateLiteralTypes1.ts(39,5): error TS23
     'A' is assignable to the constraint of type 'B', but 'B' could be instantiated with a different subtype of constraint 'string'.
       Type 'string' is not assignable to type 'B'.
         'string' is assignable to the constraint of type 'B', but 'B' could be instantiated with a different subtype of constraint 'string'.
-tests/cases/conformance/types/literal/templateLiteralTypes1.ts(184,16): error TS2590: Expression produces a union type that is too complex to represent.
+tests/cases/conformance/types/literal/templateLiteralTypes1.ts(165,15): error TS1338: 'infer' declarations are only permitted in the 'extends' clause of a conditional type.
 tests/cases/conformance/types/literal/templateLiteralTypes1.ts(188,16): error TS2590: Expression produces a union type that is too complex to represent.
 tests/cases/conformance/types/literal/templateLiteralTypes1.ts(192,16): error TS2590: Expression produces a union type that is too complex to represent.
+tests/cases/conformance/types/literal/templateLiteralTypes1.ts(196,16): error TS2590: Expression produces a union type that is too complex to represent.
 
 
-==== tests/cases/conformance/types/literal/templateLiteralTypes1.ts (5 errors) ====
+==== tests/cases/conformance/types/literal/templateLiteralTypes1.ts (6 errors) ====
     // Template types example from #12754
 
     const createScopedActionType = <S extends string>(scope: S) => <T extends string>(type: T) => `${scope}/${type}` as `${S}/${T}`;
@@ -61,10 +62,10 @@ tests/cases/conformance/types/literal/templateLiteralTypes1.ts(192,16): error TS
 
     // String transformations using recursive conditional types
 
-    type Join<T extends (string | number | boolean | bigint)[], D extends string> =
+    type Join<T extends unknown[], D extends string> =
         T extends [] ? '' :
-        T extends [unknown] ? `${T[0]}` :
-        T extends [unknown, ...infer U] ? `${T[0]}${D}${Join<U, D>}` :
+        T extends [string | number | boolean | bigint] ? `${T[0]}` :
+        T extends [string | number | boolean | bigint, ...infer U] ? `${T[0]}${D}${Join<U, D>}` :
         string;
 
     type TJ1 = Join<[1, 2, 3, 4], '.'>
@@ -180,6 +181,12 @@ tests/cases/conformance/types/literal/templateLiteralTypes1.ts(192,16): error TS
     type S1<T> = T extends `foo${infer U}bar` ? S2<U> : never;
     type S2<S extends string> = S;
 
+    // Check that infer T declarations are validated
+    
+    type TV1 = `${infer X}`;
+                  ~~~~~~~
+!!! error TS1338: 'infer' declarations are only permitted in the 'extends' clause of a conditional type.
+    
     // Batched single character inferences for lower recursion depth
 
     type Chars<S extends string> =

tests/baselines/reference/templateLiteralTypes1.js

@@ -42,10 +42,10 @@ function fa2<T, U extends T, A extends string, B extends A>(x: { [P in B as `p_$
 
 // String transformations using recursive conditional types
 
-type Join<T extends (string | number | boolean | bigint)[], D extends string> =
+type Join<T extends unknown[], D extends string> =
     T extends [] ? '' :
-    T extends [unknown] ? `${T[0]}` :
-    T extends [unknown, ...infer U] ? `${T[0]}${D}${Join<U, D>}` :
+    T extends [string | number | boolean | bigint] ? `${T[0]}` :
+    T extends [string | number | boolean | bigint, ...infer U] ? `${T[0]}${D}${Join<U, D>}` :
     string;
 
 type TJ1 = Join<[1, 2, 3, 4], '.'>
@@ -161,6 +161,10 @@ getPropValue(obj, s);  // unknown
 type S1<T> = T extends `foo${infer U}bar` ? S2<U> : never;
 type S2<S extends string> = S;
 
+// Check that infer T declarations are validated
+
+type TV1 = `${infer X}`;
+
 // Batched single character inferences for lower recursion depth
 
 type Chars<S extends string> =
@@ -246,7 +250,7 @@ declare function fa2<T, U extends T, A extends string, B extends A>(x: {
 }, y: {
     [Q in A as `p_${Q}`]: U;
 }): void;
-declare type Join<T extends (string | number | boolean | bigint)[], D extends string> = T extends [] ? '' : T extends [unknown] ? `${T[0]}` : T extends [unknown, ...infer U] ? `${T[0]}${D}${Join<U, D>}` : string;
+declare type Join<T extends unknown[], D extends string> = T extends [] ? '' : T extends [string | number | boolean | bigint] ? `${T[0]}` : T extends [string | number | boolean | bigint, ...infer U] ? `${T[0]}${D}${Join<U, D>}` : string;
 declare type TJ1 = Join<[1, 2, 3, 4], '.'>;
 declare type TJ2 = Join<['foo', 'bar', 'baz'], '-'>;
 declare type TJ3 = Join<[], '.'>;
@@ -322,6 +326,7 @@ declare const obj: {
 };
 declare type S1<T> = T extends `foo${infer U}bar` ? S2<U> : never;
 declare type S2<S extends string> = S;
+declare type TV1 = `${infer X}`;
 declare type Chars<S extends string> = string extends S ? string[] : S extends `${infer C0}${infer C1}${infer C2}${infer C3}${infer C4}${infer C5}${infer C6}${infer C7}${infer C8}${infer C9}${infer R}` ? [C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, ...Chars<R>] : S extends `${infer C}${infer R}` ? [C, ...Chars<R>] : S extends '' ? [] : never;
 declare type L1 = Chars<'FooBarBazThisIsALongerString'>;
 declare type A = any;