Implement new fix for intersections

Author: jakebailey

src/compiler/checker.ts

@@ -17019,7 +17019,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     if (!addSpans((t as TemplateLiteralType).texts, (t as TemplateLiteralType).types)) return false;
                     text += texts[i + 1];
                 }
-                else if (isGenericIndexType(t) || isPatternLiteralPlaceholderType(t)) {
+                else if (isGenericIndexType(t) || isPatternLiteralPlaceholderType(t) || t.flags & TypeFlags.Intersection) {
                     newTypes.push(t);
                     newTexts.push(text);
                     text = texts[i + 1];

tests/baselines/reference/deeplyNestedTemplateLiteralIntersection.errors.txt

@@ -0,0 +1,29 @@
+tests/cases/compiler/deeplyNestedTemplateLiteralIntersection.ts(20,11): error TS2590: Expression produces a union type that is too complex to represent.
+
+
+==== tests/cases/compiler/deeplyNestedTemplateLiteralIntersection.ts (1 errors) ====
+    type R = `${number}a` & {
+        _thing: true;
+    };
+    
+    type _S = "1" | "2" | "3" | "4" | "5" | "6";
+    
+    type S = `${_S}${_S}${_S}`;
+    
+    
+    type T = R | S;
+    type X = `${T} ${T}`;
+    
+    export type Props = Partial<{
+        x: X;
+    }>;
+    
+    const a1: Props = {};
+    const a2: Props = {};
+    
+    const b = { ...a1, ...a2 };
+              ~~~~~~~~~~~~~~~~
+!!! error TS2590: Expression produces a union type that is too complex to represent.
+    
+    export { b };
+    

tests/baselines/reference/templateLiteralIntersection.types

@@ -16,7 +16,7 @@ type OriginA1 = `${A}`
 >OriginA1 : "a"
 
 type OriginA2 = `${MixA}`
->OriginA2 : string
+>OriginA2 : `${MixA}`
 
 type B = `${typeof a}`
 >B : "a"
@@ -30,14 +30,14 @@ type OriginB1 = `${B}`
 >OriginB1 : "a"
 
 type OriginB2 = `${MixB}`
->OriginB2 : string
+>OriginB2 : `${MixB}`
 
 type MixC = { foo: string } & A
 >MixC : { foo: string; } & "a"
 >foo : string
 
 type OriginC = `${MixC}`
->OriginC : string
+>OriginC : `${MixC}`
 
 type MixD<T extends string> =
 >MixD : `${T & { foo: string; }}`
@@ -46,7 +46,7 @@ type MixD<T extends string> =
 >foo : string
 
 type OriginD = `${MixD<A & { foo: string }> & { foo: string }}`;
->OriginD : string
+>OriginD : `${`${"a" & { foo: string; } & { foo: string; }}` & { foo: string; }}`
 >foo : string
 >foo : string
 

tests/baselines/reference/templateLiteralIntersection2.errors.txt

@@ -1,17 +1,20 @@
+tests/cases/compiler/templateLiteralIntersection2.ts(7,12): error TS2345: Argument of type '"foo/bar"' is not assignable to parameter of type '`${Path}/${Path}`'.
 tests/cases/compiler/templateLiteralIntersection2.ts(20,10): error TS2345: Argument of type '""' is not assignable to parameter of type '`a${string}` & `${string}a`'.
   Type '""' is not assignable to type '`a${string}`'.
 tests/cases/compiler/templateLiteralIntersection2.ts(22,10): error TS2345: Argument of type '"ab"' is not assignable to parameter of type '`a${string}` & `${string}a`'.
   Type '"ab"' is not assignable to type '`${string}a`'.
 
 
-==== tests/cases/compiler/templateLiteralIntersection2.ts (2 errors) ====
+==== tests/cases/compiler/templateLiteralIntersection2.ts (3 errors) ====
     type Path = string & { _pathBrand: any };
 
     type JoinedPath = `${Path}/${Path}`;
 
     declare function joinedPath(p: JoinedPath): void;
 
     joinedPath("foo/bar");
+               ~~~~~~~~~
+!!! error TS2345: Argument of type '"foo/bar"' is not assignable to parameter of type '`${Path}/${Path}`'.
 
     declare const somePath: Path;
 

tests/baselines/reference/templateLiteralIntersection2.types

@@ -4,24 +4,24 @@ type Path = string & { _pathBrand: any };
 >_pathBrand : any
 
 type JoinedPath = `${Path}/${Path}`;
->JoinedPath : string
+>JoinedPath : `${Path}/${Path}`
 
 declare function joinedPath(p: JoinedPath): void;
 >joinedPath : (p: JoinedPath) => void
->p : string
+>p : `${Path}/${Path}`
 
 joinedPath("foo/bar");
 >joinedPath("foo/bar") : void
->joinedPath : (p: string) => void
+>joinedPath : (p: `${Path}/${Path}`) => void
 >"foo/bar" : "foo/bar"
 
 declare const somePath: Path;
 >somePath : Path
 
 joinedPath(`${somePath}/${somePath}`);
 >joinedPath(`${somePath}/${somePath}`) : void
->joinedPath : (p: string) => void
->`${somePath}/${somePath}` : string
+>joinedPath : (p: `${Path}/${Path}`) => void
+>`${somePath}/${somePath}` : `${Path}/${Path}`
 >somePath : Path
 >somePath : Path