// MethodCallExpression
// TODO: ref parameters!!!
private Expression Rewrite(MethodCallExpression node)
{
Expression instance = RewriteExpression(node.Instance);
ReadOnlyCollection <Expression> args = node.Arguments;
Expression[] clone = null;
Expression[] comma = null;
int ci = 0; // comma array fill index
if (args != null)
{
for (int i = 0; i < args.Count; i++)
{
Expression arg = args[i];
Expression rarg = RewriteExpression(arg);
if ((object)arg != (object)rarg)
{
if (clone == null)
{
clone = new Expression[args.Count];
if (instance != null)
{
comma = new Expression[args.Count + 2]; // + instance + the call
instance = ToTemp(instance, out comma[ci++]);
}
else
{
comma = new Expression[args.Count + 1];
}
for (int j = 0; j < i; j++)
{
clone[j] = ToTemp(args[j], out comma[ci++]);
}
}
}
if (clone != null)
{
clone[i] = ToTemp(rarg, out comma[ci++]);
}
}
}
if (clone != null)
{
comma[ci] = Ast.Call(instance, node.Method, clone);
return(Ast.Comma(comma));
}
else if ((object)instance != (object)node.Instance)
{
return(Ast.Call(
instance,
node.Method,
node.Arguments
));
}
else
{
return(node);
}
}
// CommaExpression
private Expression Rewrite(CommaExpression node)
{
ReadOnlyCollection <Expression> expressions = node.Expressions;
int index = node.ValueIndex;
Expression[] clone = null;
Expression result = null;
for (int i = 0; i < expressions.Count; i++)
{
Expression expression = expressions[i];
Expression rewritten = RewriteExpression(expression);
if ((object)expression != (object)rewritten)
{
if (clone == null)
{
int size = expressions.Count;
// If the result is not at the end of the comma,
// we need an extra element for the result temp.
if (index < expressions.Count - 1)
{
size++;
}
clone = new Expression[size];
for (int j = 0; j < i; j++)
{
Expression expr = expressions[j];
if (j == index)
{
// This expression is not the last (j < i < expressions.Count)
Debug.Assert(j < expressions.Count - 1);
result = ToTemp(expr, out expr);
}
clone[j] = expr;
}
}
}
if (clone != null)
{
if (i == index && index < expressions.Count - 1)
{
result = ToTemp(rewritten, out rewritten);
}
clone[i] = rewritten;
}
}
if (clone != null)
{
if (result != null)
{
Debug.Assert(index < expressions.Count - 1);
Debug.Assert(clone[clone.Length - 1] == null);
clone[clone.Length - 1] = result;
}
return(Ast.Comma(clone));
}
else
{
return(node);
}
}
