Work on zzzprojects#66 -> Should work now. Tests will follow on VS2017 support!

Author: jogibear9988

src/System.Linq.Dynamic.Core/DynamicExpressionParser.cs

@@ -9,6 +9,24 @@ namespace System.Linq.Dynamic.Core
     /// </summary>
     public static class DynamicExpressionParser
     {
+        /// <summary>
+        /// Parses a expression into a LambdaExpression. (Also create a constructor for all the parameters.)
+        /// </summary>
+        /// <param name="itType">The main type from the dynamic class expression.</param>
+        /// <param name="resultType">Type of the result. If not specified, it will be generated dynamically.</param>
+        /// <param name="expression">The expression.</param>
+        /// <param name="values">An object array that contains zero or more objects which are used as replacement values.</param>
+        /// <returns>The generated <see cref="LambdaExpression"/></returns>
+        public static LambdaExpression ParseLambda([CanBeNull] Type resultType, [NotNull] string expression, params object[] values)
+        {
+            Check.NotEmpty(expression, nameof(expression));
+
+
+            var parser = new ExpressionParser(new ParameterExpression[0], expression, values);
+
+            return Expression.Lambda(parser.Parse(resultType, true));
+        }
+
         /// <summary>
         /// Parses a expression into a LambdaExpression. (Also create a constructor for all the parameters.)
         /// </summary>

src/System.Linq.Dynamic.Core/ExpressionParser.cs

@@ -149,6 +149,7 @@ interface IEnumerableSignatures
             void Take(int count);
             void TakeWhile(bool predicate);
             void Distinct();
+            void GroupBy(object selector);
 
             //Executors
             void Single();
@@ -222,6 +223,7 @@ interface IEnumerableSignatures
 
         readonly Dictionary<string, object> _symbols;
         IDictionary<string, object> _externals;
+        readonly Dictionary<string, object> _internals;
         readonly Dictionary<Expression, string> _literals;
         ParameterExpression _it;
         ParameterExpression _parent;
@@ -269,6 +271,7 @@ public ExpressionParser(ParameterExpression[] parameters, string expression, obj
         {
             if (_keywords == null) _keywords = CreateKeywords();
             _symbols = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+            _internals = new Dictionary<string, object>();
             _literals = new Dictionary<Expression, string>();
             if (parameters != null) ProcessParameters(parameters);
             if (values != null) ProcessValues(values);
@@ -388,7 +391,7 @@ Expression ParseExpression()
         // ?? (null-coalescing) operator
         Expression ParseNullCoalescing()
         {
-            Expression expr = ParseConditionalOr();
+            Expression expr = ParseLambda();
             if (_textParser.CurrentToken.Id == TokenId.NullCoalescing)
             {
                 _textParser.NextToken();
@@ -398,6 +401,24 @@ Expression ParseNullCoalescing()
             return expr;
         }
 
+        // => operator - Added Support for projection operator
+        Expression ParseLambda()
+        {
+            Expression expr = ParseConditionalOr();
+            if (_textParser.CurrentToken.Id == TokenId.Lambda && _it.Type == expr.Type)
+            {
+                _textParser.NextToken();
+                if (_textParser.CurrentToken.Id == TokenId.Identifier ||
+                    _textParser.CurrentToken.Id == TokenId.OpenParen)
+                {
+                    var right = ParseExpression();
+                    return Expression.Lambda(right, new[] {(ParameterExpression) expr});
+                }
+                _textParser.ValidateToken(TokenId.OpenParen, Res.OpenParenExpected);
+            }
+            return expr;
+        }
+
         // isnull(a,b) operator
         Expression ParseIsNull()
         {
@@ -1003,7 +1024,8 @@ Expression ParseIdentifier()
             }
 
             if (_symbols.TryGetValue(_textParser.CurrentToken.Text, out value) ||
-                _externals != null && _externals.TryGetValue(_textParser.CurrentToken.Text, out value))
+                _externals != null && _externals.TryGetValue(_textParser.CurrentToken.Text, out value) || 
+                _internals.TryGetValue(_textParser.CurrentToken.Text, out value))
             {
                 Expression expr = value as Expression;
                 if (expr == null)
@@ -1093,7 +1115,9 @@ Expression GenerateConditional(Expression test, Expression expr1, Expression exp
         Expression ParseNew()
         {
             _textParser.NextToken();
-            _textParser.ValidateToken(TokenId.OpenParen, Res.OpenParenExpected);
+            if (_textParser.CurrentToken.Id != TokenId.OpenParen &&
+                _textParser.CurrentToken.Id != TokenId.OpenCurlyParen)
+                throw ParseError(Res.OpenParenExpected);
             _textParser.NextToken();
 
             var properties = new List<DynamicProperty>();
@@ -1125,7 +1149,9 @@ Expression ParseNew()
                 _textParser.NextToken();
             }
 
-            _textParser.ValidateToken(TokenId.CloseParen, Res.CloseParenOrCommaExpected);
+            if (_textParser.CurrentToken.Id != TokenId.CloseParen &&
+                _textParser.CurrentToken.Id != TokenId.CloseCurlyParen)
+                throw ParseError(Res.CloseParenOrCommaExpected);
             _textParser.NextToken();
 
             return CreateNewExpression(properties, expressions);
@@ -1134,7 +1160,7 @@ Expression ParseNew()
         private Expression CreateNewExpression(List<DynamicProperty> properties, List<Expression> expressions)
         {
             // http://solutionizing.net/category/linq/
-            Type type = _resultType;
+            Type type = null; //_resultType;
 
             if (type == null)
             {
@@ -1323,7 +1349,19 @@ Expression ParseMemberAccess(Type type, Expression instance)
             MemberInfo member = FindPropertyOrField(type, id, instance == null);
             if (member == null)
             {
-                throw ParseError(errorPos, Res.UnknownPropertyOrField, id, GetTypeName(type));
+                if (_textParser.CurrentToken.Id == TokenId.Lambda && _it.Type == type)
+                {
+                    // This might be an internal variable for use within a lambda expression, so store it as such
+                    _internals.Add(id, _it);
+                    _textParser.NextToken();
+                    var right = ParseExpression();
+                    return right;
+                }
+                else
+                {
+                    throw ParseError(errorPos, Res.UnknownPropertyOrField, id, GetTypeName(type));
+                }
+
             }
 
             var property = member as PropertyInfo;
@@ -1381,7 +1419,7 @@ Expression ParseAggregate(Expression instance, Type elementType, string methodNa
                 throw ParseError(errorPos, Res.NoApplicableAggregate, methodName);
 
             Type[] typeArgs;
-            if (new[] { "Min", "Max", "Select", "OrderBy", "OrderByDescending", "ThenBy", "ThenByDescending" }.Contains(signature.Name))
+            if (new[] { "Min", "Max", "Select", "OrderBy", "OrderByDescending", "ThenBy", "ThenByDescending", "GroupBy" }.Contains(signature.Name))
             {
                 typeArgs = new[] { elementType, args[0].Type };
             }

src/System.Linq.Dynamic.Core/Tokenizer/TextParser.cs

@@ -100,6 +100,16 @@ public void NextToken()
                     t = TokenId.CloseParen;
                     break;
 
+                case '{':
+                    NextChar();
+                    t = TokenId.OpenCurlyParen;
+                    break;
+
+                case '}':
+                    NextChar();
+                    t = TokenId.CloseCurlyParen;
+                    break;
+
                 case '*':
                     NextChar();
                     t = TokenId.Asterisk;
@@ -164,6 +174,11 @@ public void NextToken()
                         NextChar();
                         t = TokenId.DoubleEqual;
                     }
+                    else if (_ch == '>')
+                    {
+                        NextChar();
+                        t = TokenId.Lambda;
+                    }
                     else
                     {
                         t = TokenId.Equal;

src/System.Linq.Dynamic.Core/Tokenizer/TokenId.cs

@@ -13,6 +13,8 @@ internal enum TokenId
         Amphersand,
         OpenParen,
         CloseParen,
+        OpenCurlyParen,
+        CloseCurlyParen,
         Asterisk,
         Plus,
         Comma,
@@ -36,6 +38,7 @@ internal enum TokenId
         DoubleBar,
         DoubleGreaterThan,
         DoubleLessThan,
-        NullCoalescing
+        NullCoalescing,
+        Lambda
     }
 }