public void Await_Factory_AwaitPatternCheck()
{
foreach (var t in new[] { typeof(A1), typeof(A2), typeof(A3) })
{
var getAwaiter = t.GetMethod("GetAwaiter");
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Await(Expression.Default(t)));
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Await(Expression.Default(t), getAwaiter));
if (getAwaiter.IsGenericMethod)
{
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Await(Expression.Default(t), getAwaiter.MakeGenericMethod(typeof(int))));
}
}
foreach (var getAwaiter in this.GetType().GetMethods(BindingFlags.Static | BindingFlags.NonPublic).Where(m => m.Name.StartsWith("GetAwaiterA4")))
{
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Await(Expression.Default(typeof(A4)), getAwaiter));
if (getAwaiter.IsGenericMethod)
{
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Await(Expression.Default(typeof(A4)), getAwaiter.MakeGenericMethod(typeof(int))));
}
}
foreach (var t in new[] { typeof(A4), typeof(A5), typeof(A6), typeof(A7), typeof(A8), typeof(A9), typeof(A10), typeof(A11), typeof(A12) })
{
AssertEx.Throws <ArgumentException>(() => CSharpExpression.Await(Expression.Default(t)));
}
}
static void StackSpilling2()
{
var t = CSharpExpression.Await(CSharpExpression.Await(Expression.Constant(Task.FromResult(Task.FromResult(42)))));
var r = Expression.Add(t, t);
_ = Spiller.Spill(r);
}
public void Await_Factory_ArgumentChecking()
{
var expr = Expression.Default(typeof(Task <int>));
var getAwaiter = expr.Type.GetMethod("GetAwaiter");
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Await(default(Expression)));
AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Await(default(Expression), getAwaiter));
}
public void Await_Properties()
{
var e = Expression.Default(typeof(Task <int>));
var expr = CSharpExpression.Await(e);
Assert.AreEqual(CSharpExpressionType.Await, expr.CSharpNodeType);
Assert.AreSame(e, expr.Operand);
Assert.IsNotNull(expr.GetAwaiterMethod);
}
public void Await_Visitor()
{
var res = CSharpExpression.Await(Expression.Default(typeof(Task <int>)));
var v = new V();
Assert.AreSame(res, v.Visit(res));
Assert.IsTrue(v.Visited);
}
public void Await_CantReduce()
{
var e = Expression.Default(typeof(Task <int>));
var expr = CSharpExpression.Await(e);
Assert.IsFalse(expr.CanReduce);
Assert.AreSame(expr, expr.Reduce());
var f = Expression.Lambda <Func <int> >(expr);
AssertEx.Throws <ArgumentException>(() => f.Compile());
}
public void CSharpExpressionVisitor_NoChange()
{
var visitor = new V();
foreach (var e in new Expression[]
{
Expression.Constant(1),
CSharpExpression.Await(Expression.Default(typeof(Task)))
})
{
Assert.AreSame(e, visitor.Visit(e));
}
}
public void Await_Update()
{
var e = Expression.Default(typeof(Task <int>));
var expr = CSharpExpression.Await(e);
Assert.AreSame(expr, expr.Update(e));
var f = Expression.Default(typeof(Task <int>));
var upd = expr.Update(f);
Assert.AreNotSame(upd, expr);
Assert.AreSame(f, upd.Operand);
}
protected override Expression VisitMember(MemberExpression node)
{
var member = node.Member;
var type = member.DeclaringType;
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Task <>))
{
if (member.Name == "Result")
{
return(CSharpExpression.Await(Visit(node.Expression)));
}
}
return(base.VisitMember(node));
}
public void Spiller_Await()
{
var a = Expression.Constant(Task.FromResult(1));
var b = Expression.Constant(Task.FromResult(2));
var x = CSharpExpression.Await(a);
var y = CSharpExpression.Await(b);
var e = Expression.Add(x, y);
var r = Spiller.Spill(e);
Assert.AreEqual(ExpressionType.Block, r.NodeType);
var si = (BlockExpression)r;
Assert.AreEqual(2, si.Variables.Count);
var sv1 = si.Variables[0];
var sv2 = si.Variables[1];
Assert.AreEqual(1, si.Expressions.Count); // NB: LINQ stack spiller has a spurious block
var si1 = si.Expressions[0];
Assert.AreEqual(ExpressionType.Block, si1.NodeType);
var sb = (BlockExpression)si1;
Assert.AreEqual(3, sb.Expressions.Count);
var se1 = sb.Expressions[0];
var se2 = sb.Expressions[1];
var se3 = sb.Expressions[2];
Assert.AreEqual(ExpressionType.Assign, se1.NodeType);
var sa1 = (BinaryExpression)se1;
Assert.AreSame(sv1, sa1.Left);
//Assert.AreSame(x, sa1.Right); // NB: LINQ stack spiller could clone a child tree; should use an equality comparer here
Assert.AreEqual(ExpressionType.Assign, se2.NodeType);
var sa2 = (BinaryExpression)se2;
Assert.AreSame(sv2, sa2.Left);
//Assert.AreSame(y, sa2.Right); // NB: LINQ stack spiller could clone a child tree; should use an equality comparer here
Assert.AreEqual(ExpressionType.Add, se3.NodeType);
var sa3 = (BinaryExpression)se3;
Assert.AreSame(sv1, sa3.Left);
Assert.AreSame(sv2, sa3.Right);
}
public Expression GetExpression()
{
var expression = expressionInterpreterHandler.GetExpression(awaitStatement.Statement);
return(CSharpExpression.Await(expression));
}
