-
Notifications
You must be signed in to change notification settings - Fork 13.1k
Revert fix for intersections in template literals, fix differently #52836
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Changes from 10 commits
0c18a81
1dd84d2
8b1f1e5
bb599af
1f07f63
8528a63
8d55d27
0e048db
7d38709
84a7a10
014bf02
026cd53
27ae967
15e3676
File filter
Filter by extension
Conversations
Jump to
Diff view
Diff view
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -17006,32 +17006,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)) { | ||
| else if (isGenericIndexType(t) || isPatternLiteralPlaceholderType(t) || t.flags & TypeFlags.Intersection) { | ||
| 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; | ||
| } | ||
| } | ||
|
|
@@ -17049,13 +17041,15 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { | |
|
|
||
| function createTemplateLiteralType(texts: readonly string[], types: readonly Type[]) { | ||
| const type = createType(TypeFlags.TemplateLiteral) as TemplateLiteralType; | ||
| type.objectFlags = getPropagatingFlagsOfTypes(types, /*excludeKinds*/ TypeFlags.Nullable); | ||
| type.texts = texts; | ||
| type.types = types; | ||
| return type; | ||
| } | ||
|
|
||
| function getStringMappingType(symbol: Symbol, type: Type): Type { | ||
| return type.flags & (TypeFlags.Union | TypeFlags.Never) ? mapType(type, t => getStringMappingType(symbol, t)) : | ||
| type.flags & TypeFlags.Intersection ? getIntersectionType(map((type as IntersectionType).types, t => getStringMappingType(symbol, t))) : | ||
| type.flags & TypeFlags.StringLiteral ? getStringLiteralType(applyStringMapping(symbol, (type as StringLiteralType).value)) : | ||
| type.flags & TypeFlags.TemplateLiteral ? getTemplateLiteralType(...applyTemplateStringMapping(symbol, (type as TemplateLiteralType).texts, (type as TemplateLiteralType).types)) : | ||
| // Mapping<Mapping<T>> === Mapping<T> | ||
|
|
@@ -17380,12 +17374,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { | |
| } | ||
|
|
||
| function getGenericObjectFlags(type: Type): ObjectFlags { | ||
| if (type.flags & TypeFlags.UnionOrIntersection) { | ||
| if (!((type as UnionOrIntersectionType).objectFlags & ObjectFlags.IsGenericTypeComputed)) { | ||
| (type as UnionOrIntersectionType).objectFlags |= ObjectFlags.IsGenericTypeComputed | | ||
| reduceLeft((type as UnionOrIntersectionType).types, (flags, t) => flags | getGenericObjectFlags(t), 0); | ||
| if (type.flags & (TypeFlags.UnionOrIntersection | TypeFlags.TemplateLiteral)) { | ||
jakebailey marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| if (!((type as UnionOrIntersectionType | TemplateLiteralType).objectFlags & ObjectFlags.IsGenericTypeComputed)) { | ||
| (type as UnionOrIntersectionType | TemplateLiteralType).objectFlags |= ObjectFlags.IsGenericTypeComputed | | ||
| reduceLeft((type as UnionOrIntersectionType | TemplateLiteralType).types, (flags, t) => flags | getGenericObjectFlags(t), 0); | ||
| } | ||
| return (type as UnionOrIntersectionType).objectFlags & ObjectFlags.IsGenericType; | ||
| return (type as UnionOrIntersectionType | TemplateLiteralType).objectFlags & ObjectFlags.IsGenericType; | ||
| } | ||
| if (type.flags & TypeFlags.Substitution) { | ||
| if (!((type as SubstitutionType).objectFlags & ObjectFlags.IsGenericTypeComputed)) { | ||
|
|
@@ -17395,7 +17389,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { | |
| return (type as SubstitutionType).objectFlags & ObjectFlags.IsGenericType; | ||
| } | ||
| return (type.flags & TypeFlags.InstantiableNonPrimitive || isGenericMappedType(type) || isGenericTupleType(type) ? ObjectFlags.IsGenericObjectType : 0) | | ||
| (type.flags & (TypeFlags.InstantiableNonPrimitive | TypeFlags.Index | TypeFlags.TemplateLiteral | TypeFlags.StringMapping) && !isPatternLiteralType(type) ? ObjectFlags.IsGenericIndexType : 0); | ||
| (type.flags & (TypeFlags.InstantiableNonPrimitive | TypeFlags.Index | TypeFlags.StringMapping) && !isPatternLiteralType(type) ? ObjectFlags.IsGenericIndexType : 0); | ||
|
Member
Author
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. I feel like StringMapping / isPatternLiteralType could be dropped here, and instead just have |
||
| } | ||
|
|
||
| function getSimplifiedType(type: Type, writing: boolean): Type { | ||
|
|
@@ -23814,7 +23808,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { | |
| objectFlags & ObjectFlags.Reference && ((type as TypeReference).node || forEach(getTypeArguments(type as TypeReference), couldContainTypeVariables)) || | ||
| objectFlags & ObjectFlags.Anonymous && type.symbol && type.symbol.flags & (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral) && type.symbol.declarations || | ||
| objectFlags & (ObjectFlags.Mapped | ObjectFlags.ReverseMapped | ObjectFlags.ObjectRestType | ObjectFlags.InstantiationExpressionType)) || | ||
| type.flags & TypeFlags.UnionOrIntersection && !(type.flags & TypeFlags.EnumLiteral) && !isNonGenericTopLevelType(type) && some((type as UnionOrIntersectionType).types, couldContainTypeVariables)); | ||
| type.flags & (TypeFlags.UnionOrIntersection | TypeFlags.TemplateLiteral) && !(type.flags & TypeFlags.EnumLiteral) && !isNonGenericTopLevelType(type) && some((type as UnionOrIntersectionType | TemplateLiteralType).types, couldContainTypeVariables)); | ||
| if (type.flags & TypeFlags.ObjectFlagsType) { | ||
| (type as ObjectFlagsType).objectFlags |= ObjectFlags.CouldContainTypeVariablesComputed | (result ? ObjectFlags.CouldContainTypeVariables : 0); | ||
| } | ||
|
|
||
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -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 }; | ||
|
|
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,41 @@ | ||
| 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 (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; | ||
|
|
||
| joinedPath(`${somePath}/${somePath}`); | ||
|
|
||
|
|
||
| type StartsWithA = `a${string}`; | ||
| type EndsWithA = `${string}a`; | ||
|
|
||
|
|
||
| declare function withinAs(p: StartsWithA & EndsWithA): void; | ||
|
|
||
| withinAs(""); | ||
| ~~ | ||
| !!! error TS2345: Argument of type '""' is not assignable to parameter of type '`a${string}` & `${string}a`'. | ||
| !!! error TS2345: Type '""' is not assignable to type '`a${string}`'. | ||
| withinAs("a"); | ||
| withinAs("ab"); | ||
| ~~~~ | ||
| !!! error TS2345: Argument of type '"ab"' is not assignable to parameter of type '`a${string}` & `${string}a`'. | ||
| !!! error TS2345: Type '"ab"' is not assignable to type '`${string}a`'. | ||
| withinAs("aba"); | ||
| withinAs("abavvvva"); | ||
|
|
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,56 @@ | ||
| === tests/cases/compiler/templateLiteralIntersection2.ts === | ||
| type Path = string & { _pathBrand: any }; | ||
| >Path : Symbol(Path, Decl(templateLiteralIntersection2.ts, 0, 0)) | ||
| >_pathBrand : Symbol(_pathBrand, Decl(templateLiteralIntersection2.ts, 0, 22)) | ||
|
|
||
| type JoinedPath = `${Path}/${Path}`; | ||
| >JoinedPath : Symbol(JoinedPath, Decl(templateLiteralIntersection2.ts, 0, 41)) | ||
| >Path : Symbol(Path, Decl(templateLiteralIntersection2.ts, 0, 0)) | ||
| >Path : Symbol(Path, Decl(templateLiteralIntersection2.ts, 0, 0)) | ||
|
|
||
| declare function joinedPath(p: JoinedPath): void; | ||
| >joinedPath : Symbol(joinedPath, Decl(templateLiteralIntersection2.ts, 2, 36)) | ||
| >p : Symbol(p, Decl(templateLiteralIntersection2.ts, 4, 28)) | ||
| >JoinedPath : Symbol(JoinedPath, Decl(templateLiteralIntersection2.ts, 0, 41)) | ||
|
|
||
| joinedPath("foo/bar"); | ||
| >joinedPath : Symbol(joinedPath, Decl(templateLiteralIntersection2.ts, 2, 36)) | ||
|
|
||
| declare const somePath: Path; | ||
| >somePath : Symbol(somePath, Decl(templateLiteralIntersection2.ts, 8, 13)) | ||
| >Path : Symbol(Path, Decl(templateLiteralIntersection2.ts, 0, 0)) | ||
|
|
||
| joinedPath(`${somePath}/${somePath}`); | ||
| >joinedPath : Symbol(joinedPath, Decl(templateLiteralIntersection2.ts, 2, 36)) | ||
| >somePath : Symbol(somePath, Decl(templateLiteralIntersection2.ts, 8, 13)) | ||
| >somePath : Symbol(somePath, Decl(templateLiteralIntersection2.ts, 8, 13)) | ||
|
|
||
|
|
||
| type StartsWithA = `a${string}`; | ||
| >StartsWithA : Symbol(StartsWithA, Decl(templateLiteralIntersection2.ts, 10, 38)) | ||
|
|
||
| type EndsWithA = `${string}a`; | ||
| >EndsWithA : Symbol(EndsWithA, Decl(templateLiteralIntersection2.ts, 13, 32)) | ||
|
|
||
|
|
||
| declare function withinAs(p: StartsWithA & EndsWithA): void; | ||
| >withinAs : Symbol(withinAs, Decl(templateLiteralIntersection2.ts, 14, 30)) | ||
| >p : Symbol(p, Decl(templateLiteralIntersection2.ts, 17, 26)) | ||
| >StartsWithA : Symbol(StartsWithA, Decl(templateLiteralIntersection2.ts, 10, 38)) | ||
| >EndsWithA : Symbol(EndsWithA, Decl(templateLiteralIntersection2.ts, 13, 32)) | ||
|
|
||
| withinAs(""); | ||
| >withinAs : Symbol(withinAs, Decl(templateLiteralIntersection2.ts, 14, 30)) | ||
|
|
||
| withinAs("a"); | ||
| >withinAs : Symbol(withinAs, Decl(templateLiteralIntersection2.ts, 14, 30)) | ||
|
|
||
| withinAs("ab"); | ||
| >withinAs : Symbol(withinAs, Decl(templateLiteralIntersection2.ts, 14, 30)) | ||
|
|
||
| withinAs("aba"); | ||
| >withinAs : Symbol(withinAs, Decl(templateLiteralIntersection2.ts, 14, 30)) | ||
|
|
||
| withinAs("abavvvva"); | ||
| >withinAs : Symbol(withinAs, Decl(templateLiteralIntersection2.ts, 14, 30)) | ||
|
|
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,64 @@ | ||
| === tests/cases/compiler/templateLiteralIntersection2.ts === | ||
| type Path = string & { _pathBrand: any }; | ||
| >Path : string & { _pathBrand: any; } | ||
| >_pathBrand : any | ||
|
|
||
| type JoinedPath = `${Path}/${Path}`; | ||
| >JoinedPath : `${Path}/${Path}` | ||
|
|
||
| declare function joinedPath(p: JoinedPath): void; | ||
| >joinedPath : (p: JoinedPath) => void | ||
| >p : `${Path}/${Path}` | ||
|
|
||
| joinedPath("foo/bar"); | ||
| >joinedPath("foo/bar") : 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: `${Path}/${Path}`) => void | ||
| >`${somePath}/${somePath}` : `${Path}/${Path}` | ||
| >somePath : Path | ||
| >somePath : Path | ||
|
|
||
|
|
||
| type StartsWithA = `a${string}`; | ||
| >StartsWithA : `a${string}` | ||
|
|
||
| type EndsWithA = `${string}a`; | ||
| >EndsWithA : `${string}a` | ||
|
|
||
|
|
||
| declare function withinAs(p: StartsWithA & EndsWithA): void; | ||
| >withinAs : (p: StartsWithA & EndsWithA) => void | ||
| >p : `a${string}` & `${string}a` | ||
|
|
||
| withinAs(""); | ||
| >withinAs("") : void | ||
| >withinAs : (p: `a${string}` & `${string}a`) => void | ||
| >"" : "" | ||
|
|
||
| withinAs("a"); | ||
| >withinAs("a") : void | ||
| >withinAs : (p: `a${string}` & `${string}a`) => void | ||
| >"a" : "a" | ||
|
|
||
| withinAs("ab"); | ||
| >withinAs("ab") : void | ||
| >withinAs : (p: `a${string}` & `${string}a`) => void | ||
| >"ab" : "ab" | ||
|
|
||
| withinAs("aba"); | ||
| >withinAs("aba") : void | ||
| >withinAs : (p: `a${string}` & `${string}a`) => void | ||
| >"aba" : "aba" | ||
|
|
||
| withinAs("abavvvva"); | ||
| >withinAs("abavvvva") : void | ||
| >withinAs : (p: `a${string}` & `${string}a`) => void | ||
| >"abavvvva" : "abavvvva" | ||
|
|
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,32 @@ | ||
| === tests/cases/compiler/templateLiteralIntersection3.ts === | ||
| type Path = string & { _pathBrand: any }; | ||
| >Path : Symbol(Path, Decl(templateLiteralIntersection3.ts, 0, 0)) | ||
| >_pathBrand : Symbol(_pathBrand, Decl(templateLiteralIntersection3.ts, 0, 22)) | ||
|
|
||
| declare const path: Path; | ||
| >path : Symbol(path, Decl(templateLiteralIntersection3.ts, 1, 13)) | ||
| >Path : Symbol(Path, Decl(templateLiteralIntersection3.ts, 0, 0)) | ||
|
|
||
| declare const options1: { prop: number; } & { [k: string]: boolean; }; | ||
| >options1 : Symbol(options1, Decl(templateLiteralIntersection3.ts, 3, 13)) | ||
| >prop : Symbol(prop, Decl(templateLiteralIntersection3.ts, 3, 25)) | ||
| >k : Symbol(k, Decl(templateLiteralIntersection3.ts, 3, 47)) | ||
|
|
||
| options1[`foo`] = false; | ||
| >options1 : Symbol(options1, Decl(templateLiteralIntersection3.ts, 3, 13)) | ||
|
|
||
| options1[`foo/${path}`] = false; | ||
| >options1 : Symbol(options1, Decl(templateLiteralIntersection3.ts, 3, 13)) | ||
| >path : Symbol(path, Decl(templateLiteralIntersection3.ts, 1, 13)) | ||
|
|
||
|
|
||
| // Lowercase<`foo/${Path}`> => `foo/${Lowercase<Path>}` | ||
| declare const lowercasePath: Lowercase<`foo/${Path}`>; | ||
| >lowercasePath : Symbol(lowercasePath, Decl(templateLiteralIntersection3.ts, 11, 13)) | ||
| >Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) | ||
| >Path : Symbol(Path, Decl(templateLiteralIntersection3.ts, 0, 0)) | ||
|
|
||
| options1[lowercasePath] = false; | ||
| >options1 : Symbol(options1, Decl(templateLiteralIntersection3.ts, 3, 13)) | ||
| >lowercasePath : Symbol(lowercasePath, Decl(templateLiteralIntersection3.ts, 11, 13)) | ||
|
|
Uh oh!
There was an error while loading. Please reload this page.