tstyche 6.0.0-beta.0 → 6.0.0-beta.1

package/build/tstyche.js

@@ -4472,7 +4472,7 @@ class MatchWorker {
 function isStringOrNumberLiteralType(compiler, type) {
     return !!(type.flags & compiler.TypeFlags.StringOrNumberLiteral);
 }
-function isUnionType$1(compiler, type) {
+function isUnionType(compiler, type) {
     return !!(type.flags & compiler.TypeFlags.Union);
 }
 function isUniqueSymbolType(compiler, type) {
@@ -4541,7 +4541,7 @@ class ToAcceptProps {
             }
             return true;
         };
-        if (sourceType != null && isUnionType$1(this.#compiler, sourceType)) {
+        if (sourceType != null && isUnionType(this.#compiler, sourceType)) {
             return sourceType.types.some((sourceType) => check(sourceType, targetType));
         }
         return check(sourceType, targetType);
@@ -4609,7 +4609,7 @@ class ToAcceptProps {
             }
             return { diagnostics, isMatch: false };
         };
-        if (sourceType != null && isUnionType$1(this.#compiler, sourceType)) {
+        if (sourceType != null && isUnionType(this.#compiler, sourceType)) {
             let accumulator = [];
             const isMatch = sourceType.types.some((sourceType) => {
                 const text = matchWorker.assertionNode.isNot
@@ -4666,43 +4666,38 @@ class ToAcceptProps {
 function ensureArray(input) {
     return input ?? [];
 }
-function length(array) {
-    return array?.length ?? 0;
-}
-
-function isClass(type, compiler) {
-    return !!(type.objectFlags & compiler.ObjectFlags.Class);
-}
-function isConditionalType(type, compiler) {
-    return !!(type.flags & compiler.TypeFlags.Conditional);
-}
-function isFreshLiteralType(type, compiler) {
-    return !!(type.flags & compiler.TypeFlags.Freshable) && type.freshType === type;
-}
-function isIntersectionType(type, compiler) {
-    return !!(type.flags & compiler.TypeFlags.Intersection);
-}
-function isNoInferType(type, compiler) {
-    return !!(type.flags & compiler.TypeFlags.Substitution &&
-        type.constraint.flags & compiler.TypeFlags.Unknown);
+function getIndexSignatures(type, compiler, typeChecker) {
+    if (type.flags & compiler.TypeFlags.Intersection) {
+        return type.types.flatMap((type) => getIndexSignatures(type, compiler, typeChecker));
+    }
+    return typeChecker.getIndexInfosOfType(type);
 }
-function isObjectType(type, compiler) {
-    return !!(type.flags & compiler.TypeFlags.Object);
+function getSignatures(type, kind, compiler, typeChecker) {
+    if (type.flags & compiler.TypeFlags.Intersection) {
+        return type.types.flatMap((type) => getSignatures(type, kind, compiler, typeChecker));
+    }
+    return typeChecker.getSignaturesOfType(type, kind);
 }
-function isUnionType(type, compiler) {
-    return !!(type.flags & compiler.TypeFlags.Union);
+function getTypeParameterModifiers(typeParameter, compiler) {
+    if (!typeParameter.symbol.declarations) {
+        return compiler.ModifierFlags.None;
+    }
+    return (typeParameter.symbol.declarations.reduce((modifiers, declaration) => modifiers | compiler.getEffectiveModifierFlags(declaration), compiler.ModifierFlags.None) &
+        (compiler.ModifierFlags.In | compiler.ModifierFlags.Out | compiler.ModifierFlags.Const));
 }
-function isTupleType(type, compiler) {
-    return !!(type.objectFlags & compiler.ObjectFlags.Tuple);
+function getTargetSymbol(symbol, compiler) {
+    return isCheckFlagSet(symbol, compiler.CheckFlags.Instantiated, compiler)
+        ? symbol.links.target
+        : symbol;
 }
-function isTupleTypeReference(type, compiler) {
-    return isObjectType(type, compiler) && isTypeReference(type, compiler) && isTupleType(type.target, compiler);
+function isCheckFlagSet(symbol, flag, compiler) {
+    return !!(symbol.flags & compiler.SymbolFlags.Transient && symbol.links.checkFlags & flag);
 }
-function isTypeParameter(type, compiler) {
-    return !!(type.flags & compiler.TypeFlags.TypeParameter);
+function isSymbolFromDefaultLibrary(symbol, program) {
+    return !!symbol.declarations?.every((declaration) => program.isSourceFileDefaultLibrary(declaration.getSourceFile()));
 }
-function isTypeReference(type, compiler) {
-    return !!(type.objectFlags & compiler.ObjectFlags.Reference);
+function length(array) {
+    return array?.length ?? 0;
 }
 
 function getParameterFactsFromTuple(type, position, compiler) {
@@ -4712,41 +4707,30 @@ function getParameterFactsFromTuple(type, position, compiler) {
         getType: (typeChecker) => typeChecker.getTypeArguments(type)[position],
     };
 }
-function getParameterFacts(signature, position, compiler, typeChecker) {
-    if (position >= signature.parameters.length - 1 && compiler.hasRestParameter(signature.getDeclaration())) {
+function getParameterFacts(signature, parameterIndex, compiler, typeChecker) {
+    if (parameterIndex >= signature.parameters.length - 1 && compiler.hasRestParameter(signature.getDeclaration())) {
         const restType = typeChecker.getTypeOfSymbol(signature.parameters.at(-1));
-        if (isTupleTypeReference(restType, compiler)) {
+        if (typeChecker.isTupleType(restType)) {
             const fixedLength = signature.parameters.length - 1;
-            return getParameterFactsFromTuple(restType, position - fixedLength, compiler);
+            return getParameterFactsFromTuple(restType, parameterIndex - fixedLength, compiler);
         }
     }
-    const parameter = signature.parameters[position];
-    const isRest = isRestParameter(parameter, compiler);
+    const parameter = signature.parameters[parameterIndex];
     return {
         isOptional: isOptionalParameter(parameter, compiler),
-        isRest,
-        getType: (typeChecker) => getParameterType(parameter, signature, isRest, compiler, typeChecker),
+        isRest: isRestParameter(parameter, compiler),
+        getType: (typeChecker) => typeChecker.getParameterType(signature, parameterIndex),
     };
 }
-function getParameterType(parameter, signature, isRest, compiler, typeChecker) {
-    const type = typeChecker.getTypeOfSymbolAtLocation(parameter, signature.declaration);
-    if (isRest && isObjectType(type, compiler) && isTypeReference(type, compiler)) {
-        return typeChecker.getTypeArguments(type).at(0);
-    }
-    return type;
-}
 function getParameterCount(signature, compiler, typeChecker) {
-    if (hasRestParameter(signature, compiler)) {
+    if (signature.declaration != null && compiler.hasRestParameter(signature.declaration)) {
         const restType = typeChecker.getTypeOfSymbol(signature.parameters.at(-1));
-        if (isTupleTypeReference(restType, compiler)) {
+        if (typeChecker.isTupleType(restType)) {
             return signature.parameters.length + typeChecker.getTypeArguments(restType).length - 1;
         }
     }
     return signature.parameters.length;
 }
-function hasRestParameter(signature, compiler) {
-    return signature.declaration != null && compiler.hasRestParameter(signature.declaration);
-}
 function isOptionalParameter(symbol, compiler) {
     return (symbol.valueDeclaration != null &&
         compiler.isParameter(symbol.valueDeclaration) &&
@@ -4758,29 +4742,18 @@ function isRestParameter(symbol, compiler) {
         symbol.valueDeclaration.dotDotDotToken != null);
 }
 
-function getTargetSymbol(symbol, compiler) {
-    return isCheckFlagSet(symbol, compiler.CheckFlags.Instantiated, compiler)
-        ? symbol.links.target
-        : symbol;
-}
-function isCheckFlagSet(symbol, flag, compiler) {
-    return !!(symbol.flags & compiler.SymbolFlags.Transient && symbol.links.checkFlags & flag);
-}
-function isSymbolFromDefaultLibrary(symbol, program) {
-    if (!symbol.declarations) {
-        return false;
-    }
-    return symbol.declarations.every((declaration) => program.isSourceFileDefaultLibrary(declaration.getSourceFile()));
-}
-
 function getPropertyType(symbol, compiler, compilerOptions, typeChecker) {
     const type = typeChecker.getTypeOfSymbol(symbol);
     if (compilerOptions.exactOptionalPropertyTypes && isOptionalProperty(symbol, compiler)) {
-        if (isUnionType(type, compiler)) {
-            type.types = type.types.filter((type) => !("debugIntrinsicName" in type && type.debugIntrinsicName === "missing"));
-            if (type.types.length === 1) {
-                return type.types.at(0);
+        if (type.flags & compiler.TypeFlags.Union) {
+            const filteredType = type.types.filter((type) => !("debugIntrinsicName" in type && type.debugIntrinsicName === "missing"));
+            if (filteredType.length === type.types.length) {
+                return type;
             }
+            if (filteredType.length === 1) {
+                return filteredType.at(0);
+            }
+            return { ...type, types: filteredType };
         }
     }
     return type;
@@ -4795,11 +4768,26 @@ function isReadonlyProperty(symbol, compiler) {
         (symbol.flags & compiler.SymbolFlags.Accessor && !(symbol.flags & compiler.SymbolFlags.SetAccessor)));
 }
 
+class SeenService {
+    #cache = new Map();
+    memoized(a, b, compare) {
+        const key = [a.id, b.id].sort().join(":");
+        const result = this.#cache.get(key);
+        if (result !== undefined) {
+            return result !== 2;
+        }
+        this.#cache.set(key, 0);
+        const isSame = compare();
+        this.#cache.set(key, isSame ? 1 : 2);
+        return isSame;
+    }
+}
+
 class Structure {
     #compiler;
     #compilerOptions;
     #program;
-    #resultCache = new Map();
+    #seen = new SeenService();
     #typeChecker;
     constructor(compiler, program) {
         this.#compiler = compiler;
@@ -4821,7 +4809,7 @@ class Structure {
     compare(a, b) {
         a = this.#normalize(a);
         b = this.#normalize(b);
-        if (a === b) {
+        if (a.id === b.id) {
             return true;
         }
         if (a.flags & this.#compiler.TypeFlags.Any) {
@@ -4833,75 +4821,132 @@ class Structure {
         if (a.flags & this.#compiler.TypeFlags.Undefined) {
             return !!(b.flags & this.#compiler.TypeFlags.Undefined);
         }
-        if (isIntersectionType(a, this.#compiler) || isIntersectionType(b, this.#compiler)) {
-            if (isIntersectionType(a, this.#compiler) &&
-                isIntersectionType(b, this.#compiler) &&
-                a.types.length === b.types.length &&
-                a.types.every((aType, i) => this.compare(aType, b.types[i]))) {
-                return true;
-            }
-            return (this.compareProperties(a, b) &&
-                this.compareSignatures(a, b, this.#compiler.SignatureKind.Call) &&
-                this.compareSignatures(a, b, this.#compiler.SignatureKind.Construct) &&
-                this.compareIndexSignatures(a, b));
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.Intersection) {
+            return (((a.flags & b.flags & this.#compiler.TypeFlags.Intersection) !== 0 &&
+                this.compareIntersections(a, b)) ||
+                (((a.flags & b.flags) | this.#compiler.TypeFlags.StructuredType) !== 0 &&
+                    this.#seen.memoized(a, b, () => this.compareStructuredTypes(a, b))));
         }
-        if (isUnionType(a, this.#compiler) || isUnionType(b, this.#compiler)) {
-            if (isUnionType(a, this.#compiler) && isUnionType(b, this.#compiler)) {
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.Union) {
+            if (a.flags & b.flags & this.#compiler.TypeFlags.Union) {
                 return this.compareUnions(a, b);
             }
             return false;
         }
-        if (isTupleTypeReference(a, this.#compiler) || isTupleTypeReference(b, this.#compiler)) {
-            if (isTupleTypeReference(a, this.#compiler) && isTupleTypeReference(b, this.#compiler)) {
-                return this.compareTuples(a, b);
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.Object) {
+            if (a.flags & b.flags & this.#compiler.TypeFlags.Object) {
+                return this.#seen.memoized(a, b, () => this.compareObjects(a, b));
+            }
+            return false;
+        }
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.TypeParameter) {
+            if (a.flags & b.flags & this.#compiler.TypeFlags.TypeParameter) {
+                return this.compareTypeParameters(a, b);
+            }
+            return false;
+        }
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.Index) {
+            if (a.flags & b.flags & this.#compiler.TypeFlags.Index) {
+                return this.compare(a.type, b.type);
             }
             return false;
         }
-        if (isTypeParameter(a, this.#compiler) || isTypeParameter(b, this.#compiler)) {
-            if (isTypeParameter(a, this.#compiler) && isTypeParameter(b, this.#compiler)) {
-                return this.compareTypeParameter(a, b);
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.IndexedAccess) {
+            if (a.flags & b.flags & this.#compiler.TypeFlags.IndexedAccess) {
+                return this.compareIndexedAccessTypes(a, b);
             }
             return false;
         }
-        if (isConditionalType(a, this.#compiler) || isConditionalType(b, this.#compiler)) {
-            if (isConditionalType(a, this.#compiler) && isConditionalType(b, this.#compiler)) {
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.Conditional) {
+            if (a.flags & b.flags & this.#compiler.TypeFlags.Conditional) {
                 return this.compareConditionalTypes(a, b);
             }
             return false;
         }
-        if (isObjectType(a, this.#compiler) || isObjectType(b, this.#compiler)) {
-            if (isObjectType(a, this.#compiler) && isObjectType(b, this.#compiler)) {
-                return this.compareObjects(a, b);
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.Substitution) {
+            if (a.flags & b.flags & this.#compiler.TypeFlags.Substitution) {
+                return this.compareSubstitutionTypes(a, b);
             }
             return false;
         }
         return false;
     }
-    compareConditionalTypes(a, b) {
-        return (this.compare(a.checkType, b.checkType) &&
-            this.compare(a.extendsType, b.extendsType) &&
-            this.compare(this.#typeChecker.getTypeAtLocation(a.root.node.trueType), this.#typeChecker.getTypeAtLocation(b.root.node.trueType)) &&
-            this.compare(this.#typeChecker.getTypeAtLocation(a.root.node.falseType), this.#typeChecker.getTypeAtLocation(b.root.node.falseType)));
+    compareIntersections(a, b) {
+        if (a.types.length !== b.types.length) {
+            return false;
+        }
+        return a.types.every((aType, i) => this.compare(aType, b.types[i]));
     }
-    compareIndexSignatures(a, b) {
-        const aSignatures = this.#getIndexSignatures(a);
-        const bSignatures = this.#getIndexSignatures(b);
-        if (aSignatures.length !== bSignatures.length) {
+    compareUnions(a, b) {
+        if (a.types.length !== b.types.length) {
             return false;
         }
-        for (let i = 0; i < aSignatures.length; i++) {
-            if (aSignatures[i].isReadonly !== bSignatures[i].isReadonly) {
+        return a.types.every((aType) => b.types.some((bType) => this.compare(aType, bType)));
+    }
+    compareObjects(a, b) {
+        if (a.objectFlags & b.objectFlags & this.#compiler.ObjectFlags.Reference) {
+            const isSame = this.compareTypeReferences(a, b);
+            if (isSame != null) {
+                return isSame;
+            }
+        }
+        return this.compareStructuredTypes(a, b);
+    }
+    compareTypeReferences(a, b) {
+        if ((a.target.objectFlags | b.target.objectFlags) & this.#compiler.ObjectFlags.Tuple) {
+            if (a.target.objectFlags & b.target.objectFlags & this.#compiler.ObjectFlags.Tuple) {
+                return this.compareTuples(a, b);
+            }
+            return false;
+        }
+        if ((a.objectFlags | b.objectFlags) & this.#compiler.ObjectFlags.Class) {
+            return this.compareStructuredTypes(a, b);
+        }
+        if (!this.#compareTypeOfSymbol(a.symbol, b.symbol)) {
+            if (isSymbolFromDefaultLibrary(a.symbol, this.#program) || isSymbolFromDefaultLibrary(b.symbol, this.#program)) {
                 return false;
             }
-            if (!this.compare(aSignatures[i].keyType, bSignatures[i].keyType)) {
+            return;
+        }
+        if (length(a.typeArguments) !== length(b.typeArguments)) {
+            return false;
+        }
+        return ensureArray(a.typeArguments).every((type, i) => this.compare(type, ensureArray(b.typeArguments)[i]));
+    }
+    compareTuples(a, b) {
+        if (a.target.readonly !== b.target.readonly) {
+            return false;
+        }
+        const aTypeArguments = this.#typeChecker.getTypeArguments(a);
+        const bTypeArguments = this.#typeChecker.getTypeArguments(b);
+        if (length(aTypeArguments) !== length(bTypeArguments)) {
+            return false;
+        }
+        for (let i = 0; i < aTypeArguments.length; i++) {
+            if (a.target.elementFlags[i] !== b.target.elementFlags[i]) {
                 return false;
             }
-            if (!this.compare(aSignatures[i].type, bSignatures[i].type)) {
+            if (!this.compare(aTypeArguments[i], bTypeArguments[i])) {
                 return false;
             }
         }
         return true;
     }
+    compareStructuredTypes(a, b) {
+        if (!this.compareProperties(a, b)) {
+            return false;
+        }
+        if (!this.compareSignatures(a, b, this.#compiler.SignatureKind.Call)) {
+            return false;
+        }
+        if (!this.compareSignatures(a, b, this.#compiler.SignatureKind.Construct)) {
+            return false;
+        }
+        if (!this.compareIndexSignatures(a, b)) {
+            return false;
+        }
+        return true;
+    }
     compareProperties(a, b) {
         const aProperties = this.#typeChecker.getPropertiesOfType(a);
         const bProperties = this.#typeChecker.getPropertiesOfType(b);
@@ -4942,50 +4987,26 @@ class Structure {
         }
         return true;
     }
-    compareObjects(a, b) {
-        const key = this.#getCacheKey(a, b);
-        const result = this.#resultCache.get(key);
-        if (result != null) {
-            return result !== 2;
-        }
-        this.#resultCache.set(key, 0);
-        if (isTypeReference(a, this.#compiler) &&
-            !isClass(a, this.#compiler) &&
-            isTypeReference(b, this.#compiler) &&
-            !isClass(b, this.#compiler)) {
-            const isSame = this.compareTypeReferences(a, b);
-            if (isSame != null) {
-                this.#resultCache.set(key, isSame ? 1 : 2);
-                return isSame;
-            }
-        }
-        const isSame = this.compareProperties(a, b) &&
-            this.compareSignatures(a, b, this.#compiler.SignatureKind.Call) &&
-            this.compareSignatures(a, b, this.#compiler.SignatureKind.Construct) &&
-            this.compareIndexSignatures(a, b);
-        this.#resultCache.set(key, isSame ? 1 : 2);
-        return isSame;
-    }
     compareSignatures(a, b, kind) {
-        const aSignatures = this.#getSignatures(a, kind);
-        const bSignatures = this.#getSignatures(b, kind);
-        if (length(aSignatures) !== length(bSignatures)) {
+        const aSignatures = getSignatures(a, kind, this.#compiler, this.#typeChecker);
+        const bSignatures = getSignatures(b, kind, this.#compiler, this.#typeChecker);
+        if (aSignatures.length !== bSignatures.length) {
             return false;
         }
         for (let i = 0; i < aSignatures.length; i++) {
-            if (!this.compareSignature(aSignatures[i], bSignatures[i])) {
+            if (!this.#compareSignature(aSignatures[i], bSignatures[i])) {
                 return false;
             }
         }
         return true;
     }
-    compareSignature(a, b) {
+    #compareSignature(a, b) {
         if (length(a.typeParameters) !== length(b.typeParameters)) {
             return false;
         }
         if (a.typeParameters != null && b.typeParameters != null) {
             for (let i = 0; i < a.typeParameters.length; i++) {
-                if (!this.compareTypeParameter(a.typeParameters[i], b.typeParameters[i])) {
+                if (!this.compareTypeParameters(a.typeParameters[i], b.typeParameters[i])) {
                     return false;
                 }
             }
@@ -5028,76 +5049,81 @@ class Structure {
         }
         return true;
     }
-    compareTuples(a, b) {
-        if (a.target.readonly !== b.target.readonly) {
-            return false;
-        }
-        const aTypeArguments = this.#typeChecker.getTypeArguments(a);
-        const bTypeArguments = this.#typeChecker.getTypeArguments(b);
-        if (length(aTypeArguments) !== length(bTypeArguments)) {
+    compareIndexSignatures(a, b) {
+        const aSignatures = getIndexSignatures(a, this.#compiler, this.#typeChecker);
+        const bSignatures = getIndexSignatures(b, this.#compiler, this.#typeChecker);
+        if (aSignatures.length !== bSignatures.length) {
             return false;
         }
-        for (let i = 0; i < aTypeArguments.length; i++) {
-            if (a.target.elementFlags[i] !== b.target.elementFlags[i]) {
+        for (let i = 0; i < aSignatures.length; i++) {
+            if (aSignatures[i].isReadonly !== bSignatures[i].isReadonly) {
                 return false;
             }
-            if (!this.compare(aTypeArguments[i], bTypeArguments[i])) {
+            if (!this.compare(aSignatures[i].keyType, bSignatures[i].keyType)) {
+                return false;
+            }
+            if (!this.compare(aSignatures[i].type, bSignatures[i].type)) {
                 return false;
             }
         }
         return true;
     }
-    compareTypeParameter(a, b) {
-        if (!this.#compareMaybeNullish(this.#typeChecker.getBaseConstraintOfType(a), this.#typeChecker.getBaseConstraintOfType(b)) ||
-            !this.#compareMaybeNullish(this.#typeChecker.getDefaultFromTypeParameter(a), this.#typeChecker.getDefaultFromTypeParameter(b))) {
+    compareTypeParameters(a, b) {
+        if (getTypeParameterModifiers(a, this.#compiler) !== getTypeParameterModifiers(b, this.#compiler)) {
+            return false;
+        }
+        if (!this.#compareMaybeNullish(this.#typeChecker.getBaseConstraintOfType(a), this.#typeChecker.getBaseConstraintOfType(b))) {
+            return false;
+        }
+        if (!this.#compareMaybeNullish(this.#typeChecker.getDefaultFromTypeParameter(a), this.#typeChecker.getDefaultFromTypeParameter(b))) {
             return false;
         }
         return true;
     }
-    compareTypeReferences(a, b) {
-        if (!this.#compareTypeOfSymbol(a.symbol, b.symbol)) {
-            if (isSymbolFromDefaultLibrary(a.symbol, this.#program) || isSymbolFromDefaultLibrary(b.symbol, this.#program)) {
-                return false;
-            }
-            return;
+    compareIndexedAccessTypes(a, b) {
+        if (!this.compare(a.objectType, b.objectType)) {
+            return false;
         }
-        if (length(a.typeArguments) !== length(b.typeArguments)) {
+        if (!this.compare(a.indexType, b.indexType)) {
             return false;
         }
-        return ensureArray(a.typeArguments).every((type, i) => this.compare(type, ensureArray(b.typeArguments)[i]));
+        return true;
     }
-    compareUnions(a, b) {
-        if (a.types.length !== b.types.length) {
+    compareConditionalTypes(a, b) {
+        if (!this.compare(a.checkType, b.checkType)) {
             return false;
         }
-        return (a.types.every((aType) => b.types.some((bType) => this.compare(aType, bType))) &&
-            b.types.every((bType) => a.types.some((aType) => this.compare(bType, aType))));
-    }
-    #getCacheKey(a, b) {
-        return [a.id, b.id].sort().join(":");
-    }
-    #getSignatures(type, kind) {
-        if (isIntersectionType(type, this.#compiler)) {
-            return type.types.flatMap((type) => this.#getSignatures(type, kind));
+        if (!this.compare(a.extendsType, b.extendsType)) {
+            return false;
+        }
+        if (!this.compare(this.#typeChecker.getTypeAtLocation(a.root.node.trueType), this.#typeChecker.getTypeAtLocation(b.root.node.trueType))) {
+            return false;
+        }
+        if (!this.compare(this.#typeChecker.getTypeAtLocation(a.root.node.falseType), this.#typeChecker.getTypeAtLocation(b.root.node.falseType))) {
+            return false;
         }
-        return this.#typeChecker.getSignaturesOfType(type, kind);
+        return true;
     }
-    #getIndexSignatures(type) {
-        if (isIntersectionType(type, this.#compiler)) {
-            return type.types.flatMap((type) => this.#getIndexSignatures(type));
+    compareSubstitutionTypes(a, b) {
+        if (!this.compare(a.baseType, b.baseType)) {
+            return false;
         }
-        return this.#typeChecker.getIndexInfosOfType(type);
+        if (!this.compare(a.constraint, b.constraint)) {
+            return false;
+        }
+        return true;
     }
     #normalize(type) {
-        if (isFreshLiteralType(type, this.#compiler)) {
+        if (type.flags & this.#compiler.TypeFlags.Freshable && type.freshType === type) {
             return type.regularType;
         }
-        if (isNoInferType(type, this.#compiler)) {
+        if (type.flags & this.#compiler.TypeFlags.Substitution &&
+            type.constraint.flags & this.#compiler.TypeFlags.Unknown) {
             return type.baseType;
         }
-        if (isUnionType(type, this.#compiler) || isIntersectionType(type, this.#compiler)) {
+        if (type.flags & this.#compiler.TypeFlags.UnionOrIntersection) {
             const candidateType = this.#normalize(type.types[0]);
-            if (type.types.every((type) => this.compare(this.#normalize(type), candidateType))) {
+            if (type.types.every((t) => this.compare(this.#normalize(t), candidateType))) {
                 return candidateType;
             }
         }
@@ -5951,7 +5977,7 @@ class FileRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "6.0.0-beta.0";
+    static version = "6.0.0-beta.1";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "6.0.0-beta.0",
+  "version": "6.0.0-beta.1",
   "description": "Everything You Need for Type Testing.",
   "keywords": [
     "typescript",