Generalize interface impl traversal. Simplify implementation of IsDir…

…ectlyCompatibleWith.
Washi1337 · Mar 18, 2023 · bf84256 · bf84256
1 parent 078a81d
commit bf84256
Show file tree

Hide file tree

Showing 3 changed files with 13 additions and 29 deletions.
diff --git a/src/AsmResolver.DotNet/Signatures/Types/GenericInstanceTypeSignature.cs b/src/AsmResolver.DotNet/Signatures/Types/GenericInstanceTypeSignature.cs
@@ -165,13 +165,10 @@ public override IEnumerable<TypeSignature> GetDirectlyImplementedInterfaces()
         /// <inheritdoc />
         protected override bool IsDirectlyCompatibleWith(TypeSignature other, SignatureComparer comparer)
         {
-            return base.IsDirectlyCompatibleWith(other, comparer)
-                   || IsDirectlyClassCompatibleWith(other, comparer)
-                   || IsDirectlyInterfaceCompatibleWith(other, comparer);
-        }
+            if (base.IsDirectlyCompatibleWith(other, comparer))
+                return true;
 
-        private bool IsDirectlyClassCompatibleWith(TypeSignature other, SignatureComparer comparer)
-        {
+            // Other type must be a generic instance with the same generic base type and type argument count.
             if (other is not GenericInstanceTypeSignature otherGenericInstance
                 || otherGenericInstance.TypeArguments.Count != TypeArguments.Count
                 || !comparer.Equals(GenericType, otherGenericInstance.GenericType))
@@ -201,18 +198,8 @@ private bool IsDirectlyClassCompatibleWith(TypeSignature other, SignatureCompare
                 if (!argumentIsCompatible)
                     return false;
             }
-            return true;
-        }
 
-        private bool IsDirectlyInterfaceCompatibleWith(TypeSignature other, SignatureComparer comparer)
-        {
-            foreach (var @interface in GetDirectlyImplementedInterfaces())
-            {
-                if (@interface.IsCompatibleWith(other, comparer))
-                    return true;
-            }
-
-            return false;
+            return true;
         }
 
         /// <inheritdoc />

diff --git a/src/AsmResolver.DotNet/Signatures/Types/TypeDefOrRefSignature.cs b/src/AsmResolver.DotNet/Signatures/Types/TypeDefOrRefSignature.cs
@@ -118,18 +118,6 @@ public override IEnumerable<TypeSignature> GetDirectlyImplementedInterfaces()
             return type.Interfaces.Select(i => i.Interface!.ToTypeSignature(false));
         }
 
-        /// <inheritdoc />
-        protected override bool IsDirectlyCompatibleWith(TypeSignature other, SignatureComparer comparer)
-        {
-            if (base.IsDirectlyCompatibleWith(other, comparer))
-                return true;
-            if (IsValueType)
-                return false;
-
-            return comparer.Equals(GetDirectBaseClass(), other)
-                   || GetDirectlyImplementedInterfaces().Contains(other, comparer);
-        }
-
         /// <inheritdoc />
         public override TResult AcceptVisitor<TResult>(ITypeSignatureVisitor<TResult> visitor) =>
             visitor.VisitTypeDefOrRef(this);

diff --git a/src/AsmResolver.DotNet/Signatures/Types/TypeSignature.cs b/src/AsmResolver.DotNet/Signatures/Types/TypeSignature.cs
@@ -437,9 +437,18 @@ public bool IsCompatibleWith(TypeSignature other, SignatureComparer comparer)
             // Achieve the transitivity rule by moving up the type hierarchy iteratively.
             while (current is not null)
             {
+                // Is the current type compatible?
                 if (current.IsDirectlyCompatibleWith(other, comparer))
                     return true;
 
+                // Are any of the interfaces compatible instead?
+                foreach (var @interface in current.GetDirectlyImplementedInterfaces())
+                {
+                    if (@interface.IsCompatibleWith(other, comparer))
+                        return true;
+                }
+
+                // If neither, move up type hierarchy.
                 current = current.GetDirectBaseClass()?.StripModifiers();
             }