Add overload resolution for ctor calls.

ICSharpCode.Decompiler.Tests/TestCases/Correctness/OverloadResolution.cs

@@ -34,8 +34,43 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Correctness
 			TestExtensionMethod();
 			TestParamsMethod();
 			Generics();
+			ConstructorTest();
 		}
 
+		#region ConstructorTest
+		static void ConstructorTest()
+		{
+			new CtorTestObj(1);
+			new CtorTestObj((short)2);
+			new CtorTestObj(3, null);
+			new CtorTestObj(4, null, null);
+		}
+
+		class CtorTestObj
+		{
+			public CtorTestObj(int i)
+			{
+				Console.WriteLine("CtorTestObj(int = " + i + ")");
+			}
+
+			public CtorTestObj(short s)
+			{
+				Console.WriteLine("CtorTestObj(short = " + s + ")");
+			}
+
+			public CtorTestObj(int i, object item1, object item2)
+				: this(i, new object[] { item1, item2 })
+			{
+				Console.WriteLine("CtorTestObj(int = " + i + ", item1 = " + item1 + ", item2 = " + item2);
+			}
+
+			public CtorTestObj(int i, params object[] items)
+			{
+				Console.WriteLine("CtorTestObj(int = " + i + ", items = " + (items == null ? "null" : items.Length.ToString()) + ")");
+			}
+		}
+		#endregion
+
 		#region params with nulls
 		static void TestParamsMethod()
 		{

ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs

@@ -1190,8 +1190,8 @@ namespace ICSharpCode.Decompiler.CSharp
 			ResolveResult rr = new CSharpInvocationResolveResult(target.ResolveResult, method, argumentResolveResults, isExpandedForm: isExpandedForm);
 			
 			if (inst.OpCode == OpCode.NewObj) {
-				var argumentExpressions = arguments.SelectArray(arg => arg.Expression);
 				if (settings.AnonymousTypes && method.DeclaringType.IsAnonymousType()) {
+					var argumentExpressions = arguments.SelectArray(arg => arg.Expression);
 					AnonymousTypeCreateExpression atce = new AnonymousTypeCreateExpression();
 					if (CanInferAnonymousTypePropertyNamesFromArguments(argumentExpressions, expectedParameters)) {
 						atce.Initializers.AddRange(argumentExpressions);
@@ -1208,7 +1208,13 @@ namespace ICSharpCode.Decompiler.CSharp
 						.WithILInstruction(inst)
 						.WithRR(rr);
 				} else {
-					return new ObjectCreateExpression(ConvertType(inst.Method.DeclaringType), argumentExpressions)
+					if (IsUnambiguousCall(inst, target, method, Array.Empty<IType>(), arguments) != OverloadResolutionErrors.None) {
+						for (int i = 0; i < arguments.Count; i++) {
+							if (!settings.AnonymousTypes || !expectedParameters[i].Type.ContainsAnonymousType())
+								arguments[i] = arguments[i].ConvertTo(expectedParameters[i].Type, this);
+						}
+					}
+					return new ObjectCreateExpression(ConvertType(inst.Method.DeclaringType), arguments.SelectArray(arg => arg.Expression))
 						.WithILInstruction(inst).WithRR(rr);
 				}
 			} else {