public void Invoke_Compile2()
{
var invoke = MethodInfoOf((D f) => f.Invoke(default(int), default(int)));
var parameters = invoke.GetParameters();
var parameterArg1 = parameters[0];
var parameterArg2 = parameters[1];
var valueArg1 = Expression.Constant(1);
var valueArg2 = Expression.Constant(2);
var function = Expression.Constant(new D((x, y) => x + y));
AssertCompile <int>(log =>
CSharpExpression.Invoke(log(function, "F"),
CSharpExpression.Bind(parameterArg1, log(valueArg1, "1")),
CSharpExpression.Bind(parameterArg2, log(valueArg2, "2"))
),
new LogAndResult <int> {
Value = 1 + 2, Log = { "F", "1", "2" }
}
);
AssertCompile <int>(log =>
CSharpExpression.Invoke(log(function, "F"),
CSharpExpression.Bind(parameterArg1, log(valueArg1, "1"))
),
new LogAndResult <int> {
Value = 1 + 42, Log = { "F", "1" }
}
);
}
public void Index_Factory_CanUseMethod()
{
var substringMethod = MethodInfoOf((S s) => s[default(int), default(int)]);
var substringProperty = PropertyInfoOf((S s) => s[default(int), default(int)]);
var parameters = substringMethod.GetParameters();
var startIndexParameter = parameters[0];
var lengthParameter = parameters[1];
var obj = Expression.Constant(new S("foobar"));
var startIndex = Expression.Constant(1);
var length = Expression.Constant(2);
var argStartIndex = CSharpExpression.Bind(startIndexParameter, startIndex);
var argLength = CSharpExpression.Bind(lengthParameter, length);
var expr1 = CSharpExpression.Index(obj, substringMethod, argStartIndex, argLength);
Assert.AreEqual(substringProperty, expr1.Indexer);
AssertCompile <string>(_ => expr1, new LogAndResult <string> {
Value = "foobar".Substring(1, 2)
});
var expr2 = CSharpExpression.Index(obj, substringMethod, new[] { argStartIndex, argLength }.AsEnumerable());
Assert.AreEqual(substringProperty, expr2.Indexer);
AssertCompile <string>(_ => expr2, new LogAndResult <string> {
Value = "foobar".Substring(1, 2)
});
}
public void MethodCall_Compile_Instance()
{
var method = MethodInfoOf((string s) => s.Substring(default(int), default(int)));
var parameters = method.GetParameters();
var parameterStartIndex = parameters[0];
var parameterLength = parameters[1];
var obj = Expression.Constant("foobar");
var valueStartIndex = Expression.Constant(1);
var valueLength = Expression.Constant(2);
AssertCompile <string>(log =>
CSharpExpression.Call(log(obj, "O"), method,
CSharpExpression.Bind(parameterStartIndex, log(valueStartIndex, "S")),
CSharpExpression.Bind(parameterLength, log(valueLength, "L"))
),
new LogAndResult <string> {
Value = "foobar".Substring(1, 2), Log = { "O", "S", "L" }
}
);
AssertCompile <string>(log =>
CSharpExpression.Call(log(obj, "O"), method,
CSharpExpression.Bind(parameterLength, log(valueLength, "L")),
CSharpExpression.Bind(parameterStartIndex, log(valueStartIndex, "S"))
),
new LogAndResult <string> {
Value = "foobar".Substring(1, 2), Log = { "O", "L", "S" }
}
);
}
public void MethodCall_Compile_ByRef_Array3()
{
var method = MethodInfoOf((int x) => int.TryParse("", out x));
var parameters = method.GetParameters();
var parameterX = parameters[0];
var parameterY = parameters[1];
var valueX = Expression.Constant("42");
var valueY = Expression.Parameter(typeof(int));
var array = Expression.Parameter(typeof(int[, ]));
var newArray = Expression.Assign(array, Expression.NewArrayBounds(typeof(int), Expression.Constant(1), Expression.Constant(1)));
var element = Expression.ArrayIndex(array, Expression.Constant(0), Expression.Constant(0));
AssertCompile <int>(log =>
Expression.Block(new[] { array },
newArray,
CSharpExpression.Call(method,
CSharpExpression.Bind(parameterY, element),
CSharpExpression.Bind(parameterX, log(valueX, "S"))
),
element
),
new LogAndResult <int> {
Value = 42, Log = { "S" }
}
);
}
public void ParameterAssignment_Properties()
{
var method = typeof(C).GetMethod("F");
var parameter = method.GetParameters()[0];
var expr = Expression.Constant(42);
{
var res = CSharpExpression.Bind(parameter, expr);
Assert.AreSame(parameter, res.Parameter);
Assert.AreSame(expr, res.Expression);
}
{
var res = CSharpExpression.Bind(method, parameter.Name, expr);
Assert.AreSame(parameter, res.Parameter);
Assert.AreSame(expr, res.Expression);
}
{
var res = CSharpExpression.Bind(method, 0, expr);
Assert.AreSame(parameter, res.Parameter);
Assert.AreSame(expr, res.Expression);
}
}
public void New_Update()
{
var ctor = ConstructorInfoOf(() => new TimeSpan(default(int), default(int), default(int)));
var parameters = ctor.GetParameters();
var hoursParameter = parameters[0];
var minutesParameter = parameters[1];
var secondsParameter = parameters[2];
var hours = Expression.Constant(1);
var minutes = Expression.Constant(2);
var seconds = Expression.Constant(3);
var arg0 = CSharpExpression.Bind(hoursParameter, hours);
var arg1 = CSharpExpression.Bind(minutesParameter, minutes);
var arg2 = CSharpExpression.Bind(secondsParameter, seconds);
var res = CSharpExpression.New(ctor, arg0, arg1, arg2);
var upd1 = res.Update(res.Arguments);
Assert.AreSame(upd1, res);
var upd2 = res.Update(new[] { arg1, arg0, arg2 });
Assert.AreNotSame(upd2, res);
Assert.IsTrue(upd2.Arguments.SequenceEqual(new[] { arg1, arg0, arg2 }));
}
public void ConditionalCall_Compile_Extension()
{
var reverse = MethodInfoOf(() => Ext.Reverse(default(string)));
var reverseSubstring = MethodInfoOf(() => Ext.ReverseSubstring(default(string), default(int), default(int)));
var p = Expression.Parameter(typeof(string));
var q = "foobar";
var m1 = CSharpExpression.ConditionalCall(p, reverse);
var f1 = Expression.Lambda <Func <string, string> >(m1, p);
var d1 = f1.Compile();
Assert.AreEqual("raboof", d1(q));
Assert.IsNull(d1(null));
var m2 = CSharpExpression.ConditionalCall(p, reverseSubstring, new[] { Expression.Constant(2), Expression.Constant(3) });
var f2 = Expression.Lambda <Func <string, string> >(m2, p);
var d2 = f2.Compile();
Assert.AreEqual("abo", d2(q));
Assert.IsNull(d2(null));
var ps = reverseSubstring.GetParameters();
var m3 = CSharpExpression.ConditionalCall(p, reverseSubstring, CSharpExpression.Bind(ps[2], Expression.Constant(3)), CSharpExpression.Bind(ps[1], Expression.Constant(2)));
var f3 = Expression.Lambda <Func <string, string> >(m3, p);
var d3 = f3.Compile();
Assert.AreEqual("abo", d3(q));
Assert.IsNull(d3(null));
}
public void ParameterAssignment_Factory_ArgumentChecking()
{
var method = typeof(C).GetMethod("F");
var parameter = method.GetParameters()[0];
var name = parameter.Name;
var expr = Expression.Constant(42);
// null
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Bind(default(ParameterInfo), expr));
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Bind(parameter, default(Expression)));
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Bind(default(MethodInfo), name, expr));
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Bind(method, default(string), expr));
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Bind(method, name, default(Expression)));
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Bind(default(MethodInfo), 0, expr));
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Bind(method, 0, default(Expression)));
// can't find
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Bind(method, "y", expr));
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Bind(method, -1, expr));
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Bind(method, 1, expr));
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Bind(method, 2, expr));
// type mismatch
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Bind(parameter, Expression.Constant("bar")));
}
public void ConditionalCall_Update()
{
var baz = MethodInfoOf((Bar b) => b.Baz(default(int)));
var parameter = baz.GetParameters()[0];
var obj = Expression.Default(typeof(Bar));
var value = Expression.Constant(0);
var arg = CSharpExpression.Bind(parameter, value);
var res = CSharpExpression.ConditionalCall(obj, baz, arg);
Assert.AreSame(res, res.Update(res.Object, res.Arguments));
var obj1 = Expression.Default(typeof(Bar));
var upd1 = res.Update(obj1, res.Arguments);
Assert.AreNotSame(upd1, res);
Assert.AreSame(res.Arguments, upd1.Arguments);
Assert.AreSame(obj1, upd1.Object);
var upd2 = res.Update(obj, new[] { arg });
Assert.AreNotSame(upd2, res);
Assert.AreSame(res.Object, upd2.Object);
Assert.IsTrue(upd2.Arguments.SequenceEqual(new[] { arg }));
}
public void ConditionalIndex_Compile_Val()
{
var px = Expression.Parameter(typeof(QuzX?));
var qx = new QuzX();
var ix = typeof(QuzX).GetProperty("Item");
var ax = CSharpExpression.Bind(ix.GetIndexParameters()[0], Expression.Constant(0));
var mx = CSharpExpression.ConditionalIndex(px, ix, ax);
var fx = Expression.Lambda <Func <QuzX?, int?> >(mx, px);
var dx = fx.Compile();
Assert.AreEqual(42, dx(qx));
Assert.IsNull(dx(null));
var pn = Expression.Parameter(typeof(QuzN?));
var qn = new QuzN();
var jn = typeof(QuzN).GetProperty("Item");
var an = CSharpExpression.Bind(jn.GetIndexParameters()[0], Expression.Constant(0));
var mn = CSharpExpression.ConditionalIndex(pn, jn, an);
var fn = Expression.Lambda <Func <QuzN?, int?> >(mn, pn);
var dn = fn.Compile();
Assert.AreEqual(42, dn(qn));
Assert.IsNull(dn(null));
var ps = Expression.Parameter(typeof(QuzS?));
var qs = new QuzS();
var js = typeof(QuzS).GetProperty("Item");
var bs = CSharpExpression.Bind(js.GetIndexParameters()[0], Expression.Constant(0));
var ms = CSharpExpression.ConditionalIndex(ps, js, bs);
var fs = Expression.Lambda <Func <QuzS?, string> >(ms, ps);
var ds = fs.Compile();
Assert.AreEqual("bar", ds(qs));
Assert.IsNull(ds(null));
}
public void ConditionalIndex_Update()
{
var item = PropertyInfoOf((Bar b) => b[default(int)]);
var parameters = item.GetIndexParameters();
var parameter = parameters[0];
var obj = Expression.Default(typeof(Bar));
var index = Expression.Constant(0);
var arg = CSharpExpression.Bind(parameter, index);
var res = CSharpExpression.ConditionalIndex(obj, item, arg);
Assert.AreSame(res, res.Update(res.Object, res.Arguments));
var obj1 = Expression.Default(typeof(Bar));
var upd1 = res.Update(obj1, res.Arguments);
Assert.AreNotSame(upd1, res);
Assert.AreSame(res.Arguments, upd1.Arguments);
Assert.AreSame(obj1, upd1.Object);
var upd2 = res.Update(obj, new[] { arg });
Assert.AreNotSame(upd2, res);
Assert.AreSame(res.Object, upd2.Object);
Assert.IsTrue(upd2.Arguments.SequenceEqual(new[] { arg }));
}
public void Invoke_Properties()
{
var invoke = MethodInfoOf((Func <int, int, int> f) => f.Invoke(default(int), default(int)));
var parameters = invoke.GetParameters();
var arg1Parameter = parameters[0];
var arg2Parameter = parameters[1];
var arg1Value = Expression.Constant(0);
var arg2Value = Expression.Constant(1);
var arg0 = CSharpExpression.Bind(arg1Parameter, arg1Value);
var arg1 = CSharpExpression.Bind(arg2Parameter, arg2Value);
var function = Expression.Constant(new Func <int, int, int>((x, y) => x + y));
{
var res = CSharpExpression.Invoke(function, arg0, arg1);
Assert.AreEqual(CSharpExpressionType.Invoke, res.CSharpNodeType);
Assert.AreSame(function, res.Expression);
Assert.AreEqual(typeof(int), res.Type);
Assert.IsTrue(res.Arguments.SequenceEqual(new[] { arg0, arg1 }));
}
{
var res = CSharpExpression.Invoke(function, new[] { arg0, arg1 }.AsEnumerable());
Assert.AreEqual(CSharpExpressionType.Invoke, res.CSharpNodeType);
Assert.AreSame(function, res.Expression);
Assert.AreEqual(typeof(int), res.Type);
Assert.IsTrue(res.Arguments.SequenceEqual(new[] { arg0, arg1 }));
}
}
public void Invoke_Update()
{
var invoke = MethodInfoOf((Func <int, int, int> f) => f.Invoke(default(int), default(int)));
var parameters = invoke.GetParameters();
var arg1Parameter = parameters[0];
var arg2Parameter = parameters[1];
var arg1Value = Expression.Constant(0);
var arg2Value = Expression.Constant(1);
var arg0 = CSharpExpression.Bind(arg1Parameter, arg1Value);
var arg1 = CSharpExpression.Bind(arg2Parameter, arg2Value);
var function = Expression.Constant(new Func <int, int, int>((x, y) => x + y));
var res = CSharpExpression.Invoke(function, arg0, arg1);
var function1 = Expression.Constant(new Func <int, int, int>((x, y) => x + y));
var upd1 = res.Update(function1, res.Arguments);
Assert.AreNotSame(upd1, res);
Assert.AreSame(res.Arguments, upd1.Arguments);
Assert.AreSame(function1, upd1.Expression);
var upd2 = res.Update(function, new[] { arg1, arg0 });
Assert.AreNotSame(upd2, res);
Assert.AreSame(res.Expression, upd2.Expression);
Assert.IsTrue(upd2.Arguments.SequenceEqual(new[] { arg1, arg0 }));
}
public void MethodCall_Compile_ByRef_Property()
{
var method = MethodInfoOf((int x) => int.TryParse("", out x));
var parameters = method.GetParameters();
var parameterX = parameters[0];
var parameterY = parameters[1];
var valueX = Expression.Constant("42");
var valueY = Expression.Parameter(typeof(int));
var box = Expression.Parameter(typeof(MyBox <int>));
var newBox = Expression.Assign(box, Expression.New(box.Type));
var boxValue = Expression.Property(box, "Value");
AssertCompile <int>(log =>
Expression.Block(new[] { box },
newBox,
CSharpExpression.Call(method,
CSharpExpression.Bind(parameterY, boxValue),
CSharpExpression.Bind(parameterX, log(valueX, "S"))
),
boxValue
),
new LogAndResult <int> {
Value = 42, Log = { "S" }
}
);
}
public void MethodCall_Compile_ByRef_Index()
{
var method = MethodInfoOf((int x) => int.TryParse("", out x));
var parameters = method.GetParameters();
var parameterX = parameters[0];
var parameterY = parameters[1];
var valueX = Expression.Constant("42");
var valueY = Expression.Parameter(typeof(int));
var list = Expression.Parameter(typeof(List <int>));
var newList = Expression.Assign(list, Expression.ListInit(Expression.New(typeof(List <int>)), Expression.Constant(1)));
var element = Expression.MakeIndex(list, typeof(List <int>).GetProperty("Item"), new[] { Expression.Constant(0) });
AssertCompile <int>(log =>
Expression.Block(new[] { list },
newList,
CSharpExpression.Call(method,
CSharpExpression.Bind(parameterY, element),
CSharpExpression.Bind(parameterX, log(valueX, "S"))
),
element
),
new LogAndResult <int> {
Value = 42, Log = { "S" }
}
);
}
public void MethodCall_Update()
{
var substring = MethodInfoOf((string s) => s.Substring(default(int), default(int)));
var parameters = substring.GetParameters();
var startIndexParameter = parameters[0];
var lengthParameter = parameters[1];
var obj = Expression.Constant("bar");
var startIndex = Expression.Constant(0);
var length = Expression.Constant(1);
var arg0 = CSharpExpression.Bind(startIndexParameter, startIndex);
var arg1 = CSharpExpression.Bind(lengthParameter, length);
var res = CSharpExpression.Call(obj, substring, arg0, arg1);
Assert.AreSame(res, res.Update(res.Object, res.Arguments));
var obj1 = Expression.Constant("foo");
var upd1 = res.Update(obj1, res.Arguments);
Assert.AreNotSame(upd1, res);
Assert.AreSame(res.Arguments, upd1.Arguments);
Assert.AreSame(obj1, upd1.Object);
var upd2 = res.Update(obj, new[] { arg1, arg0 });
Assert.AreNotSame(upd2, res);
Assert.AreSame(res.Object, upd2.Object);
Assert.IsTrue(upd2.Arguments.SequenceEqual(new[] { arg1, arg0 }));
}
public void MethodCall_Properties_Static()
{
var min = MethodInfoOf(() => Math.Min(default(int), default(int)));
var parameters = min.GetParameters();
var val1Parameter = parameters[0];
var val2Parameter = parameters[1];
var val1 = Expression.Constant(0);
var val2 = Expression.Constant(1);
var arg0 = CSharpExpression.Bind(val1Parameter, val1);
var arg1 = CSharpExpression.Bind(val2Parameter, val2);
{
var res = CSharpExpression.Call(min, arg0, arg1);
Assert.AreEqual(CSharpExpressionType.Call, res.CSharpNodeType);
Assert.IsNull(res.Object);
Assert.AreEqual(min, res.Method);
Assert.AreEqual(typeof(int), res.Type);
Assert.IsTrue(res.Arguments.SequenceEqual(new[] { arg0, arg1 }));
}
{
var res = CSharpExpression.Call(min, new[] { arg0, arg1 }.AsEnumerable());
Assert.AreEqual(CSharpExpressionType.Call, res.CSharpNodeType);
Assert.IsNull(res.Object);
Assert.AreEqual(min, res.Method);
Assert.AreEqual(typeof(int), res.Type);
Assert.IsTrue(res.Arguments.SequenceEqual(new[] { arg0, arg1 }));
}
}
public void AssignUnary_CSharpIndex_Compile()
{
var toString = MethodInfoOf((int a) => a.ToString());
foreach (var n in new[]
{
CSharpExpressionType.PreIncrementAssign,
CSharpExpressionType.PreIncrementAssignChecked,
CSharpExpressionType.PreDecrementAssign,
CSharpExpressionType.PreDecrementAssignChecked,
CSharpExpressionType.PostIncrementAssign,
CSharpExpressionType.PostIncrementAssignChecked,
CSharpExpressionType.PostDecrementAssign,
CSharpExpressionType.PostDecrementAssignChecked,
})
{
var inc = n.ToString().Contains("Inc");
var pre = n.ToString().Contains("Pre");
var exp = new string[2];
exp[0] = inc ? "42" : "40";
exp[1] = pre ? exp[0] : "41";
AssertCompile((log, append) =>
{
var h = Expression.Parameter(typeof(Holder <int>));
var y = Expression.Parameter(typeof(int));
var item = typeof(Holder <int>).GetProperty("Item");
var pars = item.GetIndexParameters();
var index =
CSharpExpression.Index(
h,
item,
new[]
{
CSharpExpression.Bind(pars[1], Expression.Block(log("I1"), Expression.Constant(2))),
CSharpExpression.Bind(pars[0], Expression.Block(log("I2"), Expression.Constant(1))),
}
);
var field = Expression.Field(h, typeof(Holder <int>).GetField("_value"));
return
(Expression.Block(
new[] { h, y },
Expression.Assign(h, Expression.New(h.Type.GetConstructors()[0], append, Expression.Constant(41))),
Expression.Assign(y, CSharpExpression.MakeUnaryAssign(n, index, null)),
Expression.Invoke(append, Expression.Call(field, toString)),
Expression.Invoke(append, Expression.Call(y, toString))
));
}, new LogAndResult <object> {
Log = { "I1", "I2", "GI", "SI", exp[0], exp[1] }
});
}
}
public void MethodCall_Compile_Static()
{
var method = MethodInfoOf(() => F(default(int), default(int), default(int)));
var parameters = method.GetParameters();
var parameterX = parameters[0];
var parameterY = parameters[1];
var parameterZ = parameters[2];
var valueX = Expression.Constant(1);
var valueY = Expression.Constant(2);
var valueZ = Expression.Constant(3);
AssertCompile <int>(log =>
CSharpExpression.Call(method,
CSharpExpression.Bind(parameterX, log(valueX, "X")),
CSharpExpression.Bind(parameterY, log(valueY, "Y"))
),
new LogAndResult <int> {
Value = F(1, 2), Log = { "X", "Y" }
}
);
AssertCompile <int>(log =>
CSharpExpression.Call(method,
CSharpExpression.Bind(parameterY, log(valueY, "Y")),
CSharpExpression.Bind(parameterX, log(valueX, "X"))
),
new LogAndResult <int> {
Value = F(1, 2), Log = { "Y", "X" }
}
);
AssertCompile <int>(log =>
CSharpExpression.Call(method,
CSharpExpression.Bind(parameterY, log(valueY, "Y")),
CSharpExpression.Bind(parameterX, log(valueX, "X")),
CSharpExpression.Bind(parameterZ, log(valueZ, "Z"))
),
new LogAndResult <int> {
Value = F(1, 2, 3), Log = { "Y", "X", "Z" }
}
);
AssertCompile <int>(log =>
CSharpExpression.Call(method,
CSharpExpression.Bind(parameterX, log(valueX, "X")),
CSharpExpression.Bind(parameterY, log(valueY, "Y")),
CSharpExpression.Bind(parameterZ, log(valueZ, "Z"))
),
new LogAndResult <int> {
Value = F(1, 2, 3), Log = { "X", "Y", "Z" }
}
);
}
public void MethodCall_Visitor()
{
var cout = MethodInfoOf(() => Console.WriteLine(default(int)));
var valueParameter = cout.GetParameters()[0];
var value = Expression.Constant(42);
var res = CSharpExpression.Call(cout, CSharpExpression.Bind(valueParameter, value));
var v = new V();
Assert.AreSame(res, v.Visit(res));
Assert.IsTrue(v.Visited);
}
public void ParameterAssignment_Factory_CanQuote()
{
var where = MethodInfoOf(() => Queryable.Where(default(IQueryable <int>), default(Expression <Func <int, bool> >)));
var filterParameter = where.GetParameters()[1];
var filter = (Expression <Func <int, bool> >)(i => i < 0);
var res = CSharpExpression.Bind(filterParameter, filter);
Assert.AreEqual(ExpressionType.Quote, res.Expression.NodeType);
Assert.AreSame(filter, ((UnaryExpression)res.Expression).Operand);
}
public void New_Visitor()
{
var ctor = ConstructorInfoOf(() => new TimeSpan(default(long)));
var valueParameter = ctor.GetParameters()[0];
var value = Expression.Constant(42L);
var res = CSharpExpression.New(ctor, CSharpExpression.Bind(valueParameter, value));
var v = new V();
Assert.AreSame(res, v.Visit(res));
Assert.IsTrue(v.Visited);
}
public void ParameterAssignment_Factory_SupportByRef()
{
var exchange = MethodInfoOf((int x) => Interlocked.Exchange(ref x, x));
var refParameter = exchange.GetParameters()[0];
var expr = Expression.Parameter(typeof(int));
var res = CSharpExpression.Bind(refParameter, expr);
Assert.AreSame(refParameter, res.Parameter);
Assert.AreSame(expr, res.Expression);
}
public void Index_Visitor()
{
var listIndex = PropertyInfoOf((List <int> xs) => xs[default(int)]);
var valueParameter = listIndex.GetIndexParameters()[0];
var list = Expression.Constant(new List <int>());
var value = Expression.Constant(42);
var res = CSharpExpression.Index(list, listIndex, CSharpExpression.Bind(valueParameter, value));
var v = new V();
Assert.AreSame(res, v.Visit(res));
Assert.IsTrue(v.Visited);
}
public void ParameterAssignment_Visitor()
{
var method = typeof(C).GetMethod("F");
var parameter = method.GetParameters()[0];
var expr = Expression.Constant(42);
var bind = CSharpExpression.Bind(parameter, expr);
var res = CSharpExpression.Call(method, bind);
var v = new V();
Assert.AreSame(res, v.Visit(res));
Assert.IsTrue(v.Visited);
}
public void MethodCall_Compile_ByRef_MutableStruct2()
{
var y = default(int);
var method = MethodInfoOf((S s) => s.F(default(int), ref y));
var parameters = method.GetParameters();
var parameterX = parameters[0];
var parameterY = parameters[1];
var valueX = Expression.Constant(12);
var valueY = Expression.Parameter(typeof(int));
var value = Expression.Parameter(typeof(StrongBox <S>));
var prop = Expression.Field(value, "Value");
var newValue = Expression.Assign(value, Expression.New(typeof(StrongBox <S>)));
var valueZ = Expression.Field(prop, "Z");
AssertCompile <int>(log =>
Expression.Block(new[] { value, valueY },
newValue,
Expression.Assign(valueY, Expression.Constant(30)),
CSharpExpression.Call(prop, method,
CSharpExpression.Bind(parameterX, valueX),
CSharpExpression.Bind(parameterY, valueY)
),
Expression.Subtract(valueZ, valueY)
),
new LogAndResult <int> {
Value = 0
}
);
AssertCompile <int>(log =>
Expression.Block(new[] { value, valueY },
newValue,
Expression.Assign(valueY, Expression.Constant(30)),
CSharpExpression.Call(prop, method,
CSharpExpression.Bind(parameterY, valueY),
CSharpExpression.Bind(parameterX, valueX)
),
Expression.Subtract(valueZ, valueY)
),
new LogAndResult <int> {
Value = 0
}
);
}
public void ParameterAssignment_Update()
{
var method = typeof(C).GetMethod("F");
var parameter = method.GetParameters()[0];
var expr = Expression.Constant(42);
var res = CSharpExpression.Bind(parameter, expr);
Assert.AreSame(res, res.Update(res.Expression));
var rev = Expression.Constant(43);
var upd = res.Update(rev);
Assert.AreNotSame(res, upd);
Assert.AreSame(rev, upd.Expression);
}
public void New_Factory_ArgumentChecking()
{
// NB: A lot of checks are performed by LINQ helpers, so we omit tests for those cases.
var ctor = ConstructorInfoOf(() => new TimeSpan(default(int), default(int), default(int)));
var parameters = ctor.GetParameters();
var hoursParameter = parameters[0];
var minutesParameter = parameters[1];
var secondsParameter = parameters[2];
var hours = Expression.Constant(1);
var minutes = Expression.Constant(2);
var seconds = Expression.Constant(3);
var argHours = CSharpExpression.Bind(hoursParameter, hours);
var argMinutes = CSharpExpression.Bind(minutesParameter, minutes);
var argSeconds = CSharpExpression.Bind(secondsParameter, seconds);
var ticks = ConstructorInfoOf(() => new TimeSpan(default(long)));
var ticksParameter = ticks.GetParameters()[0];
var value = Expression.Constant(42L);
var argTicks = CSharpExpression.Bind(ticksParameter, value);
// duplicate
AssertEx.Throws <ArgumentException>(() => CSharpExpression.New(ctor, argHours, argHours));
// unbound
AssertEx.Throws <ArgumentException>(() => CSharpExpression.New(ctor, argHours));
// wrong member
AssertEx.Throws <ArgumentException>(() => CSharpExpression.New(ctor, argTicks));
// null
var bindings = new[] { argHours, argMinutes };
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.New(default(ConstructorInfo), bindings));
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.New(default(ConstructorInfo), bindings.AsEnumerable()));
// static ctor
var cctor = typeof(S).GetConstructors(BindingFlags.Static | BindingFlags.NonPublic).Single(c => c.IsStatic);
AssertEx.Throws <ArgumentException>(() => CSharpExpression.New(cctor));
}
public void Index_Factory_ArgumentChecking()
{
// NB: A lot of checks are performed by LINQ helpers, so we omit tests for those cases.
var substring = PropertyInfoOf((S s) => s[default(int), default(int)]);
var parameters = substring.GetIndexParameters();
var startIndexParameter = parameters[0];
var lengthParameter = parameters[1];
var obj = Expression.Constant(new S("bar"));
var startIndex = Expression.Constant(0);
var length = Expression.Constant(1);
var argStartIndex = CSharpExpression.Bind(startIndexParameter, startIndex);
var argLength = CSharpExpression.Bind(lengthParameter, length);
var listIndex = PropertyInfoOf((List <int> xs) => xs[default(int)]);
var valueParameter = listIndex.GetIndexParameters()[0];
var value = Expression.Constant(42);
var argValue = CSharpExpression.Bind(valueParameter, value);
// duplicate
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Index(obj, substring, argStartIndex, argStartIndex));
// unbound
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Index(obj, substring, argLength));
// wrong member
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Index(obj, substring, argValue));
// null
var bindings = new[] { argStartIndex, argLength };
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Index(default(Expression), substring, bindings));
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Index(default(Expression), substring, bindings.AsEnumerable()));
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Index(obj, default(PropertyInfo), bindings));
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Index(obj, default(PropertyInfo), bindings.AsEnumerable()));
// only setter
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Index(Expression.Default(typeof(X)), typeof(X).GetProperty("Item")));
}
public void MethodCall_Factory_ArgumentChecking()
{
// NB: A lot of checks are performed by LINQ helpers, so we omit tests for those cases.
var substring = MethodInfoOf((string s) => s.Substring(default(int), default(int)));
var parameters = substring.GetParameters();
var startIndexParameter = parameters[0];
var lengthParameter = parameters[1];
var obj = Expression.Constant("bar");
var startIndex = Expression.Constant(0);
var length = Expression.Constant(1);
var argStartIndex = CSharpExpression.Bind(startIndexParameter, startIndex);
var argLength = CSharpExpression.Bind(lengthParameter, length);
var cout = MethodInfoOf(() => Console.WriteLine(default(int)));
var valueParameter = cout.GetParameters()[0];
var value = Expression.Constant(42);
var argValue = CSharpExpression.Bind(valueParameter, value);
// duplicate
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Call(obj, substring, argStartIndex, argStartIndex));
// unbound
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Call(obj, substring, argStartIndex));
// wrong member
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Call(obj, substring, argValue));
// null
var bindings = new[] { argStartIndex, argLength };
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Call(default(MethodInfo), bindings));
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Call(default(MethodInfo), bindings.AsEnumerable()));
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Call(obj, default(MethodInfo), bindings));
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Call(obj, default(MethodInfo), bindings.AsEnumerable()));
}
