Replace TypeSystem-properties with own

Author: greuelpirat

DeepCopy.Fody/Copy.cs

@@ -76,7 +76,7 @@ private IEnumerable<Instruction> Copy(TypeReference type, ValueSource source, Va
                     list.Add(Instruction.Create(OpCodes.Call, extensionMethod));
                 }
             }
-            else if (typeToken == TypeSystem.StringDefinition.MetadataToken)
+            else if (typeToken == StringDefinition.MetadataToken)
             {
                 using (target.Build(list, out var next))
                 {
@@ -99,7 +99,7 @@ private IEnumerable<Instruction> Copy(TypeReference type, ValueSource source, Va
             else if (type.IsImplementing(typeof(ISet<>)))
                 list.AddRange(CopySet(type, source, target));
 
-            else if (typeToken == TypeSystem.ObjectDefinition.MetadataToken)
+            else if (typeToken == ObjectDefinition.MetadataToken)
                 throw new WeavingException(Message.NotSupported(type));
 
             else

DeepCopy.Fody/CopyArray.cs

@@ -12,7 +12,7 @@ private IEnumerable<Instruction> CopyArray(PropertyDefinition property)
             var type = ((ArrayType) property.PropertyType).GetElementType();
 
             var loopStart = Instruction.Create(OpCodes.Nop);
-            var index = NewVariable(TypeSystem.Int32Definition);
+            var index = NewVariable(Int32Definition);
             var conditionStart = Instruction.Create(OpCodes.Ldloc, index);
 
             var list = new List<Instruction>

DeepCopy.Fody/ModuleWeaver.cs

@@ -83,15 +83,15 @@ private void ExecuteInjectDeepCopy()
 
         private void AddDeepConstructor(TypeDefinition type)
         {
-            var constructor = new MethodDefinition(ConstructorName, ConstructorAttributes, TypeSystem.VoidReference);
+            var constructor = new MethodDefinition(ConstructorName, ConstructorAttributes, VoidDefinition);
             constructor.Parameters.Add(new ParameterDefinition(type));
 
             var processor = constructor.Body.GetILProcessor();
 
             Func<TypeReference, IEnumerable<Instruction>> baseCopyFunc = null;
 
             var baseElementType = type.BaseType.GetElementType().Resolve();
-            if (IsType(baseElementType, typeof(object)))
+            if (baseElementType.MetadataToken == ObjectDefinition.MetadataToken)
             {
                 processor.Emit(OpCodes.Ldarg_0);
                 processor.Emit(OpCodes.Call, ImportDefaultConstructor(ImportType(typeof(object))));
@@ -125,9 +125,7 @@ private void AddDeepConstructor(TypeDefinition type)
                 baseCopyFunc = reference => CopySet(reference, ValueSource.New(), ValueTarget.New());
             }
             else
-                throw new WeavingException(Message.NoCopyConstructorFound(type.BaseType)
-                                           + Environment.NewLine
-                                           + $"AddDeepConstructor to {type} : {type.BaseType}={type.BaseType.Resolve().MetadataToken} ({TypeSystem.ObjectDefinition.MetadataToken})");
+                throw new WeavingException(Message.NoCopyConstructorFound(type.BaseType));
 
             InsertCopyInstructions(type, constructor, baseCopyFunc);
 

DeepCopy.Fody/ModuleWeaverUtils.cs

@@ -11,9 +11,22 @@ namespace DeepCopy.Fody
 {
     public partial class ModuleWeaver
     {
+        #region TypeSystem-Replacements
+
+        private TypeDefinition _stringDefinition;
+        private TypeDefinition _objectDefinition;
+        private TypeDefinition _voidDefinition;
+        private TypeDefinition _int32Definition;
+        private TypeDefinition StringDefinition => _stringDefinition ??= ImportType(typeof(string)).Resolve();
+        private TypeDefinition ObjectDefinition => _objectDefinition ??= ImportType(typeof(object)).Resolve();
+        private TypeDefinition VoidDefinition => _voidDefinition ??= ImportType(typeof(void)).Resolve();
+        private TypeDefinition Int32Definition => _int32Definition ??= ImportType(typeof(int)).Resolve();
+
+        #endregion
+
         private MethodReference NewConstructor(TypeReference type, TypeReference parameter = null)
         {
-            var constructor = new MethodReference(ConstructorName, TypeSystem.VoidDefinition, type) { HasThis = true };
+            var constructor = new MethodReference(ConstructorName, VoidDefinition, type) { HasThis = true };
             if (parameter != null)
                 constructor.Parameters.Add(new ParameterDefinition(parameter));
             return constructor;
@@ -65,9 +78,9 @@ internal MethodReference ImportMethod(TypeReference type, string name, params Ty
         private MethodReference StringCopy()
         {
             return ModuleDefinition.ImportReference(
-                new MethodReference(nameof(string.Copy), TypeSystem.StringDefinition, TypeSystem.StringDefinition)
+                new MethodReference(nameof(string.Copy), StringDefinition, StringDefinition)
                 {
-                    Parameters = { new ParameterDefinition(TypeSystem.StringDefinition) }
+                    Parameters = { new ParameterDefinition(StringDefinition) }
                 });
         }