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");
}
