Add support of dynamic property and index assignments (#353)

Author: metoule

src/DynamicExpresso.Core/Parsing/Parser.cs

@@ -221,8 +221,8 @@ private Expression ParseAssignment()
 				if (!_arguments.Settings.AssignmentOperators.HasFlag(AssignmentOperators.AssignmentEqual))
 					throw new AssignmentOperatorDisabledException("=", _token.pos);
 
-
-				if (!IsWritable(left))
+				Func<Expression, Expression> assignLeftDynamic = null;
+				if (!IsWritable(left) && !IsDynamicWritable(left, out assignLeftDynamic))
 					throw ParseException.Create(_token.pos, ErrorMessages.ExpressionMustBeWritable);
 
 				NextToken();
@@ -233,7 +233,9 @@ private Expression ParseAssignment()
 					throw ParseException.Create(_token.pos, ErrorMessages.CannotConvertValue,
 						TypeUtils.GetTypeName(right.Type), TypeUtils.GetTypeName(left.Type));
 
-				left = Expression.Assign(left, promoted);
+				left = assignLeftDynamic == null
+					? Expression.Assign(left, promoted)
+					: assignLeftDynamic(promoted);
 			}
 			return left;
 		}
@@ -1813,7 +1815,7 @@ private static Expression ParseDynamicIndex(Type type, Expression instance, Expr
 		{
 			var argsDynamic = args.ToList();
 			argsDynamic.Insert(0, instance);
-			return Expression.Dynamic(new LateInvokeIndexCallSiteBinder(), typeof(object), argsDynamic);
+			return Expression.Dynamic(new LateGetIndexCallSiteBinder(), typeof(object), argsDynamic);
 		}
 
 		private Expression[] ParseArgumentList(TokenId openToken, string missingOpenTokenMsg,
@@ -1948,6 +1950,20 @@ private static bool IsWritable(Expression expression)
 			return false;
 		}
 
+		private static bool IsDynamicWritable(Expression expression, out Func<Expression, Expression> toWritableExpression)
+		{
+			toWritableExpression = null;
+			if (expression.NodeType != ExpressionType.Dynamic)
+				return false;
+
+			var dynamicExpression = (DynamicExpression)expression;
+			if (!(dynamicExpression.Binder is IConvertibleToWritableBinder convertibleBinder))
+				return false;
+
+			toWritableExpression = value => Expression.Dynamic(convertibleBinder.ToWritableBinder(), typeof(object), dynamicExpression.Arguments.Concat(new[] { value }));
+			return true;
+		}
+
 		private Expression GenerateEqual(Expression left, Expression right)
 		{
 			return GenerateBinary(ExpressionType.Equal, left, right);

src/DynamicExpresso.Core/Resolution/LateBinders.cs

@@ -8,7 +8,12 @@
 
 namespace DynamicExpresso.Resolution
 {
-	internal class LateGetMemberCallSiteBinder : CallSiteBinder
+	internal interface IConvertibleToWritableBinder
+	{
+		CallSiteBinder ToWritableBinder();
+	}
+
+	internal class LateGetMemberCallSiteBinder : CallSiteBinder, IConvertibleToWritableBinder
 	{
 		private readonly string _propertyOrFieldName;
 
@@ -19,11 +24,39 @@ public LateGetMemberCallSiteBinder(string propertyOrFieldName)
 
 		public override Expression Bind(object[] args, ReadOnlyCollection<ParameterExpression> parameters, LabelTarget returnLabel)
 		{
+			// there's only one argument: the instance on which the member is accessed
 			var binder = Binder.GetMember(
 				CSharpBinderFlags.None,
 				_propertyOrFieldName,
 				TypeUtils.RemoveArrayType(args[0]?.GetType()),
-				new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
+				parameters.Select(x => CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null))
+			);
+			return binder.Bind(args, parameters, returnLabel);
+		}
+
+		public CallSiteBinder ToWritableBinder()
+		{
+			return new LateSetMemberCallSiteBinder(_propertyOrFieldName);
+		}
+	}
+
+	internal class LateSetMemberCallSiteBinder : CallSiteBinder
+	{
+		private readonly string _propertyOrFieldName;
+
+		public LateSetMemberCallSiteBinder(string propertyOrFieldName)
+		{
+			_propertyOrFieldName = propertyOrFieldName;
+		}
+
+		public override Expression Bind(object[] args, ReadOnlyCollection<ParameterExpression> parameters, LabelTarget returnLabel)
+		{
+			// there are two arguments: the instance on which the member is set and the value to set
+			var binder = Binder.SetMember(
+				CSharpBinderFlags.None,
+				_propertyOrFieldName,
+				TypeUtils.RemoveArrayType(args[0]?.GetType()),
+				parameters.Select(x => CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null))
 			);
 			return binder.Bind(args, parameters, returnLabel);
 		}
@@ -96,16 +129,36 @@ public override Expression Bind(object[] args, ReadOnlyCollection<ParameterExpre
 	/// <summary>
 	/// Binds to an items invocation of an instance as late as possible.  This allows the use of anonymous types on dynamic values.
 	/// </summary>
-	internal class LateInvokeIndexCallSiteBinder : CallSiteBinder
+	internal class LateGetIndexCallSiteBinder : CallSiteBinder, IConvertibleToWritableBinder
 	{
 		public override Expression Bind(object[] args, ReadOnlyCollection<ParameterExpression> parameters, LabelTarget returnLabel)
 		{
+			// there are two arguments: the instance on which the member is set and the value of the indexer
 			var binder = Binder.GetIndex(
 				CSharpBinderFlags.None,
 				TypeUtils.RemoveArrayType(args[0]?.GetType()),
 				parameters.Select(x => CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null))
 			);
 			return binder.Bind(args, parameters, returnLabel);
 		}
+
+		public CallSiteBinder ToWritableBinder()
+		{
+			return new LateSetIndexCallSiteBinder();
+		}
+	}
+
+	internal class LateSetIndexCallSiteBinder : CallSiteBinder
+	{
+		public override Expression Bind(object[] args, ReadOnlyCollection<ParameterExpression> parameters, LabelTarget returnLabel)
+		{
+			// there are three arguments: the instance on which the member is set, the value of the indexer, and the value to set
+			var binder = Binder.SetIndex(
+				CSharpBinderFlags.None,
+				TypeUtils.RemoveArrayType(args[0]?.GetType()),
+				parameters.Select(x => CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null))
+			);
+			return binder.Bind(args, parameters, returnLabel);
+		}
 	}
 }

test/DynamicExpresso.UnitTest/DynamicTest.cs

@@ -23,6 +23,18 @@ public void Get_Property_of_an_ExpandoObject()
 			Assert.That(interpreter.Eval("dyn.Foo"), Is.EqualTo(dyn.Foo));
 		}
 
+		[Test]
+		public void Set_Property_of_an_ExpandoObject()
+		{
+			dynamic dyn = new ExpandoObject();
+			var interpreter = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LateBindObject)
+				.SetVariable("dyn", (object)dyn);
+
+			interpreter.Eval("dyn.Foo = 10");
+
+			Assert.That(dyn.Foo, Is.EqualTo(10));
+		}
+
 		[Test]
 		public void Get_Property_of_a_nested_anonymous()
 		{
@@ -32,6 +44,20 @@ public void Get_Property_of_a_nested_anonymous()
 			Assert.That(interpreter.Eval("dyn.Sub.Foo.Bar.Foo2"), Is.EqualTo(dyn.Sub.Foo.Bar.Foo2));
 		}
 
+		[Test]
+		public void Set_Property_of_a_nested_ExpandoObject()
+		{
+			dynamic dyn = new ExpandoObject();
+			dyn.Sub = new ExpandoObject();
+			dyn.Sub.Foo = "bar";
+
+			var interpreter = new Interpreter().SetVariable("dyn", (object)dyn);
+
+			interpreter.Eval("dyn.Sub.Foo = \"foobar\"");
+
+			Assert.That(dyn.Sub.Foo, Is.EqualTo("foobar"));
+		}
+
 		[Test]
 		public void Get_Property_of_a_nested_ExpandoObject()
 		{
@@ -183,6 +209,21 @@ public void Get_value_of_an_array_of_anonymous_type()
 			Assert.That(interpreter.Eval("dyn.Sub.ObjArr[1].Foo"), Is.SameAs(dyn.Sub.ObjArr[1].Foo));
 		}
 
+		[Test]
+		public void Set_value_of_a_dynamic_object()
+		{
+			dynamic dyn = new ExpandoObject();
+			dyn.Foo = new int[5];
+			dyn.Bar = new Dictionary<string, int>();
+
+			var interpreter = new Interpreter().SetVariable("dyn", (object)dyn);
+			interpreter.Eval("dyn.Foo[2] = 5");
+			interpreter.Eval("dyn.Bar[\"foo\"] = 50");
+
+			Assert.That(dyn.Foo[2], Is.EqualTo(5));
+			Assert.That(dyn.Bar["foo"], Is.EqualTo(50));
+		}
+
 		[Test]
 		public void Get_value_of_a_nested_array_error()
 		{