Merge pull request #103 from btnlq/master

Improved indexing, close #39

Author: davideicardi

src/DynamicExpresso.Core/Parsing/Parser.cs

@@ -83,22 +83,30 @@ private Expression ParseExpressionSegment()
 			// MSDN C# "Operator precedence and associativity"
 			// https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/
 
-			return ParseAssignement();
+			return ParseAssignment();
 		}
 
 		// = operator
-		private Expression ParseAssignement()
+		private Expression ParseAssignment()
 		{
 			var left = ParseConditional();
 			if (_token.id == TokenId.Equal)
 			{
 				if (!_arguments.Settings.AssignmentOperators.HasFlag(AssignmentOperators.AssignmentEqual))
 					throw new AssignmentOperatorDisabledException("=", _token.pos);
 
+				if (!IsWritable(left))
+					throw CreateParseException(_token.pos, ErrorMessages.ExpressionMustBeWritable);
+
 				NextToken();
-				var right = ParseAssignement();
-				CheckAndPromoteOperands(typeof(ParseSignatures.IEqualitySignatures), ref left, ref right);
-				left = Expression.Assign(left, right);
+
+				var right = ParseAssignment();
+				var promoted = PromoteExpression(right, left.Type, true);
+				if (promoted == null)
+					throw CreateParseException(_token.pos, ErrorMessages.CannotConvertValue,
+						GetTypeName(right.Type), GetTypeName(left.Type));
+
+				left = Expression.Assign(left, promoted);
 			}
 			return left;
 		}
@@ -1088,12 +1096,17 @@ private Expression ParseElementAccess(Expression expr)
 			NextToken();
 			if (expr.Type.IsArray)
 			{
-				if (expr.Type.GetArrayRank() != 1 || args.Length != 1)
-					throw CreateParseException(errorPos, ErrorMessages.CannotIndexMultiDimArray);
-				var index = PromoteExpression(args[0], typeof(int), true);
-				if (index == null)
-					throw CreateParseException(errorPos, ErrorMessages.InvalidIndex);
-				return Expression.ArrayIndex(expr, index);
+				if (expr.Type.GetArrayRank() != args.Length)
+					throw CreateParseException(errorPos, ErrorMessages.IncorrectNumberOfIndexes);
+
+				for (int i = 0; i < args.Length; i++)
+				{
+					args[i] = PromoteExpression(args[i], typeof(int), true);
+					if (args[i] == null)
+						throw CreateParseException(errorPos, ErrorMessages.InvalidIndex);
+				}
+
+				return Expression.ArrayAccess(expr, args);
 			}
 
 			var applicableMethods = FindIndexer(expr.Type, args);
@@ -1109,9 +1122,8 @@ private Expression ParseElementAccess(Expression expr)
 						GetTypeName(expr.Type));
 			}
 
-			var method = applicableMethods[0];
-
-			return Expression.Call(expr, (MethodInfo)method.MethodBase, method.PromotedParameters);
+			var indexer = (IndexerData) applicableMethods[0];
+			return Expression.Property(expr, indexer.Indexer, indexer.PromotedParameters);
 		}
 
 		private static bool IsNullableType(Type type)
@@ -1266,10 +1278,9 @@ private MethodData[] FindIndexer(Type type, Expression[] args)
 				MemberInfo[] members = t.GetDefaultMembers();
 				if (members.Length != 0)
 				{
-					IEnumerable<MethodBase> methods = members.
+					IEnumerable<MethodData> methods = members.
 							OfType<PropertyInfo>().
-							Select(p => (MethodBase)p.GetGetMethod()).
-							Where(m => m != null);
+							Select(p => (MethodData) new IndexerData(p));
 
 					var applicableMethods = FindBestMethod(methods, args);
 					if (applicableMethods.Length > 0)
@@ -1316,9 +1327,13 @@ private static void AddInterface(List<Type> types, Type type)
 		}
 
 		private static MethodData[] FindBestMethod(IEnumerable<MethodBase> methods, Expression[] args)
+		{
+			return FindBestMethod(methods.Select(MethodData.Gen), args);
+		}
+
+		private static MethodData[] FindBestMethod(IEnumerable<MethodData> methods, Expression[] args)
 		{
 			var applicable = methods.
-					Select(m => new MethodData { MethodBase = m, Parameters = m.GetParameters() }).
 					Where(m => CheckIfMethodIsApplicableAndPrepareIt(m, args)).
 					ToArray();
 			if (applicable.Length > 1)
@@ -1417,7 +1432,7 @@ private static bool CheckIfMethodIsApplicableAndPrepareIt(MethodData method, Exp
 
 			method.PromotedParameters = promotedArgs.ToArray();
 
-			if (method.MethodBase.IsGenericMethodDefinition &&
+			if (method.MethodBase != null && method.MethodBase.IsGenericMethodDefinition &&
 					method.MethodBase is MethodInfo)
 			{
 				var methodInfo = (MethodInfo)method.MethodBase;
@@ -1626,6 +1641,30 @@ private static bool IsCompatibleWith(Type source, Type target)
 			return false;
 		}
 
+		private static bool IsWritable(Expression expression)
+		{
+			switch (expression.NodeType)
+			{
+				case ExpressionType.Index:
+					PropertyInfo indexer = ((IndexExpression)expression).Indexer;
+					return indexer == null || indexer.CanWrite;
+				case ExpressionType.MemberAccess:
+					MemberInfo member = ((MemberExpression)expression).Member;
+					var prop = member as PropertyInfo;
+					if (prop != null)
+						return prop.CanWrite;
+					else
+					{
+						var field = (FieldInfo)member;
+						return !(field.IsInitOnly || field.IsLiteral);
+					}
+				case ExpressionType.Parameter:
+					return true;
+			}
+
+			return false;
+		}
+
 		// from http://stackoverflow.com/a/1075059/209727
 		private static Type FindAssignableGenericType(Type givenType, Type genericTypeDefinition)
 		{
@@ -2156,6 +2195,43 @@ private class MethodData
 			public ParameterInfo[] Parameters;
 			public Expression[] PromotedParameters;
 			public bool HasParamsArray;
+
+			public static MethodData Gen(MethodBase method)
+			{
+				return new MethodData
+				{
+					MethodBase = method,
+					Parameters = method.GetParameters()
+				};
+			}
+		}
+
+		private class IndexerData : MethodData
+		{
+			public readonly PropertyInfo Indexer;
+
+			public IndexerData(PropertyInfo indexer)
+			{
+				Indexer = indexer;
+
+				var method = indexer.GetGetMethod();
+				if (method != null)
+				{
+					Parameters = method.GetParameters();
+				}
+				else
+				{
+					method = indexer.GetSetMethod();
+					Parameters = RemoveLast(method.GetParameters());
+				}
+			}
+
+			private static T[] RemoveLast<T>(T[] array)
+			{
+				T[] result = new T[array.Length - 1];
+				Array.Copy(array, 0, result, 0, result.Length);
+				return result;
+			}
 		}
 	}
 }

src/DynamicExpresso.Core/Resources/ErrorMessages.Designer.cs

@@ -135,9 +135,6 @@
   <data name="CannotConvertValue" xml:space="preserve">
     <value>A value of type '{0}' cannot be converted to type '{1}'</value>
   </data>
-  <data name="CannotIndexMultiDimArray" xml:space="preserve">
-    <value>Indexing of multi-dimensional arrays is not supported</value>
-  </data>
   <data name="CloseBracketOrCommaExpected" xml:space="preserve">
     <value>']' or ',' expected</value>
   </data>
@@ -159,6 +156,9 @@
   <data name="ExpressionExpected" xml:space="preserve">
     <value>Expression expected</value>
   </data>
+  <data name="ExpressionMustBeWritable" xml:space="preserve">
+    <value>Expression must be writable</value>
+  </data>
   <data name="FirstExprMustBeBool" xml:space="preserve">
     <value>The first expression must be of type 'Boolean'</value>
   </data>
@@ -174,6 +174,9 @@
   <data name="IncompatibleOperands" xml:space="preserve">
     <value>Operator '{0}' incompatible with operand types '{1}' and '{2}'</value>
   </data>
+  <data name="IncorrectNumberOfIndexes" xml:space="preserve">
+    <value>Incorrect number of indexes</value>
+  </data>
   <data name="InvalidCharacter" xml:space="preserve">
     <value>Syntax error '{0}'</value>
   </data>

src/DynamicExpresso.Core/Resources/ErrorMessages.resx

@@ -28,7 +28,7 @@ public void Invalid_equal_assignment_operator_left_is_literal()
 		{
 			var target = new Interpreter();
 
-			Assert.Throws<ArgumentException>(() => target.Eval("352=234"));
+			Assert.Throws<ParseException>(() => target.Eval("352=234"));
 		}
 
 		[Test]