protected override Expression VisitIndex(IndexExpression node)
{
switch (node.Object)
{
case BinaryExpression binaryExpression
when binaryExpression.NodeType == ExpressionType.Coalesce:
{
return(Visit(
Expression.Condition(
Expression.NotEqual(binaryExpression.Left, Expression.Constant(null, binaryExpression.Type)),
node.Update(binaryExpression.Left, node.Arguments),
node.Update(binaryExpression.Right, node.Arguments))));
}
case ConditionalExpression conditionalExpression:
{
return(Visit(
conditionalExpression.Update(
conditionalExpression.Test,
node.Update(conditionalExpression.IfTrue, node.Arguments),
node.Update(conditionalExpression.IfFalse, node.Arguments))));
}
default:
{
return(base.VisitIndex(node));
}
}
}
public void UpdateTest()
{
SampleClassWithProperties instance = new SampleClassWithProperties
{
DefaultProperty = new List <int> {
100, 101
},
AlternativeProperty = new List <int> {
200, 201
}
};
IndexExpression expr = instance.DefaultIndexExpression;
MemberExpression newProperty = Expression.Property(Expression.Constant(instance),
typeof(SampleClassWithProperties).GetProperty(nameof(instance.AlternativeProperty)));
ConstantExpression[] newArguments = { Expression.Constant(1) };
IndexExpression exprUpdated = expr.Update(newProperty, newArguments);
// Replace Object and Arguments of IndexExpression.
IndexExpressionHelpers.AssertEqual(
exprUpdated,
Expression.MakeIndex(newProperty, instance.DefaultIndexer, newArguments));
// Invoke to check expression.
IndexExpressionHelpers.AssertInvokeCorrect(100, expr);
IndexExpressionHelpers.AssertInvokeCorrect(201, exprUpdated);
}
protected override Expression VisitIndex(IndexExpression node)
{
var o = Visit(node.Object);
var e = Visit(node.Arguments);
var args = (IList <Expression>)e;
var n = node.Arguments.Count;
var all = Pop(n, out var ess);
var os = _tilingState.Pop();
all &= os;
if (all && CanEvaluate(node.Indexer))
{
_tilingState.Push(true);
}
else
{
_tilingState.Push(false);
EvaluateIf(os, ref o);
EvaluateIf(ess, ref args);
}
return(node.Update(o, args));
}
protected override Expression VisitIndex(IndexExpression node)
{
var @object = Visit(node.Object);
if (@object == null && @object.NodeType != ExpressionType.Constant)
{
return(node.Update(@object, Visit(node.Arguments)));
}
var arguments = new Expression[node.Arguments.Count];
var shouldApply = true;
for (var i = 0; i < arguments.Length; i++)
{
var argument = Visit(node.Arguments[i]);
shouldApply &= argument.NodeType == ExpressionType.Constant;
arguments[i] = argument;
}
if (shouldApply)
{
try
{
var index = new object[arguments.Length];
for (var i = 0; i < index.Length; i++)
{
index[i] = ((ConstantExpression)arguments[i]).Value;
}
return(Expression.Constant(
node.Indexer.GetValue(
((ConstantExpression)@object).Value,
index)));
}
catch
{
// no-op, proceed to update arguments
}
}
return(node.Update(@object, arguments));
}
protected override Expression VisitIndex(IndexExpression node)
{
// Same idea here.
var expr = (node.Object is ParameterExpression)
? Expression.Default(node.Object.Type)
: node.Object;
return(base.Visit(node.Update(expr, node.Arguments)));
}
public void UpdateDifferentArgumentsTest()
{
SampleClassWithProperties instance = new SampleClassWithProperties {
DefaultProperty = new List <int> {
100, 101
}
};
IndexExpression expr = instance.DefaultIndexExpression;
Assert.NotSame(expr, expr.Update(expr.Object, new [] { Expression.Constant(0) }));
}
public void UpdateDoesntRepeatEnumeration()
{
SampleClassWithProperties instance = new SampleClassWithProperties {
DefaultProperty = new List <int> {
100, 101
}
};
IndexExpression expr = instance.DefaultIndexExpression;
Assert.Same(expr, expr.Update(expr.Object, new RunOnceEnumerable <Expression>(instance.DefaultArguments)));
}
public IndexerExpressionNode(IndexExpression expression)
{
_parameter = Expression.Parameter(expression.Object.Type);
_expression = expression.Update(_parameter, expression.Arguments);
_getDelegate = Expression.Lambda(_expression, _parameter).Compile();
var valueParameter = Expression.Parameter(expression.Type);
_setDelegate = Expression.Lambda(Expression.Assign(_expression, valueParameter), _parameter, valueParameter).Compile();
_firstArgumentDelegate = Expression.Lambda(_expression.Arguments[0], _parameter).Compile();
}
protected override Expression VisitIndex(IndexExpression node)
{
Expression obj;
if (_inLval)
{
obj = VisitLVal(node.Object);
}
else
{
obj = Visit(node.Object);
}
var args = VisitArguments(node.Indexer.GetGetMethod(nonPublic: true).GetParameters(), node.Arguments);
return(node.Update(obj, args));
}
public void UpdateSameTest()
{
SampleClassWithProperties instance = new SampleClassWithProperties {
DefaultProperty = new List <int> {
100, 101
}
};
IndexExpression expr = instance.DefaultIndexExpression;
IndexExpression exprUpdated = expr.Update(expr.Object, instance.DefaultArguments);
// Has to be the same, because everything is the same.
Assert.Same(expr, exprUpdated);
// Invoke to check expression.
IndexExpressionHelpers.AssertInvokeCorrect(100, expr);
IndexExpressionHelpers.AssertInvokeCorrect(100, exprUpdated);
}
protected override Expression VisitIndex(IndexExpression node)
{
var visitedObject = Visit(node.Object);
var visitedArguments = Visit(node.Arguments);
if (visitedObject is ConstantExpression objectConstant &&
visitedArguments.All(a => a is ConstantExpression))
{
return(Expression.Constant(
node.Indexer.GetValue(
objectConstant.Value,
visitedArguments
.Cast <ConstantExpression>()
.Select(c => c.Value)
.ToArray())));
}
return(node.Update(visitedObject, visitedArguments));
}
protected override Expression VisitIndex(IndexExpression node)
{
var changed = false;
var arguments = new Expression[node.Arguments.Count];
var i = 0;
foreach (var arg in node.Arguments)
{
var argument = Visit(arg);
arguments[i] = argument;
changed |= argument != arg;
}
var obj = Visit(node.Object);
changed |= obj != node.Object;
if (changed)
{
return(node.Update(obj, arguments));
}
return(node);
}
static IndexExpression MutateIndex(IndexExpression node, IList <Expression> operands)
{
var args = operands.Skip(1);
return(node.Update(operands[0], args));
}
IndexExpression Convert(IndexExpression expr)
{
return(expr.Update(Process(expr.Object), Process(expr.Arguments)));
}
