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