public static LoopExpression InsertAssignment( this LoopExpression loop, int insertIndex, ParameterExpression variable, Expression value) { var loopBody = (BlockExpression)loop.Body; var loopBodyExpressions = new Expression[loopBody.Expressions.Count + 1]; var expressionOffset = 0; for (var i = 0; i < loopBodyExpressions.Length; i++) { if (i != insertIndex) { loopBodyExpressions[i] = loopBody.Expressions[i - expressionOffset]; continue; } loopBodyExpressions[i] = variable.AssignTo(value); expressionOffset = 1; } loopBody = loopBody.Update(loopBody.Variables.Append(variable), loopBodyExpressions); return(loop.Update(loop.BreakLabel, loop.ContinueLabel, loopBody)); }
public Expression Adapt(LoopExpression loop) { loop = loop .InsertAssignment(Constants.BeforeLoopExitCheck, _dictionaryVariables.Key, _targetElementKey) .InsertAssignment(Constants.BeforeLoopExitCheck, _targetElementKey, _targetMemberKey); var loopBody = (BlockExpression)loop.Body; IList <ParameterExpression> loopVariables = loopBody.Variables; if (_elementKeyExists != null) { loopVariables = loopVariables.Append(_elementKeyExists); } if (ReferenceEquals(loopVariables, loopBody.Variables)) { return(loop); } loopBody = loopBody.Update(loopVariables, loopBody.Expressions); loop = loop.Update(loop.BreakLabel, loop.ContinueLabel, loopBody); return(loop); }
public Expression Adapt(LoopExpression loop) { loop = loop.InsertAssignment(Constants.BeforeLoopExitCheck, _targetElementKey, _targetMemberKey); var loopBody = (BlockExpression)loop.Body; var loopVariables = new List <ParameterExpression>(loopBody.Variables); if (_elementKeyExists != null) { loopVariables.Add(_elementKeyExists); if (PerformElementChecks && !MapperData.IsRoot) { loopVariables.Add(_dictionaryVariables.Key); } } if (loopVariables.Count == loopBody.Variables.Count) { return(loop); } loopBody = loopBody.Update(loopVariables, loopBody.Expressions); loop = loop.Update(loop.BreakLabel, loop.ContinueLabel, loopBody); return(loop); }
protected override Expression VisitLoop(LoopExpression node) { PushLabelInfo(node); var body = Visit(node.Body); PopLabelInfo(out LabelTarget @break, out LabelTarget @continue); return(node.Update(@break, @continue, body)); }
protected override Expression VisitLoop(LoopExpression node) { Write("for"); WriteSpace(); Write("("); Write(";"); Write(";"); Write(")"); WriteLine(); var result = node.Update(node.BreakLabel, node.ContinueLabel, VisitAsBlock(node.Body)); WriteLine(); return(result); }
private Expression UpdateIndexAccessLoop( LoopExpression loop, ParameterExpression sourceElement) { var loopBody = (BlockExpression)loop.Body; var loopBodyExpressions = new List <Expression>(loopBody.Expressions); const int LOOP_EXIT_CHECK_INDEX = 0; var sourceElementAssignment = Expression.Assign(sourceElement, GetIndexedElementAccess()); loopBodyExpressions.Insert(LOOP_EXIT_CHECK_INDEX + 1, sourceElementAssignment); loopBody = loopBody.Update(loopBody.Variables.Concat(sourceElement), loopBodyExpressions); return(loop.Update(loop.BreakLabel, loop.ContinueLabel, loopBody)); }
public static LoopExpression InsertAssignment( this LoopExpression loop, int insertIndex, ParameterExpression variable, Expression value) { var loopBody = (BlockExpression)loop.Body; var loopBodyExpressions = new List <Expression>(loopBody.Expressions); var variableAssignment = variable.AssignTo(value); loopBodyExpressions.Insert(insertIndex, variableAssignment); loopBody = loopBody.Update(loopBody.Variables.Append(variable), loopBodyExpressions); return(loop.Update(loop.BreakLabel, loop.ContinueLabel, loopBody)); }
public T?Simplify <T>(T?expression) where T : Expression { if (expression is null) { return(null); } Expression expr = expression.Reduce() switch { UnaryExpression unaryExpr => unaryExpr.Update(Simplify(unaryExpr.Operand)), BinaryExpression binaryExpr => binaryExpr.Update(Simplify(binaryExpr.Left), binaryExpr.Conversion, Simplify(binaryExpr.Right)), LambdaExpression lambdaExpr => Expression.Lambda(Simplify(lambdaExpr.Body), lambdaExpr.Name, lambdaExpr.TailCall, Simplify(lambdaExpr.Parameters)), TryExpression tryExpr => tryExpr.Update(Simplify(tryExpr.Body), Simplify(tryExpr.Handlers), Simplify(tryExpr.Finally), Simplify(tryExpr.Fault)), NewExpression newExpr => newExpr.Update(Simplify(newExpr.Arguments)), GotoExpression gotoExpr => gotoExpr.Update(gotoExpr.Target, Simplify(gotoExpr.Value)), LoopExpression loopExpr => loopExpr.Update(loopExpr.BreakLabel, loopExpr.ContinueLabel, Simplify(loopExpr.Body)), BlockExpression blockExpr => blockExpr.Update(Simplify(blockExpr.Variables), Simplify(blockExpr.Expressions)), IndexExpression indexExpr => indexExpr.Update(Simplify(indexExpr.Object) !, Simplify(indexExpr.Arguments)), LabelExpression labelExpr => labelExpr.Update(labelExpr.Target, Simplify(labelExpr.DefaultValue)), MemberExpression memberExpr => memberExpr.Update(Simplify(memberExpr.Expression)), SwitchExpression switchExpr => switchExpr.Update(Simplify(switchExpr.SwitchValue), Simplify(switchExpr.Cases), Simplify(switchExpr.DefaultBody)), DynamicExpression dynamicExpr => dynamicExpr.Update(Simplify(dynamicExpr.Arguments)), ListInitExpression listInitExpr => listInitExpr.Update(Simplify(listInitExpr.NewExpression), Simplify(listInitExpr.Initializers)), NewArrayExpression newArrayExpr => newArrayExpr.Update(Simplify(newArrayExpr.Expressions)), InvocationExpression invokeExpr => invokeExpr.Update(Simplify(invokeExpr.Expression), Simplify(invokeExpr.Arguments)), MemberInitExpression memberInitExpr => memberInitExpr.Update(Simplify(memberInitExpr.NewExpression), memberInitExpr.Bindings), MethodCallExpression methodCallExpr => methodCallExpr.Update(Simplify(methodCallExpr.Object), Simplify(methodCallExpr.Arguments)), TypeBinaryExpression typeBinaryExpr => typeBinaryExpr.Update(Simplify(typeBinaryExpr.Expression)), ConditionalExpression condExpr => condExpr.Update(Simplify(condExpr.Test), Simplify(condExpr.IfTrue), Simplify(condExpr.IfFalse)), RuntimeVariablesExpression runtimeVarExpr => runtimeVarExpr.Update(Simplify(runtimeVarExpr.Variables)), _ => expression }; foreach (var transform in transformers) { expr = transform.Transform(expr, this); } return((T)expr); }
/// <summary> /// Visits the children of the <see cref="LoopExpression" />. /// </summary> /// <param name="node">The expression to visit.</param> /// <returns>The modified expression, if it or any subexpression was modified; /// otherwise, returns the original expression.</returns> protected internal virtual Expression VisitLoop(LoopExpression node) { return(node.Update(VisitLabelTarget(node.BreakLabel), VisitLabelTarget(node.ContinueLabel), Visit(node.Body))); }
public void UpdateDifferentContinueIsDifferent() { LoopExpression loop = Expression.Loop(Expression.Empty(), Expression.Label(), Expression.Label()); Assert.NotSame(loop, loop.Update(loop.BreakLabel, Expression.Label(), loop.Body)); }
public void UpdateSameIsSame() { LoopExpression loop = Expression.Loop(Expression.Empty(), Expression.Label(), Expression.Label()); Assert.Same(loop, loop.Update(loop.BreakLabel, loop.ContinueLabel, loop.Body)); }
private static Expression SetChildren(ReadOnlySpan <Expression> newChildren, LoopExpression l) => l.Update(l.BreakLabel, l.ContinueLabel, newChildren[0]);
/// <summary> /// Visits the children of the <see cref="LoopExpression"/>. /// </summary> /// <param name="node">The expression to visit.</param> /// <returns>The modified expression, if it or any subexpression was modified; /// otherwise, returns the original expression.</returns> protected override Expression VisitLoop(LoopExpression node) { return(node.Update(VisitLabelTarget(node.BreakLabel), VisitLabelTarget(node.ContinueLabel), Visit(node.Body))); }
LoopExpression Convert(LoopExpression expr) { return(expr.Update(expr.BreakLabel, expr.ContinueLabel, Process(expr.Body))); }
protected virtual Expression VisitLoop(LoopExpression node, Type expectedType) => node.Update(VisitLabelTarget(node.BreakLabel, expectedType), VisitLabelTarget(node.ContinueLabel, expectedType), Visit(node.Body, node.Type));