tstyche 6.0.2 → 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;
@@ -4676,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) {
@@ -4688,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.#memoize(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;
         }
@@ -4708,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.#memoize(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);
@@ -4744,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);
@@ -4754,7 +4770,6 @@ class Structure {
             if (a.flags & b.flags & this.#compiler.TypeFlags.StringMapping) {
                 return this.compareStringMappingTypes(a, b);
             }
-            return false;
         }
         return false;
     }
@@ -4780,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) {
@@ -4823,7 +4832,7 @@ class Structure {
         }
         return true;
     }
-    compareStructuredTypes(a, b) {
+    compareStructures(a, b) {
         if (!this.compareProperties(a, b)) {
             return false;
         }
@@ -4885,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;
             }
         }
@@ -5920,7 +5914,7 @@ class FileRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "6.0.2";
+    static version = "6.0.3";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }

package/package.json

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