Fix by-ref parameter handling in hook/delegate emission

Resolve by-ref params via ByReferenceType.ElementType, avoiding GetElementType() over-unwrapping (ref int[] → int)
Carry over RefKind + In/Out metadata to emitted delegate parameters
Adjust IL emission and generic declaring-type relinking

Author: CedaryCat

ModFramework/Emitters/HookEmitter.cs

@@ -91,8 +91,8 @@ static string GetUniqueName(MethodDefinition method)
             name += "_" + string.Join("_", method.Parameters.Select(y =>
             {
                 var name = y.ParameterType.Name;
-                if (y.ParameterType.IsByReference)
-                    name = $"{y.ParameterType.GetElementType().Name}ByRef";
+                if (y.ParameterType is ByReferenceType byref)
+                    name = $"{byref.ElementType.Name}ByRef";
                 return name;
             }));
         }
@@ -133,7 +133,7 @@ static TypeDefinition CreateHookEventArgs(TypeDefinition hookType, MethodDefinit
         // for each parameter in the method, create a field
         foreach (var param in hookDefinition.Parameters)
         {
-            var paramType = param.ParameterType.IsByReference ? param.ParameterType.GetElementType() : param.ParameterType;
+            var paramType = param.ParameterType is ByReferenceType byref ? byref.ElementType : param.ParameterType;
             FieldDefinition paramField = new(param.Name, FieldAttributes.Public, paramType);
             hookEvent.Fields.Add(paramField);
         }
@@ -254,7 +254,7 @@ public static TypeDefinition GetOrCreateOriginalMethodDelegate(MonoModder modder
         };
 
         foreach (var param in originalDefinition.Parameters)
-            invoke.Parameters.Add(new(param.Name, ParameterAttributes.None, param.ParameterType));
+            invoke.Parameters.Add(param.ClonePreservingInOut());
 
         delegateType.Methods.Add(invoke);
 
@@ -266,7 +266,7 @@ public static TypeDefinition GetOrCreateOriginalMethodDelegate(MonoModder modder
             IsRuntime = true
         };
         foreach (var param in originalDefinition.Parameters)
-            beginInvoke.Parameters.Add(new(param.Name, ParameterAttributes.None, param.ParameterType));
+            beginInvoke.Parameters.Add(param.ClonePreservingInOut());
         beginInvoke.Parameters.Add(new("callback", ParameterAttributes.None, iAsyncCallback));
         beginInvoke.Parameters.Add(new("object", ParameterAttributes.None, delegateType.Module.TypeSystem.Object));
         delegateType.Methods.Add(beginInvoke);
@@ -495,7 +495,7 @@ static MethodDefinition CreateReplacement(MethodDefinition original, MethodDefin
         // if any out parameters, initialise them with default values
         foreach (var param in methodDefinition.Parameters.Where(x => x.IsOut))
         {
-            var type = param.ParameterType.GetElementType();
+            var type = ((ByReferenceType)param.ParameterType).ElementType;
             il.Emit(OpCodes.Ldarg_S, param);
             var defaultValue = CreateDefaultValueInstruction(type);
             il.Append(defaultValue);
@@ -510,14 +510,15 @@ static MethodDefinition CreateReplacement(MethodDefinition original, MethodDefin
         il.Emit(OpCodes.Ldftn, original);
         il.Emit(OpCodes.Newobj, originalMethodField.FieldType.Resolve().Methods.Single(x => x.Name == ".ctor"));
 
-        for (int i = 0; i < methodDefinition.Parameters.Count; i++)
+        foreach (var param in methodDefinition.Parameters)
         {
-            var isByRef = methodDefinition.Parameters[i].ParameterType.IsByReference;
-            var opCode = isByRef ? OpCodes.Ldarg_S : OpCodes.Ldarg;
-            il.Emit(opCode, methodDefinition.Parameters[i]);
-            if (isByRef)
-                il.Append(CreateLoadIndirectInstruction(methodDefinition.Parameters[i].ParameterType.GetElementType()));
+            il.Emit(OpCodes.Ldarg_S, param);
+            if (param.ParameterType is ByReferenceType byRefType)
+            {
+                il.Append(CreateLoadIndirectInstruction(byRefType.ElementType));
+            }
         }
+
         il.Emit(OpCodes.Call, eventInvoke);
 
         // store the event args in a local variable
@@ -530,7 +531,7 @@ static MethodDefinition CreateReplacement(MethodDefinition original, MethodDefin
             il.Emit(OpCodes.Ldarg_S, param);
             il.Emit(OpCodes.Ldloc, eventArgsVariable);
             il.Emit(OpCodes.Ldfld, field);
-            il.Append(CreateStoreIndirectFunction(field.FieldType.GetElementType()));
+            il.Append(CreateStoreIndirectFunction(field.FieldType));
         }
 
         // use ContinueExecutionName to determine whether to continue or not

ModFramework/Extensions/Replacement.Extensions.cs

@@ -43,4 +43,10 @@ public static PropertyDefinition Clone(this PropertyDefinition property)
 
         return prop;
     }
+
+    public static ParameterDefinition ClonePreservingInOut(this ParameterDefinition p) 
+    {
+        var attrs = p.Attributes & (ParameterAttributes.In | ParameterAttributes.Out);
+        return new ParameterDefinition(p.Name, attrs, p.ParameterType);
+    }
 }

ModFramework/Relinker/TypeRelinker.cs

@@ -135,7 +135,17 @@ private void CheckMethodRef(MethodReference mref)
                 CheckType(gim.GenericArguments[x], nt => gim.GenericArguments[x] = nt);
 
                 if (gim.GenericArguments[x].DeclaringType is not null)
-                    CheckType(gim.GenericArguments[x].DeclaringType, nt => gim.GenericArguments[x].DeclaringType = nt);
+                    CheckType(gim.GenericArguments[x].DeclaringType, nt => 
+                    {
+                        if (gim.GenericArguments[x] is GenericParameter gp) 
+                        {
+                            gim.GenericArguments[x] = nt.GenericParameters[gp.Position];
+                        }
+                        else 
+                        {
+                            gim.GenericArguments[x].DeclaringType = nt;
+                        }
+                    });
             }
         }
         else