tstyche 6.0.1 → 6.0.3

package/dist/tstyche.js

@@ -4569,9 +4569,6 @@ function getSignatures(type, kind, compiler, typeChecker) {
 function getThisTypeOfSignature(signature, typeChecker) {
     return signature.thisParameter && typeChecker.getTypeOfSymbol(signature.thisParameter);
 }
-function getTypeParametersOfSignature(signature) {
-    return signature.typeParameters ?? [];
-}
 function getTypeParameterModifiers(typeParameter, compiler) {
     if (!typeParameter.symbol.declarations) {
         return compiler.ModifierFlags.None;
@@ -4656,26 +4653,12 @@ 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;
-    #seen = new SeenService();
     #typeChecker;
+    #deduplicateCache = new WeakMap();
+    #memoizeCache = new Map();
     constructor(compiler, program) {
         this.#compiler = compiler;
         this.#compilerOptions = program.getCompilerOptions();
@@ -4690,7 +4673,7 @@ class Structure {
     compare(a, b) {
         a = this.#normalize(a);
         b = this.#normalize(b);
-        if (a.id === b.id) {
+        if (a === b) {
             return true;
         }
         if (a.flags & this.#compiler.TypeFlags.Any) {
@@ -4702,17 +4685,24 @@ class Structure {
         if (a.flags & this.#compiler.TypeFlags.Undefined) {
             return !!(b.flags & this.#compiler.TypeFlags.Undefined);
         }
-        if ((a.flags | b.flags) & this.#compiler.TypeFlags.Intersection) {
-            if (a.flags & b.flags & this.#compiler.TypeFlags.Intersection) {
-                if (this.compareIntersections(a, b)) {
-                    return true;
-                }
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.StructuredType) {
+            if (a.flags & this.#compiler.TypeFlags.StructuredType && b.flags & this.#compiler.TypeFlags.StructuredType) {
+                return this.#memoize(a, b, () => this.compareStructured(a, b));
             }
-            if (containsInstantiable(a, this.#compiler) || containsInstantiable(b, this.#compiler)) {
-                return false;
+            return false;
+        }
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.Instantiable) {
+            if (a.flags & this.#compiler.TypeFlags.Instantiable && b.flags & this.#compiler.TypeFlags.Instantiable) {
+                return this.#memoize(a, b, () => this.compareInstantiable(a, b));
             }
-            if ((a.flags & b.flags) | this.#compiler.TypeFlags.StructuredType) {
-                return this.#seen.memoized(a, b, () => this.compareStructuredTypes(a, b));
+            return false;
+        }
+        return false;
+    }
+    compareStructured(a, b) {
+        if (this.#typeChecker.isTupleType(a) || this.#typeChecker.isTupleType(b)) {
+            if (this.#typeChecker.isTupleType(a) && this.#typeChecker.isTupleType(b)) {
+                return this.compareTuples(a, b);
             }
             return false;
         }
@@ -4722,24 +4712,30 @@ class Structure {
             }
             return false;
         }
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.Intersection) {
+            if (a.flags & b.flags & this.#compiler.TypeFlags.Intersection) {
+                if (this.compareIntersections(a, b)) {
+                    return true;
+                }
+            }
+            if (containsInstantiable(a, this.#compiler) || containsInstantiable(b, this.#compiler)) {
+                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 this.compareObjects(a, b);
             }
-            return false;
         }
+        return this.compareStructures(a, b);
+    }
+    compareInstantiable(a, b) {
         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);
@@ -4758,6 +4754,12 @@ class Structure {
             }
             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.TemplateLiteral) {
             if (a.flags & b.flags & this.#compiler.TypeFlags.TemplateLiteral) {
                 return this.compareTemplateLiteralTypes(a, b);
@@ -4768,21 +4770,24 @@ class Structure {
             if (a.flags & b.flags & this.#compiler.TypeFlags.StringMapping) {
                 return this.compareStringMappingTypes(a, b);
             }
-            return false;
         }
         return false;
     }
     compareIntersections(a, b) {
-        if (a.types.length !== b.types.length) {
+        const aTypes = this.#deduplicate(a);
+        const bTypes = this.#deduplicate(b);
+        if (aTypes.length !== bTypes.length) {
             return false;
         }
-        return a.types.every((aType, i) => this.compare(aType, b.types[i]));
+        return aTypes.every((aType, i) => this.compare(aType, bTypes[i]));
     }
     compareUnions(a, b) {
-        if (a.types.length !== b.types.length) {
+        const aTypes = this.#deduplicate(a);
+        const bTypes = this.#deduplicate(b);
+        if (aTypes.length !== bTypes.length) {
             return false;
         }
-        return a.types.every((aType) => b.types.some((bType) => this.compare(aType, bType)));
+        return aTypes.every((aType) => bTypes.some((bType) => this.compare(aType, bType)));
     }
     compareObjects(a, b) {
         if (a.objectFlags & b.objectFlags & this.#compiler.ObjectFlags.Reference) {
@@ -4790,29 +4795,23 @@ class Structure {
                 return this.compareTypeReferences(a, b);
             }
         }
-        return this.compareStructuredTypes(a, b);
+        return this.compareStructures(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 (!this.compare(a.target, b.target)) {
-            return this.compareStructuredTypes(a, b);
-        }
-        const aTypeArguments = this.#typeChecker.getTypeArguments(a);
-        const bTypeArguments = this.#typeChecker.getTypeArguments(b);
-        if (aTypeArguments.length !== bTypeArguments.length) {
-            return false;
-        }
-        for (let i = 0; i < aTypeArguments.length; i++) {
-            if (!this.compare(aTypeArguments[i], bTypeArguments[i])) {
+        if (this.compare(a.target, b.target)) {
+            const aTypeArguments = this.#typeChecker.getTypeArguments(a);
+            const bTypeArguments = this.#typeChecker.getTypeArguments(b);
+            if (aTypeArguments.length !== bTypeArguments.length) {
                 return false;
             }
+            for (let i = 0; i < aTypeArguments.length; i++) {
+                if (!this.compare(aTypeArguments[i], bTypeArguments[i])) {
+                    return false;
+                }
+            }
+            return true;
         }
-        return true;
+        return this.compareStructures(a, b);
     }
     compareTuples(a, b) {
         if (a.target.readonly !== b.target.readonly) {
@@ -4833,7 +4832,7 @@ class Structure {
         }
         return true;
     }
-    compareStructuredTypes(a, b) {
+    compareStructures(a, b) {
         if (!this.compareProperties(a, b)) {
             return false;
         }
@@ -4895,56 +4894,41 @@ class Structure {
             return false;
         }
         for (let i = 0; i < aSignatures.length; i++) {
-            if (!this.#compareSignature(aSignatures[i], bSignatures[i])) {
+            const aThisType = getThisTypeOfSignature(aSignatures[i], this.#typeChecker);
+            const bThisType = getThisTypeOfSignature(bSignatures[i], this.#typeChecker);
+            if (!this.#compareMaybeNullish(aThisType, bThisType)) {
                 return false;
             }
-        }
-        return true;
-    }
-    #compareSignature(a, b) {
-        const aTypeParameters = getTypeParametersOfSignature(a);
-        const bTypeParameters = getTypeParametersOfSignature(b);
-        if (aTypeParameters.length !== bTypeParameters.length) {
-            return false;
-        }
-        for (let i = 0; i < aTypeParameters.length; i++) {
-            if (!this.compareTypeParameters(aTypeParameters[i], bTypeParameters[i])) {
+            const aParametersCount = getParameterCount(aSignatures[i], this.#compiler, this.#typeChecker);
+            const bParametersCount = getParameterCount(bSignatures[i], this.#compiler, this.#typeChecker);
+            if (aParametersCount !== bParametersCount) {
                 return false;
             }
-        }
-        if (!this.#compareMaybeNullish(getThisTypeOfSignature(a, this.#typeChecker), getThisTypeOfSignature(b, this.#typeChecker))) {
-            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) {
+            for (let j = 0; j < aParametersCount; j++) {
+                const aParameter = getParameterFacts(aSignatures[i], j, this.#compiler, this.#typeChecker);
+                const bParameter = getParameterFacts(bSignatures[i], j, 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;
+                }
+            }
+            const aReturnType = this.#typeChecker.getReturnTypeOfSignature(aSignatures[i]);
+            const bReturnType = this.#typeChecker.getReturnTypeOfSignature(bSignatures[i]);
+            if (!this.compare(aReturnType, bReturnType)) {
                 return false;
             }
-            if (aParameter.isRest !== bParameter.isRest) {
+            const aTypePredicate = this.#typeChecker.getTypePredicateOfSignature(aSignatures[i]);
+            const bTypePredicate = this.#typeChecker.getTypePredicateOfSignature(bSignatures[i]);
+            if (aTypePredicate?.parameterIndex !== bTypePredicate?.parameterIndex) {
                 return false;
             }
-            if (!this.compare(aParameter.getType(this.#typeChecker), bParameter.getType(this.#typeChecker))) {
+            if (aTypePredicate?.kind !== bTypePredicate?.kind ||
+                !this.#compareMaybeNullish(aTypePredicate?.type, bTypePredicate?.type)) {
                 return false;
             }
         }
@@ -5037,14 +5021,39 @@ class Structure {
         }
         return true;
     }
+    #deduplicate(target) {
+        let result = this.#deduplicateCache.get(target);
+        if (result) {
+            return result;
+        }
+        result = target.types.slice(0, 1);
+        for (let i = 1; i < target.types.length; i++) {
+            if (!result.some((existing) => this.compare(existing, target.types[i]))) {
+                result.push(target.types[i]);
+            }
+        }
+        this.#deduplicateCache.set(target, result);
+        return result;
+    }
+    #memoize(a, b, compare) {
+        const key = [a.id, b.id].sort().join(":");
+        const result = this.#memoizeCache.get(key);
+        if (result !== undefined) {
+            return result !== 2;
+        }
+        this.#memoizeCache.set(key, 0);
+        const isSame = compare();
+        this.#memoizeCache.set(key, isSame ? 1 : 2);
+        return isSame;
+    }
     #normalize(type) {
         if (type.flags & this.#compiler.TypeFlags.Freshable && type.freshType === type) {
             return type.regularType;
         }
         if (type.flags & this.#compiler.TypeFlags.UnionOrIntersection) {
-            const candidateType = type.types[0];
-            if (type.types.every((t) => this.compare(t, candidateType))) {
-                return candidateType;
+            const parts = this.#deduplicate(type);
+            if (parts.length === 1) {
+                return parts.at(0);
             }
         }
         return type;
@@ -5905,7 +5914,7 @@ class FileRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "6.0.1";
+    static version = "6.0.3";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }

package/package.json

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