public override void VisitForLoopStatement(IForLoopStatement operation)
{
VisitArray(operation.Before);
Visit(operation.Condition);
Visit(operation.Body);
VisitArray(operation.AtLoopBottom);
}
public override void VisitForLoopStatement(IForLoopStatement operation)
{
LogString(nameof(IForLoopStatement));
LogLoopStatementHeader(operation);
Visit(operation.Condition, "Condition");
LogLocals(operation.Locals);
VisitArray(operation.Before, "Before");
VisitArray(operation.AtLoopBottom, "AtLoopBottom");
VisitLoopStatementBody(operation);
}
public override void VisitForLoopStatement(IForLoopStatement operation)
{
var loopKind = operation.LoopKind;
foreach (var local in operation.Locals)
{
// empty loop body, just want to make sure it won't crash.
}
base.VisitForLoopStatement(operation);
}
/// <inheritdoc />
public override Expression VisitForLoopStatement(IForLoopStatement operation, LocalBinder argument)
{
LocalBinder binder = argument.Child();
ImmutableArray <IOperation> before = operation.Before;
Expression[] expressions = new Expression[before.Length + 1];
for (int i = 0; i < before.Length; i++)
{
expressions[i] = before[i].Accept(this, argument);
}
expressions[before.Length] = Expressive.For(
);
return(Expression.Block(
expressions
));
}
public virtual void VisitForLoopStatement(IForLoopStatement operation)
{
DefaultVisit(operation);
}
public virtual void VisitForLoopStatement(IForLoopStatement operation)
{
DefaultVisit(operation);
}
public override void VisitForLoopStatement(IForLoopStatement operation)
{
WalkLoopStatement(operation);
base.VisitForLoopStatement(operation);
}
public static IForLoopStatement Update(this IForLoopStatement self, ImmutableArray <ISymbol> @outerLocals, IOperation @initializer, ImmutableArray <ISymbol> @innerLocals, IOperation @condition, IOperation @increment, IOperation @body, ILabelSymbol @breakLabel, ILabelSymbol @continueLabel) => self;
public override void VisitForLoopStatement([NotNull] IForLoopStatement operation)
{
IncrementStatementCount(operation);
Visit(operation.Body);
}
public sealed override void Initialize(AnalysisContext context)
{
context.RegisterOperationAction(
(operationContext) =>
{
ILoopStatement loop = (ILoopStatement)operationContext.Operation;
if (loop.LoopKind == LoopKind.For)
{
IForLoopStatement forLoop = (IForLoopStatement)loop;
IExpression forCondition = forLoop.Condition;
if (forCondition.Kind == OperationKind.BinaryOperatorExpression)
{
IBinaryOperatorExpression condition = (IBinaryOperatorExpression)forCondition;
IExpression conditionLeft = condition.Left;
IExpression conditionRight = condition.Right;
if (conditionRight.ConstantValue != null &&
conditionRight.ResultType.SpecialType == SpecialType.System_Int32 &&
conditionLeft.Kind == OperationKind.LocalReferenceExpression)
{
// Test is known to be a comparison of a local against a constant.
int testValue = (int)conditionRight.ConstantValue;
ILocalSymbol testVariable = ((ILocalReferenceExpression)conditionLeft).Local;
if (forLoop.Before.Length == 1)
{
IStatement setup = forLoop.Before[0];
if (setup.Kind == OperationKind.ExpressionStatement && ((IExpressionStatement)setup).Expression.Kind == OperationKind.AssignmentExpression)
{
IAssignmentExpression setupAssignment = (IAssignmentExpression)((IExpressionStatement)setup).Expression;
if (setupAssignment.Target.Kind == OperationKind.LocalReferenceExpression &&
((ILocalReferenceExpression)setupAssignment.Target).Local == testVariable &&
setupAssignment.Value.ConstantValue != null &&
setupAssignment.Value.ResultType.SpecialType == SpecialType.System_Int32)
{
// Setup is known to be an assignment of a constant to the local used in the test.
int initialValue = (int)setupAssignment.Value.ConstantValue;
if (forLoop.AtLoopBottom.Length == 1)
{
IStatement advance = forLoop.AtLoopBottom[0];
if (advance.Kind == OperationKind.ExpressionStatement)
{
IExpression advanceExpression = ((IExpressionStatement)advance).Expression;
IExpression advanceIncrement = null;
BinaryOperationKind advanceOperationCode = BinaryOperationKind.None;
if (advanceExpression.Kind == OperationKind.AssignmentExpression)
{
IAssignmentExpression advanceAssignment = (IAssignmentExpression)advanceExpression;
if (advanceAssignment.Target.Kind == OperationKind.LocalReferenceExpression &&
((ILocalReferenceExpression)advanceAssignment.Target).Local == testVariable &&
advanceAssignment.Value.Kind == OperationKind.BinaryOperatorExpression &&
advanceAssignment.Value.ResultType.SpecialType == SpecialType.System_Int32)
{
// Advance is known to be an assignment of a binary operation to the local used in the test.
IBinaryOperatorExpression advanceOperation = (IBinaryOperatorExpression)advanceAssignment.Value;
if (!advanceOperation.UsesOperatorMethod &&
advanceOperation.Left.Kind == OperationKind.LocalReferenceExpression &&
((ILocalReferenceExpression)advanceOperation.Left).Local == testVariable &&
advanceOperation.Right.ConstantValue != null &&
advanceOperation.Right.ResultType.SpecialType == SpecialType.System_Int32)
{
// Advance binary operation is known to involve a reference to the local used in the test and a constant.
advanceIncrement = advanceOperation.Right;
advanceOperationCode = advanceOperation.BinaryKind;
}
}
}
else if (advanceExpression.Kind == OperationKind.CompoundAssignmentExpression || advanceExpression.Kind == OperationKind.IncrementExpression)
{
ICompoundAssignmentExpression advanceAssignment = (ICompoundAssignmentExpression)advanceExpression;
if (advanceAssignment.Target.Kind == OperationKind.LocalReferenceExpression &&
((ILocalReferenceExpression)advanceAssignment.Target).Local == testVariable &&
advanceAssignment.Value.ConstantValue != null &&
advanceAssignment.Value.ResultType.SpecialType == SpecialType.System_Int32)
{
// Advance binary operation is known to involve a reference to the local used in the test and a constant.
advanceIncrement = advanceAssignment.Value;
advanceOperationCode = advanceAssignment.BinaryKind;
}
}
if (advanceIncrement != null)
{
int incrementValue = (int)advanceIncrement.ConstantValue;
if (advanceOperationCode == BinaryOperationKind.IntegerSubtract)
{
advanceOperationCode = BinaryOperationKind.IntegerAdd;
incrementValue = -incrementValue;
}
if (advanceOperationCode == BinaryOperationKind.IntegerAdd &&
incrementValue != 0 &&
(condition.BinaryKind == BinaryOperationKind.IntegerLessThan ||
condition.BinaryKind == BinaryOperationKind.IntegerLessThanOrEqual ||
condition.BinaryKind == BinaryOperationKind.IntegerNotEquals ||
condition.BinaryKind == BinaryOperationKind.IntegerGreaterThan ||
condition.BinaryKind == BinaryOperationKind.IntegerGreaterThanOrEqual))
{
int iterationCount = (testValue - initialValue) / incrementValue;
if (iterationCount >= 1000000)
{
Report(operationContext, forLoop.Syntax, BigForDescriptor);
}
}
}
}
}
}
}
}
}
}
}
},
OperationKind.LoopStatement);
}
/// <inheritdoc />
public override IOperation VisitForLoopStatement(IForLoopStatement operation, object argument)
{
return(base.VisitForLoopStatement(operation, argument));
}
public override Location VisitForLoopStatement([NotNull] IForLoopStatement operation, [CanBeNull] object argument)
{
var syntax = (ForStatementSyntax)operation.Syntax;
return(syntax.ForKeyword.GetLocation());
}
public override IOperation VisitForLoopStatement(IForLoopStatement operation, object argument)
{
return(new ForLoopStatement(VisitArray(operation.Before), Visit(operation.Condition), VisitArray(operation.AtLoopBottom), operation.Locals, Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit));
}
public override void VisitForLoopStatement([NotNull] IForLoopStatement operation)
{
LoopStatementLocation = operation.GetLocationForKeyword();
}
public override void VisitForLoopStatement(IForLoopStatement operation)
{
var loopKind = operation.LoopKind;
foreach (var local in operation.Locals)
{
// empty loop body, just want to make sure it won't crash.
}
base.VisitForLoopStatement(operation);
}
