Revert PR 48044

Author: jakebailey

src/compiler/checker.ts

@@ -16971,6 +16971,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     }
 
     function getTemplateLiteralType(texts: readonly string[], types: readonly Type[]): Type {
+        // TODO(jakebailey): filter out intersections here?
         const unionIndex = findIndex(types, t => !!(t.flags & (TypeFlags.Never | TypeFlags.Union)));
         if (unionIndex >= 0) {
             return checkCrossProductUnion(types) ?
@@ -17006,32 +17007,24 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
         return type;
 
-        function addSpans(texts: readonly string[] | string, types: readonly Type[]): boolean {
-            const isTextsArray = isArray(texts);
+        function addSpans(texts: readonly string[], types: readonly Type[]): boolean {
             for (let i = 0; i < types.length; i++) {
                 const t = types[i];
-                const addText = isTextsArray ? texts[i + 1] : texts;
                 if (t.flags & (TypeFlags.Literal | TypeFlags.Null | TypeFlags.Undefined)) {
                     text += getTemplateStringForType(t) || "";
-                    text += addText;
-                    if (!isTextsArray) return true;
+                    text += texts[i + 1];
                 }
                 else if (t.flags & TypeFlags.TemplateLiteral) {
                     text += (t as TemplateLiteralType).texts[0];
                     if (!addSpans((t as TemplateLiteralType).texts, (t as TemplateLiteralType).types)) return false;
-                    text += addText;
-                    if (!isTextsArray) return true;
+                    text += texts[i + 1];
                 }
                 else if (isGenericIndexType(t) || isPatternLiteralPlaceholderType(t)) {
                     newTypes.push(t);
                     newTexts.push(text);
-                    text = addText;
+                    text = texts[i + 1];
                 }
-                else if (t.flags & TypeFlags.Intersection) {
-                    const added = addSpans(texts[i + 1], (t as IntersectionType).types);
-                    if (!added) return false;
-                }
-                else if (isTextsArray) {
+                else {
                     return false;
                 }
             }

tests/baselines/reference/deeplyNestedTemplateLiteralIntersection.errors.txt

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

tests/baselines/reference/templateLiteralIntersection.types

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