From fa2345017a22c74d13d9dd84b21bfc158d13b80d Mon Sep 17 00:00:00 2001
From: walon <walon@code-philosophy.com>
Date: Sun, 19 Jul 2026 13:02:21 +0800
Subject: [PATCH] fix: fix
 VirtualMethodGroupCalculator.TypeFlatMethods::IsLooseTypeSigMatch treats type
 and forward type as different type by type.AssemblyQualifiedName which leads
 same-virtual-slot virtual methods are grouped to different virtual method
 group. see
 [issue-32](https://github.com/focus-creative-games/obfuz/issues/32)

---
 .../ObfusPasses/SymbolObfus/SymbolRename.cs   | 41 +++++++++++--------
 .../VirtualMethodGroupCalculator.cs           | 10 ++++-
 2 files changed, 32 insertions(+), 19 deletions(-)

diff --git a/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs b/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs
index efa00d1..fbb904d 100644
--- a/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs
+++ b/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs
@@ -49,6 +49,7 @@ namespace Obfuz.ObfusPasses.SymbolObfus
         private readonly Dictionary<ModuleDef, List<CustomAttributeInfo>> _customAttributeArgumentsWithTypeByMods = new Dictionary<ModuleDef, List<CustomAttributeInfo>>();
         private readonly RenameRecordMap _renameRecordMap;
         private readonly VirtualMethodGroupCalculator _virtualMethodGroupCalculator;
+        private readonly List<MethodDef> _virtualMethods = new List<MethodDef>();
         private readonly List<Type> _customPolicyTypes;
 
         class CustomAttributeInfo
@@ -205,6 +206,7 @@ namespace Obfuz.ObfusPasses.SymbolObfus
         public void Process()
         {
             _renameRecordMap.Init(_toObfuscatedModules, _nameMaker);
+            BuildVirtualMethodGroup();
             RenameTypes();
             RenameFields();
             RenameMethods();
@@ -525,11 +527,28 @@ namespace Obfuz.ObfusPasses.SymbolObfus
             }
         }
 
+        private void BuildVirtualMethodGroup()
+        {
+            foreach (ModuleDef mod in _obfuscatedAndNotObfuscatedModules)
+            {
+                foreach (TypeDef type in mod.GetTypes())
+                {
+                    _virtualMethodGroupCalculator.CalculateType(type);
+                    foreach (MethodDef method in type.Methods)
+                    {
+                        if (method.IsVirtual)
+                        {
+                            _virtualMethods.Add(method);
+                        }
+                    }
+                }
+            }
+        }
+
         private void RenameMethods()
         {
             //Debug.Log("Rename methods begin");
             //Debug.Log("Rename not virtual methods begin");
-            var virtualMethods = new List<MethodDef>();
             var refMethodMetasMap = new Dictionary<MethodDef, RefMethodMetas>();
             BuildRefMethodMetasMap(refMethodMetasMap);
             foreach (ModuleDef mod in _toObfuscatedModules)
@@ -552,28 +571,13 @@ namespace Obfuz.ObfusPasses.SymbolObfus
                 }
             }
 
-            foreach (ModuleDef mod in _obfuscatedAndNotObfuscatedModules)
-            {
-                foreach (TypeDef type in mod.GetTypes())
-                {
-                    _virtualMethodGroupCalculator.CalculateType(type);
-                    foreach (MethodDef method in type.Methods)
-                    {
-                        if (method.IsVirtual)
-                        {
-                            virtualMethods.Add(method);
-                        }
-                    }
-                }
-            }
-
             //Debug.Log("Rename not virtual methods end");
 
 
             //Debug.Log("Rename virtual methods begin");
             var visitedVirtualMethods = new HashSet<MethodDef>();
             var groupNeedRenames = new Dictionary<VirtualMethodGroup, bool>();
-            foreach (var method in virtualMethods)
+            foreach (var method in _virtualMethods)
             {
                 if (!visitedVirtualMethods.Add(method))
                 {
@@ -753,7 +757,8 @@ namespace Obfuz.ObfusPasses.SymbolObfus
                 foreach (TypeRef typeRef in refTypeDefMeta.typeRefs)
                 {
                     Assert.AreEqual(typeRef.FullName, oldFullName);
-                    Assert.IsTrue(typeRef.DefinitionAssembly.Name == moduleName);
+                    // Assert fail when typeRef to a fowarded type
+                    // Assert.IsTrue(typeRef.DefinitionAssembly.Name == moduleName);
                     if (!string.IsNullOrEmpty(oldNamespace))
                     {
                         typeRef.Namespace = newNamespace;
diff --git a/Editor/ObfusPasses/SymbolObfus/VirtualMethodGroupCalculator.cs b/Editor/ObfusPasses/SymbolObfus/VirtualMethodGroupCalculator.cs
index 997de92..b8d2041 100644
--- a/Editor/ObfusPasses/SymbolObfus/VirtualMethodGroupCalculator.cs
+++ b/Editor/ObfusPasses/SymbolObfus/VirtualMethodGroupCalculator.cs
@@ -160,7 +160,15 @@ namespace Obfuz.ObfusPasses.SymbolObfus
                     case ElementType.Class:
                     case ElementType.ValueType:
                     {
-                        return t1.AssemblyQualifiedName == t2.AssemblyQualifiedName;
+                        if (t1.AssemblyQualifiedName == t2.AssemblyQualifiedName)
+                        {
+                            return true;
+                        }
+                        if (t1.FullName == t2.FullName)
+                        {
+                            return t1.ToTypeDefOrRef().ResolveTypeDefThrow() == t2.ToTypeDefOrRef().ResolveTypeDefThrow();
+                        }
+                        return false;
                     }
                     case ElementType.Ptr:
                     case ElementType.ByRef: