public void ExpressionVisitorGeneric_Simple13()
{
var v = new MyVisitor();
var add = Microsoft.CSharp.RuntimeBinder.Binder.BinaryOperation(
Microsoft.CSharp.RuntimeBinder.CSharpBinderFlags.None,
ExpressionType.Add,
typeof(ExpressionEqualityComparerTests),
new[]
{
Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo.Create(Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags.None, name: null),
Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo.Create(Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags.None, name: null)
}
);
var o = Expression.Dynamic(
add,
typeof(object),
Expression.Constant(1),
Expression.Constant(2)
);
var r = v.Visit(o);
var n = Expression.Dynamic(
add,
typeof(object),
Expression.Constant(2),
Expression.Constant(4)
);
var e = new ExpressionEqualityComparer();
Assert.IsTrue(e.Equals(r, n));
}
public static IDictionary <string, MemberInfo> GetGetters <TIn, TEntity>(Expression <Func <TIn, TEntity> > setValues)
{
var vis = new MyVisitor <TIn, TEntity>();
vis.Visit(setValues);
return(vis.MemberInfos);
}
public void LvalExpressionVisitor_Basics()
{
var visitor = new MyVisitor();
var x = Expression.Parameter(typeof(int), "x");
var xs = Expression.Parameter(typeof(int[]), "xs");
var sb = Expression.Parameter(typeof(StrongBox <int>), "sb");
var m = typeof(Interlocked).GetMethod(nameof(Interlocked.Increment), new[] { typeof(int).MakeByRefType() });
var xs0 = Expression.ArrayAccess(xs, Expression.Constant(0));
var val = Expression.Field(sb, nameof(StrongBox <int> .Value));
var e =
Expression.Block(
Expression.Assign(x, Expression.Constant(1)),
Expression.Assign(xs0, Expression.Constant(1)),
Expression.Call(m, val)
);
var r = visitor.Visit(e);
Assert.AreSame(e, r);
CollectionAssert.AreEqual(
new Expression[] { x, xs0, xs, val, sb },
visitor.Lvals
);
}
public static LambdaExpression ChangeParameterNameImpl(LambdaExpression expression, Func <string, string> selector)
{
var list = new List <KeyValuePair <ParameterExpression, ParameterExpression> >();
var ps = new List <ParameterExpression>();
foreach (var item in expression.Parameters)
{
var after = selector(item.Name);
var exist = list.Where(pair => pair.Value.Name == after).Select(pair => pair.Value).FirstOrDefault();
if (exist != null)
{
if (item.Type != exist.Type)
{
throw new ArgumentException("");
}
list.Add(new KeyValuePair <ParameterExpression, ParameterExpression>(item, exist));
}
else
{
var p = Expression.Parameter(item.Type, after);
list.Add(new KeyValuePair <ParameterExpression, ParameterExpression>(item, p));
ps.Add(p);
}
}
var visitor = new MyVisitor();
visitor.Selector = p => list.Where(pair => pair.Key == p).Select(pair => pair.Value).Single();
return(Expression.Lambda(visitor.Visit(expression.Body), ps));
}
public void DataTypeVisitor_Simple()
{
var mv = new MyVisitor();
Assert.IsNull(mv.Visit(type: null));
foreach (var kv in new Dictionary <Type, Type>
{
{ typeof(int), typeof(long) },
{ typeof(int?), typeof(long?) },
{ typeof(int[]), typeof(long[]) },
{ typeof(List <int>), typeof(List <long>) },
{ typeof(Func <int>), typeof(Func <long>) },
{ typeof(Func <int, bool>), typeof(Func <long, bool>) },
{ typeof(Func <bool, double, int>), typeof(Func <bool, double, long>) },
{ typeof(Tuple <bool, int, double>), typeof(Tuple <bool, long, double>) },
{ typeof(Expression <Func <int> >), typeof(Expression <Func <long> >) },
{ typeof(BinaryExpression), typeof(BinaryExpression) },
})
{
var t = DataType.FromType(kv.Key);
var e = DataType.FromType(kv.Value);
var r = mv.Visit(t);
Assert.AreEqual(e.ToString(), r.ToString());
}
}
static LambdaExpression OrElseImpl(LambdaExpression first, IEnumerable <LambdaExpression> rest)
{
LambdaExpression acc = first;
foreach (var item in rest)
{
var ps = acc.Parameters.Concat(item.Parameters).ToList();
var dups = Helper.DuplicatedParameters(ps);
if (dups.Any())
{
throw new ArgumentException($"Some parameters are same name buf differ type: {dups.First().First().Name}");
}
var visitor = new MyVisitor(ps);
acc = Expression.Lambda(
Expression.OrElse(
visitor.Visit(acc.Body),
visitor.Visit(item.Body)
),
ps.Select(visitor.Selector).MyDistinct()
);
}
return(acc);
}
public void ConditionalClones()
{
var visitor = new MyVisitor();
var v = Throw(Default(typeof(Exception)), typeof(void));
var b1 = Condition(Constant(true), Default(typeof(int)), Default(typeof(int)));
var a1 = visitor.Visit(b1);
Assert.AreNotSame(b1, a1);
var b2 = Condition(Constant(true), Default(typeof(void)), Default(typeof(void)));
var a2 = visitor.Visit(b2);
Assert.AreNotSame(b2, a2);
var b3 = Condition(Default(typeof(bool)), v, Default(typeof(void)));
var a3 = visitor.Visit(b3);
Assert.AreNotSame(b3, a3);
var b4 = Condition(Default(typeof(bool)), Default(typeof(void)), v);
var a4 = visitor.Visit(b4);
Assert.AreNotSame(b4, a4);
}
public void Run()
{
// http://www.umutozel.com/javascript-linq-01
var expList = new List <Expression>();
var calls1 = from exp in expList
where exp.NodeType == ExpressionType.Call
select exp;
// turns into this
var calls2 = expList.Where(e => e.NodeType == ExpressionType.Call);
Action <string> normalLambda = (string message) => Console.WriteLine(message);
// same syntax, compiler magic!
Expression <Action <string> > expressionLambda = (string message) => Console.WriteLine(message);
Console.WriteLine(expressionLambda.ToString());
var visitor = new MyVisitor();
var newExp = (LambdaExpression)visitor.Visit(expressionLambda);
Console.WriteLine(newExp.ToString());
// only Lambda can be compiled
var newAction = (Action <string>)newExp.Compile();
Console.WriteLine(newAction);
newAction("Merhaba");
}
public static IQueryable <T> WhereSpecial <T>(this IQueryable <T> queryable, Expression <Func <T, bool> > expression)
{
MyVisitor visitor = new MyVisitor();
var newBody = visitor.Visit(expression.Body);
expression = expression.Update(newBody, expression.Parameters);
return(queryable.Where(expression));
}
public void Visitor_SomeChange()
{
var visitor = new MyVisitor();
var json = @"{ ""foo"": 123, ""bar"": [ 1, 2, 3 ], ""qux"": 8}";
var res = visitor.Visit(JsonParser.Parse(json));
Assert.AreEqual(@"{""foo"":123,""bar"":[1,1,3],""qux"":4}", res.ToString());
}
public void ExpressionVisitorGeneric_Simple2()
{
var v = new MyVisitor();
var r = v.Visit(Expression.UnaryPlus(Expression.Constant(2)));
var e = new ExpressionEqualityComparer();
Assert.IsTrue(e.Equals(r, Expression.Negate(Expression.Constant(4))));
}
public void ExpressionVisitorGeneric_Simple9()
{
var v = new MyVisitor();
var r = v.Visit(Expression.NewArrayInit(typeof(int), Expression.Constant(2), Expression.Constant(3)));
var e = new ExpressionEqualityComparer();
Assert.IsTrue(e.Equals(r, Expression.NewArrayInit(typeof(int), Expression.Constant(6), Expression.Constant(4))));
}
public void ExpressionVisitorGeneric_Simple1()
{
var v = new MyVisitor();
var r = v.Visit(Expression.Add(Expression.Constant(2), Expression.Constant(3)));
var e = new ExpressionEqualityComparer();
Assert.IsTrue(e.Equals(r, Expression.Subtract(Expression.Constant(4), Expression.Constant(6))));
}
public void ExpressionVisitorGeneric_Simple6()
{
var v = new MyVisitor();
var r = v.Visit(Expression.Condition(Expression.Constant(true), Expression.Constant(2), Expression.Constant(3)));
var e = new ExpressionEqualityComparer();
Assert.IsTrue(e.Equals(r, Expression.Condition(Expression.Constant(false), Expression.Constant(6), Expression.Constant(4))));
}
public void ExpressionVisitorGeneric_Simple5()
{
var v = new MyVisitor();
var r = v.Visit(Expression.TypeIs(Expression.Constant(2), typeof(int)));
var e = new ExpressionEqualityComparer();
Assert.IsTrue(e.Equals(r, Expression.TypeIs(Expression.Constant(4), typeof(string))));
}
public void ExpressionVisitorGeneric_Simple3()
{
var v = new MyVisitor();
var r = v.Visit(Expression.Default(typeof(int)));
var e = new ExpressionEqualityComparer();
Assert.IsTrue(e.Equals(r, Expression.Default(typeof(string))));
}
public void MemberInfoSlimVisitor_Generic_GenericMethod()
{
var visitor = new MyVisitor();
var genDef = SlimType.GetGenericDefinitionMethod("Foo", new TypeSlim[] { TypeSlim.GenericParameter("T") }.ToReadOnly(), EmptyReadOnlyCollection <TypeSlim> .Instance, returnType: null);
var generic = SlimType.GetGenericMethod(genDef, new TypeSlim[] { SlimType }.ToReadOnly());
var res = visitor.Visit(generic);
Assert.AreEqual(42, res);
}
public override double ObtenerValor(Empresa empresa, int periodo, List <ComponenteOperando> listaOperandos)
{
AntlrInputStream input = new AntlrInputStream(this.Formula);
gramaticaLexer lexer = new gramaticaLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
gramaticaParser parser = new gramaticaParser(tokens);
IParseTree tree = parser.expr();
MyVisitor visitor = new MyVisitor(empresa, periodo, listaOperandos);
return(Math.Round(visitor.Visit(tree), 2));
}
public void ExpressionVisitorGeneric_Simple17()
{
var v = new MyVisitor();
var o = (Expression <Func <Bar, int> >)(b => b.Foo);
var r = v.Visit(o);
var n = (Expression <Func <Bar, int> >)(f => f.ooF);
var e = new ExpressionEqualityComparer();
Assert.IsTrue(e.Equals(r, n));
}
public void DataTypeVisitor_Custom()
{
var v = new MyVisitor();
var d = new MyDataType();
var e = v.Visit(d);
Assert.ThrowsException <NotImplementedException>(() => _ = new DataTypeVisitor().Visit(d));
Assert.AreSame(d, e);
Assert.AreEqual(d.ToString(), e.ToString());
}
static void CreateCode()
{
AntlrInputStream input = new AntlrInputStream(File.OpenRead(structurePath));
eRegsGrammarLexer lexer = new eRegsGrammarLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
eRegsGrammarParser parser = new eRegsGrammarParser(tokens);
IParseTree tree = parser.r();
MyVisitor visitor = new MyVisitor();
File.WriteAllText(classPath, visitor.Visit(tree).ToString());
}
public void ExpressionVisitorGeneric_Simple8()
{
var v = new MyVisitor();
var o = (Expression <Func <double, double> >)(x => Math.Sin(x));
var r = v.Visit(o);
var n = (Expression <Func <double, double> >)(x => Math.Cos(x));
var e = new ExpressionEqualityComparer();
Assert.IsTrue(e.Equals(r, n));
}
public void ExpressionVisitorGeneric_Simple19()
{
var v = new MyVisitor();
var o = (Expression <Func <int[, ], int> >)(xs => xs[1, 2]);
var r = v.Visit(o);
var n = (Expression <Func <int[, ], int> >)(xs => xs[4, 2]);
var e = new ExpressionEqualityComparer();
Assert.IsTrue(e.Equals(r, n));
}
public static String compile()
{
var fileName = "C:\\temp\\code.txt";
StreamReader inputStream = new StreamReader(fileName);
AntlrInputStream input = new AntlrInputStream(inputStream.ReadToEnd());
CompilerLexer lexer = new CompilerLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CompilerParser parser = new CompilerParser(tokens);
IParseTree tree = parser.program();
Console.WriteLine(tree.ToStringTree(parser));
var visitor = new MyVisitor();
return createJasminFile(visitor.Visit(tree));
}
public void ExpressionVisitorGeneric_Simple21()
{
var v = new MyVisitor();
var p = Expression.Parameter(typeof(int[, ]));
var o = Expression.ArrayAccess(p, Expression.Constant(1), Expression.Constant(2));
var r = v.Visit(o);
var n = Expression.ArrayAccess(p, Expression.Constant(4), Expression.Constant(2));
var e = new ExpressionEqualityComparer();
Assert.IsTrue(e.Equals(r, n));
}
public void ExpressionVisitorGeneric_Simple16()
{
var v = new MyVisitor();
var p = Expression.Parameter(typeof(Func <int, int, int>));
var o = Expression.Invoke(p, Expression.Constant(1), Expression.Constant(2));
var r = v.Visit(o);
var n = Expression.Invoke(p, Expression.Constant(4), Expression.Constant(2));
var e = new ExpressionEqualityComparer();
Assert.IsTrue(e.Equals(r, n));
}
public void ExpressionVisitorGeneric_Simple14()
{
var v = new MyVisitor();
var l = Expression.Label("ret");
var o = Expression.Return(l, Expression.Constant(2));
var r = v.Visit(o);
var n = Expression.Return(l, Expression.Constant(4));
var e = new ExpressionEqualityComparer();
Assert.IsTrue(e.Equals(r, n));
}
public static void Modify1()
{
var id = 10;
Expression <Func <User, bool> > expr = f => f.Id == id || f.Name == "ss";
Expression <Func <User, bool> > other = u => u.Name == "ds";
var expr2 = Expression.Lambda(expr.Body, Expression.Parameter(expr.Parameters[0].Type, "f2"));
var pm = new ParameterUpdate(expr, "f3");
var expr3 = pm.Visit(expr);
var modifier = new MyVisitor();
expr = (Expression <Func <User, bool> >)modifier.Modify(expr, other);
var fn1 = expr.Compile();
}
public void Visitor_NoChange()
{
var visitor = new MyVisitor();
foreach (var json in new[] {
JsonParser.Parse("17", ensureTopLevelObjectOrArray: false),
JsonParser.Parse("\"foo\"", ensureTopLevelObjectOrArray: false),
JsonParser.Parse("[1, 3, [5, 7], 9]"),
JsonParser.Parse("{ \"foo\": 123, \"bar\": [-1, -3, -5] }"),
})
{
var res = visitor.Visit(json);
Assert.AreSame(json, res);
}
}
public void ExpressionVisitorGeneric_Simple22()
{
var v = new MyVisitor();
var p = Expression.Parameter(typeof(int));
var q = Expression.Parameter(typeof(int));
var o = Expression.RuntimeVariables(p, q);
var r = v.Visit(o);
var n = Expression.RuntimeVariables(q, p);
var e = new ExpressionEqualityComparer();
Assert.IsTrue(e.Equals(r, n));
}
public void ExpressionVisitorGeneric_Simple15()
{
var v = new MyVisitor();
var l = Expression.Label("lbl_o");
var m = Expression.Label("lbl_n");
var o = Expression.Block(Expression.Constant(2), Expression.Goto(l), Expression.Constant(3), Expression.Label(l), Expression.Constant(4));
var r = v.Visit(o);
var n = Expression.Block(Expression.Constant(8), Expression.Label(m), Expression.Constant(6), Expression.Goto(m), Expression.Constant(4));
var e = new ExpressionEqualityComparer();
Assert.IsTrue(e.Equals(r, n));
}
public void TreeVisitor_Trivial()
{
var tree = new Tree <int>(42, new Tree <int>(43), new Tree <int>(44, new Tree <int>(45), new Tree <int>(46)));
var res1 = new MyVisitor().Visit(tree);
var res2 = new MyVisitor <int>().Visit(tree);
var expected = new Tree <int>(42, new Tree <int>(44, new Tree <int>(46), new Tree <int>(45)), new Tree <int>(43));
var eq1 = new TreeEqualityComparer();
var eq2 = new TreeEqualityComparer <int>();
Assert.IsTrue(eq1.Equals(expected, res1));
Assert.IsTrue(eq2.Equals(expected, res2));
}
