private Result RewriteIndexAssignment(BinaryExpression node, Stack stack)
{
var index = (IndexExpression)node.Left;
var cr = new ChildRewriter(this, stack, 2 + index.ArgumentCount);
cr.Add(index.Object);
cr.AddArguments(index);
cr.Add(node.Right);
if (cr.Action == RewriteAction.SpillStack)
{
cr.MarkRefInstance(index.Object);
}
if (cr.Rewrite)
{
node = new AssignBinaryExpression(
new IndexExpression(
cr[0], // Object
index.Indexer,
cr[1, -2] ! // arguments
),
cr[-1] ! // value
);
}
return(cr.Finish(node));
}
private Result RewriteMethodCallExpression(Expression expr, Stack stack)
{
MethodCallExpression node = (MethodCallExpression)expr;
var cr = new ChildRewriter(this, stack, node.ArgumentCount + 1);
// For instance methods, the instance executes on the
// stack as is, but stays on the stack, making it non-empty.
cr.Add(node.Object);
cr.AddArguments(node);
if (cr.Action == RewriteAction.SpillStack)
{
cr.MarkRefInstance(node.Object);
cr.MarkRefArgs(node.Method, startIndex: 1);
}
if (cr.Rewrite)
{
if (node.Object != null)
{
expr = new InstanceMethodCallExpressionN(node.Method, cr[0], cr[1, -1]);
}
else
{
expr = new MethodCallExpressionN(node.Method, cr[1, -1]);
}
}
return(cr.Finish(expr));
}
private Result RewriteIndexExpression(Expression expr, Stack stack)
{
var node = (IndexExpression)expr;
var cr = new ChildRewriter(this, stack, node.ArgumentCount + 1);
// For instance methods, the instance executes on the
// stack as is, but stays on the stack, making it non-empty.
cr.Add(node.Object);
cr.AddArguments(node);
if (cr.Action == RewriteAction.SpillStack)
{
cr.MarkRefInstance(node.Object);
}
if (cr.Rewrite)
{
expr = new IndexExpression(
cr[0],
node.Indexer,
cr[1, -1]
);
}
return(cr.Finish(expr));
}
// MethodCallExpression
private Result RewriteMethodCallExpression(Expression expr, Stack stack)
{
MethodCallExpression node = (MethodCallExpression)expr;
ChildRewriter cr = new ChildRewriter(this, stack, node.Arguments.Count + 1);
// For instance methods, the instance executes on the
// stack as is, but stays on the stack, making it non-empty.
cr.Add(node.Object);
cr.AddArguments(node);
if (cr.Action == RewriteAction.SpillStack)
{
#if LINQ
RequireNotRefInstance(node.Object);
RequireNoRefArgs(node.Method);
#else
MarkRefInstance(cr, node.Object);
MarkRefArgs(cr, node.Method, 1);
#endif
}
return(cr.Finish(cr.Rewrite ? node.Rewrite(cr[0], cr[1, -1]) : expr));
}
private Result RewriteDynamicExpression(Expression expr, Stack stack)
{
var node = (IDynamicExpression)expr;
// CallSite is on the stack
ChildRewriter cr = new ChildRewriter(this, Stack.NonEmpty, node.ArgumentCount);
cr.AddArguments(node);
if (cr.Action == RewriteAction.SpillStack)
{
RequireNoRefArgs(node.DelegateType.GetMethod("Invoke"));
}
return(cr.Finish(cr.Rewrite ? node.Rewrite(cr[0, -1]) : expr));
}
private Result RewriteInvocationExpression(Expression expr, Stack stack)
{
var node = (InvocationExpression)expr;
ChildRewriter cr;
// See if the lambda will be inlined.
LambdaExpression lambda = node.LambdaOperand;
if (lambda != null)
{
// Arguments execute on current stack.
cr = new ChildRewriter(this, stack, node.ArgumentCount);
cr.AddArguments(node);
if (cr.Action == RewriteAction.SpillStack)
{
cr.MarkRefArgs(Expression.GetInvokeMethod(node.Expression), startIndex: 0);
}
// Lambda body also executes on current stack.
var spiller = new StackSpiller(stack);
lambda = lambda.Accept(spiller);
if (cr.Rewrite || spiller._lambdaRewrite != RewriteAction.None)
{
node = new InvocationExpressionN(lambda, cr[0, -1], node.Type);
}
Result result = cr.Finish(node);
return(new Result(result.Action | spiller._lambdaRewrite, result.Node));
}
cr = new ChildRewriter(this, stack, node.ArgumentCount + 1);
// First argument starts on stack as provided.
cr.Add(node.Expression);
// Rest of arguments have non-empty stack (the delegate instance is on the stack).
cr.AddArguments(node);
if (cr.Action == RewriteAction.SpillStack)
{
cr.MarkRefArgs(Expression.GetInvokeMethod(node.Expression), startIndex: 1);
}
return(cr.Finish(cr.Rewrite ? new InvocationExpressionN(cr[0], cr[1, -1], node.Type) : expr));
}
private Result RewriteNewExpression(Expression expr, Stack stack)
{
var node = (NewExpression)expr;
// The first expression starts on a stack as provided by parent,
// rest are definitely non-empty (which ChildRewriter guarantees).
var cr = new ChildRewriter(this, stack, node.ArgumentCount);
cr.AddArguments(node);
if (cr.Action == RewriteAction.SpillStack)
{
cr.MarkRefArgs(node.Constructor, startIndex: 0);
}
return(cr.Finish(cr.Rewrite ? new NewExpression(node.Constructor, cr[0, -1], node.Members) : expr));
}
// NewExpression
private Result RewriteNewExpression(Expression expr, Stack stack)
{
NewExpression node = (NewExpression)expr;
// The first expression starts on a stack as provided by parent,
// rest are definitely non-empty (which ChildRewriter guarantees)
ChildRewriter cr = new ChildRewriter(this, stack, node.Arguments.Count);
cr.AddArguments(node);
if (cr.Action == RewriteAction.SpillStack)
{
#if LINQ
RequireNoRefArgs(node.Constructor);
#else
MarkRefArgs(cr, node.Constructor, 0);
#endif
}
return(cr.Finish(cr.Rewrite ? CreateNewExpression(node.Constructor, cr[0, -1], node.Members) : expr));
}