Merge pull request #712 from Sergio0694/user/sergiopedri/create-constructor-overload

Add 'CreateConstructor' overload taking just 'CorLibTypeFactory'

Author: Washi1337

src/AsmResolver.DotNet/MethodDefinition.cs

@@ -830,12 +830,27 @@ public static MethodDefinition CreateStaticConstructor(ModuleDefinition module)
         /// any of the declaring type's base classes. For an idiomatic .NET binary, this should be added.
         /// </remarks>
         public static MethodDefinition CreateConstructor(ModuleDefinition module, params TypeSignature[] parameterTypes)
+        {
+            return CreateConstructor(module.CorLibTypeFactory, parameterTypes);
+        }
+
+        /// <summary>
+        /// Creates a new public constructor for a type that is executed when its declaring type is loaded by the CLR.
+        /// </summary>
+        /// <param name="corLibTypeFactory">The <see cref="CorLibTypeFactory"/> instance to use to resolve fundamental type signatures.</param>
+        /// <param name="parameterTypes">An ordered list of types the parameters of the constructor should have.</param>
+        /// <returns>The constructor.</returns>
+        /// <remarks>
+        /// The resulting method's body will consist of a single <c>ret</c> instruction, and does not contain a call to
+        /// any of the declaring type's base classes. For an idiomatic .NET binary, this should be added.
+        /// </remarks>
+        public static MethodDefinition CreateConstructor(CorLibTypeFactory corLibTypeFactory, params TypeSignature[] parameterTypes)
         {
             var ctor = new MethodDefinition(".ctor",
                 MethodAttributes.Public
                 | MethodAttributes.SpecialName
                 | MethodAttributes.RuntimeSpecialName,
-                MethodSignature.CreateInstance(module.CorLibTypeFactory.Void, parameterTypes));
+                MethodSignature.CreateInstance(corLibTypeFactory.Void, parameterTypes));
 
             for (int i = 0; i < parameterTypes.Length; i++)
                 ctor.ParameterDefinitions.Add(new ParameterDefinition(null));

test/AsmResolver.DotNet.Tests/MethodDefinitionTest.cs

@@ -641,7 +641,7 @@ public void VerifyGenericParameterCount()
         }
 
         [Fact]
-        public void CreateParameterlessConstructor()
+        public void CreateParameterlessConstructorFromModuleDefinition()
         {
             var module = ModuleDefinition.FromFile(typeof(Constructors).Assembly.Location, TestReaderParameters);
             var ctor = MethodDefinition.CreateConstructor(module);
@@ -653,7 +653,7 @@ public void CreateParameterlessConstructor()
         }
 
         [Fact]
-        public void CreateConstructor()
+        public void CreateConstructorFromModuleDefinition()
         {
             var module = ModuleDefinition.FromFile(typeof(Constructors).Assembly.Location, TestReaderParameters);
             var factory = module.CorLibTypeFactory;
@@ -663,6 +663,29 @@ public void CreateConstructor()
             Assert.Equal(new[] {factory.Int32, factory.Double}, ctor.Parameters.Select(x => x.ParameterType));
         }
 
+        [Fact]
+        public void CreateParameterlessConstructorFromCorLibTypeFactory()
+        {
+            var module = ModuleDefinition.FromFile(typeof(Constructors).Assembly.Location, TestReaderParameters);
+            var ctor = MethodDefinition.CreateConstructor(module.CorLibTypeFactory);
+
+            Assert.True(ctor.IsConstructor);
+            Assert.Empty(ctor.Parameters);
+            Assert.NotNull(ctor.CilMethodBody);
+            Assert.Equal(CilOpCodes.Ret, Assert.Single(ctor.CilMethodBody.Instructions).OpCode);
+        }
+
+        [Fact]
+        public void CreateConstructorFromCorLibTypeFactory()
+        {
+            var module = ModuleDefinition.FromFile(typeof(Constructors).Assembly.Location, TestReaderParameters);
+            var factory = module.CorLibTypeFactory;
+            var ctor = MethodDefinition.CreateConstructor(factory, factory.Int32, factory.Double);
+
+            Assert.True(ctor.IsConstructor);
+            Assert.Equal(new[] { factory.Int32, factory.Double }, ctor.Parameters.Select(x => x.ParameterType));
+        }
+
         [Fact]
         public void BodyHasOwner()
         {