Use NamedArgumentResolveResult for dynamic invocations.

ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs

@@ -1883,6 +1883,20 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		#endregion
 		
 		#region ResolveInvocation
+
+		IList<ResolveResult> AddArgumentNamesIfNecessary(ResolveResult[] arguments, string[] argumentNames) {
+			if (argumentNames == null) {
+				return arguments;
+			}
+			else {
+				var result = new ResolveResult[arguments.Length];
+				for (int i = 0; i < arguments.Length; i++) {
+					result[i] = (argumentNames[i] != null ? new NamedArgumentResolveResult(argumentNames[i], arguments[i]) : arguments[i]);
+				}
+				return result;
+			}
+		}
+
 		/// <summary>
 		/// Resolves an invocation.
 		/// </summary>
@@ -1900,7 +1914,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			// C# 4.0 spec: §7.6.5
 			
 			if (target.Type.Kind == TypeKind.Dynamic) {
-				return new DynamicInvocationResolveResult(target, DynamicInvocationType.Invocation, arguments.Select((a, i) => new DynamicInvocationArgument(argumentNames != null ? argumentNames[i] : null, a)).ToList().AsReadOnly());
+				return new DynamicInvocationResolveResult(target, DynamicInvocationType.Invocation, AddArgumentNamesIfNecessary(arguments, argumentNames));
 			}
 			
 			MethodGroupResolveResult mgrr = target as MethodGroupResolveResult;
@@ -1923,7 +1937,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 								l.Add(new MethodListWithDeclaringType(m.DeclaringType));
 							l[l.Count - 1].Add(m.Method);
 						}
-						return new DynamicInvocationResolveResult(new MethodGroupResolveResult(actualTarget, mgrr.MethodName, l, mgrr.TypeArguments), DynamicInvocationType.Invocation, arguments.Select((a, i) => new DynamicInvocationArgument(argumentNames != null ? argumentNames[i] : null, a)).ToList().AsReadOnly());
+						return new DynamicInvocationResolveResult(new MethodGroupResolveResult(actualTarget, mgrr.MethodName, l, mgrr.TypeArguments), DynamicInvocationType.Invocation, AddArgumentNamesIfNecessary(arguments, argumentNames));
 					}
 				}
 
@@ -2065,7 +2079,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			switch (target.Type.Kind) {
 				case TypeKind.Dynamic:
-					return new DynamicInvocationResolveResult(target, DynamicInvocationType.Indexing, arguments.Select((a, i) => new DynamicInvocationArgument(argumentNames != null ? argumentNames[i] : null, a)).ToList().AsReadOnly());
+					return new DynamicInvocationResolveResult(target, DynamicInvocationType.Indexing, AddArgumentNamesIfNecessary(arguments, argumentNames));
 					
 				case TypeKind.Array:
 				case TypeKind.Pointer:
@@ -2085,7 +2099,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				var applicableIndexers = indexers.SelectMany(x => x).Where(m => OverloadResolution.IsApplicable(or2.AddCandidate(m))).ToList();
 
 				if (applicableIndexers.Count > 1) {
-					return new DynamicInvocationResolveResult(target, DynamicInvocationType.Indexing, arguments.Select((a, i) => new DynamicInvocationArgument(argumentNames != null ? argumentNames[i] : null, a)).ToList().AsReadOnly());
+					return new DynamicInvocationResolveResult(target, DynamicInvocationType.Indexing, AddArgumentNamesIfNecessary(arguments, argumentNames));
 				}
 			}
 
@@ -2166,7 +2180,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 
 			if (allApplicable != null && allApplicable.Count > 1) {
 				// If we have dynamic arguments, we need to represent the invocation as a dynamic invocation if there is more than one applicable constructor.
-				return new DynamicInvocationResolveResult(new MethodGroupResolveResult(null, allApplicable[0].Name, new[] { new MethodListWithDeclaringType(type, allApplicable) }, null), DynamicInvocationType.ObjectCreation, arguments.Select((a, i) => new DynamicInvocationArgument(argumentNames != null ? argumentNames[i] : null, a)).ToList().AsReadOnly(), initializerStatements);
+				return new DynamicInvocationResolveResult(new MethodGroupResolveResult(null, allApplicable[0].Name, new[] { new MethodListWithDeclaringType(type, allApplicable) }, null), DynamicInvocationType.ObjectCreation, AddArgumentNamesIfNecessary(arguments, argumentNames), initializerStatements);
 			}
 
 			if (or.BestCandidate != null) {

ICSharpCode.NRefactory.CSharp/Resolver/DynamicInvocationResolveResult.cs

@@ -25,26 +25,6 @@ using ICSharpCode.NRefactory.TypeSystem;
 
 namespace ICSharpCode.NRefactory.CSharp.Resolver
 {
-	/// <summary>
-	/// Represents a single argument in a dynamic invocation.
-	/// </summary>
-	public class DynamicInvocationArgument {
-		/// <summary>
-		/// Parameter name, if the argument is named. Null otherwise.
-		/// </summary>
-		public readonly string Name;
-
-		/// <summary>
-		/// Value of the argument.
-		/// </summary>
-		public readonly ResolveResult Value;
-
-		public DynamicInvocationArgument(string name, ResolveResult value) {
-			Name = name;
-			Value = value;
-		}
-	}
-
 	public enum DynamicInvocationType {
 		/// <summary>
 		/// The invocation is a normal invocation ( 'a(b)' ).
@@ -78,9 +58,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		public readonly DynamicInvocationType InvocationType;
 
 		/// <summary>
-		/// Arguments for the call.
+		/// Arguments for the call. Named arguments will be instances of <see cref="NamedArgumentResolveResult"/>.
 		/// </summary>
-		public readonly IList<DynamicInvocationArgument> Arguments; 
+		public readonly IList<ResolveResult> Arguments; 
 
 		/// <summary>
 		/// Gets the list of initializer statements that are appplied to the result of this invocation.
@@ -91,10 +71,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// </summary>
 		public readonly IList<ResolveResult> InitializerStatements;
 
-		public DynamicInvocationResolveResult(ResolveResult target, DynamicInvocationType invocationType, IList<DynamicInvocationArgument> arguments, IList<ResolveResult> initializerStatements = null) : base(SpecialType.Dynamic) {
+		public DynamicInvocationResolveResult(ResolveResult target, DynamicInvocationType invocationType, IList<ResolveResult> arguments, IList<ResolveResult> initializerStatements = null) : base(SpecialType.Dynamic) {
 			this.Target                = target;
 			this.InvocationType        = invocationType;
-			this.Arguments             = arguments ?? EmptyList<DynamicInvocationArgument>.Instance;
+			this.Arguments             = arguments ?? EmptyList<ResolveResult>.Instance;
 			this.InitializerStatements = initializerStatements ?? EmptyList<ResolveResult>.Instance;
 		}
 

ICSharpCode.NRefactory.Tests/CSharp/Resolver/DynamicTests.cs

@@ -10,6 +10,14 @@ using NUnit.Framework;
 namespace ICSharpCode.NRefactory.CSharp.Resolver {
 	[TestFixture]
 	public class DynamicTests : ResolverTestBase {
+		private void AssertNamedArgument<T>(ResolveResult rr, string parameterName, Func<T, bool> verifier) where T : ResolveResult {
+			var narr = rr as NamedArgumentResolveResult;
+			Assert.That(narr, Is.Not.Null);
+			Assert.That(narr.ParameterName, Is.EqualTo(parameterName));
+			Assert.That(narr.Argument, Is.InstanceOf<T>());
+			Assert.That(verifier((T)narr.Argument), Is.True);
+		}
+
 		[Test]
 		public void AccessToDynamicMember() {
 			string program = @"using System;
@@ -44,10 +52,8 @@ class TestClass {
 			Assert.That(dynamicMember.Target is LocalResolveResult && ((LocalResolveResult)dynamicMember.Target).Variable.Name == "obj");
 			Assert.That(dynamicMember.Member, Is.EqualTo("SomeMethod"));
 			Assert.That(rr.Arguments.Count, Is.EqualTo(2));
-			Assert.That(rr.Arguments[0].Name, Is.Null);
-			Assert.That(rr.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0].Value).Variable.Name == "a");
-			Assert.That(rr.Arguments[1].Name, Is.Null);
-			Assert.That(rr.Arguments[1].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[1].Value).Variable.Name == "b");
+			Assert.That(rr.Arguments[0] is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0]).Variable.Name == "a");
+			Assert.That(rr.Arguments[1] is LocalResolveResult && ((LocalResolveResult)rr.Arguments[1]).Variable.Name == "b");
 		}
 
 		[Test]
@@ -69,12 +75,9 @@ class TestClass {
 			Assert.That(dynamicMember.Target is LocalResolveResult && ((LocalResolveResult)dynamicMember.Target).Variable.Name == "obj");
 			Assert.That(dynamicMember.Member, Is.EqualTo("SomeMethod"));
 			Assert.That(rr.Arguments.Count, Is.EqualTo(3));
-			Assert.That(rr.Arguments[0].Name, Is.Null);
-			Assert.That(rr.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0].Value).Variable.Name == "x");
-			Assert.That(rr.Arguments[1].Name, Is.EqualTo("param1"));
-			Assert.That(rr.Arguments[1].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[1].Value).Variable.Name == "a");
-			Assert.That(rr.Arguments[2].Name, Is.EqualTo("param2"));
-			Assert.That(rr.Arguments[2].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[2].Value).Variable.Name == "b");
+			Assert.That(rr.Arguments[0] is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0]).Variable.Name == "x");
+			AssertNamedArgument<LocalResolveResult>(rr.Arguments[1], "param1", lrr => lrr.Variable.Name == "a");
+			AssertNamedArgument<LocalResolveResult>(rr.Arguments[2], "param2", lrr => lrr.Variable.Name == "b");
 		}
 
 		[Test]
@@ -98,11 +101,9 @@ class TestClass {
 			Assert.That(dynamicMember.Member, Is.EqualTo("SomeMethod"));
 			Assert.That(rr.InvocationType, Is.EqualTo(DynamicInvocationType.Invocation));
 			Assert.That(innerInvocation.Arguments.Count, Is.EqualTo(1));
-			Assert.That(innerInvocation.Arguments[0].Name, Is.Null);
-			Assert.That(innerInvocation.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)innerInvocation.Arguments[0].Value).Variable.Name == "a");
+			Assert.That(innerInvocation.Arguments[0] is LocalResolveResult && ((LocalResolveResult)innerInvocation.Arguments[0]).Variable.Name == "a");
 			Assert.That(rr.Arguments.Count, Is.EqualTo(1));
-			Assert.That(rr.Arguments[0].Name, Is.Null);
-			Assert.That(rr.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0].Value).Variable.Name == "b");
+			Assert.That(rr.Arguments[0] is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0]).Variable.Name == "b");
 		}
 
 		[Test]
@@ -156,7 +157,7 @@ class TestClass : TestBase {
 			Assert.That(mg.Methods.Any(m => m.Parameters.Count == 1 && m.DeclaringType.Name == "TestClass" && m.Name == "SomeMethod" && m.Parameters[0].Type.Name == "String"));
 
 			Assert.That(rr.Arguments.Count, Is.EqualTo(1));
-			Assert.That(rr.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0].Value).Variable.Name == "obj");
+			Assert.That(rr.Arguments[0] is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0]).Variable.Name == "obj");
 		}
 
 		[Test, Ignore("Fails")]
@@ -212,7 +213,7 @@ class TestClass {
 			Assert.That(mg.Methods.All(m => m.Name == "SomeMethod" && m.DeclaringType.Name == "TestClass"));
 
 			Assert.That(rr.Arguments.Count, Is.EqualTo(1));
-			Assert.That(rr.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0].Value).Variable.Name == "obj");
+			Assert.That(rr.Arguments[0] is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0]).Variable.Name == "obj");
 		}
 
 		[Test]
@@ -240,7 +241,7 @@ class TestClass {
 			Assert.That(mg.Methods.All(m => m.Name == "SomeMethod" && m.DeclaringType.Name == "TestClass"));
 
 			Assert.That(rr.Arguments.Count, Is.EqualTo(1));
-			Assert.That(rr.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0].Value).Variable.Name == "obj");
+			Assert.That(rr.Arguments[0] is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0]).Variable.Name == "obj");
 		}
 
 		[Test]
@@ -268,7 +269,7 @@ class TestClass {
 			Assert.That(mg.Methods.All(m => m.Name == "SomeMethod" && m.DeclaringType.Name == "TestClass"));
 
 			Assert.That(rr.Arguments.Count, Is.EqualTo(1));
-			Assert.That(rr.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0].Value).Variable.Name == "obj");
+			Assert.That(rr.Arguments[0] is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0]).Variable.Name == "obj");
 		}
 
 		[Test]
@@ -315,10 +316,8 @@ class TestClass {
 			Assert.That(mg.Methods.All(m => m.Name == "SomeMethod" && m.DeclaringType.Name == "TestClass"));
 
 			Assert.That(rr.Arguments.Count, Is.EqualTo(2));
-			Assert.That(rr.Arguments[0].Name, Is.EqualTo("a"));
-			Assert.That(rr.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0].Value).Variable.Name == "obj");
-			Assert.That(rr.Arguments[1].Name, Is.EqualTo("i"));
-			Assert.That(rr.Arguments[1].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[1].Value).Variable.Name == "idx");
+			AssertNamedArgument<LocalResolveResult>(rr.Arguments[0], "a", lrr => lrr.Variable.Name == "obj");
+			AssertNamedArgument<LocalResolveResult>(rr.Arguments[1], "i", lrr => lrr.Variable.Name == "idx");
 		}
 
 		[Test]
@@ -336,8 +335,7 @@ class TestClass {
 			Assert.That(rr.InvocationType, Is.EqualTo(DynamicInvocationType.Indexing));
 			Assert.That(rr.Target is LocalResolveResult && ((LocalResolveResult)rr.Target).Variable.Name == "obj");
 			Assert.That(rr.Arguments.Count, Is.EqualTo(1));
-			Assert.That(rr.Arguments[0].Name, Is.Null);
-			Assert.That(rr.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0].Value).Variable.Name == "a");
+			Assert.That(rr.Arguments[0] is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0]).Variable.Name == "a");
 		}
 
 		[Test]
@@ -355,10 +353,8 @@ class TestClass {
 			Assert.That(rr.InvocationType, Is.EqualTo(DynamicInvocationType.Indexing));
 			Assert.That(rr.Target is LocalResolveResult && ((LocalResolveResult)rr.Target).Variable.Name == "obj");
 			Assert.That(rr.Arguments.Count, Is.EqualTo(2));
-			Assert.That(rr.Arguments[0].Name, Is.EqualTo("arg1"));
-			Assert.That(rr.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0].Value).Variable.Name == "a");
-			Assert.That(rr.Arguments[1].Name, Is.EqualTo("arg2"));
-			Assert.That(rr.Arguments[1].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[1].Value).Variable.Name == "b");
+			AssertNamedArgument<LocalResolveResult>(rr.Arguments[0], "arg1", lrr => lrr.Variable.Name == "a");
+			AssertNamedArgument<LocalResolveResult>(rr.Arguments[1], "arg2", lrr => lrr.Variable.Name == "b");
 		}
 
 		[Test]
@@ -400,8 +396,7 @@ class TestClass {
 			Assert.That(rr.InvocationType, Is.EqualTo(DynamicInvocationType.Indexing));
 			Assert.That(rr.Target, Is.InstanceOf<ThisResolveResult>());
 			Assert.That(rr.Arguments.Count, Is.EqualTo(1));
-			Assert.That(rr.Arguments[0].Name, Is.Null);
-			Assert.That(rr.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0].Value).Variable.Name == "obj");
+			Assert.That(rr.Arguments[0] is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0]).Variable.Name == "obj");
 		}
 
 		[Test]
@@ -424,8 +419,7 @@ class TestClass : TestBase {
 			Assert.That(rr.InvocationType, Is.EqualTo(DynamicInvocationType.Indexing));
 			Assert.That(rr.Target, Is.InstanceOf<ThisResolveResult>());
 			Assert.That(rr.Arguments.Count, Is.EqualTo(1));
-			Assert.That(rr.Arguments[0].Name, Is.Null);
-			Assert.That(rr.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0].Value).Variable.Name == "obj");
+			Assert.That(rr.Arguments[0] is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0]).Variable.Name == "obj");
 		}
 
 		[Test, Ignore("Fails")]
@@ -472,10 +466,8 @@ class TestClass {
 			Assert.That(rr.InvocationType, Is.EqualTo(DynamicInvocationType.Indexing));
 			Assert.That(rr.Target, Is.InstanceOf<ThisResolveResult>());
 			Assert.That(rr.Arguments.Count, Is.EqualTo(2));
-			Assert.That(rr.Arguments[0].Name, Is.EqualTo("a"));
-			Assert.That(rr.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0].Value).Variable.Name == "obj");
-			Assert.That(rr.Arguments[1].Name, Is.EqualTo("i"));
-			Assert.That(rr.Arguments[1].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[1].Value).Variable.Name == "idx");
+			AssertNamedArgument<LocalResolveResult>(rr.Arguments[0], "a", lrr => lrr.Variable.Name == "obj");
+			AssertNamedArgument<LocalResolveResult>(rr.Arguments[1], "i", lrr => lrr.Variable.Name == "idx");
 		}
 
   		[Test]
@@ -526,8 +518,8 @@ class TestClass {
 			Assert.That(mg.Methods.All(m => m.Name == ".ctor" && m.DeclaringType.Name == "TestClass"));
 
 			Assert.That(rr.Arguments.Count, Is.EqualTo(2));
-			Assert.That(rr.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0].Value).Variable.Name == "obj");
-			Assert.That(rr.Arguments[1].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[1].Value).Variable.Name == "i");
+			Assert.That(rr.Arguments[0] is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0]).Variable.Name == "obj");
+			Assert.That(rr.Arguments[1] is LocalResolveResult && ((LocalResolveResult)rr.Arguments[1]).Variable.Name == "i");
 		}
 
  		[Test]
@@ -556,10 +548,8 @@ class TestClass {
 			Assert.That(mg.Methods.All(m => m.Name == ".ctor" && m.DeclaringType.Name == "TestClass"));
 
 			Assert.That(rr.Arguments.Count, Is.EqualTo(2));
-			Assert.That(rr.Arguments[0].Name, Is.EqualTo("arg1"));
-			Assert.That(rr.Arguments[0].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[0].Value).Variable.Name == "obj");
-			Assert.That(rr.Arguments[1].Name, Is.EqualTo("arg2"));
-			Assert.That(rr.Arguments[1].Value is LocalResolveResult && ((LocalResolveResult)rr.Arguments[1].Value).Variable.Name == "i");
+			AssertNamedArgument<LocalResolveResult>(rr.Arguments[0], "arg1", lrr => lrr.Variable.Name == "obj");
+			AssertNamedArgument<LocalResolveResult>(rr.Arguments[1], "arg2", lrr => lrr.Variable.Name == "i");
 		}
 
  		[Test]
@@ -649,8 +639,8 @@ class TestClass : TestBase {
 			Assert.That(mg.Methods.All(m => m.Name == ".ctor" && m.DeclaringType.Name == "TestBase"));
 
 			Assert.That(rr.Arguments.Count, Is.EqualTo(2));
-			Assert.That(rr.Arguments[0].Value is MemberResolveResult && ((MemberResolveResult)rr.Arguments[0].Value).Member.Name == "d");
-			Assert.That(rr.Arguments[1].Value is MemberResolveResult && ((MemberResolveResult)rr.Arguments[1].Value).Member.Name == "i");
+			Assert.That(rr.Arguments[0] is MemberResolveResult && ((MemberResolveResult)rr.Arguments[0]).Member.Name == "d");
+			Assert.That(rr.Arguments[1] is MemberResolveResult && ((MemberResolveResult)rr.Arguments[1]).Member.Name == "i");
 		}
 
 		[Test]
@@ -708,8 +698,8 @@ class TestClass {
 			Assert.That(mg.Methods.All(m => m.Name == ".ctor" && m.DeclaringType.Name == "TestClass"));
 
 			Assert.That(rr.Arguments.Count, Is.EqualTo(2));
-			Assert.That(rr.Arguments[0].Value is MemberResolveResult && ((MemberResolveResult)rr.Arguments[0].Value).Member.Name == "d");
-			Assert.That(rr.Arguments[1].Value is MemberResolveResult && ((MemberResolveResult)rr.Arguments[1].Value).Member.Name == "i");
+			Assert.That(rr.Arguments[0] is MemberResolveResult && ((MemberResolveResult)rr.Arguments[0]).Member.Name == "d");
+			Assert.That(rr.Arguments[1] is MemberResolveResult && ((MemberResolveResult)rr.Arguments[1]).Member.Name == "i");
 		}
 	}
 }