(#41) ImportLogic: correct allowlist for the interface implementations

JetBrains · Dec 30, 2024 · 89be17b · 89be17b
1 parent 93e9c79
commit 89be17b
Show file tree

Hide file tree

Showing 6 changed files with 27 additions and 15 deletions.
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
@@ -1,6 +1,6 @@
 <Project>
     <PropertyGroup Label="Packaging">
-        <Version>2.0.1-pre06</Version>
+        <Version>2.0.1-pre07</Version>
         <Copyright>Copyright © JetBrains 2024</Copyright>
 
         <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>

diff --git a/src/Refasmer/Importer/ImportLogic.cs b/src/Refasmer/Importer/ImportLogic.cs
@@ -23,7 +23,8 @@ private bool AllowImportType( EntityHandle typeHandle )
         switch (typeHandle.Kind)
         {
             case HandleKind.TypeDefinition:
-                return true;
+                var type = _reader.GetTypeDefinition((TypeDefinitionHandle)typeHandle);
+                return Filter.AllowImport(type, _reader);
             case HandleKind.TypeReference:
                 return true;
             case HandleKind.TypeSpecification:
@@ -87,7 +88,7 @@ private TypeDefinitionHandle ImportTypeDefinitionSkeleton(TypeDefinitionHandle s
         if (!forcePreservePrivateFields)
             PostProcessSkippedValueTypeFields(skippedInstanceFields!, importedInstanceFields!);
 
-        var implementations = GetCurrentAssemblyInterfaceMethodImplementations(src);
+        var implementations = GetAllowlistedInterfaceMethodImplementations(src);
 
         foreach (var srcMethodHandle in src.GetMethods())
         {
@@ -402,7 +403,7 @@ public bool IsReferenceAssembly() =>
             .Select(_reader.GetFullname)
             .Any(name => name == FullNames.ReferenceAssembly);
 
-    private ImmutableHashSet<MethodDefinitionHandle> GetCurrentAssemblyInterfaceMethodImplementations(
+    private ImmutableHashSet<MethodDefinitionHandle> GetAllowlistedInterfaceMethodImplementations(
         TypeDefinition type)
     {
         return GetImplementations().ToImmutableHashSet();
@@ -413,15 +414,8 @@ IEnumerable<MethodDefinitionHandle> GetImplementations()
                 .Select(_reader.GetMethodImplementation);
             foreach (var mi in implementations)
             {
-                if (!AllowImportType(_reader.GetMethodClass(mi.MethodDeclaration)))
-                    continue;
-
-                var bodyHandle = (MethodDefinitionHandle)mi.MethodBody;
-                var method = _reader.GetMethodDefinition(bodyHandle);
-                var isStatic = (method.Attributes & MethodAttributes.Static) != 0;
-                if (isStatic) continue;
-
-                yield return bodyHandle;
+                if (AllowImportType(_reader.GetMethodClass(mi.MethodDeclaration)))
+                    yield return (MethodDefinitionHandle)mi.MethodBody;
             }
         }
     }
@@ -430,7 +424,7 @@ private bool AllowImportMethod(
         IImmutableSet<MethodDefinitionHandle> implementations,
         MethodDefinitionHandle methodHandle,
         MethodDefinition method) =>
-        !implementations.Contains(methodHandle) && (Filter == null || Filter.AllowImport(method, _reader));
+        implementations.Contains(methodHandle) || Filter == null || Filter.AllowImport(method, _reader);
 
     public ReservedBlob<GuidHandle> Import()
     {
@@ -672,7 +666,7 @@ private IEnumerable<TypeDefinitionHandle> CalculateInternalTypesToPreserve(
                     AcceptFieldSignature(field, collector);
             }
 
-            var methodImplementations = GetCurrentAssemblyInterfaceMethodImplementations(type);
+            var methodImplementations = GetAllowlistedInterfaceMethodImplementations(type);
             foreach (var methodHandle in type.GetMethods())
             {
                 var method = _reader.GetMethodDefinition(methodHandle);

diff --git a/tests/Refasmer.Tests/IntegrationTests.cs b/tests/Refasmer.Tests/IntegrationTests.cs
@@ -27,6 +27,7 @@ public async Task CheckRefasmedType(string typeName)
     [TestCase("RefasmerTestAssembly.NonBlittableGraph")]
     [TestCase("RefasmerTestAssembly.EmptyStructWithStaticMember")]
     [TestCase("RefasmerTestAssembly.NonEmptyStructWithStaticMember")]
+    [TestCase("RefasmerTestAssembly.CustomEnumerable")]
     public async Task CheckRefasmedTypeOmitNonApi(string typeName)
     {
         var assemblyPath = await BuildTestAssembly();

diff --git a/...s.CheckRefasmedTypeOmitNonApi_typeName=RefasmerTestAssembly.CustomEnumerable.verified.txt b/...s.CheckRefasmedTypeOmitNonApi_typeName=RefasmerTestAssembly.CustomEnumerable.verified.txt
@@ -0,0 +1,5 @@
+public class: RefasmerTestAssembly.CustomEnumerable
+  - interface impl: System.Collections.IEnumerable
+methods:
+- System.Collections.IEnumerable.GetEnumerator(): System.Collections.IEnumerator:
+- .ctor(): System.Void:
diff --git a/tests/Refasmer.Tests/data/IntegrationTests.InterfaceImplementations.verified.txt b/tests/Refasmer.Tests/data/IntegrationTests.InterfaceImplementations.verified.txt
@@ -5,10 +5,13 @@ methods:
 - GetHashCode(): System.Int32:
 - op_Equality(RefasmerTestAssembly.InterfaceImplementations a, RefasmerTestAssembly.InterfaceImplementations b): System.Boolean:
 - op_Inequality(RefasmerTestAssembly.InterfaceImplementations a, RefasmerTestAssembly.InterfaceImplementations b): System.Boolean:
+- InstanceMethod(): System.Void:
 - .ctor(): System.Void:
 public interface: RefasmerTestAssembly.IWithStaticMethods`1
 methods:
 - op_Equality(TSelf a, TSelf b): System.Boolean:
   - <abstract>
 - op_Inequality(TSelf a, TSelf b): System.Boolean:
   - <abstract>
+- InstanceMethod(): System.Void:
+  - <abstract>
diff --git a/tests/RefasmerTestAssembly/InterfaceImplementations.cs b/tests/RefasmerTestAssembly/InterfaceImplementations.cs
@@ -1,11 +1,14 @@
 using System;
+using System.Collections;
 
 namespace RefasmerTestAssembly;
 
 public interface IWithStaticMethods<TSelf> where TSelf : IWithStaticMethods<TSelf>
 {
     static abstract bool operator ==(TSelf a, TSelf b);
     static abstract bool operator !=(TSelf a, TSelf b);
+
+    void InstanceMethod();
 }
 public class InterfaceImplementations : IWithStaticMethods<InterfaceImplementations>
 {
@@ -16,4 +19,10 @@ public class InterfaceImplementations : IWithStaticMethods<InterfaceImplementati
     public static bool operator ==(InterfaceImplementations a, InterfaceImplementations b) => throw new NotSupportedException();
 
     public static bool operator !=(InterfaceImplementations a, InterfaceImplementations b) => throw new NotSupportedException();
+
+    public void InstanceMethod() { }
+}
+public class CustomEnumerable : IEnumerable
+{
+    IEnumerator IEnumerable.GetEnumerator() => null!;
 }