diff --git a/RecodeItGUI/GUI/Main.cs b/RecodeItGUI/GUI/Main.cs index b2094f4..a486c88 100644 --- a/RecodeItGUI/GUI/Main.cs +++ b/RecodeItGUI/GUI/Main.cs @@ -1,4 +1,3 @@ -using ReCodeIt.AutoMapper; using ReCodeIt.Models; using ReCodeIt.ReMapper; using ReCodeIt.Utils; @@ -9,8 +8,6 @@ namespace ReCodeIt.GUI; public partial class ReCodeItForm : Form { private static ReCodeItRemapper Remapper { get; set; } = new(); - private static ReCodeItAutoMapper AutoMapper { get; set; } = new(); - private static Settings AppSettings => DataProvider.Settings; private bool _isSearched = false; @@ -487,12 +484,7 @@ public partial class ReCodeItForm : Form RemapperOutputDirectoryPath.Text = result; } } - - private void RunAutoMapButton_Click(object sender, EventArgs e) - { - AutoMapper.InitializeAutoMapping(); - } - + #endregion MAIN_BUTTONS #region LISTBOX_BUTTONS @@ -717,11 +709,8 @@ public partial class ReCodeItForm : Form { if (string.IsNullOrEmpty(DataProvider.Settings.AutoMapper.AssemblyPath)) { - MessageBox.Show("Please go to the settings tab and load an assembly and select and output location", "Assembly not loaded"); - return; + MessageBox.Show("Feature has been removed from this build.", "Feature Removed"); } - - AutoMapper.InitializeAutoMapping(); } #endregion LISTBOX_BUTTONS diff --git a/RecodeItLib/AutoMapper/MappingPair.cs b/RecodeItLib/AutoMapper/MappingPair.cs deleted file mode 100644 index 3c3038d..0000000 --- a/RecodeItLib/AutoMapper/MappingPair.cs +++ /dev/null @@ -1,65 +0,0 @@ -using dnlib.DotNet; - -namespace ReCodeIt.AutoMapper; - -/// -/// Represents a match of a field name to obfuscated class -/// -/// -/// -/// -/// -public sealed class MappingPair( - TypeDef type, - string name, - bool isInterface, - bool isStruct, - bool isPublic) -{ - public TypeDef OriginalTypeDefinition { get; private set; } = type; - - /// - /// The type reference we want to change - /// - public TypeDef NewTypeRef { get; set; } - - /// - /// Is this field an interface? - /// - public bool IsInterface { get; set; } = isInterface; - - /// - /// Is this type a struct? - /// - public bool IsStruct { get; set; } = isStruct; - - /// - /// Has this type been renamed? Use for checking for failures at the end - /// - public bool HasBeenRenamed { get; set; } = false; - - /// - /// Did this match come from a method? - /// - public AutoMappingResult AutoMappingResult { get; set; } = AutoMappingResult.None; - - /// - /// This is the name we want to change the assembly class to - /// - public string Name { get; set; } = name; - - /// - /// Original name of the property or field type - /// - public string OriginalPropOrFieldName { get; } = name; -} - -public enum AutoMappingResult -{ - None, - Match_From_Field, - Match_From_Property, - Match_From_Method, - Fail_From_Already_Contained_Name, - Fail_From_New_Type_Ref_Null, -} \ No newline at end of file diff --git a/RecodeItLib/AutoMapper/ReCodeItAutoMapper.cs b/RecodeItLib/AutoMapper/ReCodeItAutoMapper.cs deleted file mode 100644 index f88b066..0000000 --- a/RecodeItLib/AutoMapper/ReCodeItAutoMapper.cs +++ /dev/null @@ -1,532 +0,0 @@ -using dnlib.DotNet; -using ReCodeIt.Models; -using ReCodeIt.ReMapper; -using ReCodeIt.Utils; - -namespace ReCodeIt.AutoMapper; - -public class ReCodeItAutoMapper -{ - private ModuleDefMD Module { get; set; } - private List MappingPairs { get; set; } = []; - - private List CompilerGeneratedClasses = []; - - private List AllTypes { get; set; } = []; - - private List AlreadyChangedNames { get; set; } = []; - - private static AutoMapperSettings Settings => DataProvider.Settings.AutoMapper; - - private static bool Error { get; set; } = false; - private int FailureCount { get; set; } = 0; - - private int TotalFieldRenameCount { get; set; } = 0; - private int TotalPropertyRenameCount { get; set; } = 0; - - /// - /// Start the automapping process - /// - public void InitializeAutoMapping() - { - Logger.ClearLog(); - Logger.Log($"Starting Auto Mapping..."); - - // Clear any previous pairs - MappingPairs = []; - CompilerGeneratedClasses = []; - AllTypes = []; - AlreadyChangedNames = []; - - Module = DataProvider.LoadModule(Settings.AssemblyPath); - - Error = false; - FailureCount = 0; - TotalFieldRenameCount = 0; - TotalPropertyRenameCount = 0; - - var types = Module.GetTypes(); - AllTypes.AddRange(types); - - FindCompilerGeneratedObjects(types); - - Logger.Log($"Found {AllTypes.Count - CompilerGeneratedClasses.Count} potential remappable types"); - Logger.Log($"Found {CompilerGeneratedClasses.Count} compiler generated objects"); - - foreach (var type in types) - { - // We dont want to do anything with compiler generated objects - if (CompilerGeneratedClasses.Contains(type.Name)) - { - continue; - } - - MappingPairs.AddRange(FilterFieldNames(type)); - MappingPairs.AddRange(FilterPropertyNames(type)); - - if (Settings.SearchMethods) - { - MappingPairs.AddRange(GatherFromMethods(type)); - } - } - - PrimaryTypeNameFilter(); - SanitizeProposedNames(); - StartRenameProcess(); - - WriteChanges(); - } - - /// - /// Finds any compiler generated code so we can ignore it, its mostly LINQ garbage - /// - /// - private void FindCompilerGeneratedObjects(IEnumerable types) - { - foreach (var typeDefinition in types) - { - if (typeDefinition.IsClass || typeDefinition.IsInterface || typeDefinition.IsValueType) // Check for class or struct - { - if (typeDefinition.HasCustomAttributes && - typeDefinition.CustomAttributes.Any(attr => attr.AttributeType.FullName == "System.Runtime.CompilerServices.CompilerGeneratedAttribute")) - { - string typeName = typeDefinition.Name; - CompilerGeneratedClasses.Add(typeName); - //Logger.Log($"Compiler Generated object found: {typeName}", ConsoleColor.Yellow); - } - } - - if (typeDefinition.NestedTypes.Count > 0) - { - FindCompilerGeneratedObjects(typeDefinition.NestedTypes); - } - } - } - - #region METHODS - - private List GatherFromMethods(TypeDef type) - { - var methodsWithTypes = new List(); - - // Handle nested types recursively - foreach (var nestedType in type.NestedTypes) - { - methodsWithTypes.AddRange(GatherFromMethods(nestedType)); - } - - var methods = type.Methods - // We only want methods with parameters - .Where(m => m.HasParams()) - - // Only want parameter names of a certain length - .Where(m => m.Parameters.Any(p => p.Name.Length > Settings.MinLengthToMatch)); - - // Now go over over all filterd methods manually, because fuck this with linq - foreach (var method in methods) - { - // Now over all parameters in the method - foreach (var parm in method.Parameters) - { - // We dont want blacklisted items - if (Settings.MethodParamaterBlackList.Contains(parm.Name) - || Settings.TypesToIgnore.Contains(parm.Name)) - { - continue; - } - - //Logger.Log($"Method Data Found"); - //Logger.Log($"Parameter count: {method.Parameters.Count}"); - //Logger.Log($"Paremeter Names: {string.Join(", ", parmNames)}"); - //Logger.Log($"Paremeter Types: {string.Join(", ", parmTypes)}\n"); - - if (parm.Type.TryGetTypeDef() is null) continue; - - var mapPair = new MappingPair( - parm.Type.TryGetTypeDef(), - parm.Name, - parm.Type.TryGetTypeDef().IsInterface, - parm.Type.TryGetTypeDef().Name.Contains("Struct"), - true); - - mapPair.AutoMappingResult = AutoMappingResult.Match_From_Method; - - methodsWithTypes.Add(mapPair); - } - } - - return methodsWithTypes; - } - - #endregion METHODS - - #region FIELDS_PROPERTIES - - /// - /// Pair field declaring types with their names - /// - /// - /// - private List FilterFieldNames(TypeDef type) - { - var fieldsWithTypes = new List(); - - // Handle nested types recursively - foreach (var nestedType in type.NestedTypes) - { - fieldsWithTypes.AddRange(FilterFieldNames(nestedType)); - } - - var fields = type.Fields - // we dont want names shorter than 4 - .Where(f => f.Name.Length > 3) - - // Skip value types - .Where(f => !f.FieldType.IsValueType) - - // TODO: Renaming arrays is strange, come back to this later - .Where(p => !p.FieldType.IsArray) - - // We dont want fields in the system type ignore list - .Where(f => !Settings.TypesToIgnore.Contains(f.Name.TrimAfterSpecialChar())); - - // Include fields from the current type - foreach (var field in fields) - { - //Logger.Log($"Collecting Field: OriginalTypeRef: {field.FieldType.Name.TrimAfterSpecialChar()} Field Name: {field.Name}"); - - var typeDef = field.FieldType.TryGetTypeDef(); - - // Dont rename things we cant resolve - if (typeDef is null) { continue; } - - var pair = new MappingPair( - typeDef, - field.Name, - typeDef.Name.Contains("Interface"), - typeDef.Name.Contains("Struct"), - field.IsPublic); - - pair.AutoMappingResult = AutoMappingResult.Match_From_Field; - - fieldsWithTypes.Add(pair); - } - - return fieldsWithTypes; - } - - /// - /// Pair field declaring types with their names - /// - /// - /// - private IEnumerable FilterPropertyNames(TypeDef type) - { - var propertiesWithTypes = new List(); - - // Handle nested types recursively - foreach (var nestedType in type.NestedTypes) - { - propertiesWithTypes.AddRange(FilterPropertyNames(nestedType)); - } - - var properties = type.Properties - // we dont want names shorter than 4 - .Where(p => p.Name.Length > 3) - - // Skip value types - .Where(p => !p.PropertySig.RetType.GetIsValueType()) - - // TODO: Renaming arrays is strange, come back to this later - .Where(p => !p.PropertySig.RetType.IsArray) - - // We dont want fields in the global ignore list - .Where(p => !Settings.TypesToIgnore.Contains(p.Name.TrimAfterSpecialChar())); - - // Include fields from the current type - foreach (var property in properties) - { - //Logger.Log($"Collecting Property: OriginalTypeRef: {property.PropertyType.Name.TrimAfterSpecialChar()} Field Name: {property.Name}"); - - var typeDef = property.PropertySig.RetType.TryGetTypeDef(); - - // Dont rename things we cant resolve - if (typeDef is null) { continue; } - - var mapPair = new MappingPair( - typeDef, - property.Name, - typeDef.Name.Contains("Interface"), - typeDef.Name.Contains("Struct"), - true); - - mapPair.AutoMappingResult = AutoMappingResult.Match_From_Property; - - propertiesWithTypes.Add(mapPair); - } - - return propertiesWithTypes; - } - - #endregion FIELDS_PROPERTIES - - #region FILTER - - /// - /// This giant linq statement handles all of the filtering once the initial gathering of fields - /// and properties is complete - /// - private void PrimaryTypeNameFilter() - { - // Filter types to the ones we're looking for - var mappingPairs = MappingPairs - // Filter based on length, short lengths dont make good class names - .Where(pair => pair.Name.Length >= Settings.MinLengthToMatch) - - // Filter out anything that doesnt start with our specified tokens (Where - // pair.OriginalTypeRef.Name is the property OriginalTypeRef name `Class1202` and token - // is start identifer we are looking for `GClass` - .Where(pair => Settings.TokensToMatch - .Any(token => pair.OriginalTypeDefinition.Name.StartsWith(token))) - - // Filter out anything that has the same name as the type, we cant remap those - .Where(pair => !Settings.TokensToMatch - .Any(token => pair.Name.ToLower().StartsWith(token.ToLower()))) - - // Filter based on direct name blacklist (Where pair.Name is the property name and token - // is blacklisted item `Columns` - .Where(pair => !Settings.PropertyFieldBlackList - .Any(token => pair.Name.ToLower().StartsWith(token.ToLower()))) - - // Filter out backing fields - /// This is slow, but oh well - .Where(pair => !pair.Name.ToCharArray().Contains('<')).ToList(); - - MappingPairs = mappingPairs; - SecondaryTypeNameFilter(); - } - - /// - /// This is where we filter down based on more specific parameters - /// - /// - private void SecondaryTypeNameFilter() - { - // Filter property/field names by required number of matches - MappingPairs = MappingPairs - .GroupBy(pair => pair.OriginalPropOrFieldName.TrimAfterSpecialChar()) - .Where(group => group.Count() > Settings.RequiredMatches) - .SelectMany(group => group) - .ToList() - // We dont want names that already exist to be considered - .Where(pair => AllTypes - .Any(token => !pair.OriginalTypeDefinition.FullName.Contains(token.FullName))).ToList(); - - FinalGroupAndSelect(); - } - - /// - /// This is where we make sure everything is original - /// - private void FinalGroupAndSelect() - { - MappingPairs = MappingPairs - // We only want types once, so make it unique - .GroupBy(pair => pair.OriginalTypeDefinition.FullName) - .Select(group => group.First()) - .GroupBy(pair => pair.Name) - .Select(group => group.First()).ToList(); - } - - #endregion FILTER - - #region OUTPUT - - /// - /// Sanitizes and prepares mapping pairs for remapping once filtering is complete. - /// - private void SanitizeProposedNames() - { - foreach (var pair in MappingPairs) - { - char first = pair.Name.ToCharArray().ElementAt(0); - - if (first.Equals('_')) - { - pair.Name = string.Concat("", pair.Name.AsSpan(1)); - } - - // Re-run incase prefix removed - first = pair.Name.ToCharArray().ElementAt(0); - - if (char.IsLower(first)) - { - pair.Name = string.Concat(char.ToUpper(first).ToString(), pair.Name.AsSpan(1)); - } - - if (pair.IsInterface) - { - pair.Name = string.Concat("I", pair.Name.AsSpan(0)); - pair.Name = pair.Name.Replace("Class", ""); - } - /* - // Try and remove any trailing 's' that exist - if (pair.WasCollection) - { - if (pair.Name.ToLower().EndsWith('s')) - { - pair.Name = pair.Name.Substring(0, pair.Name.Length - 1); - } - } - */ - - if (pair.IsInterface) - { - // Replace class if it exists - pair.Name = pair.Name.Replace("Class", ""); - } - else if (pair.IsStruct) - { - pair.Name = string.Concat(pair.Name, "Struct"); - } - else - { - pair.Name = string.Concat(pair.Name, "Class"); - } - - Logger.Log($"------------------------------------------------------------------------"); - Logger.Log($"Original Name: {pair.OriginalTypeDefinition.FullName} : Sanitized Name: {pair.Name}"); - Logger.Log($"Matched From Name: {pair.OriginalPropOrFieldName}"); - Logger.Log($"IsInterface: {pair.IsInterface}"); - Logger.Log($"IsStruct: {pair.IsStruct}"); - Logger.Log($"Is match from: {pair.AutoMappingResult}"); - Logger.Log($"------------------------------------------------------------------------"); - } - - Logger.Log($"Automatically remapped {MappingPairs.Count()} objects"); - } - - /// - /// Start renaming assembly definitions - /// - private void StartRenameProcess() - { - // Gather up any matches we have - foreach (var type in Module.GetTypes().ToArray()) - { - foreach (var pair in MappingPairs.ToArray()) - { - GatherMatchedTypeRefs(pair, type); - } - } - - // Rename Types to matched types - foreach (var pair in MappingPairs) - { - if (pair.NewTypeRef != null && !AlreadyChangedNames.Contains(pair.Name)) - { - Logger.Log($"------------------------------------------------------------------------", ConsoleColor.Green); - Logger.Log($"Renaming: {pair.OriginalTypeDefinition.Name} to {pair.Name}", ConsoleColor.Green); - Logger.Log($"Is match from method: {pair.AutoMappingResult}", ConsoleColor.Green); - - var fieldCount = RenameHelper.RenameAllFields( - pair.OriginalTypeDefinition.Name, - pair.Name, - Module.GetTypes()); - - var propCount = RenameHelper.RenameAllProperties( - pair.OriginalTypeDefinition.Name, - pair.Name, - Module.GetTypes()); - - Logger.Log($"Renamed: {fieldCount} fields", ConsoleColor.Green); - Logger.Log($"Renamed: {propCount} properties", ConsoleColor.Green); - Logger.Log($"------------------------------------------------------------------------", ConsoleColor.Green); - - AlreadyChangedNames.Add(pair.Name); - pair.NewTypeRef.Name = pair.Name; - pair.HasBeenRenamed = true; - continue; - } - - if (pair.HasBeenRenamed) { continue; } - - // Set some error codes - - if (AlreadyChangedNames.Contains(pair.Name)) - { - pair.AutoMappingResult = AutoMappingResult.Fail_From_Already_Contained_Name; - } - - if (pair.NewTypeRef == null) - { - pair.AutoMappingResult = AutoMappingResult.Fail_From_New_Type_Ref_Null; - } - } - - // Do a final error check - foreach (var pair in MappingPairs) - { - if (!pair.HasBeenRenamed) - { - Logger.Log($"------------------------------------------------------------------------", ConsoleColor.Red); - Logger.Log($"Renaming: {pair.OriginalTypeDefinition.Name} to {pair.Name} has failed", ConsoleColor.Red); - Logger.Log($"Result Code: {pair.AutoMappingResult}", ConsoleColor.Red); - Logger.Log($"IsInterface: {pair.IsInterface}", ConsoleColor.Red); - Logger.Log($"IsStruct: {pair.IsStruct}", ConsoleColor.Red); - Logger.Log($"------------------------------------------------------------------------", ConsoleColor.Red); - - FailureCount++; - Error = true; - } - } - } - - /// - /// Recursively handle all renaming on nested types on a given type - /// - /// - /// - private void GatherMatchedTypeRefs(MappingPair pair, TypeDef type) - { - // Handle nested types recursively - foreach (var nestedType in type.NestedTypes.ToArray()) - { - GatherMatchedTypeRefs(pair, nestedType); - } - - if (type == pair.OriginalTypeDefinition) - { - pair.NewTypeRef = type; - } - } - - private void WriteChanges() - { - var path = Path.Combine(Settings.OutputPath, Module.Assembly.Name + "-auto_mapped.dll"); - - Module.Write(path); - - var fieldCountMatchResult = MappingPairs - .Count(x => x.AutoMappingResult == AutoMappingResult.Match_From_Field); - - var propertyCountMatchResult = MappingPairs - .Count(x => x.AutoMappingResult == AutoMappingResult.Match_From_Property); - - var methodCountMatchResult = MappingPairs - .Count(x => x.AutoMappingResult == AutoMappingResult.Match_From_Method); - - Logger.Log($"-------------------------------RESULT-----------------------------------", ConsoleColor.Green); - Logger.Log($"Complete: Assembly written to `{path}`", ConsoleColor.Green); - Logger.Log($"Found {MappingPairs.Count()} automatic remaps", ConsoleColor.Green); - Logger.Log($"Found {fieldCountMatchResult} automatic remaps from fields", ConsoleColor.Green); - Logger.Log($"Found {propertyCountMatchResult} automatic remaps from properties", ConsoleColor.Green); - Logger.Log($"Found {methodCountMatchResult} automatic remaps from methods", ConsoleColor.Green); - Logger.Log($"Renamed {TotalFieldRenameCount} fields", ConsoleColor.Green); - Logger.Log($"Renamed {TotalPropertyRenameCount} properties", ConsoleColor.Green); - Logger.Log($"Failed to rename: {FailureCount} mapping pairs", (FailureCount == 0 ? ConsoleColor.Green : ConsoleColor.Red)); - Logger.Log($"------------------------------------------------------------------------", ConsoleColor.Green); - } - - #endregion OUTPUT -} \ No newline at end of file diff --git a/RecodeItLib/Dumper/DumperClass.cs b/RecodeItLib/Dumper/DumperClass.cs index 2a8e5cb..6df6998 100644 --- a/RecodeItLib/Dumper/DumperClass.cs +++ b/RecodeItLib/Dumper/DumperClass.cs @@ -158,14 +158,14 @@ public class DumperClass /// /// ICollection /// string - private void CheckNullOrMulti(ICollection types, string name = "") + private void CheckNullOrMulti(ICollection? types, string name = "") { if (types == null) { Logger.Log($"{name} was null"); } - if (types.Count > 1) + if (types?.Count > 1) { Logger.Log($"{name} count was more than 1"); } @@ -186,24 +186,24 @@ public class DumperClass if (method == null || method.Body.Instructions.Count != 269) { - Logger.Log($"BackRequest Instructions count has changed from 269 to {method.Body.Instructions.Count}", ConsoleColor.Red); + Logger.Log($"BackRequest Instructions count has changed from 269 to {method?.Body.Instructions.Count}", ConsoleColor.Red); } var startOfInstructions = 252; - var liList = DumpyILHelper.GetBackRequestInstructions(method, _gameImporter); - var index = method.Body.Instructions[startOfInstructions]; + var liList = DumpyILHelper.GetBackRequestInstructions(method!, _gameImporter); + var index = method?.Body.Instructions[startOfInstructions]; foreach (var li in liList) { // something along these lines, this needs to be tested - method.Body.Instructions.InsertBefore(index, li); + method?.Body.Instructions.InsertBefore(index!, li); } // create instruction - var ins = Instruction.Create(OpCodes.Brfalse_S, method.Body.Instructions[startOfInstructions]); + var ins = Instruction.Create(OpCodes.Brfalse_S, method?.Body.Instructions[startOfInstructions]); // replace instruction at 220 with this - method.Body.Instructions[220] = ins; + method!.Body.Instructions[220] = ins; } /// diff --git a/RecodeItLib/Models/RemapModel.cs b/RecodeItLib/Models/RemapModel.cs index 7e0ad01..e2c7bf8 100644 --- a/RecodeItLib/Models/RemapModel.cs +++ b/RecodeItLib/Models/RemapModel.cs @@ -93,22 +93,18 @@ public class SearchParams #region LISTS - public List IncludeMethods { get; set; } - public List ExcludeMethods { get; set; } - public List IncludeFields { get; set; } - public List ExcludeFields { get; set; } - public List IncludeProperties { get; set; } - public List ExcludeProperties { get; set; } - public List IncludeNestedTypes { get; set; } - public List ExcludeNestedTypes { get; set; } - public List IncludeEvents { get; set; } = []; - public List ExcludeEvents { get; set; } = []; + public List IncludeMethods { get; init; } = []; + public List ExcludeMethods { get; init; } = []; + public List IncludeFields { get; init; } = []; + public List ExcludeFields { get; init; } = []; + public List IncludeProperties { get; init; } = []; + public List ExcludeProperties { get; init; } = []; + public List IncludeNestedTypes { get; init; } = []; + public List ExcludeNestedTypes { get; init; } = []; + public List IncludeEvents { get; init; } = []; + public List ExcludeEvents { get; init; } = []; #endregion LISTS - - public SearchParams() - { - } } internal class AdvancedSearchParams diff --git a/RecodeItLib/Remapper/RenameHelper.cs b/RecodeItLib/Remapper/RenameHelper.cs index ece3499..d93e551 100644 --- a/RecodeItLib/Remapper/RenameHelper.cs +++ b/RecodeItLib/Remapper/RenameHelper.cs @@ -14,7 +14,7 @@ internal static class RenameHelper /// /// /// - public static void RenameAll(IEnumerable types, RemapModel remap, bool direct = false) + public static void RenameAll(IEnumerable types, RemapModel remap) { // Rename all fields and properties first if (DataProvider.Settings.Remapper.MappingSettings.RenameFields) @@ -39,12 +39,27 @@ internal static class RenameHelper types); } - if (!direct) - { - RenameType(types, remap); - } + RenameType(types, remap); - Logger.Log($"{remap.TypePrimeCandidate.Name.String} Renamed.", ConsoleColor.Green); + //Logger.Log($"{remap.TypePrimeCandidate.Name.String} Renamed.", ConsoleColor.Green); + } + + private static IEnumerable FixMethods( + IEnumerable typesToCheck, + RemapModel remap) + { + foreach (var type in typesToCheck) + { + var methods = type.Methods + .Where(method => method.Name.StartsWith(remap.TypePrimeCandidate.Name.String)); + + if (methods.Any()) + { + Logger.Log($"Found {methods.Count()} methods with mangled names", ConsoleColor.Red); + } + } + + return typesToCheck; } /// @@ -58,8 +73,7 @@ internal static class RenameHelper string oldTypeName, string newTypeName, - IEnumerable typesToCheck, - int overAllCount = 0) + IEnumerable typesToCheck) { foreach (var type in typesToCheck) { @@ -86,7 +100,6 @@ internal static class RenameHelper UpdateAllTypeFieldMemberRefs(typesToCheck, field, oldName); fieldCount++; - overAllCount++; } } } @@ -126,12 +139,10 @@ internal static class RenameHelper /// /// /// - /// - public static int RenameAllProperties( + public static void RenameAllProperties( string oldTypeName, string newTypeName, - IEnumerable typesToCheck, - int overAllCount = 0) + IEnumerable typesToCheck) { foreach (var type in typesToCheck) { @@ -153,22 +164,19 @@ internal static class RenameHelper property.Name = new UTF8String(newPropertyName); propertyCount++; - overAllCount++; } } } - - return overAllCount; } - public static string GetNewFieldName(string NewName, int fieldCount = 0) + private static string GetNewFieldName(string NewName, int fieldCount = 0) { string newFieldCount = fieldCount > 0 ? $"_{fieldCount}" : string.Empty; return $"{char.ToLower(NewName[0])}{NewName[1..]}{newFieldCount}"; } - public static string GetNewPropertyName(string newName, int propertyCount = 0) + private static string GetNewPropertyName(string newName, int propertyCount = 0) { return propertyCount > 0 ? $"{newName}_{propertyCount}" : newName; } diff --git a/de4dot/AssemblyData/AssemblyServer.cs b/de4dot/AssemblyData/AssemblyServer.cs index 8958870..da713ac 100644 --- a/de4dot/AssemblyData/AssemblyServer.cs +++ b/de4dot/AssemblyData/AssemblyServer.cs @@ -17,7 +17,6 @@ along with de4dot. If not, see . */ -#if NETFRAMEWORK using System; using System.Collections; using System.Runtime.Remoting; @@ -51,13 +50,3 @@ namespace AssemblyServer { } } } -#else -namespace AssemblyServer { - public static class Start { - public static int Main(string[] args) { - System.Console.WriteLine("Not supported"); - return -1; - } - } -} -#endif