gistfile1.cs

//Copyright (C) Microsoft Corporation.  All rights reserved.
// Updated by Ido Ran (ido.ran@gmail.com)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;

namespace System.Linq.Dynamic {
  public static class DynamicQueryable {
    public static IQueryable<T> Where<T>(this IQueryable<T> source, string predicate, params object[] values) {
      return (IQueryable<T>)Where((IQueryable)source, predicate, values);
    }

    public static IQueryable Where(this IQueryable source, string predicate, params object[] values) {
      if (source == null) throw new ArgumentNullException("source");
      if (predicate == null) throw new ArgumentNullException("predicate");
      LambdaExpression lambda = DynamicExpression.ParseLambda(source.ElementType, typeof(bool), predicate, values);
      return source.Provider.CreateQuery(
          Expression.Call(
              typeof(Queryable), "Where",
              new Type[] { source.ElementType },
              source.Expression, Expression.Quote(lambda)));
    }

    public static IQueryable Select(this IQueryable source, string selector, params object[] values) {
      if (source == null) throw new ArgumentNullException("source");
      if (selector == null) throw new ArgumentNullException("selector");
      LambdaExpression lambda = DynamicExpression.ParseLambda(source.ElementType, null, selector, values);
      return source.Provider.CreateQuery(
          Expression.Call(
              typeof(Queryable), "Select",
              new Type[] { source.ElementType, lambda.Body.Type },
              source.Expression, Expression.Quote(lambda)));
    }

    public static IQueryable<T> OrderBy<T>(this IQueryable<T> source, string ordering, params object[] values) {
      return (IQueryable<T>)OrderBy((IQueryable)source, ordering, values);
    }

    public static IQueryable OrderBy(this IQueryable source, string ordering, params object[] values) {
      if (source == null) throw new ArgumentNullException("source");
      if (ordering == null) throw new ArgumentNullException("ordering");
      ParameterExpression[] parameters = new ParameterExpression[] {
                Expression.Parameter(source.ElementType, "") };
      ExpressionParser parser = new ExpressionParser(parameters, ordering, values, DynamicExpression.EmptyExtenderTypes);
      IEnumerable<DynamicOrdering> orderings = parser.ParseOrdering();
      Expression queryExpr = source.Expression;
      string methodAsc = "OrderBy";
      string methodDesc = "OrderByDescending";
      foreach (DynamicOrdering o in orderings) {
        queryExpr = Expression.Call(
            typeof(Queryable), o.Ascending ? methodAsc : methodDesc,
            new Type[] { source.ElementType, o.Selector.Type },
            queryExpr, Expression.Quote(Expression.Lambda(o.Selector, parameters)));
        methodAsc = "ThenBy";
        methodDesc = "ThenByDescending";
      }
      return source.Provider.CreateQuery(queryExpr);
    }

    public static IQueryable Take(this IQueryable source, int count) {
      if (source == null) throw new ArgumentNullException("source");
      return source.Provider.CreateQuery(
          Expression.Call(
              typeof(Queryable), "Take",
              new Type[] { source.ElementType },
              source.Expression, Expression.Constant(count)));
    }

    public static IQueryable Skip(this IQueryable source, int count) {
      if (source == null) throw new ArgumentNullException("source");
      return source.Provider.CreateQuery(
          Expression.Call(
              typeof(Queryable), "Skip",
              new Type[] { source.ElementType },
              source.Expression, Expression.Constant(count)));
    }

    public static IQueryable GroupBy(this IQueryable source, string keySelector, string elementSelector, params object[] values) {
      if (source == null) throw new ArgumentNullException("source");
      if (keySelector == null) throw new ArgumentNullException("keySelector");
      if (elementSelector == null) throw new ArgumentNullException("elementSelector");
      LambdaExpression keyLambda = DynamicExpression.ParseLambda(source.ElementType, null, keySelector, values);
      LambdaExpression elementLambda = DynamicExpression.ParseLambda(source.ElementType, null, elementSelector, values);
      return source.Provider.CreateQuery(
          Expression.Call(
              typeof(Queryable), "GroupBy",
              new Type[] { source.ElementType, keyLambda.Body.Type, elementLambda.Body.Type },
              source.Expression, Expression.Quote(keyLambda), Expression.Quote(elementLambda)));
    }

    public static bool Any(this IQueryable source) {
      if (source == null) throw new ArgumentNullException("source");
      return (bool)source.Provider.Execute(
          Expression.Call(
              typeof(Queryable), "Any",
              new Type[] { source.ElementType }, source.Expression));
    }

    public static int Count(this IQueryable source) {
      if (source == null) throw new ArgumentNullException("source");
      return (int)source.Provider.Execute(
          Expression.Call(
              typeof(Queryable), "Count",
              new Type[] { source.ElementType }, source.Expression));
    }
  }

  public abstract class DynamicClass {
    public override string ToString() {
      PropertyInfo[] props = this.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
      StringBuilder sb = new StringBuilder();
      sb.Append("{");
      for (int i = 0; i < props.Length; i++) {
        if (i > 0) sb.Append(", ");
        sb.Append(props[i].Name);
        sb.Append("=");
        sb.Append(props[i].GetValue(this, null));
      }
      sb.Append("}");
      return sb.ToString();
    }
  }

  public class DynamicProperty {
    string name;
    Type type;

    public DynamicProperty(string name, Type type) {
      if (name == null) throw new ArgumentNullException("name");
      if (type == null) throw new ArgumentNullException("type");
      this.name = name;
      this.type = type;
    }

    public string Name {
      get { return name; }
    }

    public Type Type {
      get { return type; }
    }
  }

  public static class DynamicExpression {

    internal static readonly Type[] EmptyExtenderTypes = new Type[0];

    public static Expression Parse(Type resultType, string expression, params object[] values) {
      ExpressionParser parser = new ExpressionParser(null, expression, values, EmptyExtenderTypes);
      return parser.Parse(resultType);
    }

    public static LambdaExpression ParseLambda(Type itType, Type resultType, string expression, params object[] values) {
      return ParseLambda(new ParameterExpression[] { Expression.Parameter(itType, "") }, resultType, expression, values);
    }

    public static LambdaExpression ParseLambdaWithExtension(Type itType, Type resultType, string expression, Type[] extenderTypes, params object[] values) {
      return ParseLambdaWithExtension(new ParameterExpression[] { Expression.Parameter(itType, "") }, resultType, expression, extenderTypes, values);
    }

    public static LambdaExpression ParseLambda(ParameterExpression[] parameters, Type resultType, string expression, params object[] values) {
      ExpressionParser parser = new ExpressionParser(parameters, expression, values, null);
      return Expression.Lambda(parser.Parse(resultType), parameters);
    }

    public static LambdaExpression ParseLambdaWithExtension(ParameterExpression[] parameters, Type resultType, string expression, Type[] extenderTypes, params object[] values) {
      ExpressionParser parser = new ExpressionParser(parameters, expression, values, extenderTypes);
      return Expression.Lambda(parser.Parse(resultType), parameters);
    }

    public static Expression<Func<T, S>> ParseLambda<T, S>(string expression, params object[] values) {
      return (Expression<Func<T, S>>)ParseLambda(typeof(T), typeof(S), expression, values);
    }

    public static Expression<Func<T, S>> ParseLambdaWithExtension<T, S>(string expression, Type[] extenderTypes) {
      return ParseLambdaWithExtension<T, S>(expression, extenderTypes, null);
    }

    public static Expression<Func<T, S>> ParseLambdaWithExtension<T, S>(string expression, Type[] extenderTypes, object[] values) {
      return (Expression<Func<T, S>>)ParseLambdaWithExtension(typeof(T), typeof(S), expression, extenderTypes, values);
    }

    public static Type CreateClass(params DynamicProperty[] properties) {
      return ClassFactory.Instance.GetDynamicClass(properties);
    }

    public static Type CreateClass(IEnumerable<DynamicProperty> properties) {
      return ClassFactory.Instance.GetDynamicClass(properties);
    }

    private static readonly object[] EmptyObjectArray = new object[0];
  }

  internal class DynamicOrdering {
    public Expression Selector;
    public bool Ascending;
  }

  internal class Signature : IEquatable<Signature> {
    public DynamicProperty[] properties;
    public int hashCode;

    public Signature(IEnumerable<DynamicProperty> properties) {
      this.properties = properties.ToArray();
      hashCode = 0;
      foreach (DynamicProperty p in properties) {
        hashCode ^= p.Name.GetHashCode() ^ p.Type.GetHashCode();
      }
    }

    public override int GetHashCode() {
      return hashCode;
    }

    public override bool Equals(object obj) {
      return obj is Signature ? Equals((Signature)obj) : false;
    }

    public bool Equals(Signature other) {
      if (properties.Length != other.properties.Length) return false;
      for (int i = 0; i < properties.Length; i++) {
        if (properties[i].Name != other.properties[i].Name ||
            properties[i].Type != other.properties[i].Type) return false;
      }
      return true;
    }
  }

  [System.Reflection.Obfuscation(Exclude=true)]
  internal class ClassFactory {
    public static readonly ClassFactory Instance = new ClassFactory();

    static ClassFactory() { }  // Trigger lazy initialization of static fields

    ModuleBuilder module;
    Dictionary<Signature, Type> classes;
    int classCount;
    ReaderWriterLock rwLock;

    private ClassFactory() {
      AssemblyName name = new AssemblyName("DynamicClasses");
      AssemblyBuilder assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run);
#if ENABLE_LINQ_PARTIAL_TRUST
            new ReflectionPermission(PermissionState.Unrestricted).Assert();
#endif
      try {
        module = assembly.DefineDynamicModule("Module");
      }
      finally {
#if ENABLE_LINQ_PARTIAL_TRUST
                PermissionSet.RevertAssert();
#endif
      }
      classes = new Dictionary<Signature, Type>();
      rwLock = new ReaderWriterLock();
    }

    public Type GetDynamicClass(IEnumerable<DynamicProperty> properties) {
      rwLock.AcquireReaderLock(Timeout.Infinite);
      try {
        Signature signature = new Signature(properties);
        Type type;
        if (!classes.TryGetValue(signature, out type)) {
          type = CreateDynamicClass(signature.properties);
          classes.Add(signature, type);
        }
        return type;
      }
      finally {
        rwLock.ReleaseReaderLock();
      }
    }

    Type CreateDynamicClass(DynamicProperty[] properties) {
      LockCookie cookie = rwLock.UpgradeToWriterLock(Timeout.Infinite);
      try {
        string typeName = "DynamicClass" + (classCount + 1);
#if ENABLE_LINQ_PARTIAL_TRUST
                new ReflectionPermission(PermissionState.Unrestricted).Assert();
#endif
        try {
          TypeBuilder tb = this.module.DefineType(typeName, TypeAttributes.Class |
              TypeAttributes.Public, typeof(DynamicClass));
          FieldInfo[] fields = GenerateProperties(tb, properties);
          GenerateEquals(tb, fields);
          GenerateGetHashCode(tb, fields);
          Type result = tb.CreateType();
          classCount++;
          return result;
        }
        finally {
#if ENABLE_LINQ_PARTIAL_TRUST
                    PermissionSet.RevertAssert();
#endif
        }
      }
      finally {
        rwLock.DowngradeFromWriterLock(ref cookie);
      }
    }

    FieldInfo[] GenerateProperties(TypeBuilder tb, DynamicProperty[] properties) {
      FieldInfo[] fields = new FieldBuilder[properties.Length];
      for (int i = 0; i < properties.Length; i++) {
        DynamicProperty dp = properties[i];
        FieldBuilder fb = tb.DefineField("_" + dp.Name, dp.Type, FieldAttributes.Private);
        PropertyBuilder pb = tb.DefineProperty(dp.Name, PropertyAttributes.HasDefault, dp.Type, null);
        MethodBuilder mbGet = tb.DefineMethod("get_" + dp.Name,
            MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
            dp.Type, Type.EmptyTypes);
        ILGenerator genGet = mbGet.GetILGenerator();
        genGet.Emit(OpCodes.Ldarg_0);
        genGet.Emit(OpCodes.Ldfld, fb);
        genGet.Emit(OpCodes.Ret);
        MethodBuilder mbSet = tb.DefineMethod("set_" + dp.Name,
            MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
            null, new Type[] { dp.Type });
        ILGenerator genSet = mbSet.GetILGenerator();
        genSet.Emit(OpCodes.Ldarg_0);
        genSet.Emit(OpCodes.Ldarg_1);
        genSet.Emit(OpCodes.Stfld, fb);
        genSet.Emit(OpCodes.Ret);
        pb.SetGetMethod(mbGet);
        pb.SetSetMethod(mbSet);
        fields[i] = fb;
      }
      return fields;
    }

    void GenerateEquals(TypeBuilder tb, FieldInfo[] fields) {
      MethodBuilder mb = tb.DefineMethod("Equals",
          MethodAttributes.Public | MethodAttributes.ReuseSlot |
          MethodAttributes.Virtual | MethodAttributes.HideBySig,
          typeof(bool), new Type[] { typeof(object) });
      ILGenerator gen = mb.GetILGenerator();
      LocalBuilder other = gen.DeclareLocal(tb);
      Label next = gen.DefineLabel();
      gen.Emit(OpCodes.Ldarg_1);
      gen.Emit(OpCodes.Isinst, tb);
      gen.Emit(OpCodes.Stloc, other);
      gen.Emit(OpCodes.Ldloc, other);
      gen.Emit(OpCodes.Brtrue_S, next);
      gen.Emit(OpCodes.Ldc_I4_0);
      gen.Emit(OpCodes.Ret);
      gen.MarkLabel(next);
      foreach (FieldInfo field in fields) {
        Type ft = field.FieldType;
        Type ct = typeof(EqualityComparer<>).MakeGenericType(ft);
        next = gen.DefineLabel();
        gen.EmitCall(OpCodes.Call, ct.GetMethod("get_Default"), null);
        gen.Emit(OpCodes.Ldarg_0);
        gen.Emit(OpCodes.Ldfld, field);
        gen.Emit(OpCodes.Ldloc, other);
        gen.Emit(OpCodes.Ldfld, field);
        gen.EmitCall(OpCodes.Callvirt, ct.GetMethod("Equals", new Type[] { ft, ft }), null);
        gen.Emit(OpCodes.Brtrue_S, next);
        gen.Emit(OpCodes.Ldc_I4_0);
        gen.Emit(OpCodes.Ret);
        gen.MarkLabel(next);
      }
      gen.Emit(OpCodes.Ldc_I4_1);
      gen.Emit(OpCodes.Ret);
    }

    void GenerateGetHashCode(TypeBuilder tb, FieldInfo[] fields) {
      MethodBuilder mb = tb.DefineMethod("GetHashCode",
          MethodAttributes.Public | MethodAttributes.ReuseSlot |
          MethodAttributes.Virtual | MethodAttributes.HideBySig,
          typeof(int), Type.EmptyTypes);
      ILGenerator gen = mb.GetILGenerator();
      gen.Emit(OpCodes.Ldc_I4_0);
      foreach (FieldInfo field in fields) {
        Type ft = field.FieldType;
        Type ct = typeof(EqualityComparer<>).MakeGenericType(ft);
        gen.EmitCall(OpCodes.Call, ct.GetMethod("get_Default"), null);
        gen.Emit(OpCodes.Ldarg_0);
        gen.Emit(OpCodes.Ldfld, field);
        gen.EmitCall(OpCodes.Callvirt, ct.GetMethod("GetHashCode", new Type[] { ft }), null);
        gen.Emit(OpCodes.Xor);
      }
      gen.Emit(OpCodes.Ret);
    }
  }

  public sealed class ParseException : Exception {
    int position;

    public ParseException(string message, int position)
      : base(message) {
      this.position = position;
    }

    public int Position {
      get { return position; }
    }

    public override string ToString() {
      return string.Format(Res.ParseExceptionFormat, Message, position);
    }
  }

  [System.Reflection.Obfuscation(Exclude = true, ApplyToMembers=true)]
  internal class ExpressionParser {
    [System.Reflection.Obfuscation(Exclude = true)]
    struct Token {
      public TokenId id;
      public string text;
      public int pos;
    }

    [System.Reflection.Obfuscation(Exclude = true)]
    enum TokenId {
      Unknown,
      End,
      Identifier,
      StringLiteral,
      IntegerLiteral,
      RealLiteral,
      Exclamation,
      Percent,
      Amphersand,
      OpenParen,
      CloseParen,
      Asterisk,
      Plus,
      Comma,
      Minus,
      Dot,
      Slash,
      Colon,
      LessThan,
      Equal,
      GreaterThan,
      Question,
      OpenBracket,
      CloseBracket,
      Bar,
      ExclamationEqual,
      DoubleAmphersand,
      LessThanEqual,
      LessGreater,
      DoubleEqual,
      GreaterThanEqual,
      DoubleBar
    }

    [System.Reflection.Obfuscation(Exclude = true)]
    interface ILogicalSignatures {
      void F(bool x, bool y);
      void F(bool? x, bool? y);
    }

    [System.Reflection.Obfuscation(Exclude = true)]
    interface IArithmeticSignatures {
      void F(int x, int y);
      void F(uint x, uint y);
      void F(long x, long y);
      void F(ulong x, ulong y);
      void F(float x, float y);
      void F(double x, double y);
      void F(decimal x, decimal y);
      void F(int? x, int? y);
      void F(uint? x, uint? y);
      void F(long? x, long? y);
      void F(ulong? x, ulong? y);
      void F(float? x, float? y);
      void F(double? x, double? y);
      void F(decimal? x, decimal? y);
    }

    [System.Reflection.Obfuscation(Exclude = true)]
    interface IRelationalSignatures : IArithmeticSignatures {
      void F(string x, string y);
      void F(char x, char y);
      void F(DateTime x, DateTime y);
      void F(TimeSpan x, TimeSpan y);
      void F(char? x, char? y);
      void F(DateTime? x, DateTime? y);
      void F(TimeSpan? x, TimeSpan? y);
    }

    [System.Reflection.Obfuscation(Exclude = true)]
    interface IEqualitySignatures : IRelationalSignatures {
      void F(bool x, bool y);
      void F(bool? x, bool? y);
      void F(Guid x, Guid y);
      void F(Guid? x, Guid? y);
    }

    [System.Reflection.Obfuscation(Exclude = true)]
    interface IAddSignatures : IArithmeticSignatures {
      void F(DateTime x, TimeSpan y);
      void F(TimeSpan x, TimeSpan y);
      void F(DateTime? x, TimeSpan? y);
      void F(TimeSpan? x, TimeSpan? y);
    }

    [System.Reflection.Obfuscation(Exclude = true)]
    interface ISubtractSignatures : IAddSignatures {
      void F(DateTime x, DateTime y);
      void F(DateTime? x, DateTime? y);
    }

    [System.Reflection.Obfuscation(Exclude = true)]
    interface INegationSignatures {
      void F(int x);
      void F(long x);
      void F(float x);
      void F(double x);
      void F(decimal x);
      void F(int? x);
      void F(long? x);
      void F(float? x);
      void F(double? x);
      void F(decimal? x);
    }

    [System.Reflection.Obfuscation(Exclude = true)]
    interface INotSignatures {
      void F(bool x);
      void F(bool? x);
    }

    [System.Reflection.Obfuscation(Exclude = true)]
    interface IEnumerableSignatures {
      void First();
      void Last();
      void Distinct();
      void Where(bool predicate);
      void Any();
      void Any(bool predicate);
      void All(bool predicate);
      void Count();
      void Count(bool predicate);
      void Min(object selector);
      void Max(object selector);
      void Sum(int selector);
      void Sum(int? selector);
      void Sum(long selector);
      void Sum(long? selector);
      void Sum(float selector);
      void Sum(float? selector);
      void Sum(double selector);
      void Sum(double? selector);
      void Sum(decimal selector);
      void Sum(decimal? selector);
      void Average(int selector);
      void Average(int? selector);
      void Average(long selector);
      void Average(long? selector);
      void Average(float selector);
      void Average(float? selector);
      void Average(double selector);
      void Average(double? selector);
      void Average(decimal selector);
      void Average(decimal? selector);
    }

    static readonly Type[] predefinedTypes = {
            typeof(Object),
            typeof(Boolean),
            typeof(Char),
            typeof(String),
            typeof(SByte),
            typeof(Byte),
            typeof(Int16),
            typeof(UInt16),
            typeof(Int32),
            typeof(UInt32),
            typeof(Int64),
            typeof(UInt64),
            typeof(Single),
            typeof(Double),
            typeof(Decimal),
            typeof(DateTime),
            typeof(TimeSpan),
            typeof(Guid),
            typeof(Math),
            typeof(Convert)
        };

    static readonly Expression trueLiteral = Expression.Constant(true);
    static readonly Expression falseLiteral = Expression.Constant(false);
    static readonly Expression nullLiteral = Expression.Constant(null);

    static readonly string keywordIt = "it";
    static readonly string keywordIif = "iif";
    static readonly string keywordNew = "new";

    static Dictionary<string, object> keywords;

    Dictionary<string, object> symbols;
    IDictionary<string, object> externals;
    Dictionary<Expression, string> literals;
    Type[] extenderTypes;
    ParameterExpression it;
    string text;
    int textPos;
    int textLen;
    char ch;
    Token token;

    public ExpressionParser(ParameterExpression[] parameters, string expression, object[] values, IEnumerable<Type> extenderTypes) {
      if (expression == null) throw new ArgumentNullException("expression");
      if (keywords == null) keywords = CreateKeywords();
      symbols = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
      literals = new Dictionary<Expression, string>();
      if (parameters != null) ProcessParameters(parameters);
      if (values != null) ProcessValues(values);
      this.extenderTypes = extenderTypes == null ? DynamicExpression.EmptyExtenderTypes : extenderTypes.ToArray();
      text = expression;
      textLen = text.Length;
      SetTextPos(0);
      NextToken();
    }

    void ProcessParameters(ParameterExpression[] parameters) {
      foreach (ParameterExpression pe in parameters)
        if (!String.IsNullOrEmpty(pe.Name))
          AddSymbol(pe.Name, pe);
      if (parameters.Length == 1 && String.IsNullOrEmpty(parameters[0].Name))
        it = parameters[0];
    }

    void ProcessValues(object[] values) {
      for (int i = 0; i < values.Length; i++) {
        object value = values[i];
        if (i == values.Length - 1 && value is IDictionary<string, object>) {
          externals = (IDictionary<string, object>)value;
        }
        else {
          AddSymbol("@" + i.ToString(System.Globalization.CultureInfo.InvariantCulture), value);
        }
      }
    }

    void AddSymbol(string name, object value) {
      if (symbols.ContainsKey(name))
        throw ParseError(Res.DuplicateIdentifier, name);
      symbols.Add(name, value);
    }

    public Expression Parse(Type resultType) {
      int exprPos = token.pos;
      Expression expr = ParseExpression();
      if (resultType != null) {
        Type actualType = expr.Type;
        if ((expr = PromoteExpression(expr, resultType, true)) == null)
          throw ParseError(exprPos, Res.ExpressionTypeMismatch, actualType, GetTypeName(resultType));
      }
      ValidateToken(TokenId.End, Res.SyntaxError);
      return expr;
    }

#pragma warning disable 0219
    public IEnumerable<DynamicOrdering> ParseOrdering() {
      List<DynamicOrdering> orderings = new List<DynamicOrdering>();
      while (true) {
        Expression expr = ParseExpression();
        bool ascending = true;
        if (TokenIdentifierIs("asc") || TokenIdentifierIs("ascending")) {
          NextToken();
        }
        else if (TokenIdentifierIs("desc") || TokenIdentifierIs("descending")) {
          NextToken();
          ascending = false;
        }
        orderings.Add(new DynamicOrdering { Selector = expr, Ascending = ascending });
        if (token.id != TokenId.Comma) break;
        NextToken();
      }
      ValidateToken(TokenId.End, Res.SyntaxError);
      return orderings;
    }
#pragma warning restore 0219

    // ?: operator
    Expression ParseExpression() {
      int errorPos = token.pos;
      Expression expr = ParseLogicalOr();
      if (token.id == TokenId.Question) {
        NextToken();
        Expression expr1 = ParseExpression();
        ValidateToken(TokenId.Colon, Res.ColonExpected);
        NextToken();
        Expression expr2 = ParseExpression();
        expr = GenerateConditional(expr, expr1, expr2, errorPos);
      }
      return expr;
    }

    // ||, or operator
    Expression ParseLogicalOr() {
      Expression left = ParseLogicalAnd();
      while (token.id == TokenId.DoubleBar || TokenIdentifierIs("or")) {
        Token op = token;
        NextToken();
        Expression right = ParseLogicalAnd();
        CheckAndPromoteOperands(typeof(ILogicalSignatures), op.text, ref left, ref right, op.pos);
        left = Expression.OrElse(left, right);
      }
      return left;
    }

    // &&, and operator
    Expression ParseLogicalAnd() {
      Expression left = ParseComparison();
      while (token.id == TokenId.DoubleAmphersand || TokenIdentifierIs("and")) {
        Token op = token;
        NextToken();
        Expression right = ParseComparison();
        CheckAndPromoteOperands(typeof(ILogicalSignatures), op.text, ref left, ref right, op.pos);
        left = Expression.AndAlso(left, right);
      }
      return left;
    }

    // =, ==, !=, <>, >, >=, <, <= operators
    Expression ParseComparison() {
      Expression left = ParseAdditive();
      while (token.id == TokenId.Equal || token.id == TokenId.DoubleEqual ||
          token.id == TokenId.ExclamationEqual || token.id == TokenId.LessGreater ||
          token.id == TokenId.GreaterThan || token.id == TokenId.GreaterThanEqual ||
          token.id == TokenId.LessThan || token.id == TokenId.LessThanEqual) {
        Token op = token;
        NextToken();
        Expression right = ParseAdditive();
        bool isEquality = op.id == TokenId.Equal || op.id == TokenId.DoubleEqual ||
            op.id == TokenId.ExclamationEqual || op.id == TokenId.LessGreater;
        if (isEquality && !left.Type.IsValueType && !right.Type.IsValueType) {
          if (left.Type != right.Type) {
            if (left.Type.IsAssignableFrom(right.Type)) {
              right = Expression.Convert(right, left.Type);
            }
            else if (right.Type.IsAssignableFrom(left.Type)) {
              left = Expression.Convert(left, right.Type);
            }
            else {
              throw IncompatibleOperandsError(op.text, left, right, op.pos);
            }
          }
        }
        else if (IsEnumType(left.Type) || IsEnumType(right.Type)) {
          if (left.Type != right.Type) {
            Expression e;
            if ((e = PromoteExpression(right, left.Type, true)) != null) {
              right = e;
            }
            else if ((e = PromoteExpression(left, right.Type, true)) != null) {
              left = e;
            }
            else {
              throw IncompatibleOperandsError(op.text, left, right, op.pos);
            }
          }
        }
        else {
          CheckAndPromoteOperands(isEquality ? typeof(IEqualitySignatures) : typeof(IRelationalSignatures),
              op.text, ref left, ref right, op.pos);
        }
        switch (op.id) {
          case TokenId.Equal:
          case TokenId.DoubleEqual:
            left = GenerateEqual(left, right);
            break;
          case TokenId.ExclamationEqual:
          case TokenId.LessGreater:
            left = GenerateNotEqual(left, right);
            break;
          case TokenId.GreaterThan:
            left = GenerateGreaterThan(left, right);
            break;
          case TokenId.GreaterThanEqual:
            left = GenerateGreaterThanEqual(left, right);
            break;
          case TokenId.LessThan:
            left = GenerateLessThan(left, right);
            break;
          case TokenId.LessThanEqual:
            left = GenerateLessThanEqual(left, right);
            break;
        }
      }
      return left;
    }

    // +, -, & operators
    Expression ParseAdditive() {
      Expression left = ParseMultiplicative();
      while (token.id == TokenId.Plus || token.id == TokenId.Minus ||
          token.id == TokenId.Amphersand) {
        Token op = token;
        NextToken();
        Expression right = ParseMultiplicative();
        switch (op.id) {
          case TokenId.Plus:
            if (left.Type == typeof(string) || right.Type == typeof(string))
              goto case TokenId.Amphersand;
            CheckAndPromoteOperands(typeof(IAddSignatures), op.text, ref left, ref right, op.pos);
            left = GenerateAdd(left, right);
            break;
          case TokenId.Minus:
            CheckAndPromoteOperands(typeof(ISubtractSignatures), op.text, ref left, ref right, op.pos);
            left = GenerateSubtract(left, right);
            break;
          case TokenId.Amphersand:
            left = GenerateStringConcat(left, right);
            break;
        }
      }
      return left;
    }

    // *, /, %, mod operators
    Expression ParseMultiplicative() {
      Expression left = ParseUnary();
      while (token.id == TokenId.Asterisk || token.id == TokenId.Slash ||
          token.id == TokenId.Percent || TokenIdentifierIs("mod")) {
        Token op = token;
        NextToken();
        Expression right = ParseUnary();
        CheckAndPromoteOperands(typeof(IArithmeticSignatures), op.text, ref left, ref right, op.pos);
        switch (op.id) {
          case TokenId.Asterisk:
            left = Expression.Multiply(left, right);
            break;
          case TokenId.Slash:
            left = Expression.Divide(left, right);
            break;
          case TokenId.Percent:
          case TokenId.Identifier:
            left = Expression.Modulo(left, right);
            break;
        }
      }
      return left;
    }

    // -, !, not unary operators
    Expression ParseUnary() {
      if (token.id == TokenId.Minus || token.id == TokenId.Exclamation ||
          TokenIdentifierIs("not")) {
        Token op = token;
        NextToken();
        if (op.id == TokenId.Minus && (token.id == TokenId.IntegerLiteral ||
            token.id == TokenId.RealLiteral)) {
          token.text = "-" + token.text;
          token.pos = op.pos;
          return ParsePrimary();
        }
        Expression expr = ParseUnary();
        if (op.id == TokenId.Minus) {
          CheckAndPromoteOperand(typeof(INegationSignatures), op.text, ref expr, op.pos);
          expr = Expression.Negate(expr);
        }
        else {
          CheckAndPromoteOperand(typeof(INotSignatures), op.text, ref expr, op.pos);
          expr = Expression.Not(expr);
        }
        return expr;
      }
      return ParsePrimary();
    }

    Expression ParsePrimary() {
      Expression expr = ParsePrimaryStart();
      while (true) {
        if (token.id == TokenId.Dot) {
          NextToken();
          expr = ParseMemberAccess(null, expr);
          // expr = ParsePrimaryStart();
        }
        else if (token.id == TokenId.OpenBracket) {
          expr = ParseElementAccess(expr);
        }
        else {
          break;
        }
      }
      return expr;
    }

    Expression ParsePrimaryStart() {
      switch (token.id) {
        case TokenId.Identifier:
          return ParseIdentifier();
        case TokenId.StringLiteral:
          return ParseStringLiteral();
        case TokenId.IntegerLiteral:
          return ParseIntegerLiteral();
        case TokenId.RealLiteral:
          return ParseRealLiteral();
        case TokenId.OpenParen:
          return ParseParenExpression();
        default:
          throw ParseError(Res.ExpressionExpected);
      }
    }

    Expression ParseStringLiteral() {
      ValidateToken(TokenId.StringLiteral);
      char quote = token.text[0];
      string s = token.text.Substring(1, token.text.Length - 2);
      int start = 0;
      while (true) {
        int i = s.IndexOf(quote, start);
        if (i < 0) break;
        s = s.Remove(i, 1);
        start = i + 1;
      }
      if (quote == '\'') {
        if (s.Length != 1)
          throw ParseError(Res.InvalidCharacterLiteral);
        NextToken();
        return CreateLiteral(s[0], s);
      }
      NextToken();
      return CreateLiteral(s, s);
    }

    Expression ParseIntegerLiteral() {
      ValidateToken(TokenId.IntegerLiteral);
      string text = token.text;
      if (text[0] != '-') {
        ulong value;
        if (!UInt64.TryParse(text, out value))
          throw ParseError(Res.InvalidIntegerLiteral, text);
        NextToken();
        if (value <= (ulong)Int32.MaxValue) return CreateLiteral((int)value, text);
        if (value <= (ulong)UInt32.MaxValue) return CreateLiteral((uint)value, text);
        if (value <= (ulong)Int64.MaxValue) return CreateLiteral((long)value, text);
        return CreateLiteral(value, text);
      }
      else {
        long value;
        if (!Int64.TryParse(text, out value))
          throw ParseError(Res.InvalidIntegerLiteral, text);
        NextToken();
        if (value >= Int32.MinValue && value <= Int32.MaxValue)
          return CreateLiteral((int)value, text);
        return CreateLiteral(value, text);
      }
    }

    Expression ParseRealLiteral() {
      ValidateToken(TokenId.RealLiteral);
      string text = token.text;
      object value = null;
      char last = text[text.Length - 1];
      if (last == 'F' || last == 'f') {
        float f;
        if (Single.TryParse(text.Substring(0, text.Length - 1), out f)) value = f;
      }
      else {
        double d;
        if (Double.TryParse(text, out d)) value = d;
      }
      if (value == null) throw ParseError(Res.InvalidRealLiteral, text);
      NextToken();
      return CreateLiteral(value, text);
    }

    Expression CreateLiteral(object value, string text) {
      ConstantExpression expr = Expression.Constant(value);
      literals.Add(expr, text);
      return expr;
    }

    Expression ParseParenExpression() {
      ValidateToken(TokenId.OpenParen, Res.OpenParenExpected);
      NextToken();
      Expression e = ParseExpression();
      ValidateToken(TokenId.CloseParen, Res.CloseParenOrOperatorExpected);
      NextToken();
      return e;
    }

    Expression ParseIdentifier() {
      ValidateToken(TokenId.Identifier);
      object value;
      if (keywords.TryGetValue(token.text, out value)) {
        if (value is Type) return ParseTypeAccess((Type)value);
        if (value == (object)keywordIt) return ParseIt();
        if (value == (object)keywordIif) return ParseIif();
        if (value == (object)keywordNew) return ParseNew();
        NextToken();
        return (Expression)value;
      }
      if (symbols.TryGetValue(token.text, out value) ||
          externals != null && externals.TryGetValue(token.text, out value)) {
        Expression expr = value as Expression;
        if (expr == null) {
          expr = Expression.Constant(value);
        }
        else {
          LambdaExpression lambda = expr as LambdaExpression;
          if (lambda != null) return ParseLambdaInvocation(lambda);
        }
        NextToken();
        return expr;
      }
      if (it != null) return ParseMemberAccess(null, it);
      throw ParseError(Res.UnknownIdentifier, token.text);
    }

    Expression ParseIt() {
      if (it == null)
        throw ParseError(Res.NoItInScope);
      NextToken();
      return it;
    }

    Expression ParseIif() {
      int errorPos = token.pos;
      NextToken();
      Expression[] args = ParseArgumentList();
      if (args.Length != 3)
        throw ParseError(errorPos, Res.IifRequiresThreeArgs);
      return GenerateConditional(args[0], args[1], args[2], errorPos);
    }

    Expression GenerateConditional(Expression test, Expression expr1, Expression expr2, int errorPos) {
      if (test.Type != typeof(bool))
        throw ParseError(errorPos, Res.FirstExprMustBeBool);
      if (expr1.Type != expr2.Type) {
        Expression expr1as2 = expr2 != nullLiteral ? PromoteExpression(expr1, expr2.Type, true) : null;
        Expression expr2as1 = expr1 != nullLiteral ? PromoteExpression(expr2, expr1.Type, true) : null;
        if (expr1as2 != null && expr2as1 == null) {
          expr1 = expr1as2;
        }
        else if (expr2as1 != null && expr1as2 == null) {
          expr2 = expr2as1;
        }
        else {
          string type1 = expr1 != nullLiteral ? expr1.Type.Name : "null";
          string type2 = expr2 != nullLiteral ? expr2.Type.Name : "null";
          if (expr1as2 != null && expr2as1 != null)
            throw ParseError(errorPos, Res.BothTypesConvertToOther, type1, type2);
          throw ParseError(errorPos, Res.NeitherTypeConvertsToOther, type1, type2);
        }
      }
      return Expression.Condition(test, expr1, expr2);
    }

    Expression ParseNew() {
      NextToken();
      ValidateToken(TokenId.OpenParen, Res.OpenParenExpected);
      NextToken();
      List<DynamicProperty> properties = new List<DynamicProperty>();
      List<Expression> expressions = new List<Expression>();
      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;
        }
        expressions.Add(expr);
        properties.Add(new DynamicProperty(propName, expr.Type));
        if (token.id != TokenId.Comma) break;
        NextToken();
      }
      ValidateToken(TokenId.CloseParen, Res.CloseParenOrCommaExpected);
      NextToken();
      Type type = DynamicExpression.CreateClass(properties);
      MemberBinding[] bindings = new MemberBinding[properties.Count];
      for (int i = 0; i < bindings.Length; i++)
        bindings[i] = Expression.Bind(type.GetProperty(properties[i].Name), expressions[i]);
      return Expression.MemberInit(Expression.New(type), bindings);
    }

    Expression ParseLambdaInvocation(LambdaExpression lambda) {
      int errorPos = token.pos;
      NextToken();
      Expression[] args = ParseArgumentList();
      MethodBase method;
      if (FindMethod(lambda.Type, "Invoke", false, args, out method) != 1)
        throw ParseError(errorPos, Res.ArgsIncompatibleWithLambda);
      return Expression.Invoke(lambda, args);
    }

    Expression ParseTypeAccess(Type type) {
      int errorPos = token.pos;
      NextToken();
      if (token.id == TokenId.Question) {
        if (!type.IsValueType || IsNullableType(type))
          throw ParseError(errorPos, Res.TypeHasNoNullableForm, GetTypeName(type));
        type = typeof(Nullable<>).MakeGenericType(type);
        NextToken();
      }
      if (token.id == TokenId.OpenParen) {
        Expression[] args = ParseArgumentList();
        MethodBase method;
        switch (FindBestMethod(type.GetConstructors(), args, out method)) {
          case 0:
            if (args.Length == 1)
              return GenerateConversion(args[0], type, errorPos);
            throw ParseError(errorPos, Res.NoMatchingConstructor, GetTypeName(type));
          case 1:
            return Expression.New((ConstructorInfo)method, args);
          default:
            throw ParseError(errorPos, Res.AmbiguousConstructorInvocation, GetTypeName(type));
        }
      }
      ValidateToken(TokenId.Dot, Res.DotOrOpenParenExpected);
      NextToken();
      return ParseMemberAccess(type, null);
    }

    Expression GenerateConversion(Expression expr, Type type, int errorPos) {
      Type exprType = expr.Type;
      if (exprType == type) return expr;
      if (exprType.IsValueType && type.IsValueType) {
        if ((IsNullableType(exprType) || IsNullableType(type)) &&
            GetNonNullableType(exprType) == GetNonNullableType(type))
          return Expression.Convert(expr, type);
        if ((IsNumericType(exprType) || IsEnumType(exprType)) &&
            (IsNumericType(type)) || IsEnumType(type))
          return Expression.ConvertChecked(expr, type);
      }
      if (exprType.IsAssignableFrom(type) || type.IsAssignableFrom(exprType) ||
          exprType.IsInterface || type.IsInterface)
        return Expression.Convert(expr, type);
      throw ParseError(errorPos, Res.CannotConvertValue,
          GetTypeName(exprType), GetTypeName(type));
    }

    Expression ParseMemberAccess(Type type, Expression instance) {
      if (instance != null) type = instance.Type;
      int errorPos = token.pos;
      string id = GetIdentifier();
      NextToken();
      if (token.id == TokenId.OpenParen) {
        if (instance != null && type != typeof(string)) {
          Type enumerableType = FindGenericType(typeof(IEnumerable<>), type);
          if (enumerableType != null) {
            Type elementType = enumerableType.GetGenericArguments()[0];
            return ParseAggregate(instance, elementType, id, errorPos);
          }
        }
        Expression[] args = ParseArgumentList();
        MethodBase mb;
        switch (FindMethod(type, id, instance == null, args, out mb)) {
          case 0:
            // Give chance to extension method
            Expression extensionCall = ParseExtensionCall(instance, type, id, args);
            if (extensionCall != null) return extensionCall;

            throw ParseError(errorPos, Res.NoApplicableMethod,
                id, GetTypeName(type));
          case 1:
            MethodInfo method = (MethodInfo)mb;
            if (!IsPredefinedType(method.DeclaringType))
              throw ParseError(errorPos, Res.MethodsAreInaccessible, GetTypeName(method.DeclaringType));
            if (method.ReturnType == typeof(void))
              throw ParseError(errorPos, Res.MethodIsVoid,
                  id, GetTypeName(method.DeclaringType));
            return Expression.Call(instance, (MethodInfo)method, args);
          default:
            throw ParseError(errorPos, Res.AmbiguousMethodInvocation,
                id, GetTypeName(type));
        }
      }
      else {
        MemberInfo member = FindPropertyOrField(type, id, instance == null);
        if (member == null)
          throw ParseError(errorPos, Res.UnknownPropertyOrField,
              id, GetTypeName(type));
        return member is PropertyInfo ?
            Expression.Property(instance, (PropertyInfo)member) :
            Expression.Field(instance, (FieldInfo)member);
      }
    }

    private Expression ParseExtensionCall(Expression instance, Type type, string methodName, Expression[] args) {
      if (args.Length > 0) throw new NotSupportedException("Not supporting extension methods with arguments yet");

      ParameterExpression[] extensionArgs = new ParameterExpression[args.Length + 1];
      extensionArgs[0] = it;
      args.CopyTo(extensionArgs, 1);

      MethodData[] applicable = GetExtensionMethods(type).
          Where(m => m.Name.Equals(methodName)).
          Select(m => new MethodData { MethodBase = m, Parameters = m.GetParameters() }).
          Where(m => IsApplicable(m, extensionArgs)).
          ToArray();

      switch (applicable.Length) {
        case 0:
          return null;
        case 1:
          var method = applicable[0].MethodBase;
          Type[] typeArguments = new Type[0];
          return Expression.Call(method.DeclaringType, method.Name, typeArguments, extensionArgs);
        default:
          throw new InvalidOperationException("Ambigous extension methods");
      }
              
    }

    private IEnumerable<MethodInfo> GetExtensionMethods(Type extendedType) {
      var query = from type in extenderTypes
                  where type.IsSealed && !type.IsGenericType && !type.IsNested
                  from method in type.GetMethods(BindingFlags.Static
                      | BindingFlags.Public | BindingFlags.NonPublic)
                  where method.IsDefined(typeof(ExtensionAttribute), false)
                  where method.GetParameters()[0].ParameterType == extendedType
                  select method;
      return query;
    }


    static Type FindGenericType(Type generic, Type type) {
      while (type != null && type != typeof(object)) {
        if (type.IsGenericType && type.GetGenericTypeDefinition() == generic) return type;
        if (generic.IsInterface) {
          foreach (Type intfType in type.GetInterfaces()) {
            Type found = FindGenericType(generic, intfType);
            if (found != null) return found;
          }
        }
        type = type.BaseType;
      }
      return null;
    }

    Expression ParseAggregate(Expression instance, Type elementType, string methodName, int errorPos) {
      ParameterExpression outerIt = it;
      ParameterExpression innerIt = Expression.Parameter(elementType, "");
      it = innerIt;
      Expression[] args = ParseArgumentList();
      it = outerIt;

      Type[] typeArgs;

      if (methodName.Equals("select", StringComparison.InvariantCultureIgnoreCase)) {
        typeArgs = new Type[] { elementType, args[0].Type };
        args = new Expression[] { instance, Expression.Lambda(args[0], innerIt) };
        return Expression.Call(typeof(Enumerable), "Select", typeArgs, args);
      }
      else if (methodName.Equals("selectmany", StringComparison.InvariantCultureIgnoreCase)) {
        Type enumerableType = FindGenericType(typeof(IEnumerable<>), args[0].Type);
        Type resultElementType = enumerableType.GetGenericArguments()[0];
        typeArgs = new Type[] { elementType, resultElementType };
        args = new Expression[] { instance, Expression.Lambda(args[0], innerIt) };
        return Expression.Call(typeof(Enumerable), "SelectMany", typeArgs, args);
      }

      MethodBase signature;
      if (FindMethod(typeof(IEnumerableSignatures), methodName, false, args, out signature) != 1)
        throw ParseError(errorPos, Res.NoApplicableAggregate, methodName);
      if (signature.Name == "Min" || signature.Name == "Max") {
        typeArgs = new Type[] { elementType, args[0].Type };
      }
      else {
        typeArgs = new Type[] { elementType };
      }
      if (args.Length == 0) {
        args = new Expression[] { instance };
      }
      else {
        args = new Expression[] { instance, Expression.Lambda(args[0], innerIt) };
      }
      return Expression.Call(typeof(Enumerable), signature.Name, typeArgs, args);
    }

    Expression[] ParseArgumentList() {
      ValidateToken(TokenId.OpenParen, Res.OpenParenExpected);
      NextToken();
      Expression[] args = token.id != TokenId.CloseParen ? ParseArguments() : new Expression[0];
      ValidateToken(TokenId.CloseParen, Res.CloseParenOrCommaExpected);
      NextToken();
      return args;
    }

    Expression[] ParseArguments() {
      List<Expression> argList = new List<Expression>();
      while (true) {
        argList.Add(ParseExpression());
        if (token.id != TokenId.Comma) break;
        NextToken();
      }
      return argList.ToArray();
    }

    Expression ParseElementAccess(Expression expr) {
      int errorPos = token.pos;
      ValidateToken(TokenId.OpenBracket, Res.OpenParenExpected);
      NextToken();
      Expression[] args = ParseArguments();
      ValidateToken(TokenId.CloseBracket, Res.CloseBracketOrCommaExpected);
      NextToken();
      if (expr.Type.IsArray) {
        if (expr.Type.GetArrayRank() != 1 || args.Length != 1)
          throw ParseError(errorPos, Res.CannotIndexMultiDimArray);
        Expression index = PromoteExpression(args[0], typeof(int), true);
        if (index == null)
          throw ParseError(errorPos, Res.InvalidIndex);
        return Expression.ArrayIndex(expr, index);
      }
      else {
        MethodBase mb;
        switch (FindIndexer(expr.Type, args, out mb)) {
          case 0:
            throw ParseError(errorPos, Res.NoApplicableIndexer,
                GetTypeName(expr.Type));
          case 1:
            return Expression.Call(expr, (MethodInfo)mb, args);
          default:
            throw ParseError(errorPos, Res.AmbiguousIndexerInvocation,
                GetTypeName(expr.Type));
        }
      }
    }

    static bool IsPredefinedType(Type type) {
      return true; // Chagned by Ido - Allow to invoke method on any type.

      //foreach (Type t in predefinedTypes) if (t == type) return true;
      //return false;
    }

    static bool IsNullableType(Type type) {
      return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
    }

    static Type GetNonNullableType(Type type) {
      return IsNullableType(type) ? type.GetGenericArguments()[0] : type;
    }

    static string GetTypeName(Type type) {
      Type baseType = GetNonNullableType(type);
      string s = baseType.Name;
      if (type != baseType) s += '?';
      return s;
    }

    static bool IsNumericType(Type type) {
      return GetNumericTypeKind(type) != 0;
    }

    static bool IsSignedIntegralType(Type type) {
      return GetNumericTypeKind(type) == 2;
    }

    static bool IsUnsignedIntegralType(Type type) {
      return GetNumericTypeKind(type) == 3;
    }

    static int GetNumericTypeKind(Type type) {
      type = GetNonNullableType(type);
      if (type.IsEnum) return 0;
      switch (Type.GetTypeCode(type)) {
        case TypeCode.Char:
        case TypeCode.Single:
        case TypeCode.Double:
        case TypeCode.Decimal:
          return 1;
        case TypeCode.SByte:
        case TypeCode.Int16:
        case TypeCode.Int32:
        case TypeCode.Int64:
          return 2;
        case TypeCode.Byte:
        case TypeCode.UInt16:
        case TypeCode.UInt32:
        case TypeCode.UInt64:
          return 3;
        default:
          return 0;
      }
    }

    static bool IsEnumType(Type type) {
      return GetNonNullableType(type).IsEnum;
    }

    void CheckAndPromoteOperand(Type signatures, string opName, ref Expression expr, int errorPos) {
      Expression[] args = new Expression[] { expr };
      MethodBase method;
      if (FindMethod(signatures, "F", false, args, out method) != 1)
        throw ParseError(errorPos, Res.IncompatibleOperand,
            opName, GetTypeName(args[0].Type));
      expr = args[0];
    }

    void CheckAndPromoteOperands(Type signatures, string opName, ref Expression left, ref Expression right, int errorPos) {
      Expression[] args = new Expression[] { left, right };
      MethodBase method;
      if (FindMethod(signatures, "F", false, args, out method) != 1)
        throw IncompatibleOperandsError(opName, left, right, errorPos);
      left = args[0];
      right = args[1];
    }

    Exception IncompatibleOperandsError(string opName, Expression left, Expression right, int pos) {
      return ParseError(pos, Res.IncompatibleOperands,
          opName, GetTypeName(left.Type), GetTypeName(right.Type));
    }

    MemberInfo FindPropertyOrField(Type type, string memberName, bool staticAccess) {
      BindingFlags flags = BindingFlags.Public | BindingFlags.DeclaredOnly |
          (staticAccess ? BindingFlags.Static : BindingFlags.Instance);
      foreach (Type t in SelfAndBaseTypes(type)) {
        MemberInfo[] members = t.FindMembers(MemberTypes.Property | MemberTypes.Field,
            flags, Type.FilterNameIgnoreCase, memberName);
        if (members.Length != 0) return members[0];
      }
      return null;
    }

    int FindMethod(Type type, string methodName, bool staticAccess, Expression[] args, out MethodBase method) {
      BindingFlags flags = BindingFlags.Public | BindingFlags.DeclaredOnly |
          (staticAccess ? BindingFlags.Static : BindingFlags.Instance);
      foreach (Type t in SelfAndBaseTypes(type)) {
        MemberInfo[] members = t.FindMembers(MemberTypes.Method,
            flags, Type.FilterNameIgnoreCase, methodName);
        int count = FindBestMethod(members.Cast<MethodBase>(), args, out method);
        if (count != 0) return count;
      }
      method = null;
      return 0;
    }

    int FindIndexer(Type type, Expression[] args, out MethodBase method) {
      foreach (Type t in SelfAndBaseTypes(type)) {
        MemberInfo[] members = t.GetDefaultMembers();
        if (members.Length != 0) {
          IEnumerable<MethodBase> methods = members.
              OfType<PropertyInfo>().
              Select(p => (MethodBase)p.GetGetMethod()).
              Where(m => m != null);
          int count = FindBestMethod(methods, args, out method);
          if (count != 0) return count;
        }
      }
      method = null;
      return 0;
    }

    static IEnumerable<Type> SelfAndBaseTypes(Type type) {
      if (type.IsInterface) {
        List<Type> types = new List<Type>();
        AddInterface(types, type);
        return types;
      }
      return SelfAndBaseClasses(type);
    }

    static IEnumerable<Type> SelfAndBaseClasses(Type type) {
      while (type != null) {
        yield return type;
        type = type.BaseType;
      }
    }

    static void AddInterface(List<Type> types, Type type) {
      if (!types.Contains(type)) {
        types.Add(type);
        foreach (Type t in type.GetInterfaces()) AddInterface(types, t);
      }
    }

    class MethodData {
      public MethodBase MethodBase;
      public ParameterInfo[] Parameters;
      public Expression[] Args;
    }

    int FindBestMethod(IEnumerable<MethodBase> methods, Expression[] args, out MethodBase method) {
      MethodData[] applicable = methods.
          Select(m => new MethodData { MethodBase = m, Parameters = m.GetParameters() }).
          Where(m => IsApplicable(m, args)).
          ToArray();
      if (applicable.Length > 1) {
        applicable = applicable.
            Where(m => applicable.All(n => m == n || IsBetterThan(args, m, n))).
            ToArray();
      }
      if (applicable.Length == 1) {
        MethodData md = applicable[0];
        for (int i = 0; i < args.Length; i++) args[i] = md.Args[i];
        method = md.MethodBase;
      }
      else {
        method = null;
      }
      return applicable.Length;
    }

    bool IsApplicable(MethodData method, Expression[] args) {
      if (method.Parameters.Length != args.Length) return false;
      Expression[] promotedArgs = new Expression[args.Length];
      for (int i = 0; i < args.Length; i++) {
        ParameterInfo pi = method.Parameters[i];
        if (pi.IsOut) return false;
        Expression promoted = PromoteExpression(args[i], pi.ParameterType, false);
        if (promoted == null) return false;
        promotedArgs[i] = promoted;
      }
      method.Args = promotedArgs;
      return true;
    }

    Expression PromoteExpression(Expression expr, Type type, bool exact) {
      if (expr.Type == type) return expr;
      if (expr is ConstantExpression) {
        ConstantExpression ce = (ConstantExpression)expr;
        if (ce == nullLiteral) {
          if (!type.IsValueType || IsNullableType(type))
            return Expression.Constant(null, type);
        }
        else {
          string text;
          if (literals.TryGetValue(ce, out text)) {
            Type target = GetNonNullableType(type);
            Object value = null;
            switch (Type.GetTypeCode(ce.Type)) {
              case TypeCode.Int32:
              case TypeCode.UInt32:
              case TypeCode.Int64:
              case TypeCode.UInt64:
                value = ParseNumber(text, target);
                break;
              case TypeCode.Double:
                if (target == typeof(decimal)) value = ParseNumber(text, target);
                break;
              case TypeCode.String:
                value = ParseEnum(text, target);
                break;
            }
            if (value != null)
              return Expression.Constant(value, type);
          }
        }
      }
      if (IsCompatibleWith(expr.Type, type)) {
        if (type.IsValueType || exact) return Expression.Convert(expr, type);
        return expr;
      }
      return null;
    }

    static object ParseNumber(string text, Type type) {
      switch (Type.GetTypeCode(GetNonNullableType(type))) {
        case TypeCode.SByte:
          sbyte sb;
          if (sbyte.TryParse(text, out sb)) return sb;
          break;
        case TypeCode.Byte:
          byte b;
          if (byte.TryParse(text, out b)) return b;
          break;
        case TypeCode.Int16:
          short s;
          if (short.TryParse(text, out s)) return s;
          break;
        case TypeCode.UInt16:
          ushort us;
          if (ushort.TryParse(text, out us)) return us;
          break;
        case TypeCode.Int32:
          int i;
          if (int.TryParse(text, out i)) return i;
          break;
        case TypeCode.UInt32:
          uint ui;
          if (uint.TryParse(text, out ui)) return ui;
          break;
        case TypeCode.Int64:
          long l;
          if (long.TryParse(text, out l)) return l;
          break;
        case TypeCode.UInt64:
          ulong ul;
          if (ulong.TryParse(text, out ul)) return ul;
          break;
        case TypeCode.Single:
          float f;
          if (float.TryParse(text, out f)) return f;
          break;
        case TypeCode.Double:
          double d;
          if (double.TryParse(text, out d)) return d;
          break;
        case TypeCode.Decimal:
          decimal e;
          if (decimal.TryParse(text, out e)) return e;
          break;
      }
      return null;
    }

    static object ParseEnum(string name, Type type) {
      if (type.IsEnum) {
        MemberInfo[] memberInfos = type.FindMembers(MemberTypes.Field,
            BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Static,
            Type.FilterNameIgnoreCase, name);
        if (memberInfos.Length != 0) return ((FieldInfo)memberInfos[0]).GetValue(null);
      }
      return null;
    }

    static bool IsCompatibleWith(Type source, Type target) {
      if (source == target) return true;
      if (!target.IsValueType) return target.IsAssignableFrom(source);
      Type st = GetNonNullableType(source);
      Type tt = GetNonNullableType(target);
      if (st != source && tt == target) return false;
      TypeCode sc = st.IsEnum ? TypeCode.Object : Type.GetTypeCode(st);
      TypeCode tc = tt.IsEnum ? TypeCode.Object : Type.GetTypeCode(tt);
      switch (sc) {
        case TypeCode.SByte:
          switch (tc) {
            case TypeCode.SByte:
            case TypeCode.Int16:
            case TypeCode.Int32:
            case TypeCode.Int64:
            case TypeCode.Single:
            case TypeCode.Double:
            case TypeCode.Decimal:
              return true;
          }
          break;
        case TypeCode.Byte:
          switch (tc) {
            case TypeCode.Byte:
            case TypeCode.Int16:
            case TypeCode.UInt16:
            case TypeCode.Int32:
            case TypeCode.UInt32:
            case TypeCode.Int64:
            case TypeCode.UInt64:
            case TypeCode.Single:
            case TypeCode.Double:
            case TypeCode.Decimal:
              return true;
          }
          break;
        case TypeCode.Int16:
          switch (tc) {
            case TypeCode.Int16:
            case TypeCode.Int32:
            case TypeCode.Int64:
            case TypeCode.Single:
            case TypeCode.Double:
            case TypeCode.Decimal:
              return true;
          }
          break;
        case TypeCode.UInt16:
          switch (tc) {
            case TypeCode.UInt16:
            case TypeCode.Int32:
            case TypeCode.UInt32:
            case TypeCode.Int64:
            case TypeCode.UInt64:
            case TypeCode.Single:
            case TypeCode.Double:
            case TypeCode.Decimal:
              return true;
          }
          break;
        case TypeCode.Int32:
          switch (tc) {
            case TypeCode.Int32:
            case TypeCode.Int64:
            case TypeCode.Single:
            case TypeCode.Double:
            case TypeCode.Decimal:
              return true;
          }
          break;
        case TypeCode.UInt32:
          switch (tc) {
            case TypeCode.UInt32:
            case TypeCode.Int64:
            case TypeCode.UInt64:
            case TypeCode.Single:
            case TypeCode.Double:
            case TypeCode.Decimal:
              return true;
          }
          break;
        case TypeCode.Int64:
          switch (tc) {
            case TypeCode.Int64:
            case TypeCode.Single:
            case TypeCode.Double:
            case TypeCode.Decimal:
              return true;
          }
          break;
        case TypeCode.UInt64:
          switch (tc) {
            case TypeCode.UInt64:
            case TypeCode.Single:
            case TypeCode.Double:
            case TypeCode.Decimal:
              return true;
          }
          break;
        case TypeCode.Single:
          switch (tc) {
            case TypeCode.Single:
            case TypeCode.Double:
              return true;
          }
          break;
        default:
          if (st == tt) return true;
          break;
      }
      return false;
    }

    static bool IsBetterThan(Expression[] args, MethodData m1, MethodData m2) {
      bool better = false;
      for (int i = 0; i < args.Length; i++) {
        int c = CompareConversions(args[i].Type,
            m1.Parameters[i].ParameterType,
            m2.Parameters[i].ParameterType);
        if (c < 0) return false;
        if (c > 0) better = true;
      }
      return better;
    }

    // Return 1 if s -> t1 is a better conversion than s -> t2
    // Return -1 if s -> t2 is a better conversion than s -> t1
    // Return 0 if neither conversion is better
    static int CompareConversions(Type s, Type t1, Type t2) {
      if (t1 == t2) return 0;
      if (s == t1) return 1;
      if (s == t2) return -1;
      bool t1t2 = IsCompatibleWith(t1, t2);
      bool t2t1 = IsCompatibleWith(t2, t1);
      if (t1t2 && !t2t1) return 1;
      if (t2t1 && !t1t2) return -1;
      if (IsSignedIntegralType(t1) && IsUnsignedIntegralType(t2)) return 1;
      if (IsSignedIntegralType(t2) && IsUnsignedIntegralType(t1)) return -1;
      return 0;
    }

    Expression GenerateEqual(Expression left, Expression right) {
      return Expression.Equal(left, right);
    }

    Expression GenerateNotEqual(Expression left, Expression right) {
      return Expression.NotEqual(left, right);
    }

    Expression GenerateGreaterThan(Expression left, Expression right) {
      if (left.Type == typeof(string)) {
        return Expression.GreaterThan(
            GenerateStaticMethodCall("Compare", left, right),
            Expression.Constant(0)
        );
      }
      return Expression.GreaterThan(left, right);
    }

    Expression GenerateGreaterThanEqual(Expression left, Expression right) {
      if (left.Type == typeof(string)) {
        return Expression.GreaterThanOrEqual(
            GenerateStaticMethodCall("Compare", left, right),
            Expression.Constant(0)
        );
      }
      return Expression.GreaterThanOrEqual(left, right);
    }

    Expression GenerateLessThan(Expression left, Expression right) {
      if (left.Type == typeof(string)) {
        return Expression.LessThan(
            GenerateStaticMethodCall("Compare", left, right),
            Expression.Constant(0)
        );
      }
      return Expression.LessThan(left, right);
    }

    Expression GenerateLessThanEqual(Expression left, Expression right) {
      if (left.Type == typeof(string)) {
        return Expression.LessThanOrEqual(
            GenerateStaticMethodCall("Compare", left, right),
            Expression.Constant(0)
        );
      }
      return Expression.LessThanOrEqual(left, right);
    }

    Expression GenerateAdd(Expression left, Expression right) {
      if (left.Type == typeof(string) && right.Type == typeof(string)) {
        return GenerateStaticMethodCall("Concat", left, right);
      }
      return Expression.Add(left, right);
    }

    Expression GenerateSubtract(Expression left, Expression right) {
      return Expression.Subtract(left, right);
    }

    Expression GenerateStringConcat(Expression left, Expression right) {
      return Expression.Call(
          null,
          typeof(string).GetMethod("Concat", new[] { typeof(object), typeof(object) }),
          new[] { left, right });
    }

    MethodInfo GetStaticMethod(string methodName, Expression left, Expression right) {
      return left.Type.GetMethod(methodName, new[] { left.Type, right.Type });
    }

    Expression GenerateStaticMethodCall(string methodName, Expression left, Expression right) {
      return Expression.Call(null, GetStaticMethod(methodName, left, right), new[] { left, right });
    }

    void SetTextPos(int pos) {
      textPos = pos;
      ch = textPos < textLen ? text[textPos] : '\0';
    }

    void NextChar() {
      if (textPos < textLen) textPos++;
      ch = textPos < textLen ? text[textPos] : '\0';
    }

    void NextToken() {
      while (Char.IsWhiteSpace(ch)) NextChar();
      TokenId t;
      int tokenPos = textPos;
      switch (ch) {
        case '!':
          NextChar();
          if (ch == '=') {
            NextChar();
            t = TokenId.ExclamationEqual;
          }
          else {
            t = TokenId.Exclamation;
          }
          break;
        case '%':
          NextChar();
          t = TokenId.Percent;
          break;
        case '&':
          NextChar();
          if (ch == '&') {
            NextChar();
            t = TokenId.DoubleAmphersand;
          }
          else {
            t = TokenId.Amphersand;
          }
          break;
        case '(':
          NextChar();
          t = TokenId.OpenParen;
          break;
        case ')':
          NextChar();
          t = TokenId.CloseParen;
          break;
        case '*':
          NextChar();
          t = TokenId.Asterisk;
          break;
        case '+':
          NextChar();
          t = TokenId.Plus;
          break;
        case ',':
          NextChar();
          t = TokenId.Comma;
          break;
        case '-':
          NextChar();
          t = TokenId.Minus;
          break;
        case '.':
          NextChar();
          t = TokenId.Dot;
          break;
        case '/':
          NextChar();
          t = TokenId.Slash;
          break;
        case ':':
          NextChar();
          t = TokenId.Colon;
          break;
        case '<':
          NextChar();
          if (ch == '=') {
            NextChar();
            t = TokenId.LessThanEqual;
          }
          else if (ch == '>') {
            NextChar();
            t = TokenId.LessGreater;
          }
          else {
            t = TokenId.LessThan;
          }
          break;
        case '=':
          NextChar();
          if (ch == '=') {
            NextChar();
            t = TokenId.DoubleEqual;
          }
          else {
            t = TokenId.Equal;
          }
          break;
        case '>':
          NextChar();
          if (ch == '=') {
            NextChar();
            t = TokenId.GreaterThanEqual;
          }
          else {
            t = TokenId.GreaterThan;
          }
          break;
        case '?':
          NextChar();
          t = TokenId.Question;
          break;
        case '[':
          NextChar();
          t = TokenId.OpenBracket;
          break;
        case ']':
          NextChar();
          t = TokenId.CloseBracket;
          break;
        case '|':
          NextChar();
          if (ch == '|') {
            NextChar();
            t = TokenId.DoubleBar;
          }
          else {
            t = TokenId.Bar;
          }
          break;
        case '"':
        case '\'':
          char quote = ch;
          do {
            NextChar();
            while (textPos < textLen && ch != quote) NextChar();
            if (textPos == textLen)
              throw ParseError(textPos, Res.UnterminatedStringLiteral);
            NextChar();
          } while (ch == quote);
          t = TokenId.StringLiteral;
          break;
        default:
          if (Char.IsLetter(ch) || ch == '@' || ch == '_') {
            do {
              NextChar();
            } while (Char.IsLetterOrDigit(ch) || ch == '_');
            t = TokenId.Identifier;
            break;
          }
          if (Char.IsDigit(ch)) {
            t = TokenId.IntegerLiteral;
            do {
              NextChar();
            } while (Char.IsDigit(ch));
            if (ch == '.') {
              t = TokenId.RealLiteral;
              NextChar();
              ValidateDigit();
              do {
                NextChar();
              } while (Char.IsDigit(ch));
            }
            if (ch == 'E' || ch == 'e') {
              t = TokenId.RealLiteral;
              NextChar();
              if (ch == '+' || ch == '-') NextChar();
              ValidateDigit();
              do {
                NextChar();
              } while (Char.IsDigit(ch));
            }
            if (ch == 'F' || ch == 'f') NextChar();
            break;
          }
          if (textPos == textLen) {
            t = TokenId.End;
            break;
          }
          throw ParseError(textPos, Res.InvalidCharacter, ch);
      }
      token.id = t;
      token.text = text.Substring(tokenPos, textPos - tokenPos);
      token.pos = tokenPos;
    }

    bool TokenIdentifierIs(string id) {
      return token.id == TokenId.Identifier && String.Equals(id, token.text, StringComparison.OrdinalIgnoreCase);
    }

    string GetIdentifier() {
      ValidateToken(TokenId.Identifier, Res.IdentifierExpected);
      string id = token.text;
      if (id.Length > 1 && id[0] == '@') id = id.Substring(1);
      return id;
    }

    void ValidateDigit() {
      if (!Char.IsDigit(ch)) throw ParseError(textPos, Res.DigitExpected);
    }

    void ValidateToken(TokenId t, string errorMessage) {
      if (token.id != t) throw ParseError(errorMessage);
    }

    void ValidateToken(TokenId t) {
      if (token.id != t) throw ParseError(Res.SyntaxError);
    }

    Exception ParseError(string format, params object[] args) {
      return ParseError(token.pos, format, args);
    }

    Exception ParseError(int pos, string format, params object[] args) {
      return new ParseException(string.Format(System.Globalization.CultureInfo.CurrentCulture, format, args), pos);
    }

    static Dictionary<string, object> CreateKeywords() {
      Dictionary<string, object> d = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
      d.Add("true", trueLiteral);
      d.Add("false", falseLiteral);
      d.Add("null", nullLiteral);
      d.Add(keywordIt, keywordIt);
      d.Add(keywordIif, keywordIif);
      d.Add(keywordNew, keywordNew);
      foreach (Type type in predefinedTypes) d.Add(type.Name, type);
      return d;
    }
  }

  [System.Reflection.Obfuscation(Exclude = true)]
  static class Res {
    public const string DuplicateIdentifier = "The identifier '{0}' was defined more than once";
    public const string ExpressionTypeMismatch = "Expression of type '{0}' found where expression of type '{0}' expected";
    public const string ExpressionExpected = "Expression expected";
    public const string InvalidCharacterLiteral = "Character literal must contain exactly one character";
    public const string InvalidIntegerLiteral = "Invalid integer literal '{0}'";
    public const string InvalidRealLiteral = "Invalid real literal '{0}'";
    public const string UnknownIdentifier = "Unknown identifier '{0}'";
    public const string NoItInScope = "No 'it' is in scope";
    public const string IifRequiresThreeArgs = "The 'iif' function requires three arguments";
    public const string FirstExprMustBeBool = "The first expression must be of type 'Boolean'";
    public const string BothTypesConvertToOther = "Both of the types '{0}' and '{1}' convert to the other";
    public const string NeitherTypeConvertsToOther = "Neither of the types '{0}' and '{1}' converts to the other";
    public const string MissingAsClause = "Expression is missing an 'as' clause";
    public const string ArgsIncompatibleWithLambda = "Argument list incompatible with lambda expression";
    public const string TypeHasNoNullableForm = "Type '{0}' has no nullable form";
    public const string NoMatchingConstructor = "No matching constructor in type '{0}'";
    public const string AmbiguousConstructorInvocation = "Ambiguous invocation of '{0}' constructor";
    public const string CannotConvertValue = "A value of type '{0}' cannot be converted to type '{1}'";
    public const string NoApplicableMethod = "No applicable method '{0}' exists in type '{1}'";
    public const string MethodsAreInaccessible = "Methods on type '{0}' are not accessible";
    public const string MethodIsVoid = "Method '{0}' in type '{1}' does not return a value";
    public const string AmbiguousMethodInvocation = "Ambiguous invocation of method '{0}' in type '{1}'";
    public const string UnknownPropertyOrField = "No property or field '{0}' exists in type '{1}'";
    public const string NoApplicableAggregate = "No applicable aggregate method '{0}' exists";
    public const string CannotIndexMultiDimArray = "Indexing of multi-dimensional arrays is not supported";
    public const string InvalidIndex = "Array index must be an integer expression";
    public const string NoApplicableIndexer = "No applicable indexer exists in type '{0}'";
    public const string AmbiguousIndexerInvocation = "Ambiguous invocation of indexer in type '{0}'";
    public const string IncompatibleOperand = "Operator '{0}' incompatible with operand type '{1}'";
    public const string IncompatibleOperands = "Operator '{0}' incompatible with operand types '{1}' and '{2}'";
    public const string UnterminatedStringLiteral = "Unterminated string literal";
    public const string InvalidCharacter = "Syntax error '{0}'";
    public const string DigitExpected = "Digit expected";
    public const string SyntaxError = "Syntax error";
    public const string TokenExpected = "{0} expected";
    public const string ParseExceptionFormat = "{0} (at index {1})";
    public const string ColonExpected = "':' expected";
    public const string OpenParenExpected = "'(' expected";
    public const string CloseParenOrOperatorExpected = "')' or operator expected";
    public const string CloseParenOrCommaExpected = "')' or ',' expected";
    public const string DotOrOpenParenExpected = "'.' or '(' expected";
    public const string OpenBracketExpected = "'[' expected";
    public const string CloseBracketOrCommaExpected = "']' or ',' expected";
    public const string IdentifierExpected = "Identifier expected";
  }
}

Hello @ido-ran,

Could you please tell me what license is attached to this gist?
Or if it's taken from somewhere else, could you tell me what the original source is?

Thanks in advance! 😊

The following code is licensed under MIT license.

Thank you very much, Ido! :)