tstyche 5.0.2 → 6.0.0-beta.1

package/build/tstyche.d.ts

@@ -158,6 +158,7 @@ interface ConfigFileOptions {
     checkSuppressedErrors?: boolean;
     failFast?: boolean;
     fixtureFileMatch?: Array<string>;
+    legacyToBe?: boolean;
     plugins?: Array<string>;
     rejectAnyType?: boolean;
     rejectNeverType?: boolean;
@@ -719,7 +720,9 @@ declare class Store {
     #private;
     static manifest: Manifest | undefined;
     static fetch(tag: string): Promise<void>;
-    static load(tag: string): Promise<typeof ts | undefined>;
+    static load(tag: string, options?: {
+        notPatched?: boolean;
+    }): Promise<typeof ts | undefined>;
     static open(): Promise<void>;
     static prune(): Promise<void>;
     static update(): Promise<void>;

package/build/tstyche.js

@@ -924,7 +924,7 @@ class Store {
         }
         await Store.#packageService.ensure(version, Store.manifest);
     }
-    static async load(tag) {
+    static async load(tag, options) {
         let compilerInstance = Store.#compilerInstanceCache.get(tag);
         if (compilerInstance != null) {
             return compilerInstance;
@@ -955,7 +955,13 @@ class Store {
             if (!Version.isSatisfiedWith(packageVersion, "5.3")) {
                 modulePath = Path.resolve(modulePath, "../tsserverlibrary.js");
             }
-            compilerInstance = await Store.#loadPatchedModule(modulePath);
+            if (options?.notPatched) {
+                const moduleSpecifier = pathToFileURL(modulePath).toString();
+                compilerInstance = (await import(moduleSpecifier)).default;
+            }
+            else {
+                compilerInstance = await Store.#loadPatchedModule(modulePath);
+            }
             Store.#compilerInstanceCache.set(tag, compilerInstance);
             Store.#compilerInstanceCache.set(compilerInstance.version, compilerInstance);
         }
@@ -1101,6 +1107,12 @@ class Options {
             group: 2,
             name: "help",
         },
+        {
+            brand: "boolean",
+            description: "Use the patch-based implementation of the '.toBe()' matcher.",
+            group: 4,
+            name: "legacyToBe",
+        },
         {
             brand: "true",
             description: "Print the list of supported versions of the 'typescript' package and exit.",
@@ -1591,6 +1603,7 @@ const defaultOptions = {
     checkSuppressedErrors: true,
     failFast: false,
     fixtureFileMatch: ["**/__fixtures__/*.{ts,tsx}", "**/fixtures/*.{ts,tsx}"],
+    legacyToBe: false,
     plugins: [],
     rejectAnyType: true,
     rejectNeverType: true,
@@ -4350,14 +4363,37 @@ class ExpectDiagnosticText {
     }
 }
 
+class RelationMatcherBase {
+    explain(matchWorker, sourceNode, targetNode) {
+        const sourceTypeText = matchWorker.getTypeText(sourceNode);
+        const targetTypeText = matchWorker.getTypeText(targetNode);
+        const text = matchWorker.assertionNode.isNot
+            ? this.explainText(sourceTypeText, targetTypeText)
+            : this.explainNotText(sourceTypeText, targetTypeText);
+        const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertionNode);
+        return [Diagnostic.error(text, origin)];
+    }
+}
+
+class LegacyToBe extends RelationMatcherBase {
+    explainText = ExpectDiagnosticText.isTheSame;
+    explainNotText = ExpectDiagnosticText.isNotTheSame;
+    match(matchWorker, sourceNode, targetNode) {
+        return {
+            explain: () => this.explain(matchWorker, sourceNode, targetNode),
+            isMatch: matchWorker.checkIsIdenticalTo(sourceNode, targetNode),
+        };
+    }
+}
+
 class MatchWorker {
     assertionNode;
     #compiler;
     #signatureCache = new Map();
     typeChecker;
-    constructor(compiler, typeChecker, assertionNode) {
+    constructor(compiler, program, assertionNode) {
         this.#compiler = compiler;
-        this.typeChecker = typeChecker;
+        this.typeChecker = program.getTypeChecker();
         this.assertionNode = assertionNode;
     }
     checkIsAssignableTo(sourceNode, targetNode) {
@@ -4446,9 +4482,9 @@ function isUniqueSymbolType(compiler, type) {
 class ToAcceptProps {
     #compiler;
     #typeChecker;
-    constructor(compiler, typeChecker) {
+    constructor(compiler, program) {
         this.#compiler = compiler;
-        this.#typeChecker = typeChecker;
+        this.#typeChecker = program.getTypeChecker();
     }
     #explain(matchWorker, sourceNode, targetNode) {
         const isExpression = nodeBelongsToArgumentList(this.#compiler, sourceNode);
@@ -4627,25 +4663,486 @@ class ToAcceptProps {
     }
 }
 
-class RelationMatcherBase {
-    explain(matchWorker, sourceNode, targetNode) {
-        const sourceTypeText = matchWorker.getTypeText(sourceNode);
-        const targetTypeText = matchWorker.getTypeText(targetNode);
-        const text = matchWorker.assertionNode.isNot
-            ? this.explainText(sourceTypeText, targetTypeText)
-            : this.explainNotText(sourceTypeText, targetTypeText);
-        const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertionNode);
-        return [Diagnostic.error(text, origin)];
+function ensureArray(input) {
+    return input ?? [];
+}
+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 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 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 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) {
+    return !!symbol.declarations?.every((declaration) => program.isSourceFileDefaultLibrary(declaration.getSourceFile()));
+}
+function length(array) {
+    return array?.length ?? 0;
+}
+
+function getParameterFactsFromTuple(type, position, compiler) {
+    return {
+        isOptional: !!(type.target.elementFlags[position] & compiler.ElementFlags.Optional),
+        isRest: !!(type.target.elementFlags[position] & compiler.ElementFlags.Rest),
+        getType: (typeChecker) => typeChecker.getTypeArguments(type)[position],
+    };
+}
+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 (typeChecker.isTupleType(restType)) {
+            const fixedLength = signature.parameters.length - 1;
+            return getParameterFactsFromTuple(restType, parameterIndex - fixedLength, compiler);
+        }
+    }
+    const parameter = signature.parameters[parameterIndex];
+    return {
+        isOptional: isOptionalParameter(parameter, compiler),
+        isRest: isRestParameter(parameter, compiler),
+        getType: (typeChecker) => typeChecker.getParameterType(signature, parameterIndex),
+    };
+}
+function getParameterCount(signature, compiler, typeChecker) {
+    if (signature.declaration != null && compiler.hasRestParameter(signature.declaration)) {
+        const restType = typeChecker.getTypeOfSymbol(signature.parameters.at(-1));
+        if (typeChecker.isTupleType(restType)) {
+            return signature.parameters.length + typeChecker.getTypeArguments(restType).length - 1;
+        }
+    }
+    return signature.parameters.length;
+}
+function isOptionalParameter(symbol, compiler) {
+    return (symbol.valueDeclaration != null &&
+        compiler.isParameter(symbol.valueDeclaration) &&
+        (symbol.valueDeclaration.questionToken != null || symbol.valueDeclaration.initializer != null));
+}
+function isRestParameter(symbol, compiler) {
+    return (symbol.valueDeclaration != null &&
+        compiler.isParameter(symbol.valueDeclaration) &&
+        symbol.valueDeclaration.dotDotDotToken != null);
+}
+
+function getPropertyType(symbol, compiler, compilerOptions, typeChecker) {
+    const type = typeChecker.getTypeOfSymbol(symbol);
+    if (compilerOptions.exactOptionalPropertyTypes && isOptionalProperty(symbol, compiler)) {
+        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;
+}
+function isOptionalProperty(symbol, compiler) {
+    return !!(symbol.flags & compiler.SymbolFlags.Optional);
+}
+function isReadonlyProperty(symbol, compiler) {
+    return !!(isCheckFlagSet(symbol, compiler.CheckFlags.Readonly, compiler) ||
+        (symbol.flags & compiler.SymbolFlags.Property &&
+            compiler.getDeclarationModifierFlagsFromSymbol(symbol) & compiler.ModifierFlags.Readonly) ||
+        (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;
+    #seen = new SeenService();
+    #typeChecker;
+    constructor(compiler, program) {
+        this.#compiler = compiler;
+        this.#compilerOptions = program.getCompilerOptions();
+        this.#program = program;
+        this.#typeChecker = program.getTypeChecker();
+    }
+    #compareMaybeNullish(a, b) {
+        if (a != null && b != null) {
+            return this.compare(a, b);
+        }
+        return !a && !b;
+    }
+    #compareTypeOfSymbol(a, b) {
+        const aTypeOfSymbol = a && this.#typeChecker.getTypeOfSymbol(a);
+        const bTypeOfSymbol = b && this.#typeChecker.getTypeOfSymbol(b);
+        return this.#compareMaybeNullish(aTypeOfSymbol, bTypeOfSymbol);
+    }
+    compare(a, b) {
+        a = this.#normalize(a);
+        b = this.#normalize(b);
+        if (a.id === b.id) {
+            return true;
+        }
+        if (a.flags & this.#compiler.TypeFlags.Any) {
+            return !!(b.flags & this.#compiler.TypeFlags.Any);
+        }
+        if (a.flags & this.#compiler.TypeFlags.Never) {
+            return !!(b.flags & this.#compiler.TypeFlags.Never);
+        }
+        if (a.flags & this.#compiler.TypeFlags.Undefined) {
+            return !!(b.flags & this.#compiler.TypeFlags.Undefined);
+        }
+        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 ((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 ((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 ((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 ((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 ((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;
+    }
+    compareIntersections(a, b) {
+        if (a.types.length !== b.types.length) {
+            return false;
+        }
+        return a.types.every((aType, i) => this.compare(aType, b.types[i]));
+    }
+    compareUnions(a, b) {
+        if (a.types.length !== b.types.length) {
+            return false;
+        }
+        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;
+            }
+            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(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);
+        if (aProperties.length !== bProperties.length) {
+            return false;
+        }
+        for (const aProperty of aProperties) {
+            const bProperty = bProperties.find((bProperty) => bProperty.escapedName === aProperty.escapedName);
+            if (!bProperty) {
+                return false;
+            }
+            if (aProperty === bProperty) {
+                continue;
+            }
+            const aAccessibility = this.#compiler.getDeclarationModifierFlagsFromSymbol(aProperty) &
+                this.#compiler.ModifierFlags.NonPublicAccessibilityModifier;
+            const bAccessibility = this.#compiler.getDeclarationModifierFlagsFromSymbol(bProperty) &
+                this.#compiler.ModifierFlags.NonPublicAccessibilityModifier;
+            if (aAccessibility !== bAccessibility) {
+                return false;
+            }
+            if (aAccessibility) {
+                if (getTargetSymbol(aProperty, this.#compiler) !== getTargetSymbol(bProperty, this.#compiler)) {
+                    return false;
+                }
+            }
+            if (isOptionalProperty(aProperty, this.#compiler) !== isOptionalProperty(bProperty, this.#compiler)) {
+                return false;
+            }
+            if (isReadonlyProperty(aProperty, this.#compiler) !== isReadonlyProperty(bProperty, this.#compiler)) {
+                return false;
+            }
+            const aType = getPropertyType(aProperty, this.#compiler, this.#compilerOptions, this.#typeChecker);
+            const bType = getPropertyType(bProperty, this.#compiler, this.#compilerOptions, this.#typeChecker);
+            if (!this.compare(aType, bType)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    compareSignatures(a, b, kind) {
+        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])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    #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.compareTypeParameters(a.typeParameters[i], b.typeParameters[i])) {
+                    return false;
+                }
+            }
+        }
+        if (!this.#compareTypeOfSymbol(a.thisParameter, b.thisParameter)) {
+            return false;
+        }
+        if (!this.compareParameters(a, b)) {
+            return false;
+        }
+        if (!this.compare(this.#typeChecker.getReturnTypeOfSignature(a), this.#typeChecker.getReturnTypeOfSignature(b))) {
+            return false;
+        }
+        const aTypePredicate = this.#typeChecker.getTypePredicateOfSignature(a);
+        const bTypePredicate = this.#typeChecker.getTypePredicateOfSignature(b);
+        if (aTypePredicate?.kind !== bTypePredicate?.kind ||
+            !this.#compareMaybeNullish(aTypePredicate?.type, bTypePredicate?.type)) {
+            return false;
+        }
+        return true;
+    }
+    compareParameters(a, b) {
+        const aParametersCount = getParameterCount(a, this.#compiler, this.#typeChecker);
+        const bParametersCount = getParameterCount(b, this.#compiler, this.#typeChecker);
+        if (aParametersCount !== bParametersCount) {
+            return false;
+        }
+        for (let i = 0; i < aParametersCount; i++) {
+            const aParameter = getParameterFacts(a, i, this.#compiler, this.#typeChecker);
+            const bParameter = getParameterFacts(b, i, this.#compiler, this.#typeChecker);
+            if (aParameter.isOptional !== bParameter.isOptional) {
+                return false;
+            }
+            if (aParameter.isRest !== bParameter.isRest) {
+                return false;
+            }
+            if (!this.compare(aParameter.getType(this.#typeChecker), bParameter.getType(this.#typeChecker))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    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 < aSignatures.length; i++) {
+            if (aSignatures[i].isReadonly !== bSignatures[i].isReadonly) {
+                return false;
+            }
+            if (!this.compare(aSignatures[i].keyType, bSignatures[i].keyType)) {
+                return false;
+            }
+            if (!this.compare(aSignatures[i].type, bSignatures[i].type)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    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;
+    }
+    compareIndexedAccessTypes(a, b) {
+        if (!this.compare(a.objectType, b.objectType)) {
+            return false;
+        }
+        if (!this.compare(a.indexType, b.indexType)) {
+            return false;
+        }
+        return true;
+    }
+    compareConditionalTypes(a, b) {
+        if (!this.compare(a.checkType, b.checkType)) {
+            return false;
+        }
+        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 true;
+    }
+    compareSubstitutionTypes(a, b) {
+        if (!this.compare(a.baseType, b.baseType)) {
+            return false;
+        }
+        if (!this.compare(a.constraint, b.constraint)) {
+            return false;
+        }
+        return true;
+    }
+    #normalize(type) {
+        if (type.flags & this.#compiler.TypeFlags.Freshable && type.freshType === type) {
+            return type.regularType;
+        }
+        if (type.flags & this.#compiler.TypeFlags.Substitution &&
+            type.constraint.flags & this.#compiler.TypeFlags.Unknown) {
+            return type.baseType;
+        }
+        if (type.flags & this.#compiler.TypeFlags.UnionOrIntersection) {
+            const candidateType = this.#normalize(type.types[0]);
+            if (type.types.every((t) => this.compare(this.#normalize(t), candidateType))) {
+                return candidateType;
+            }
+        }
+        return type;
     }
 }
 
 class ToBe extends RelationMatcherBase {
+    #structure;
+    constructor(compiler, program) {
+        super();
+        this.#structure = new Structure(compiler, program);
+    }
     explainText = ExpectDiagnosticText.isTheSame;
     explainNotText = ExpectDiagnosticText.isNotTheSame;
     match(matchWorker, sourceNode, targetNode) {
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNode),
-            isMatch: matchWorker.checkIsIdenticalTo(sourceNode, targetNode),
+            isMatch: this.#structure.compare(matchWorker.getType(sourceNode), matchWorker.getType(targetNode)),
         };
     }
 }
@@ -4974,8 +5471,8 @@ class ToRaiseError {
 
 class ExpectService {
     #compiler;
+    #program;
     #reject;
-    #typeChecker;
     toAcceptProps;
     toBe;
     toBeApplicable;
@@ -4985,12 +5482,12 @@ class ExpectService {
     toBeConstructableWith;
     toHaveProperty;
     toRaiseError;
-    constructor(compiler, typeChecker, reject) {
+    constructor(compiler, program, reject, resolvedConfig) {
         this.#compiler = compiler;
+        this.#program = program;
         this.#reject = reject;
-        this.#typeChecker = typeChecker;
-        this.toAcceptProps = new ToAcceptProps(compiler, typeChecker);
-        this.toBe = new ToBe();
+        this.toAcceptProps = new ToAcceptProps(compiler, program);
+        this.toBe = resolvedConfig.legacyToBe ? new LegacyToBe() : new ToBe(compiler, program);
         this.toBeApplicable = new ToBeApplicable(compiler);
         this.toBeAssignableFrom = new ToBeAssignableFrom();
         this.toBeAssignableTo = new ToBeAssignableTo();
@@ -5004,7 +5501,7 @@ class ExpectService {
         if (!argumentOrTypeArgumentIsProvided("source", "Source", assertionNode.source[0], assertionNode.node.expression, onDiagnostics)) {
             return;
         }
-        const matchWorker = new MatchWorker(this.#compiler, this.#typeChecker, assertionNode);
+        const matchWorker = new MatchWorker(this.#compiler, this.#program, assertionNode);
         if (!(matcherNameText === "toRaiseError" && assertionNode.isNot === false) &&
             this.#reject.argumentType([
                 ["source", assertionNode.source[0]],
@@ -5068,9 +5565,9 @@ class Reject {
     #compiler;
     #rejectedArgumentTypes = new Set();
     #typeChecker;
-    constructor(compiler, typeChecker, resolvedConfig) {
+    constructor(compiler, program, resolvedConfig) {
         this.#compiler = compiler;
-        this.#typeChecker = typeChecker;
+        this.#typeChecker = program.getTypeChecker();
         if (resolvedConfig?.rejectAnyType) {
             this.#rejectedArgumentTypes.add("any");
         }
@@ -5227,15 +5724,15 @@ class TestTreeWalker {
     #position;
     #resolvedConfig;
     #whenService;
-    constructor(compiler, typeChecker, resolvedConfig, onFileDiagnostics, options) {
+    constructor(compiler, program, resolvedConfig, onFileDiagnostics, options) {
         this.#compiler = compiler;
         this.#resolvedConfig = resolvedConfig;
         this.#onFileDiagnostics = onFileDiagnostics;
         this.#cancellationToken = options.cancellationToken;
         this.#hasOnly = options.hasOnly || resolvedConfig.only != null || options.position != null;
         this.#position = options.position;
-        const reject = new Reject(compiler, typeChecker, resolvedConfig);
-        this.#expectService = new ExpectService(compiler, typeChecker, reject);
+        const reject = new Reject(compiler, program, resolvedConfig);
+        this.#expectService = new ExpectService(compiler, program, reject, resolvedConfig);
         this.#whenService = new WhenService(reject, onFileDiagnostics);
     }
     async #resolveRunMode(flags, node) {
@@ -5425,9 +5922,8 @@ class FileRunner {
         }
         const semanticDiagnostics = languageService?.getSemanticDiagnostics(file.path);
         const program = languageService?.getProgram();
-        const typeChecker = program?.getTypeChecker();
         const sourceFile = program?.getSourceFile(file.path);
-        if (!sourceFile) {
+        if (!program || !sourceFile) {
             return;
         }
         const directiveRanges = Directive.getDirectiveRanges(this.#compiler, sourceFile);
@@ -5451,7 +5947,7 @@ class FileRunner {
         }
         const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics);
         this.#suppressedService.match(testTree);
-        return { runModeFlags, testTree, typeChecker };
+        return { runModeFlags, testTree, program };
     }
     async #run(file, fileResult, cancellationToken) {
         if (!existsSync(file.path)) {
@@ -5469,7 +5965,7 @@ class FileRunner {
         const onFileDiagnostics = (diagnostics) => {
             this.#onDiagnostics(diagnostics, fileResult);
         };
-        const testTreeWalker = new TestTreeWalker(this.#compiler, facts.typeChecker, this.#resolvedConfig, onFileDiagnostics, {
+        const testTreeWalker = new TestTreeWalker(this.#compiler, facts.program, this.#resolvedConfig, onFileDiagnostics, {
             cancellationToken,
             hasOnly: facts.testTree.hasOnly,
             position: file.position,
@@ -5481,7 +5977,7 @@ class FileRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "5.0.2";
+    static version = "6.0.0-beta.1";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -5538,7 +6034,7 @@ class Runner {
         for (const target of this.#resolvedConfig.target) {
             const targetResult = new TargetResult(target, files);
             EventEmitter.dispatch(["target:start", { result: targetResult }]);
-            const compiler = await Store.load(target);
+            const compiler = await Store.load(target, { notPatched: !this.#resolvedConfig.legacyToBe });
             if (compiler) {
                 const fileRunner = new FileRunner(compiler, this.#resolvedConfig);
                 for (const file of files) {

package/package.json

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