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)); }