重构Rename

Editor/CleanUpInstructionPass.cs

@@ -21,9 +21,9 @@ namespace Obfuz
 
         public override void Process(ObfuscatorContext ctx)
         {
-            foreach (var ass in ctx.assemblies)
+            foreach (ModuleDef mod in ctx.toObfuscatedModules)
             {
-                foreach (TypeDef type in ass.module.GetTypes())
+                foreach (TypeDef type in mod.GetTypes())
                 {
                     foreach (MethodDef method in type.Methods)
                     {

Editor/MethodBodyObfuscationPassBase.cs

@@ -11,10 +11,10 @@ namespace Obfuz
 
         public override void Process(ObfuscatorContext ctx)
         {
-            foreach (var ass in ctx.assemblies)
+            foreach (ModuleDef mod in ctx.toObfuscatedModules)
             {
                 // ToArray to avoid modify list exception
-                foreach (TypeDef type in ass.module.GetTypes().ToArray())
+                foreach (TypeDef type in mod.GetTypes().ToArray())
                 {
                     if (type.Name.StartsWith("$Obfuz$"))
                     {

Editor/Obfuscator.cs

@@ -16,11 +16,10 @@ namespace Obfuz
         private readonly string _obfuscatedAssemblyOutputDir;
         private readonly AssemblyCache _assemblyCache;
 
-        private readonly List<ObfuzAssemblyInfo> _obfuzAssemblies = new List<ObfuzAssemblyInfo>();
-
-
         private readonly List<string> _toObfuscatedAssemblyNames;
         private readonly List<string> _notObfuscatedAssemblyNamesReferencingObfuscated;
+        private readonly List<ModuleDef> _toObfuscatedModules = new List<ModuleDef>();
+        private readonly List<ModuleDef> _obfuscatedAndNotObfuscatedModules = new List<ModuleDef>();
 
         private readonly ObfuzPipeline _pipeline = new ObfuzPipeline();
 
@@ -63,7 +62,8 @@ namespace Obfuz
             _ctx = new ObfuscatorContext
             {
                 assemblyCache = _assemblyCache,
-                assemblies = _obfuzAssemblies,
+                toObfuscatedModules = _toObfuscatedModules,
+                obfuscatedAndNotObfuscatedModules = _obfuscatedAndNotObfuscatedModules,
                 toObfuscatedAssemblyNames = _toObfuscatedAssemblyNames,
                 notObfuscatedAssemblyNamesReferencingObfuscated = _notObfuscatedAssemblyNamesReferencingObfuscated,
                 obfuscatedAssemblyOutputDir = _obfuscatedAssemblyOutputDir,
@@ -73,7 +73,7 @@ namespace Obfuz
 
         private void LoadAssemblies()
         {
-            foreach (string assName in _toObfuscatedAssemblyNames)
+            foreach (string assName in _toObfuscatedAssemblyNames.Concat(_notObfuscatedAssemblyNamesReferencingObfuscated))
             {
                 ModuleDefMD mod = _assemblyCache.TryLoadModule(assName);
                 if (mod == null)
@@ -81,28 +81,11 @@ namespace Obfuz
                     Debug.Log($"assembly: {assName} not found! ignore.");
                     continue;
                 }
-                var obfuzAsm = new ObfuzAssemblyInfo
+                if (_toObfuscatedAssemblyNames.Contains(assName))
                 {
-                    name = assName,
+                    _toObfuscatedModules.Add(mod);
-                    module = mod,
-                    referenceMeAssemblies = new List<ObfuzAssemblyInfo>(),
-                };
-                obfuzAsm.referenceMeAssemblies.Add(obfuzAsm);
-                _obfuzAssemblies.Add(obfuzAsm);
-            }
-            
-            var assByName = _obfuzAssemblies.ToDictionary(x => x.name);
-            foreach (var ass in _obfuzAssemblies)
-            {
-                foreach (var refAss in ass.module.GetAssemblyRefs())
-                {
-                    string refAssName = refAss.Name.ToString();
-                    if (assByName.TryGetValue(refAssName, out var refAssembly))
-                    {
-                        //UnityEngine.Debug.Log($"assembly:{ass.name} reference to {refAssName}");
-                        refAssembly.referenceMeAssemblies.Add(ass);
-                    }
                 }
+                _obfuscatedAndNotObfuscatedModules.Add(mod);
             }
         }
 
@@ -117,11 +100,12 @@ namespace Obfuz
         {
             _pipeline.Stop(_ctx);
 
-            foreach (var ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _obfuscatedAndNotObfuscatedModules)
             {
-                string outputFile = $"{_obfuscatedAssemblyOutputDir}/{ass.module.Name}";
+                string assNameWithExt = mod.Name;
-                ass.module.Write(outputFile);
+                string outputFile = $"{_obfuscatedAssemblyOutputDir}/{assNameWithExt}";
-                Debug.Log($"save module. oldName:{ass.name} newName:{ass.module.Name} output:{outputFile}");
+                mod.Write(outputFile);
+                Debug.Log($"save module. name:{mod.Assembly.Name} output:{outputFile}");
             }
         }
     }

Editor/ObfuscatorContext.cs

@@ -1,4 +1,5 @@
-using Obfuz.Rename;
+using dnlib.DotNet;
+using Obfuz.Rename;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -12,10 +13,10 @@ namespace Obfuz
     {
         public AssemblyCache assemblyCache;
 
-        public List<ObfuzAssemblyInfo> assemblies;
+        public List<ModuleDef> toObfuscatedModules;
+        public List<ModuleDef> obfuscatedAndNotObfuscatedModules;
 
         public List<string> toObfuscatedAssemblyNames;
-
         public List<string> notObfuscatedAssemblyNamesReferencingObfuscated;
 
         public string obfuscatedAssemblyOutputDir;

Editor/ObfuzAssemblyInfo.cs

@@ -1,14 +0,0 @@
-using dnlib.DotNet;
-using System.Collections.Generic;
-
-namespace Obfuz
-{
-    public class ObfuzAssemblyInfo
-    {
-        public string name;
-
-        public ModuleDefMD module;
-
-        public List<ObfuzAssemblyInfo> referenceMeAssemblies;
-    }
-}

Editor/Rename/CacheRenamePolicy.cs

@@ -15,7 +15,7 @@ namespace Obfuz.Rename
             _underlyingPolicy = underlyingPolicy;
         }
 
-        public override bool NeedRename(ModuleDefMD mod)
+        public override bool NeedRename(ModuleDef mod)
         {
             if (!_computeCache.TryGetValue(mod, out var value))
             {

Editor/Rename/CombineRenamePolicy.cs

@@ -12,7 +12,7 @@ namespace Obfuz.Rename
             _policies = policies;
         }
 
-        public bool NeedRename(ModuleDefMD mod)
+        public bool NeedRename(ModuleDef mod)
         {
             return _policies.All(policy => policy.NeedRename(mod));
         }

Editor/Rename/INameMaker.cs

@@ -4,7 +4,7 @@ namespace Obfuz.Rename
 {
     public interface INameMaker
     {
-        void AddPreservedName(ModuleDefMD mod, string name);
+        void AddPreservedName(ModuleDef mod, string name);
         
         void AddPreservedName(TypeDef typeDef, string name);
 
@@ -20,7 +20,7 @@ namespace Obfuz.Rename
 
         void AddPreservedName(EventDef eventDef, string name);
 
-        string GetNewName(ModuleDefMD mod, string originalName);
+        string GetNewName(ModuleDef mod, string originalName);
 
         string GetNewName(TypeDef typeDef, string originalName);
 

Editor/Rename/IRenamePolicy.cs

@@ -4,7 +4,7 @@ namespace Obfuz.Rename
 {
     public interface IRenamePolicy
     {
-        bool NeedRename(ModuleDefMD mod);
+        bool NeedRename(ModuleDef mod);
 
         bool NeedRename(TypeDef typeDef);
 

Editor/Rename/NameMakerBase.cs

@@ -26,7 +26,7 @@ namespace Obfuz.Rename
             return nameScope;
         }
 
-        public void AddPreservedName(ModuleDefMD mod, string name)
+        public void AddPreservedName(ModuleDef mod, string name)
         {
             GetNameScope(mod).AddPreservedName(name);
         }
@@ -67,7 +67,7 @@ namespace Obfuz.Rename
         }
 
 
-        public string GetNewName(ModuleDefMD mod, string originalName)
+        public string GetNewName(ModuleDef mod, string originalName)
         {
             return GetDefaultNewName(this, originalName);
         }

Editor/Rename/ObfuscateRuleConfig.cs

@@ -11,7 +11,7 @@ using UnityEngine;
 namespace Obfuz
 {
 
-    public class ObfuscateRuleConfig : IRenamePolicy
+    public class ObfuscateRuleConfig : RenamePolicyBase
     {
         enum ObfuscationType
         {
@@ -610,7 +610,7 @@ namespace Obfuz
             }
         }
 
-        public bool NeedRename(ModuleDefMD mod)
+        public override bool NeedRename(ModuleDef mod)
         {
             //string name = mod.Assembly.Name;
             //if (!_assemblyRuleSpecs.TryGetValue(name, out var assemblyRuleSpec))
@@ -839,13 +839,13 @@ namespace Obfuz
             return cache;
         }
 
-        public bool NeedRename(TypeDef typeDef)
+        public override bool NeedRename(TypeDef typeDef)
         {
             TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
             return cache.obfuscateName;
         }
 
-        public bool NeedRename(MethodDef methodDef)
+        public override bool NeedRename(MethodDef methodDef)
         {
             TypeDef typeDef = methodDef.DeclaringType;
             TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
@@ -856,28 +856,28 @@ namespace Obfuz
             return methodCache.obfuscateName;
         }
 
-        public bool NeedRename(FieldDef fieldDef)
+        public override bool NeedRename(FieldDef fieldDef)
         {
             TypeDef typeDef = fieldDef.DeclaringType;
             TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
             return !cache.notObfuscatedFields.Contains(fieldDef);
         }
 
-        public bool NeedRename(PropertyDef propertyDef)
+        public override bool NeedRename(PropertyDef propertyDef)
         {
             TypeDef typeDef = propertyDef.DeclaringType;
             TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
             return !cache.notObfuscatedProperties.Contains(propertyDef);
         }
 
-        public bool NeedRename(EventDef eventDef)
+        public override bool NeedRename(EventDef eventDef)
         {
             TypeDef typeDef = eventDef.DeclaringType;
             TypeDefComputeCache cache = GetOrCreateTypeDefRenameComputeCache(typeDef);
             return !cache.notObfuscatedEvents.Contains(eventDef);
         }
 
-        public bool NeedRename(ParamDef paramDef)
+        public override bool NeedRename(ParamDef paramDef)
         {
             MethodDef methodDef = paramDef.DeclaringMethod;
             TypeDef typeDef = methodDef.DeclaringType;

Editor/Rename/RenamePolicyBase.cs

@@ -4,9 +4,9 @@ namespace Obfuz.Rename
 {
     public abstract class RenamePolicyBase : IRenamePolicy
     {
-        public virtual bool NeedRename(ModuleDefMD mod)
+        public virtual bool NeedRename(ModuleDef mod)
         {
-            return true;
+            return false;
         }
 
         public virtual bool NeedRename(TypeDef typeDef)

Editor/Rename/RenameRecordMap.cs

@@ -93,7 +93,7 @@ namespace Obfuz
         private readonly Dictionary<string, RenameMappingAssembly> _assemblies = new Dictionary<string, RenameMappingAssembly>();
 
 
-        private readonly Dictionary<ModuleDefMD, RenameRecord> _modRenames = new Dictionary<ModuleDefMD, RenameRecord>();
+        private readonly Dictionary<ModuleDef, RenameRecord> _modRenames = new Dictionary<ModuleDef, RenameRecord>();
         private readonly Dictionary<TypeDef, RenameRecord> _typeRenames = new Dictionary<TypeDef, RenameRecord>();
         private readonly Dictionary<MethodDef, RenameRecord> _methodRenames = new Dictionary<MethodDef, RenameRecord>();
         private readonly Dictionary<ParamDef, RenameRecord> _paramRenames = new Dictionary<ParamDef, RenameRecord>();
@@ -108,12 +108,11 @@ namespace Obfuz
             _mappingFile = mappingFile;
         }
 
-        public void Init(List<ObfuzAssemblyInfo> assemblies, INameMaker nameMaker)
+        public void Init(List<ModuleDef> assemblies, INameMaker nameMaker)
         {
             LoadXmlMappingFile(_mappingFile);
-            foreach (var ObfuzAssemblyInfo in assemblies)
+            foreach (ModuleDef mod in assemblies)
             {
-                ModuleDefMD mod = ObfuzAssemblyInfo.module;
                 string name = mod.Assembly.Name;
                 nameMaker.AddPreservedName(mod, name);
 
@@ -406,7 +405,7 @@ namespace Obfuz
             doc.AppendChild(root);
             foreach (var kvp in _modRenames)
             {
-                ModuleDefMD mod = kvp.Key;
+                ModuleDef mod = kvp.Key;
                 RenameRecord record = kvp.Value;
                 var assemblyNode = doc.CreateElement("assembly");
                 assemblyNode.SetAttribute("name", mod.Assembly.Name);
@@ -619,7 +618,7 @@ namespace Obfuz
             methodEle.AppendChild(paramNode);
         }
 
-        public void AddRename(ModuleDefMD mod, string newName)
+        public void AddRename(ModuleDef mod, string newName)
         {
             RenameRecord record = _modRenames[mod];
             record.status = RenameStatus.Renamed;
@@ -680,7 +679,7 @@ namespace Obfuz
             record.newName = newName;
         }
 
-        public bool TryGetExistRenameMapping(ModuleDefMD mod, out string newName)
+        public bool TryGetExistRenameMapping(ModuleDef mod, out string newName)
         {
             if (_modRenames.TryGetValue(mod, out var record) && record.renameMappingData != null)
             {

Editor/Rename/SymbolRename.cs

@@ -18,12 +18,26 @@ namespace Obfuz
 
     public class SymbolRename
     {
+        class AssemblyReferenceInfo
+        {
+            public string name;
+
+            public bool needObfuscated;
+
+            public ModuleDef module;
+
+            public List<AssemblyReferenceInfo> referenceMeAssemblies;
+        }
+
         private readonly List<string> _obfuscationRuleFiles;
         private readonly string _mappingXmlPath;
 
         private AssemblyCache _assemblyCache;
-        private List<ObfuzAssemblyInfo> _obfuzAssemblies;
+
-        private HashSet<ModuleDef> _obfuscatedModules = new HashSet<ModuleDef>();
+        private List<ModuleDef> _toObfuscatedModules;
+        private List<ModuleDef> _obfuscatedAndNotObfuscatedModules;
+        private List<AssemblyReferenceInfo> _obfuzAssemblies;
+        private HashSet<ModuleDef> _toObfuscatedModuleSet;
         private ObfuscateRuleConfig _obfuscateRuleConfig;
         private IRenamePolicy _renamePolicy;
         private INameMaker _nameMaker;
@@ -50,19 +64,49 @@ namespace Obfuz
         public void Init(ObfuscatorContext ctx)
         {
             _assemblyCache = ctx.assemblyCache;
-            _obfuzAssemblies = ctx.assemblies;
+            _toObfuscatedModules = ctx.toObfuscatedModules;
+            _obfuscatedAndNotObfuscatedModules = ctx.obfuscatedAndNotObfuscatedModules;
+            _toObfuscatedModuleSet = ctx.toObfuscatedModules.ToHashSet();
+            _obfuzAssemblies = BuildAssemblyReferenceInfos(ctx);
             _obfuscateRuleConfig = new ObfuscateRuleConfig(ctx.toObfuscatedAssemblyNames);
             _obfuscateRuleConfig.LoadXmls(_obfuscationRuleFiles);
             _renamePolicy = new CacheRenamePolicy(new CombineRenamePolicy(new SystemRenamePolicy(), new UnityRenamePolicy(), _obfuscateRuleConfig));
             _nameMaker = NameMakerFactory.CreateNameMakerBaseASCIICharSet();
-
-            foreach (var mod in ctx.assemblies)
-            {
-                _obfuscatedModules.Add(mod.module);
-            }
             BuildCustomAttributeArguments();
         }
 
+        private static List<AssemblyReferenceInfo> BuildAssemblyReferenceInfos(ObfuscatorContext ctx)
+        {
+            var obfuzAssemblies = new List<AssemblyReferenceInfo>();
+            foreach (ModuleDef mod in ctx.obfuscatedAndNotObfuscatedModules)
+            {
+                var obfuzAsm = new AssemblyReferenceInfo
+                {
+                    name = mod.Assembly.Name,
+                    needObfuscated = ctx.toObfuscatedModules.Contains(mod),
+                    module = mod,
+                    referenceMeAssemblies = new List<AssemblyReferenceInfo>(),
+                };
+                obfuzAsm.referenceMeAssemblies.Add(obfuzAsm);
+                obfuzAssemblies.Add(obfuzAsm);
+            }
+
+            var assByName = obfuzAssemblies.ToDictionary(x => x.name);
+            foreach (var ass in obfuzAssemblies)
+            {
+                foreach (var refAss in ass.module.GetAssemblyRefs())
+                {
+                    string refAssName = refAss.Name;
+                    if (assByName.TryGetValue(refAssName, out var refAssembly))
+                    {
+                        //UnityEngine.Debug.Log($"assembly:{ass.name} reference to {refAssName}");
+                        refAssembly.referenceMeAssemblies.Add(ass);
+                    }
+                }
+            }
+            return obfuzAssemblies;
+        }
+
         private void CollectCArgumentWithTypeOf(IHasCustomAttribute meta, List<CustomAttributeInfo> customAttributes)
         {
             int index = 0;
@@ -94,11 +138,11 @@ namespace Obfuz
 
         private void BuildCustomAttributeArguments()
         {
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _obfuscatedAndNotObfuscatedModules)
             {
                 var customAttributes = new List<CustomAttributeInfo>();
-                CollectCArgumentWithTypeOf(ass.module, customAttributes);
+                CollectCArgumentWithTypeOf(mod, customAttributes);
-                foreach (TypeDef type in ass.module.GetTypes())
+                foreach (TypeDef type in mod.GetTypes())
                 {
                     CollectCArgumentWithTypeOf(type, customAttributes);
                     foreach (FieldDef field in type.Fields)
@@ -126,13 +170,13 @@ namespace Obfuz
                     }
                 }
 
-                _customAttributeArgumentsWithTypeByMods.Add(ass.module, customAttributes);
+                _customAttributeArgumentsWithTypeByMods.Add(mod, customAttributes);
             }
         }
 
         public void Process()
         {
-            _renameRecordMap.Init(_obfuzAssemblies, _nameMaker);
+            _renameRecordMap.Init(_toObfuscatedModules, _nameMaker);
             RenameModules();
             RenameTypes();
             RenameFields();
@@ -141,7 +185,7 @@ namespace Obfuz
             RenameEvents();
         }
 
-        private List<ObfuzAssemblyInfo> GetReferenceMeAssemblies(ModuleDef mod)
+        private List<AssemblyReferenceInfo> GetReferenceMeAssemblies(ModuleDef mod)
         {
             return _obfuzAssemblies.Find(ass => ass.module == mod).referenceMeAssemblies;
         }
@@ -149,11 +193,11 @@ namespace Obfuz
         private void RenameModules()
         {
             Debug.Log("Rename Modules begin");
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
             {
-                if (_renamePolicy.NeedRename(ass.module))
+                if (_renamePolicy.NeedRename(mod))
                 {
-                    Rename(ass.module);
+                    Rename(mod);
                 }
             }
             Debug.Log("Rename Modules end");
@@ -169,9 +213,9 @@ namespace Obfuz
 
         private void BuildRefTypeDefMetasMap(Dictionary<TypeDef, RefTypeDefMetas> refTypeDefMetasMap)
         {
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
             {
-                foreach (TypeRef typeRef in ass.module.GetTypeRefs())
+                foreach (TypeRef typeRef in mod.GetTypeRefs())
                 {
                     TypeDef typeDef = typeRef.ResolveThrow();
                     if (!refTypeDefMetasMap.TryGetValue(typeDef, out var typeDefMetas))
@@ -244,9 +288,9 @@ namespace Obfuz
             BuildRefTypeDefMetasMap(_refTypeRefMetasMap);
             _assemblyCache.EnableTypeDefCache = false;
 
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
             {
-                foreach (TypeDef type in ass.module.GetTypes())
+                foreach (TypeDef type in mod.GetTypes())
                 {
                     if (_renamePolicy.NeedRename(type))
                     {
@@ -279,9 +323,9 @@ namespace Obfuz
 
         private void BuildRefFieldMetasMap(Dictionary<FieldDef, RefFieldMetas> refFieldMetasMap)
         {
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
             {
-                foreach (MemberRef memberRef in ass.module.GetMemberRefs())
+                foreach (MemberRef memberRef in mod.GetMemberRefs())
                 {
                     if (!memberRef.IsFieldRef)
                     {
@@ -348,9 +392,9 @@ namespace Obfuz
             var refFieldMetasMap = new Dictionary<FieldDef, RefFieldMetas>();
             BuildRefFieldMetasMap(refFieldMetasMap);
 
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
             {
-                foreach (TypeDef type in ass.module.GetTypes())
+                foreach (TypeDef type in mod.GetTypes())
                 {
                     foreach (FieldDef field in type.Fields)
                     {
@@ -371,9 +415,9 @@ namespace Obfuz
 
         private void BuildRefMethodMetasMap(Dictionary<MethodDef, RefMethodMetas> refMethodMetasMap)
         {
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
             {
-                foreach (MemberRef memberRef in ass.module.GetMemberRefs())
+                foreach (MemberRef memberRef in mod.GetMemberRefs())
                 {
                     if (!memberRef.IsMethodRef)
                     {
@@ -410,9 +454,9 @@ namespace Obfuz
             var virtualMethods = new List<MethodDef>();
             var refMethodMetasMap = new Dictionary<MethodDef, RefMethodMetas>();
             BuildRefMethodMetasMap(refMethodMetasMap);
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
             {
-                foreach (TypeDef type in ass.module.GetTypes())
+                foreach (TypeDef type in mod.GetTypes())
                 {
                     _virtualMethodGroupCalculator.CalculateType(type);
                     foreach (MethodDef method in type.Methods)
@@ -444,7 +488,7 @@ namespace Obfuz
                 VirtualMethodGroup group = _virtualMethodGroupCalculator.GetMethodGroup(method);
                 if (!groupNeedRenames.TryGetValue(group, out var needRename))
                 {
-                    needRename = group.methods.All(m => _obfuscatedModules.Contains(m.DeclaringType.Module) && _renamePolicy.NeedRename(m));
+                    needRename = group.methods.All(m => _toObfuscatedModuleSet.Contains(m.DeclaringType.Module) && _renamePolicy.NeedRename(m));
                     groupNeedRenames.Add(group, needRename);
                     if (needRename)
                     {
@@ -522,9 +566,9 @@ namespace Obfuz
             Debug.Log("Rename properties begin");
             var refPropertyMetasMap = new Dictionary<PropertyDef, RefPropertyMetas>();
             BuildRefPropertyMetasMap(refPropertyMetasMap);
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
             {
-                foreach (TypeDef type in ass.module.GetTypes())
+                foreach (TypeDef type in mod.GetTypes())
                 {
                     foreach (PropertyDef property in type.Properties)
                     {
@@ -541,9 +585,9 @@ namespace Obfuz
         private void RenameEvents()
         {
             Debug.Log("Rename events begin");
-            foreach (ObfuzAssemblyInfo ass in _obfuzAssemblies)
+            foreach (ModuleDef mod in _toObfuscatedModules)
             {
-                foreach (TypeDef type in ass.module.GetTypes())
+                foreach (TypeDef type in mod.GetTypes())
                 {
                     foreach (EventDef eventDef in type.Events)
                     {
@@ -557,7 +601,7 @@ namespace Obfuz
             Debug.Log("Rename events begin");
         }
 
-        private void Rename(ModuleDefMD mod)
+        private void Rename(ModuleDef mod)
         {
             string oldName = mod.Assembly.Name;
             string newName = _renameRecordMap.TryGetExistRenameMapping(mod, out var n) ? n :  _nameMaker.GetNewName(mod, oldName);
@@ -565,7 +609,7 @@ namespace Obfuz
             mod.Assembly.Name = newName;
             mod.Name = $"{newName}.dll";
             //Debug.Log($"rename module. oldName:{oldName} newName:{newName}");
-            foreach (ObfuzAssemblyInfo ass in GetReferenceMeAssemblies(mod))
+            foreach (AssemblyReferenceInfo ass in GetReferenceMeAssemblies(mod))
             {
                 foreach (AssemblyRef assRef in ass.module.GetAssemblyRefs())
                 {

Editor/Utils/PathAssemblyResolver.cs

@@ -24,7 +24,7 @@ namespace Obfuz
                 string assPath = Path.Combine(path, assemblyName + ".dll");
                 if (File.Exists(assPath))
                 {
-                    //Debug.Log($"resolve {assemblyName} at {assPath}");
+                    Debug.Log($"resolve {assemblyName} at {assPath}");
                     return assPath;
                 }
             }