public static void DoPass(RewriteGlobalContext context) { foreach (var assemblyContext in context.Assemblies) { foreach (var typeContext in assemblyContext.Types) { foreach (var methodRewriteContext in typeContext.Methods) { var originalMethod = methodRewriteContext.OriginalMethod; var newMethod = methodRewriteContext.NewMethod; foreach (var originalMethodParameter in originalMethod.Parameters) { var newName = originalMethodParameter.Name.IsObfuscated(context.Options) ? $"param_{originalMethodParameter.Sequence}" : originalMethodParameter.Name; var newParameter = new ParameterDefinition(newName, originalMethodParameter.Attributes & ~ParameterAttributes.HasFieldMarshal, assemblyContext.RewriteTypeRef(originalMethodParameter.ParameterType)); newParameter.Constant = originalMethodParameter.Constant; newMethod.Parameters.Add(newParameter); } var paramsMethod = context.CreateParamsMethod(originalMethod, newMethod, assemblyContext.Imports, type => assemblyContext.RewriteTypeRef(type)); if (paramsMethod != null) { typeContext.NewType.Methods.Add(paramsMethod); } } } } }
public static void DoPass(RewriteGlobalContext context) { int methodsUnstripped = 0; int methodsIgnored = 0; foreach (var unityAssembly in context.UnityAssemblies.Assemblies) { var processedAssembly = context.TryGetAssemblyByName(unityAssembly.Name.Name); if (processedAssembly == null) { continue; } var imports = processedAssembly.Imports; foreach (var unityType in unityAssembly.MainModule.Types) { var processedType = processedAssembly.TryGetTypeByName(unityType.FullName); if (processedType == null) { continue; } foreach (var unityMethod in unityType.Methods) { if (unityMethod.Name == ".cctor" || unityMethod.Name == ".ctor") { continue; } if (unityMethod.IsAbstract) { continue; } var processedMethod = processedType.TryGetMethodByUnityAssemblyMethod(unityMethod); if (processedMethod != null) { continue; } var returnType = ResolveTypeInNewAssemblies(context, unityMethod.ReturnType, imports); if (returnType == null) { LogSupport.Trace($"Method {unityMethod} has unsupported return type {unityMethod.ReturnType}"); methodsIgnored++; continue; } var newMethod = new MethodDefinition(unityMethod.Name, unityMethod.Attributes & ~MethodAttributes.MemberAccessMask | MethodAttributes.Public, returnType); var hadBadParameter = false; foreach (var unityMethodParameter in unityMethod.Parameters) { var convertedType = ResolveTypeInNewAssemblies(context, unityMethodParameter.ParameterType, imports); if (convertedType == null) { hadBadParameter = true; LogSupport.Trace($"Method {unityMethod} has unsupported parameter type {unityMethodParameter.ParameterType}"); break; } newMethod.Parameters.Add(new ParameterDefinition(unityMethodParameter.Name, unityMethodParameter.Attributes, convertedType)); } if (hadBadParameter) { methodsIgnored++; continue; } foreach (var unityMethodGenericParameter in unityMethod.GenericParameters) { var newParameter = new GenericParameter(unityMethodGenericParameter.Name, newMethod); newParameter.Attributes = unityMethodGenericParameter.Attributes; foreach (var genericParameterConstraint in unityMethodGenericParameter.Constraints) { if (genericParameterConstraint.ConstraintType.FullName == "System.ValueType") { continue; } if (genericParameterConstraint.ConstraintType.Resolve().IsInterface) { continue; } var newType = ResolveTypeInNewAssemblies(context, genericParameterConstraint.ConstraintType, imports); if (newType != null) { newParameter.Constraints.Add(new GenericParameterConstraint(newType)); } } newMethod.GenericParameters.Add(newParameter); } if ((unityMethod.ImplAttributes & MethodImplAttributes.InternalCall) != 0) { var delegateType = UnstripGenerator.CreateDelegateTypeForICallMethod(unityMethod, newMethod, imports); processedType.NewType.NestedTypes.Add(delegateType); delegateType.DeclaringType = processedType.NewType; processedType.NewType.Methods.Add(newMethod); var delegateField = UnstripGenerator.GenerateStaticCtorSuffix(processedType.NewType, delegateType, unityMethod, imports); UnstripGenerator.GenerateInvokerMethodBody(newMethod, delegateField, delegateType, processedType, imports); } else { Pass81FillUnstrippedMethodBodies.PushMethod(unityMethod, newMethod, processedType, imports); processedType.NewType.Methods.Add(newMethod); } if (unityMethod.IsGetter) { GetOrCreateProperty(unityMethod, newMethod).GetMethod = newMethod; } else if (unityMethod.IsSetter) { GetOrCreateProperty(unityMethod, newMethod).SetMethod = newMethod; } var paramsMethod = context.CreateParamsMethod(unityMethod, newMethod, imports, type => ResolveTypeInNewAssemblies(context, type, imports)); if (paramsMethod != null) { processedType.NewType.Methods.Add(paramsMethod); } methodsUnstripped++; } } } LogSupport.Info(""); // finish the progress line LogSupport.Info($"{methodsUnstripped} methods restored"); LogSupport.Info($"{methodsIgnored} methods failed to restore"); }