adding support for array and dictionary expression parsing

NuGet/rgdev_System.Linq.Dynamic.1.0.8.nuspec

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd">
+  <metadata>
+    <id>rgdev_System.Linq.Dynamic</id>
+    <version>1.0.8</version>
+    <authors>Microsoft</authors>
+    <owners>Microsoft</owners>
+    <requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <licenseUrl>http://www.opensource.org/licenses/ms-pl</licenseUrl>
+    <projectUrl>https://github.com/kahanu/System.Linq.Dynamic</projectUrl>
+    <description>This is the Microsoft assembly for the .Net 4.0 Dynamic language functionality.</description>
+    <releaseNotes>lafar6502/System.Linq.Dynamic build
+contains some modifications not merged yet into the original repo kahanu</releaseNotes>
+    <tags>system linq dynamic</tags>
+  </metadata>
+  <files>
+    <file src="lib\net40\System.Linq.Dynamic.dll" target="lib\net40\System.Linq.Dynamic.dll" />
+    <file src="lib\net40\System.Linq.Dynamic.pdb" target="lib\net40\System.Linq.Dynamic.pdb" />
+  </files>
+</package>

Src/System.Linq.Dynamic.Test/DynamicExpressionTests.cs

@@ -42,6 +42,53 @@ public void ParseLambda_DelegateTypeMethodCall_ReturnsEventHandlerLambdaExpressi
             Assert.AreEqual(typeof(EventHandler), expression.Type);
         }
 
+        [TestMethod]
+        public void ParseLambda_NewArrayInit()
+        {
+            DateTime dt = DateTime.Now;
+
+            var expr = DynamicExpression.ParseLambda(
+                typeof(Func<DateTime, object[]>),
+                new []
+                {
+                    Expression.Parameter(typeof(DateTime), "dt")
+                },
+                null,
+                "array(dt.Year, dt.Month, 15, \"ala ma kota\", dt.Ticks, dt.Date.Ticks)"
+                );
+
+
+            Assert.AreEqual(typeof(object[]), expr.ReturnType);
+            Assert.AreEqual(typeof(Func<DateTime, object[]>), expr.Type);
+            var texpr = (Expression<Func<DateTime, object[]>>)expr;
+            var fun = texpr.Compile();
+            var res = fun(dt);
+        }
+
+        [TestMethod]
+        public void ParseLambda_NewDictionary()
+        {
+            //this does not work - didnt figure oout how to make useful lambda with dictionary initialization
+            DateTime dt = DateTime.Now;
+
+            var expr = DynamicExpression.ParseLambda(
+                typeof(Func<DateTime, Dictionary<string, object>>),
+                new[]
+                {
+                    Expression.Parameter(typeof(DateTime), "dt")
+                },
+                typeof(Dictionary<string, object>),
+                "dictionary(dt.Year as y, dt.Month as m, 15 as fifteen, \"ala ma kota\" as text, dt.Ticks, dt.Date.Ticks as rounded_ticks)"
+                );
+
+
+            Assert.AreEqual(typeof(Dictionary<string, object>), expr.ReturnType);
+            Assert.AreEqual(typeof(Func<DateTime, Dictionary<string, object>>), expr.Type);
+            var texpr = (Expression<Func<DateTime, Dictionary<string, object>>>)expr;
+            var fun = texpr.Compile();
+            var res = fun(dt);
+        }
+
         [TestMethod]
         public void ParseLambda_VoidMethodCall_ReturnsActionDelegate()
         {
@@ -53,6 +100,7 @@ public void ParseLambda_VoidMethodCall_ReturnsActionDelegate()
             Assert.AreEqual(typeof(Action<System.IO.FileStream>), expression.Type);
         }
 
+
         [TestMethod]
         public void CreateClass_TheadSafe()
         {

Src/System.Linq.Dynamic/DynamicLinq.cs

@@ -790,6 +790,8 @@ interface IEnumerableSignatures
         static readonly string keywordIt = "it";
         static readonly string keywordIif = "iif";
         static readonly string keywordNew = "new";
+        static readonly string keywordArray = "array";
+        static readonly string keywordDic = "dictionary";
         static readonly string keywordOuterIt = "outerIt";
 
         static Dictionary<string, object> keywords;
@@ -1262,6 +1264,8 @@ Expression ParseIdentifier()
                 if (value == (object)keywordOuterIt) return ParseOuterIt();
                 if (value == (object)keywordIif) return ParseIif();
                 if (value == (object)keywordNew) return ParseNew();
+                if (value == (object)keywordArray) return ParseNewArray();
+                if (value == (object)keywordDic) return ParseNewDictionary();
                 NextToken();
                 return (Expression)value;
             }
@@ -1377,6 +1381,73 @@ Expression ParseNew()
             return Expression.MemberInit(Expression.New(type), bindings);
         }
 
+        /// <summary>
+        /// array(x1, x2, x3, ....)
+        /// </summary>
+        /// <returns></returns>
+        Expression ParseNewArray()
+        {
+            NextToken();
+            ValidateToken(TokenId.OpenParen, Res.OpenParenExpected);
+            NextToken();
+            List<Expression> expressions = new List<Expression>();
+            while (true)
+            {
+                int exprPos = token.pos;
+                Expression expr = ParseExpression();
+                expr = Expression.Convert(expr, typeof(object));
+                expressions.Add(expr);
+                if (token.id != TokenId.Comma) break;
+                NextToken();
+            }
+            ValidateToken(TokenId.CloseParen, Res.CloseParenOrCommaExpected);
+            NextToken();
+            return Expression.NewArrayInit(typeof(object), expressions);
+        }
+
+        //dictionary string->object
+        Expression ParseNewDictionary()
+        {
+
+            NextToken();
+            ValidateToken(TokenId.OpenParen, Res.OpenParenExpected);
+            NextToken();
+
+            List<ElementInit> elemz = new List<ElementInit>();
+            var dicType = typeof(Dictionary<string, object>);
+            var mi = dicType.GetMethod("Add");
+
+            while (true)
+            {
+                int exprPos = token.pos;
+                Expression expr = ParseExpression();
+                string propName;
+                if (TokenIdentifierIs("as"))
+                {
+                    NextToken();
+                    propName = GetIdentifier();
+                    NextToken();
+                }
+                else
+                {
+                    MemberExpression me = expr as MemberExpression;
+                    if (me == null) throw ParseError(exprPos, Res.MissingAsClause);
+                    propName = me.Member.Name;
+                }
+                if (expr.Type != typeof(object)) expr = Expression.Convert(expr, typeof(object));
+
+                var el = Expression.ElementInit(mi, Expression.Constant(propName), expr);
+                elemz.Add(el);
+                if (token.id != TokenId.Comma) break;
+                NextToken();
+            }
+            ValidateToken(TokenId.CloseParen, Res.CloseParenOrCommaExpected);
+            NextToken();
+
+            return Expression.ListInit(Expression.New(dicType), elemz);
+
+        }
+
         Expression ParseLambdaInvocation(LambdaExpression lambda)
         {
             int errorPos = token.pos;
@@ -2436,6 +2507,8 @@ static Dictionary<string, object> CreateKeywords()
             d.Add(keywordOuterIt, keywordOuterIt);
             d.Add(keywordIif, keywordIif);
             d.Add(keywordNew, keywordNew);
+            d.Add(keywordArray, keywordArray);
+            d.Add(keywordDic, keywordDic);
             foreach (Type type in predefinedTypes) d.Add(type.Name, type);
             return d;
         }