Fix TypeMapper

Author: Windows10CE

TypeMapper.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using HarmonyLib;
 using Mono.Cecil.Cil;
 using MonoMod.Utils;
@@ -9,22 +10,10 @@ namespace APIPlugin
 {
     [AttributeUsage(AttributeTargets.Field)]
     public class IgnoreMappingAttribute : Attribute {}
-    public static unsafe class TypeMapper<S, D> where S : class where D : class, new()
+    public static class TypeMapper<S, D> where S : class where D : class
     {
-        private struct GetFieldDelegate
-        {
-            public delegate*<S, object> Del;
-            public Type FieldType;
-        }
-
-        private struct SetFieldDelegate
-        {
-            public delegate*<D, object, void> Del;
-            public Type FieldType;
-        }
-
-        private static Dictionary<string, GetFieldDelegate> _accessors = null;
-        private static Dictionary<string, GetFieldDelegate> FieldAccessors
+        private static Dictionary<string, MethodInfo> _accessors = null;
+        private static Dictionary<string, MethodInfo> FieldAccessors
         {
             get
             {
@@ -39,21 +28,17 @@ private static Dictionary<string, GetFieldDelegate> FieldAccessors
                         il.Emit(OpCodes.Ldarg_0);
                         il.Emit(OpCodes.Ldfld, accessor.Module.ImportReference(field));
                         if (field.FieldType.IsValueType)
-                            il.Emit(OpCodes.Box);
+                            il.Emit(OpCodes.Box, field.FieldType);
                         il.Emit(OpCodes.Ret);
-                        _accessors.Add(field.Name, new GetFieldDelegate
-                        {
-                            Del = (delegate*<S, object>)accessor.Generate().MethodHandle.GetFunctionPointer(),
-                            FieldType = field.FieldType
-                        });
+                        _accessors.Add(field.Name, accessor.Generate());
                     }
                 }
                 return _accessors;
             }
         }
 
-        private static Dictionary<string, SetFieldDelegate> _setters = null;
-        private static Dictionary<string, SetFieldDelegate> FieldSetters
+        private static Dictionary<string, MethodInfo> _setters = null;
+        private static Dictionary<string, MethodInfo> FieldSetters
         {
             get
             {
@@ -63,43 +48,28 @@ private static Dictionary<string, SetFieldDelegate> FieldSetters
 
                     foreach (var field in AccessTools.GetDeclaredFields(typeof(D)))
                     {
-                        var fieldType = field.FieldType;
                         var setter = new DynamicMethodDefinition("set_" + field.Name, typeof(void), new Type[] { typeof(D), typeof(object) });
                         var il = setter.GetILProcessor();
                         il.Emit(OpCodes.Ldarg_0);
                         il.Emit(OpCodes.Ldarg_1);
-                        if (FieldAccessors.TryGetValue(field.Name, out var getter) && getter.FieldType.GetGenericTypeDefinition() == typeof(Nullable<>) && getter.FieldType.GetGenericArguments()[0] == field.FieldType)
-                        {
-                            il.Emit(OpCodes.Call, AccessTools.DeclaredPropertyGetter(fieldType, "Value"));
-                            fieldType = getter.FieldType.GetGenericArguments()[0];
-                        }
-                        else if (fieldType.IsValueType)
-                            il.Emit(OpCodes.Unbox, setter.Module.ImportReference(field.FieldType));
-                        else
-                            il.Emit(OpCodes.Castclass, setter.Module.ImportReference(field.FieldType));
+                        il.Emit(OpCodes.Unbox_Any, setter.Module.ImportReference(field.FieldType));
                         il.Emit(OpCodes.Stfld, setter.Module.ImportReference(field));
                         il.Emit(OpCodes.Ret);
-                        _setters.Add(field.Name, new SetFieldDelegate
-                        {
-                            Del = (delegate*<D, object, void>)setter.Generate().MethodHandle.GetFunctionPointer(),
-                            FieldType = field.FieldType
-                        });
+                        _setters.Add(field.Name, setter.Generate());
                     }
                 }
                 return _setters;
             }
         }
 
-        public static D Convert(S source, D destination = null)
+        public static D Convert(S source, D destination)
         {
-            destination ??= new();
-
             foreach (var field in FieldAccessors)
             {
-                object val = field.Value.Del(source);
-                if (val is not null)
+                object val = field.Value.Invoke(null, new object[] {source});
+                if (val is not null && FieldSetters.ContainsKey(field.Key))
                 {
-                    FieldSetters[field.Key].Del(destination, val);
+                    FieldSetters[field.Key].Invoke(null, new object[] {destination, val});
                 }
             }