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