Merge pull request #87 from erik-kallen/DynamicExpressionsUseNamedArgumentResolveResult

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.CSharp/Resolver/ResolveVisitor.cs

@@ -390,34 +390,43 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		void ProcessConversionsInInvocation(Expression target, IEnumerable<Expression> arguments, CSharpInvocationResolveResult invocation)
-		{
-			if (invocation == null) {
-				// we still need to handle the named arguments if invocation==null
-				MarkUnknownNamedArguments(arguments);
-				return;
-			}
-			int i = 0;
-			if (invocation.IsExtensionMethodInvocation) {
-				Debug.Assert(arguments.Count() + 1 == invocation.Arguments.Count);
-				ProcessConversionResult(target, invocation.Arguments[0] as ConversionResolveResult);
-				i = 1;
-			} else {
-				Debug.Assert(arguments.Count() == invocation.Arguments.Count);
-			}
-			foreach (Expression arg in arguments) {
-				ResolveResult argRR = invocation.Arguments[i++];
-				NamedArgumentExpression nae = arg as NamedArgumentExpression;
-				NamedArgumentResolveResult nrr = argRR as NamedArgumentResolveResult;
-				Debug.Assert((nae == null) == (nrr == null));
-				if (nae != null && nrr != null) {
-					StoreCurrentState(nae);
-					StoreResult(nae, nrr);
-					ProcessConversionResult(nae.Expression, nrr.Argument as ConversionResolveResult);
-				} else {
-					ProcessConversionResult(arg, argRR as ConversionResolveResult);
+		void ProcessInvocationResult(Expression target, IEnumerable<Expression> arguments, ResolveResult invocation)
+		{
+			if (invocation is CSharpInvocationResolveResult || invocation is DynamicInvocationResolveResult) {
+				int i = 0;
+				IList<ResolveResult> argumentsRR;
+				if (invocation is CSharpInvocationResolveResult) {
+					var csi = (CSharpInvocationResolveResult)invocation;
+					if (csi.IsExtensionMethodInvocation) {
+						Debug.Assert(arguments.Count() + 1 == csi.Arguments.Count);
+						ProcessConversionResult(target, csi.Arguments[0] as ConversionResolveResult);
+						i = 1;
+					} else {
+						Debug.Assert(arguments.Count() == csi.Arguments.Count);
+					}
+					argumentsRR = csi.Arguments;
+				}
+				else {
+					argumentsRR = ((DynamicInvocationResolveResult)invocation).Arguments;
+				}
+
+				foreach (Expression arg in arguments) {
+					ResolveResult argRR = argumentsRR[i++];
+					NamedArgumentExpression nae = arg as NamedArgumentExpression;
+					NamedArgumentResolveResult nrr = argRR as NamedArgumentResolveResult;
+					Debug.Assert((nae == null) == (nrr == null));
+					if (nae != null && nrr != null) {
+						StoreCurrentState(nae);
+						StoreResult(nae, nrr);
+						ProcessConversionResult(nae.Expression, nrr.Argument as ConversionResolveResult);
+					} else {
+						ProcessConversionResult(arg, argRR as ConversionResolveResult);
+					}
 				}
 			}
+			else {
+				MarkUnknownNamedArguments(arguments);
+			}
 		}
 		#endregion
 		
@@ -1415,7 +1424,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					MarkUnknownNamedArguments(indexerExpression.Arguments);
 					ProcessConversionResults(indexerExpression.Arguments, aarr.Indexes);
 				} else {
-					ProcessConversionsInInvocation(target, indexerExpression.Arguments, rr as CSharpInvocationResolveResult);
+					ProcessInvocationResult(target, indexerExpression.Arguments, rr);
 				}
 				return rr;
 			} else {
@@ -1524,7 +1533,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				}
 			} else {
 				// process conversions in all other cases
-				ProcessConversionsInInvocation(null, objectCreateExpression.Arguments, rr as CSharpInvocationResolveResult);
+				ProcessInvocationResult(null, objectCreateExpression.Arguments, rr);
 				return rr;
 			}
 		}
@@ -1550,7 +1559,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 						OverloadResolution or = mgrr.PerformOverloadResolution(resolver.Compilation, addArguments, null, false, false, resolver.CheckForOverflow, resolver.conversions);
 						var invocationRR = or.CreateResolveResult(initializedObject);
 						StoreResult(aie, invocationRR);
-						ProcessConversionsInInvocation(null, aie.Elements, invocationRR);
+						ProcessInvocationResult(null, aie.Elements, invocationRR);
 						initializerStatements.Add(invocationRR);
 					} else {
 						StoreResult(aie, addRR);
@@ -1880,7 +1889,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			string[] argumentNames;
 			ResolveResult[] arguments = GetArguments(invocationExpression.Arguments, out argumentNames);
 			ResolveResult rr = resolver.ResolveInvocation(target, arguments, argumentNames);
-			ProcessConversionsInInvocation(invocationExpression.Target, invocationExpression.Arguments, rr as CSharpInvocationResolveResult);
+			ProcessInvocationResult(invocationExpression.Target, invocationExpression.Arguments, rr);
 			return rr;
 		}
 		#endregion
@@ -3172,7 +3181,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			string[] argumentNames;
 			ResolveResult[] arguments = GetArguments(constructorArguments, out argumentNames);
 			ResolveResult rr = resolver.ResolveObjectCreation(type, arguments, argumentNames, false, initializerStatements);
-			ProcessConversionsInInvocation(null, constructorArguments, rr as CSharpInvocationResolveResult);
+			ProcessInvocationResult(null, constructorArguments, rr);
 			return rr;
 		}
 		
@@ -3813,7 +3822,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			string[] argumentNames;
 			ResolveResult[] arguments = GetArguments(constructorInitializer.Arguments, out argumentNames);
 			ResolveResult rr = resolver.ResolveObjectCreation(target.Type, arguments, argumentNames, allowProtectedAccess: true);
-			ProcessConversionsInInvocation(null, constructorInitializer.Arguments, rr as CSharpInvocationResolveResult);
+			ProcessInvocationResult(null, constructorInitializer.Arguments, rr);
 			return rr;
 		}
 		#endregion

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");
 		}
 	}
 }