Skip to content

Commit

Permalink
Smarter algorithm to distribute intersections of unions.
Browse files Browse the repository at this point in the history
Helps avoid exponential blowup for `keyof` large unions even when
`keyof` each type in the union is not a union of unit types (e.g.,
because there is an index signature or a type variable).

Remove the special handling of intersections of unions of unit types
because it's no longer needed.  This reverts the code changes of pull
request microsoft#24137 (commit 3fc3df3 with
respect to 3fc727b) but keeps the test.

Fixes microsoft#24223.
  • Loading branch information
mattmccutchen committed Jul 19, 2018
1 parent 1cedab1 commit 230c842
Show file tree
Hide file tree
Showing 7 changed files with 427 additions and 40 deletions.
75 changes: 39 additions & 36 deletions src/compiler/checker.ts
Original file line number Diff line number Diff line change
Expand Up @@ -8683,7 +8683,7 @@ namespace ts {
includes & TypeFlags.Undefined ? includes & TypeFlags.NonWideningType ? undefinedType : undefinedWideningType :
neverType;
}
return getUnionTypeFromSortedList(typeSet, includes & TypeFlags.NotUnit ? 0 : TypeFlags.UnionOfUnitTypes, aliasSymbol, aliasTypeArguments);
return getUnionTypeFromSortedList(typeSet, aliasSymbol, aliasTypeArguments);
}

function getUnionTypePredicate(signatures: ReadonlyArray<Signature>): TypePredicate | undefined {
Expand Down Expand Up @@ -8723,7 +8723,7 @@ namespace ts {
}

// This function assumes the constituent type list is sorted and deduplicated.
function getUnionTypeFromSortedList(types: Type[], unionOfUnitTypes: TypeFlags, aliasSymbol?: Symbol, aliasTypeArguments?: ReadonlyArray<Type>): Type {
function getUnionTypeFromSortedList(types: Type[], aliasSymbol?: Symbol, aliasTypeArguments?: ReadonlyArray<Type>): Type {
if (types.length === 0) {
return neverType;
}
Expand All @@ -8734,7 +8734,7 @@ namespace ts {
let type = unionTypes.get(id);
if (!type) {
const propagatedFlags = getPropagatingFlagsOfTypes(types, /*excludeKinds*/ TypeFlags.Nullable);
type = <UnionType>createType(TypeFlags.Union | propagatedFlags | unionOfUnitTypes);
type = <UnionType>createType(TypeFlags.Union | propagatedFlags);
unionTypes.set(id, type);
type.types = types;
/*
Expand Down Expand Up @@ -8806,29 +8806,6 @@ namespace ts {
}
}

// When intersecting unions of unit types we can simply intersect based on type identity.
// Here we remove all unions of unit types from the given list and replace them with a
// a single union containing an intersection of the unit types.
function intersectUnionsOfUnitTypes(types: Type[]) {
const unionIndex = findIndex(types, t => (t.flags & TypeFlags.UnionOfUnitTypes) !== 0);
const unionType = <UnionType>types[unionIndex];
let intersection = unionType.types;
let i = types.length - 1;
while (i > unionIndex) {
const t = types[i];
if (t.flags & TypeFlags.UnionOfUnitTypes) {
intersection = filter(intersection, u => containsType((<UnionType>t).types, u));
orderedRemoveItemAt(types, i);
}
i--;
}
if (intersection === unionType.types) {
return false;
}
types[unionIndex] = getUnionTypeFromSortedList(intersection, unionType.flags & TypeFlags.UnionOfUnitTypes);
return true;
}

// We normalize combinations of intersection and union types based on the distributive property of the '&'
// operator. Specifically, because X & (A | B) is equivalent to X & A | X & B, we can transform intersection
// types with union type constituents into equivalent union types with intersection type constituents and
Expand Down Expand Up @@ -8866,18 +8843,44 @@ namespace ts {
return typeSet[0];
}
if (includes & TypeFlags.Union) {
if (includes & TypeFlags.UnionOfUnitTypes && intersectUnionsOfUnitTypes(typeSet)) {
// When the intersection creates a reduced set (which might mean that *all* union types have
// disappeared), we restart the operation to get a new set of combined flags. Once we have
// reduced we'll never reduce again, so this occurs at most once.
return getIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
}
// We are attempting to construct a type of the form X & (A | B) & Y. Transform this into a type of
// the form X & A & Y | X & B & Y and recursively reduce until no union type constituents remain.
const unionIndex = findIndex(typeSet, t => (t.flags & TypeFlags.Union) !== 0);
const lastNonfinalUnionIndex = findLastIndex(typeSet, t => (t.flags & TypeFlags.Union) !== 0, typeSet.length - 2);
let partialIntersectionStartIndex: number, unionIndex: number;
if (lastNonfinalUnionIndex === -1) {
// typeSet[typeSet.length - 1] must be the only union. Distribute it and we're done.
partialIntersectionStartIndex = 0;
unionIndex = typeSet.length - 1;
}
else {
// `keyof` a large union of types results in an intersection of unions containing many unit types (GH#24223).
// To help avoid an exponential blowup, distribute the last union over the later constituents of the
// intersection and simplify the resulting union before distributing earlier unions. (Exception: don't
// distribute a union that is the last constituent of the intersection over the zero remaining constituents
// because that would have no effect.)
partialIntersectionStartIndex = lastNonfinalUnionIndex;
unionIndex = lastNonfinalUnionIndex;
}
const unionType = <UnionType>typeSet[unionIndex];
return getUnionType(map(unionType.types, t => getIntersectionType(replaceElement(typeSet, unionIndex, t))),
UnionReduction.Literal, aliasSymbol, aliasTypeArguments);
let relevantUnionMembers = unionType.types;
// As of 2018-07-19, discarding mismatching unit types here rather than letting it
// happen when we create the distributed union gives a 5x speedup on the test case
// for #23977.
if (includes & TypeFlags.Unit) {
const unitTypeInIntersection = find(typeSet, t => (t.flags & TypeFlags.Unit) !== 0)!;
relevantUnionMembers = filter(unionType.types, t => t === unitTypeInIntersection || (t.flags & TypeFlags.Unit) === 0);
}
const partialIntersectionMembers = typeSet.slice(partialIntersectionStartIndex);
const distributedMembers = map(relevantUnionMembers, t => getIntersectionType(replaceElement(partialIntersectionMembers, unionIndex - partialIntersectionStartIndex, t)));
if (partialIntersectionStartIndex === 0) {
return getUnionType(distributedMembers, UnionReduction.Literal, aliasSymbol, aliasTypeArguments);
}
else {
const distributedUnion = getUnionType(distributedMembers, UnionReduction.Literal);
const newIntersectionMembers = typeSet.slice(0, partialIntersectionStartIndex + 1);
newIntersectionMembers[partialIntersectionStartIndex] = distributedUnion;
return getIntersectionType(newIntersectionMembers, aliasSymbol, aliasTypeArguments);
}
}
const id = getTypeListId(typeSet);
let type = intersectionTypes.get(id);
Expand Down Expand Up @@ -13963,7 +13966,7 @@ namespace ts {
if (type.flags & TypeFlags.Union) {
const types = (<UnionType>type).types;
const filtered = filter(types, f);
return filtered === types ? type : getUnionTypeFromSortedList(filtered, type.flags & TypeFlags.UnionOfUnitTypes);
return filtered === types ? type : getUnionTypeFromSortedList(filtered);
}
return f(type) ? type : neverType;
}
Expand Down
4 changes: 0 additions & 4 deletions src/compiler/types.ts
Original file line number Diff line number Diff line change
Expand Up @@ -3674,8 +3674,6 @@ namespace ts {
/* @internal */
FreshLiteral = 1 << 25, // Fresh literal or unique type
/* @internal */
UnionOfUnitTypes = 1 << 26, // Type is union of unit types
/* @internal */
ContainsWideningType = 1 << 27, // Type is or contains undefined or null widening type
/* @internal */
ContainsObjectLiteral = 1 << 28, // Type is or contains object literal type
Expand Down Expand Up @@ -3719,8 +3717,6 @@ namespace ts {
Narrowable = Any | Unknown | StructuredOrInstantiable | StringLike | NumberLike | BooleanLike | ESSymbol | UniqueESSymbol | NonPrimitive,
NotUnionOrUnit = Any | Unknown | ESSymbol | Object | NonPrimitive,
/* @internal */
NotUnit = Any | String | Number | Boolean | Enum | ESSymbol | Void | Never | StructuredOrInstantiable,
/* @internal */
RequiresWidening = ContainsWideningType | ContainsObjectLiteral,
/* @internal */
PropagatingFlags = ContainsWideningType | ContainsObjectLiteral | ContainsAnyFunctionType,
Expand Down
45 changes: 45 additions & 0 deletions tests/baselines/reference/intersectionsOfLargeUnions2.errors.txt
Original file line number Diff line number Diff line change
@@ -0,0 +1,45 @@
tests/cases/compiler/intersectionsOfLargeUnions2.ts(31,15): error TS2536: Type 'T' cannot be used to index type 'HTMLElementTagNameMap'.
tests/cases/compiler/intersectionsOfLargeUnions2.ts(31,15): error TS2536: Type 'P' cannot be used to index type 'HTMLElementTagNameMap[T]'.


==== tests/cases/compiler/intersectionsOfLargeUnions2.ts (2 errors) ====
// Repro from #24223

declare global {
interface ElementTagNameMap {
[index: number]: HTMLElement
}

interface HTMLElement {
[index: number]: HTMLElement;
}
}

export function assertIsElement(node: Node | null): node is Element {
let nodeType = node === null ? null : node.nodeType;
return nodeType === 1;
}

export function assertNodeTagName<
T extends keyof ElementTagNameMap,
U extends ElementTagNameMap[T]>(node: Node | null, tagName: T): node is U {
if (assertIsElement(node)) {
const nodeTagName = node.tagName.toLowerCase();
return nodeTagName === tagName;
}
return false;
}

export function assertNodeProperty<
T extends keyof ElementTagNameMap,
P extends keyof ElementTagNameMap[T],
V extends HTMLElementTagNameMap[T][P]>(node: Node | null, tagName: T, prop: P, value: V) {
~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2536: Type 'T' cannot be used to index type 'HTMLElementTagNameMap'.
~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2536: Type 'P' cannot be used to index type 'HTMLElementTagNameMap[T]'.
if (assertNodeTagName(node, tagName)) {
node[prop];
}
}

61 changes: 61 additions & 0 deletions tests/baselines/reference/intersectionsOfLargeUnions2.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,61 @@
//// [intersectionsOfLargeUnions2.ts]
// Repro from #24223

declare global {
interface ElementTagNameMap {
[index: number]: HTMLElement
}

interface HTMLElement {
[index: number]: HTMLElement;
}
}

export function assertIsElement(node: Node | null): node is Element {
let nodeType = node === null ? null : node.nodeType;
return nodeType === 1;
}

export function assertNodeTagName<
T extends keyof ElementTagNameMap,
U extends ElementTagNameMap[T]>(node: Node | null, tagName: T): node is U {
if (assertIsElement(node)) {
const nodeTagName = node.tagName.toLowerCase();
return nodeTagName === tagName;
}
return false;
}

export function assertNodeProperty<
T extends keyof ElementTagNameMap,
P extends keyof ElementTagNameMap[T],
V extends HTMLElementTagNameMap[T][P]>(node: Node | null, tagName: T, prop: P, value: V) {
if (assertNodeTagName(node, tagName)) {
node[prop];
}
}


//// [intersectionsOfLargeUnions2.js]
"use strict";
// Repro from #24223
exports.__esModule = true;
function assertIsElement(node) {
var nodeType = node === null ? null : node.nodeType;
return nodeType === 1;
}
exports.assertIsElement = assertIsElement;
function assertNodeTagName(node, tagName) {
if (assertIsElement(node)) {
var nodeTagName = node.tagName.toLowerCase();
return nodeTagName === tagName;
}
return false;
}
exports.assertNodeTagName = assertNodeTagName;
function assertNodeProperty(node, tagName, prop, value) {
if (assertNodeTagName(node, tagName)) {
node[prop];
}
}
exports.assertNodeProperty = assertNodeProperty;
115 changes: 115 additions & 0 deletions tests/baselines/reference/intersectionsOfLargeUnions2.symbols
Original file line number Diff line number Diff line change
@@ -0,0 +1,115 @@
=== tests/cases/compiler/intersectionsOfLargeUnions2.ts ===
// Repro from #24223

declare global {
>global : Symbol(global, Decl(intersectionsOfLargeUnions2.ts, 0, 0))

interface ElementTagNameMap {
>ElementTagNameMap : Symbol(ElementTagNameMap, Decl(lib.dom.d.ts, --, --), Decl(intersectionsOfLargeUnions2.ts, 2, 16))

[index: number]: HTMLElement
>index : Symbol(index, Decl(intersectionsOfLargeUnions2.ts, 4, 9))
>HTMLElement : Symbol(HTMLElement, Decl(intersectionsOfLargeUnions2.ts, 5, 5))
}

interface HTMLElement {
>HTMLElement : Symbol(HTMLElement, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --), Decl(intersectionsOfLargeUnions2.ts, 5, 5))

[index: number]: HTMLElement;
>index : Symbol(index, Decl(intersectionsOfLargeUnions2.ts, 8, 9))
>HTMLElement : Symbol(HTMLElement, Decl(intersectionsOfLargeUnions2.ts, 5, 5))
}
}

export function assertIsElement(node: Node | null): node is Element {
>assertIsElement : Symbol(assertIsElement, Decl(intersectionsOfLargeUnions2.ts, 10, 1))
>node : Symbol(node, Decl(intersectionsOfLargeUnions2.ts, 12, 32))
>Node : Symbol(Node, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --))
>node : Symbol(node, Decl(intersectionsOfLargeUnions2.ts, 12, 32))
>Element : Symbol(Element, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --))

let nodeType = node === null ? null : node.nodeType;
>nodeType : Symbol(nodeType, Decl(intersectionsOfLargeUnions2.ts, 13, 7))
>node : Symbol(node, Decl(intersectionsOfLargeUnions2.ts, 12, 32))
>node.nodeType : Symbol(Node.nodeType, Decl(lib.dom.d.ts, --, --))
>node : Symbol(node, Decl(intersectionsOfLargeUnions2.ts, 12, 32))
>nodeType : Symbol(Node.nodeType, Decl(lib.dom.d.ts, --, --))

return nodeType === 1;
>nodeType : Symbol(nodeType, Decl(intersectionsOfLargeUnions2.ts, 13, 7))
}

export function assertNodeTagName<
>assertNodeTagName : Symbol(assertNodeTagName, Decl(intersectionsOfLargeUnions2.ts, 15, 1))

T extends keyof ElementTagNameMap,
>T : Symbol(T, Decl(intersectionsOfLargeUnions2.ts, 17, 34))
>ElementTagNameMap : Symbol(ElementTagNameMap, Decl(lib.dom.d.ts, --, --), Decl(intersectionsOfLargeUnions2.ts, 2, 16))

U extends ElementTagNameMap[T]>(node: Node | null, tagName: T): node is U {
>U : Symbol(U, Decl(intersectionsOfLargeUnions2.ts, 18, 38))
>ElementTagNameMap : Symbol(ElementTagNameMap, Decl(lib.dom.d.ts, --, --), Decl(intersectionsOfLargeUnions2.ts, 2, 16))
>T : Symbol(T, Decl(intersectionsOfLargeUnions2.ts, 17, 34))
>node : Symbol(node, Decl(intersectionsOfLargeUnions2.ts, 19, 36))
>Node : Symbol(Node, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --))
>tagName : Symbol(tagName, Decl(intersectionsOfLargeUnions2.ts, 19, 54))
>T : Symbol(T, Decl(intersectionsOfLargeUnions2.ts, 17, 34))
>node : Symbol(node, Decl(intersectionsOfLargeUnions2.ts, 19, 36))
>U : Symbol(U, Decl(intersectionsOfLargeUnions2.ts, 18, 38))

if (assertIsElement(node)) {
>assertIsElement : Symbol(assertIsElement, Decl(intersectionsOfLargeUnions2.ts, 10, 1))
>node : Symbol(node, Decl(intersectionsOfLargeUnions2.ts, 19, 36))

const nodeTagName = node.tagName.toLowerCase();
>nodeTagName : Symbol(nodeTagName, Decl(intersectionsOfLargeUnions2.ts, 21, 13))
>node.tagName.toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --))
>node.tagName : Symbol(Element.tagName, Decl(lib.dom.d.ts, --, --))
>node : Symbol(node, Decl(intersectionsOfLargeUnions2.ts, 19, 36))
>tagName : Symbol(Element.tagName, Decl(lib.dom.d.ts, --, --))
>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --))

return nodeTagName === tagName;
>nodeTagName : Symbol(nodeTagName, Decl(intersectionsOfLargeUnions2.ts, 21, 13))
>tagName : Symbol(tagName, Decl(intersectionsOfLargeUnions2.ts, 19, 54))
}
return false;
}

export function assertNodeProperty<
>assertNodeProperty : Symbol(assertNodeProperty, Decl(intersectionsOfLargeUnions2.ts, 25, 1))

T extends keyof ElementTagNameMap,
>T : Symbol(T, Decl(intersectionsOfLargeUnions2.ts, 27, 35))
>ElementTagNameMap : Symbol(ElementTagNameMap, Decl(lib.dom.d.ts, --, --), Decl(intersectionsOfLargeUnions2.ts, 2, 16))

P extends keyof ElementTagNameMap[T],
>P : Symbol(P, Decl(intersectionsOfLargeUnions2.ts, 28, 38))
>ElementTagNameMap : Symbol(ElementTagNameMap, Decl(lib.dom.d.ts, --, --), Decl(intersectionsOfLargeUnions2.ts, 2, 16))
>T : Symbol(T, Decl(intersectionsOfLargeUnions2.ts, 27, 35))

V extends HTMLElementTagNameMap[T][P]>(node: Node | null, tagName: T, prop: P, value: V) {
>V : Symbol(V, Decl(intersectionsOfLargeUnions2.ts, 29, 41))
>HTMLElementTagNameMap : Symbol(HTMLElementTagNameMap, Decl(lib.dom.d.ts, --, --))
>T : Symbol(T, Decl(intersectionsOfLargeUnions2.ts, 27, 35))
>P : Symbol(P, Decl(intersectionsOfLargeUnions2.ts, 28, 38))
>node : Symbol(node, Decl(intersectionsOfLargeUnions2.ts, 30, 43))
>Node : Symbol(Node, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --))
>tagName : Symbol(tagName, Decl(intersectionsOfLargeUnions2.ts, 30, 61))
>T : Symbol(T, Decl(intersectionsOfLargeUnions2.ts, 27, 35))
>prop : Symbol(prop, Decl(intersectionsOfLargeUnions2.ts, 30, 73))
>P : Symbol(P, Decl(intersectionsOfLargeUnions2.ts, 28, 38))
>value : Symbol(value, Decl(intersectionsOfLargeUnions2.ts, 30, 82))
>V : Symbol(V, Decl(intersectionsOfLargeUnions2.ts, 29, 41))

if (assertNodeTagName(node, tagName)) {
>assertNodeTagName : Symbol(assertNodeTagName, Decl(intersectionsOfLargeUnions2.ts, 15, 1))
>node : Symbol(node, Decl(intersectionsOfLargeUnions2.ts, 30, 43))
>tagName : Symbol(tagName, Decl(intersectionsOfLargeUnions2.ts, 30, 61))

node[prop];
>node : Symbol(node, Decl(intersectionsOfLargeUnions2.ts, 30, 43))
>prop : Symbol(prop, Decl(intersectionsOfLargeUnions2.ts, 30, 73))
}
}

0 comments on commit 230c842

Please sign in to comment.