tsc-ts 0.0.10 → 0.1.1

package/dist/api/compiler/checker-type-factory.d.ts

@@ -106,6 +106,11 @@ export declare function getIntersectionType(c: Checker, types: Type[]): Type;
 export declare function getIntersectionTypeEx(c: Checker, types: Type[], flags: IntersectionFlags, alias: TypeAlias | undefined): Type;
 export declare function isPrimitiveOrObjectOrEmptyType(c: Checker, t: Type): boolean;
 export declare function containsMissingType(c: Checker, t: Type): boolean;
+/**
+ * Whether `union` contains `t`, `undefined` where `t` is the missing type and the other way around, or
+ * the primitive type of literal `t` (of a unique symbol only with `matchSymbol`).
+ */
+export declare function unionContainsTypeOrPrimitive(c: Checker, union: UnionType, t: Type, matchSymbol: boolean): boolean;
 export declare function getCrossProductUnionSize(types: readonly Type[]): number;
 export declare function checkCrossProductUnion(c: Checker, types: readonly Type[]): boolean;
 export declare function getUnionOrIntersectionType(c: Checker, types: Type[], isUnion: boolean, reduction: UnionReduction): Type;

package/dist/api/compiler/checker-type-factory.js

@@ -8,6 +8,7 @@ import { getAliasForTypeNode, getTypeArgumentsOfDeferredReference } from './chec
 import { popTypeResolution, pushTypeResolution } from './checker-symbols.js';
 import { isGenericIndexType } from './checker-type-operators.js';
 import { compareCodePoints } from './diagnostics.js';
+import { utf8Length } from './character-codes.js';
 import { cachedTypeKey, EvolvingArrayType, IndexInfo, IndexType, IndexedAccessType, InstantiationExpressionType, InterfaceType, IntersectionType, MappedType, ObjectType, ReverseMappedType, SubstitutionType, TemplateLiteralType, TupleElementInfo, TupleType, TypeAlias, TypeReference, UnionType, ArrayTypeMapper, ArrayToSingleTypeMapper, MergedTypeMapper, SimpleTypeMapper, emptyIndexInfos, emptySignatures, emptySymbols, emptyTypes, ReferenceCache, } from './checker-types.js';
 import { getNamedMembers, getMembersOfSymbol } from './checker-symbols.js';
 import { getBaseConstraintOfType, getBaseConstraintOrType, getIndexTypeOfType, getPropertiesOfType, getTypeOfPropertyOfType, isArrayLikeType, resolveStructuredTypeMembers, hasResolvedProperties, memberResolutionFlags, membersHolder, } from './checker-members.js';
@@ -19,6 +20,7 @@ import { addOptionality } from './checker-symbol-types.js';
 import { getSourceFileOfNode } from './binder-utilities.js';
 import { isPartOfTypeNode } from './transformers/alias-references.js';
 import { declarationCount, getSymbolId } from './symbol.js';
+import { comparePseudoBigInts } from './pseudo-bigint.js';
 // ---- Keys
 export function typeListKey(types) {
     let key = '';
@@ -402,6 +404,10 @@ export function compareNodes(c, n1, n2) {
         return 1;
     if (n2 === undefined)
         return -1;
+    // Siblings are in one file: most compared declarations are members of one declaration.
+    const parent = n1.parent;
+    if (parent !== undefined && parent === n2.parent)
+        return n1.pos - n2.pos;
     const s1 = sourceFileOf(n1);
     const s2 = sourceFileOf(n2);
     if (s1 !== s2)
@@ -470,12 +476,14 @@ function compareTypeNames(c, t1, t2) {
     const s1 = getTypeNameSymbol(t1);
     const s2 = getTypeNameSymbol(t2);
     if (s1 === s2)
-        return t1.alias !== undefined ? compareTypeLists(c, t1.alias.typeArguments, t2.alias.typeArguments) : 0;
+        return compareTypeLists(c, t1.alias?.typeArguments, t2.alias?.typeArguments);
     if (s1 === undefined)
         return 1;
     if (s2 === undefined)
         return -1;
-    return compareCodePoints(s1.name, s2.name);
+    const r = compareCodePoints(s1.name, s2.name);
+    // Distinct declarations with the same name stay together before alias arguments or structure decide.
+    return r !== 0 ? r : compareSymbols(c, s1, s2);
 }
 function compareTypeLists(c, s1, s2) {
     // Index the parameters directly: an alias such as `s1 ?? emptyTypes` would hold its own reference.
@@ -734,9 +742,21 @@ export function compareTypes(c, t1, t2) {
         // Only distinguished by ids.
     }
     else if ((flags & 1048576 /* TypeFlags.Object */) !== 0) {
-        r = compareSymbols(c, t1.symbol, t2.symbol);
-        if (r !== 0)
-            return r;
+        if ((t1.objectFlags & t2.objectFlags & 16777216 /* ObjectFlags.InstantiationExpressionType */) !== 0) {
+            // Instantiation expression types are ordered by their source declaration, since one expression
+            // can produce a type for each union constituent, then by the expression, without symbol ids.
+            r = compareNodes(c, t1.symbol?.declaration, t2.symbol?.declaration);
+            if (r !== 0)
+                return r;
+            r = compareNodes(c, t1.node, t2.node);
+            if (r !== 0)
+                return r;
+        }
+        else {
+            r = compareSymbols(c, t1.symbol, t2.symbol);
+            if (r !== 0)
+                return r;
+        }
         if ((t1.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 && (t2.objectFlags & 4 /* ObjectFlags.Reference */) !== 0) {
             const r1 = t1;
             const r2 = t2;
@@ -766,10 +786,34 @@ export function compareTypes(c, t1, t2) {
         else if ((t2.objectFlags & 4 /* ObjectFlags.Reference */) !== 0)
             return 1;
         else {
+            // Unnamed non-reference object types are ordered by kind and instantiation data.
             r = (t1.objectFlags & 50332991 /* ObjectFlags.ObjectTypeKindMask */) - (t2.objectFlags & 50332991 /* ObjectFlags.ObjectTypeKindMask */);
             if (r !== 0)
                 return r;
-            r = compareTypeMappers(c, t1.mapper, t2.mapper);
+            if ((t1.objectFlags & 1024 /* ObjectFlags.ReverseMapped */) !== 0) {
+                const r1 = t1;
+                const r2 = t2;
+                r = compareTypes(c, r1.source, r2.source);
+                if (r !== 0)
+                    return r;
+                r = compareTypes(c, r1.mappedType, r2.mappedType);
+                if (r !== 0)
+                    return r;
+                r = compareTypes(c, r1.constraintType, r2.constraintType);
+                if (r !== 0)
+                    return r;
+            }
+            let m1 = t1.mapper;
+            let m2 = t2.mapper;
+            if ((t1.objectFlags & 32 /* ObjectFlags.Mapped */) !== 0) {
+                // instantiateAnonymousType prepends a mapping to a fresh type parameter; compare the
+                // instantiation itself rather than the identity of that parameter.
+                if (m1 instanceof CompositeTypeMapper)
+                    m1 = m1.m2;
+                if (m2 instanceof CompositeTypeMapper)
+                    m2 = m2.m2;
+            }
+            r = compareTypeMappers(c, m1, m2);
             if (r !== 0)
                 return r;
         }
@@ -812,6 +856,11 @@ export function compareTypes(c, t1, t2) {
         if (r !== 0)
             return r;
     }
+    else if ((flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0) {
+        r = comparePseudoBigInts(t1.stringValue, t2.stringValue);
+        if (r !== 0)
+            return r;
+    }
     else if ((flags & 8192 /* TypeFlags.BooleanLiteral */) !== 0) {
         const b1 = t1.stringValue === 'true';
         const b2 = t2.stringValue === 'true';
@@ -1099,7 +1148,26 @@ export function filterType(c, type, f) {
     return (type.flags & 262144 /* TypeFlags.Never */) !== 0 || f(type) ? type : c.neverType;
 }
 export function removeType(c, type, target) {
-    return filterType(c, type, (t) => t !== target);
+    if ((type.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return type === target ? c.neverType : type;
+    const union = type;
+    const origin = union.origin;
+    // An origin that lists the target keeps the rest of its constituents.
+    if (origin !== undefined &&
+        (origin.flags & 134217728 /* TypeFlags.Union */) !== 0 &&
+        containsType(c, origin.types, target))
+        return filterType(c, type, (t) => t !== target);
+    const types = union.types;
+    const index = types.length < linearTypeSearchLimit ? indexOfType(types, target, 0) : binarySearchTypes(c, types, target);
+    if (index < 0)
+        return type;
+    if (types.length === 2)
+        return types[1 - index];
+    const filtered = [];
+    for (let i = 0; i < types.length; i++)
+        if (i !== index)
+            filtered.push(types[i]);
+    return getUnionTypeFromSortedList(c, filtered, union.objectFlags & (32768 /* ObjectFlags.PrimitiveUnion */ | 33554432 /* ObjectFlags.ContainsIntersections */), undefined, undefined);
 }
 export function countTypes(type) {
     if ((type.flags & 134217728 /* TypeFlags.Union */) !== 0)
@@ -1119,37 +1187,78 @@ export function getUnionTypeEx(c, types, unionReduction, alias, origin) {
         return c.neverType;
     if (types.length === 1)
         return types[0];
-    // Optimize the common case of unioning a union with some other type, like `undefined`.
-    if (types.length === 2 &&
-        origin === undefined &&
-        ((types[0].flags & 134217728 /* TypeFlags.Union */) !== 0 || (types[1].flags & 134217728 /* TypeFlags.Union */) !== 0)) {
-        let id1 = types[0].id;
-        let id2 = types[1].id;
+    // Unioning two types is the common case, both a union with some other type, like `undefined`, and
+    // two constituents of a list, and the same pairs recur. The union is a function of the two types,
+    // the reduction and the alias, so the result is cached by the pair. A union that exceeded the
+    // complexity limit was reported at the expression that needed it and comes back as the error
+    // type: caching that would silence the report at the next expression with the same input list, so
+    // an error result is not cached.
+    if (types.length === 2 && origin === undefined) {
+        const t0 = types[0];
+        const t1 = types[1];
+        let id1 = t0.id;
+        let id2 = t1.id;
         if (id1 > id2) {
             const t = id1;
             id1 = id2;
             id2 = t;
         }
-        // Without an alias, both ids and the reduction pack into one exact number.
-        if (alias === undefined && id2 < UnionPairIdLimit) {
+        // Without an alias or a constrained intersection, both ids and the reduction pack into one
+        // exact number. A constrained intersection's reduction resolves a type variable's constraint
+        // (`addTypeToUnion`), so those pairs take the general path.
+        if (alias === undefined &&
+            id2 < UnionPairIdLimit &&
+            !isConstrainedIntersection(t0) &&
+            !isConstrainedIntersection(t1)) {
             const id = (id1 * UnionPairIdLimit + id2) * 4 + unionReduction;
             let result = c.unionOfUnionTypesById.get(id);
             if (result === undefined) {
                 result = getUnionTypeWorker(c, types, unionReduction, alias, undefined);
-                c.unionOfUnionTypesById.set(id, result);
+                if (result !== c.errorType)
+                    c.unionOfUnionTypesById.set(id, result);
+            }
+            return result;
+        }
+        if ((t0.flags & 134217728 /* TypeFlags.Union */) !== 0 || (t1.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+            const key = id1 + ',' + id2 + ',' + unionReduction + aliasKey(alias);
+            let result = c.unionOfUnionTypes.get(key);
+            if (result === undefined) {
+                result = getUnionTypeWorker(c, types, unionReduction, alias, undefined);
+                if (result !== c.errorType)
+                    c.unionOfUnionTypes.set(key, result);
             }
             return result;
         }
-        const key = id1 + ',' + id2 + ',' + unionReduction + aliasKey(alias);
-        let result = c.unionOfUnionTypes.get(key);
+    }
+    // Longer lists recur too, from nested unions and from constituents mapped in the same order.
+    // Normalizing a list costs a sort of its constituents and the reductions, and the union is a
+    // function of the list as given, the reduction and the alias, so the result is cached by the list.
+    if (origin === undefined) {
+        const hash = typeListHash(types, alias, unionReduction);
+        let result = c.unionTypesByInputList.get(hash, types, alias, unionReduction);
         if (result === undefined) {
             result = getUnionTypeWorker(c, types, unionReduction, alias, undefined);
-            c.unionOfUnionTypes.set(key, result);
+            if (result !== c.errorType && !hasConstrainedIntersection(types))
+                c.unionTypesByInputList.set(hash, types.slice(), alias, unionReduction, result);
         }
         return result;
     }
     return getUnionTypeWorker(c, types, unionReduction, alias, origin);
 }
+/** An intersection that `addTypeToUnion` reduces by resolving a type variable's constraint. */
+function isConstrainedIntersection(t) {
+    return (t.flags & 268435456 /* TypeFlags.Intersection */) !== 0 && (t.objectFlags & 134217728 /* ObjectFlags.IsConstrainedTypeVariable */) !== 0;
+}
+/** Whether `addTypesToUnion` would set `IncludesConstrainedTypeVariable` for `types`. */
+function hasConstrainedIntersection(types) {
+    for (const t of types) {
+        if (isConstrainedIntersection(t))
+            return true;
+        if ((t.flags & 134217728 /* TypeFlags.Union */) !== 0 && hasConstrainedIntersection(t.types))
+            return true;
+    }
+    return false;
+}
 class TypeSet {
     types = [];
     includes = 0;
@@ -1534,7 +1643,7 @@ function removeSubtypes(c, types, hasObjectTypes) {
             if (count === 100000) {
                 const estimatedCount = Math.trunc(count / (length - i)) * length;
                 if (estimatedCount > 1000000) {
-                    c.error(c.currentNode, 738 /* Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent */);
+                    c.error(c.currentNode, 745 /* Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent */);
                     return undefined;
                 }
             }
@@ -1937,28 +2046,33 @@ function intersectUnionsOfPrimitiveTypes(c, types) {
     return true;
 }
 function eachUnionContains(c, unionTypes, t) {
-    for (const type of unionTypes) {
-        const u = type;
-        if (unionContainsType(c, u, t))
-            continue;
-        if (t === c.missingType)
-            return unionContainsType(c, u, c.undefinedType);
-        if (t === c.undefinedType)
-            return unionContainsType(c, u, c.missingType);
-        let primitive;
-        if ((t.flags & 1024 /* TypeFlags.StringLiteral */) !== 0)
-            primitive = c.stringType;
-        else if ((t.flags & (65536 /* TypeFlags.Enum */ | 2048 /* TypeFlags.NumberLiteral */)) !== 0)
-            primitive = c.numberType;
-        else if ((t.flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0)
-            primitive = c.bigintType;
-        else if ((t.flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0)
-            primitive = c.esSymbolType;
-        if (primitive === undefined || !unionContainsType(c, u, primitive))
+    for (const type of unionTypes)
+        if (!unionContainsTypeOrPrimitive(c, type, t, true))
             return false;
-    }
     return true;
 }
+/**
+ * Whether `union` contains `t`, `undefined` where `t` is the missing type and the other way around, or
+ * the primitive type of literal `t` (of a unique symbol only with `matchSymbol`).
+ */
+export function unionContainsTypeOrPrimitive(c, union, t, matchSymbol) {
+    if (unionContainsType(c, union, t))
+        return true;
+    if (t === c.missingType)
+        return unionContainsType(c, union, c.undefinedType);
+    if (t === c.undefinedType)
+        return unionContainsType(c, union, c.missingType);
+    let primitive;
+    if ((t.flags & 1024 /* TypeFlags.StringLiteral */) !== 0)
+        primitive = c.stringType;
+    else if ((t.flags & (65536 /* TypeFlags.Enum */ | 2048 /* TypeFlags.NumberLiteral */)) !== 0)
+        primitive = c.numberType;
+    else if ((t.flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0)
+        primitive = c.bigintType;
+    else if ((t.flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0 && matchSymbol)
+        primitive = c.esSymbolType;
+    return primitive !== undefined && unionContainsType(c, union, primitive);
+}
 export function getCrossProductUnionSize(types) {
     let size = 1;
     for (const t of types) {
@@ -1972,7 +2086,7 @@ export function getCrossProductUnionSize(types) {
 export function checkCrossProductUnion(c, types) {
     const size = getCrossProductUnionSize(types);
     if (size >= 100000) {
-        c.error(c.currentNode, 738 /* Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent */);
+        c.error(c.currentNode, 745 /* Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent */);
         return false;
     }
     return true;
@@ -2353,8 +2467,8 @@ class TupleNormalizer {
                 const spreadTypes = getElementTypes(c, t);
                 if (spreadTypes.length + this.types.length >= 10000) {
                     c.error(c.currentNode, c.currentNode !== undefined && isPartOfTypeNode(c.currentNode)
-                        ? 931 /* Diagnostics.Type_produces_a_tuple_type_that_is_too_large_to_represent */
-                        : 932 /* Diagnostics.Expression_produces_a_tuple_type_that_is_too_large_to_represent */);
+                        ? 938 /* Diagnostics.Type_produces_a_tuple_type_that_is_too_large_to_represent */
+                        : 939 /* Diagnostics.Expression_produces_a_tuple_type_that_is_too_large_to_represent */);
                     return false;
                 }
                 const spreadInfos = tupleTargetOf(t).elementInfos;
@@ -2438,9 +2552,9 @@ export function getTypeArguments(c, t) {
         }
         const errorNode = node ?? c.currentNode;
         if (target.symbol !== undefined)
-            c.error(errorNode, 1095 /* Diagnostics.Type_arguments_for_0_circularly_reference_themselves */, symbolToString(c, target.symbol));
+            c.error(errorNode, 1102 /* Diagnostics.Type_arguments_for_0_circularly_reference_themselves */, symbolToString(c, target.symbol));
         else
-            c.error(errorNode, 1096 /* Diagnostics.Tuple_type_arguments_circularly_reference_themselves */);
+            c.error(errorNode, 1103 /* Diagnostics.Tuple_type_arguments_circularly_reference_themselves */);
     }
     return resolved;
 }
@@ -2475,8 +2589,13 @@ export function getTemplateLiteralType(c, texts, types) {
     if (types.includes(c.wildcardType))
         return c.wildcardType;
     const builder = new TemplateBuilder(c, texts[0]);
-    if (!builder.addSpans(texts, types))
+    if (!builder.addSpans(texts, types)) {
+        if (builder.tooLarge) {
+            c.error(c.currentNode, 744 /* Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite */);
+            return c.errorType;
+        }
         return c.stringType;
+    }
     if (builder.newTypes.length === 0)
         return getStringLiteralType(c, builder.text);
     builder.newTexts.push(builder.text);
@@ -2497,36 +2616,61 @@ export function getTemplateLiteralType(c, texts, types) {
     }
     return type;
 }
+/**
+ * Limits on the size of a template literal type that getTemplateLiteralType builds, in UTF-8 bytes of text
+ * and in placeholders. Recursive instantiations such as `Recur<any, `${S}_${S}`>` double the text or the
+ * placeholders on every step and exhaust memory long before the tail recursion limit of conditional types.
+ */
+const maxTemplateLiteralTypeLength = 50_000_000;
+const maxTemplateLiteralTypeSpans = 100_000;
 class TemplateBuilder {
     c;
     text;
     newTypes = [];
     newTexts = [];
+    /** UTF-8 bytes of `text`. */
+    textBytes;
+    /** UTF-8 bytes of the texts already moved into `newTexts`. */
+    movedBytes = 0;
+    /** Whether `addSpans` stopped because the result passed a size limit. */
+    tooLarge = false;
     constructor(c, text) {
         this.c = c;
         this.text = text;
+        this.textBytes = utf8Length(text);
     }
     addSpans(texts, types) {
         const c = this.c;
         for (let i = 0; i < types.length; i++) {
             const t = types[i];
             if ((t.flags & (15360 /* TypeFlags.Literal */ | 8 /* TypeFlags.Null */ | 4 /* TypeFlags.Undefined */)) !== 0) {
-                this.text += getTemplateStringForType(c, t) + texts[i + 1];
+                const added = getTemplateStringForType(c, t) + texts[i + 1];
+                this.text += added;
+                this.textBytes += utf8Length(added);
             }
             else if ((t.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0) {
                 const template = t;
                 this.text += template.texts[0];
+                this.textBytes += utf8Length(template.texts[0]);
                 if (!this.addSpans(template.texts, template.types))
                     return false;
                 this.text += texts[i + 1];
+                this.textBytes += utf8Length(texts[i + 1]);
             }
             else if (isGenericIndexType(c, t) || isPatternLiteralPlaceholderType(c, t)) {
                 this.newTypes.push(t);
                 this.newTexts.push(this.text);
+                this.movedBytes += this.textBytes;
                 this.text = texts[i + 1];
+                this.textBytes = utf8Length(this.text);
             }
             else
                 return false;
+            if (this.movedBytes + this.textBytes > maxTemplateLiteralTypeLength ||
+                this.newTypes.length > maxTemplateLiteralTypeSpans) {
+                this.tooLarge = true;
+                return false;
+            }
         }
         return true;
     }

package/dist/api/compiler/checker-type-nodes.d.ts

@@ -6,6 +6,7 @@ export declare function getTypeFromTypeNode(c: Checker, node: Node): Type;
 export declare function getTypeFromThisTypeNode(c: Checker, node: Node): Type;
 export declare function getTypeFromIndexedAccessTypeNode(c: Checker, node: IndexedAccessTypeNode): Type;
 export declare function getESSymbolLikeTypeForNode(c: Checker, node: Node): Type;
+export declare function isAssertionExpression(node: Node | undefined): boolean;
 export declare function getTypeFromTypeReference(c: Checker, node: Node): Type;
 export declare function getSymbolFromTypeReference(c: Checker, node: Node): Symbol;
 export declare function resolveTypeReferenceName(c: Checker, typeReference: Node, meaning: SymbolFlags, ignoreErrors: boolean): Symbol;