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