Fix build.

ICSharpCode.Decompiler/CSharp/CallBuilder.cs

@@ -811,7 +811,7 @@ namespace ICSharpCode.Decompiler.CSharp
 				// that are no longer required once we add the type arguments.
 				// We lend overload resolution a hand by detecting such cases beforehand and requiring type arguments,
 				// if necessary.
-				if (!CanInferTypeArgumentsFromParameters(method, argumentList.Arguments.SelectArray(a => a.ResolveResult), expressionBuilder.typeInference)) {
+				if (!CanInferTypeArgumentsFromArguments(method, argumentList, expressionBuilder.typeInference)) {
 					requireTypeArguments = true;
 					typeArguments = method.TypeArguments.ToArray();
 					appliedRequireTypeArgumentsShortcut = true;
@@ -895,14 +895,14 @@ namespace ICSharpCode.Decompiler.CSharp
 			return method.IsExtensionMethod && arguments.Count > 0 && arguments[0].Expression is NullReferenceExpression;
 		}
 
-		public static bool CanInferTypeArgumentsFromParameters(IMethod method, IReadOnlyList<ResolveResult> arguments,
-			TypeInference typeInference)
+		static bool CanInferTypeArgumentsFromArguments(IMethod method, ArgumentList argumentList, TypeInference typeInference)
 		{
 			if (method.TypeParameters.Count == 0)
 				return true;
 			// always use unspecialized member, otherwise type inference fails
 			method = (IMethod)method.MemberDefinition;
-			typeInference.InferTypeArguments(method.TypeParameters, arguments, method.Parameters.SelectReadOnlyArray(p => p.Type),
+			var parametersInArgumentOrder = argumentList.ArgumentToParameterMap == null ? method.Parameters : argumentList.ArgumentToParameterMap.SelectReadOnlyArray(index => method.Parameters[index]);
+			typeInference.InferTypeArguments(method.TypeParameters, argumentList.Arguments.SelectReadOnlyArray(a => a.ResolveResult), parametersInArgumentOrder.SelectReadOnlyArray(p => p.Type),
 				out bool success);
 			return success;
 		}

ICSharpCode.Decompiler/CSharp/Resolver/Log.cs

@@ -29,7 +29,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 	/// </summary>
 	static class Log
 	{
-		const bool logEnabled = true;
+		const bool logEnabled = false;
 #if __MonoCS__
 		[Conditional("MCS_DEBUG")]
 #else

ICSharpCode.Decompiler/IL/Transforms/TransformCollectionAndObjectInitializers.cs

@@ -378,9 +378,24 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 				return false;
 			if (!targetType.GetAllBaseTypes().Any(i => i.IsKnownType(KnownTypeCode.IEnumerable) || i.IsKnownType(KnownTypeCode.IEnumerableOfT)))
 				return false;
-			return CSharp.CallBuilder.CanInferTypeArgumentsFromParameters(
-				method, method.Parameters.SelectReadOnlyArray(p => new ResolveResult(p.Type)),
-				new TypeInference(resolveContext.Compilation));
+			return CanInferTypeArgumentsFromParameters(method);
+
+			bool CanInferTypeArgumentsFromParameters(IMethod method)
+			{
+				if (method.TypeParameters.Count == 0)
+					return true;
+				// always use unspecialized member, otherwise type inference fails
+				method = (IMethod)method.MemberDefinition;
+				new TypeInference(resolveContext.Compilation)
+					.InferTypeArguments(
+						method.TypeParameters,
+						// TODO : this is not entirely correct... we need argument type information to resolve Add methods properly
+						method.Parameters.SelectReadOnlyArray(p => new ResolveResult(p.Type)),
+						method.Parameters.SelectReadOnlyArray(p => p.Type),
+						out bool success
+					);
+				return success;
+			}
 		}
 
 		static IType GetReturnTypeFromInstruction(ILInstruction instruction)