public override void VisitCompoundAssignmentExpression(ICompoundAssignmentExpression operation)
{
var operatorMethod = operation.OperatorMethod;
var binaryOperationKind = operation.OperatorKind;
base.VisitCompoundAssignmentExpression(operation);
}
public override void VisitCompoundAssignmentExpression(ICompoundAssignmentExpression operation)
{
LogString(nameof(ICompoundAssignmentExpression));
var kindStr = $"{nameof(BinaryOperationKind)}.{operation.BinaryOperationKind}";
LogString($" ({kindStr})");
LogHasOperatorMethodExpressionCommon(operation);
LogCommonPropertiesAndNewLine(operation);
Visit(operation.Target, "Left");
Visit(operation.Value, "Right");
}
public virtual void VisitCompoundAssignmentExpression(ICompoundAssignmentExpression operation)
{
DefaultVisit(operation);
}
public virtual void VisitCompoundAssignmentExpression(ICompoundAssignmentExpression operation)
{
DefaultVisit(operation);
}
public override void VisitCompoundAssignmentExpression(ICompoundAssignmentExpression operation)
{
Visit(operation.Target);
Visit(operation.Value);
}
public static ICompoundAssignmentExpression Update(this ICompoundAssignmentExpression self, ValueType @operator, IOperation @left, IOperation @right, Conversion @leftConversion, Conversion @finalConversion, Enum @resultKind, ITypeSymbol @type) => self;
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 VisitCompoundAssignmentExpression(ICompoundAssignmentExpression operation, object argument)
{
return(base.VisitCompoundAssignmentExpression(operation, argument));
}
/// <inheritdoc />
public override Expression VisitCompoundAssignmentExpression(ICompoundAssignmentExpression operation, LocalBinder argument)
{
return(base.VisitCompoundAssignmentExpression(operation, argument));
}
public override IOperation VisitCompoundAssignmentExpression(ICompoundAssignmentExpression operation, object argument)
{
return(new CompoundAssignmentExpression(operation.OperatorKind, operation.IsLifted, operation.IsChecked, Visit(operation.Target), Visit(operation.Value), operation.UsesOperatorMethod, operation.OperatorMethod, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit));
}
public override void VisitCompoundAssignmentExpression(ICompoundAssignmentExpression operation)
{
var usesOperatorMethod = operation.UsesOperatorMethod;
var operatorMethod = operation.OperatorMethod;
var binaryOperationKind = operation.BinaryOperationKind;
base.VisitCompoundAssignmentExpression(operation);
}
/// <summary>
/// Get binary operand kinds.
/// </summary>
public static BinaryOperandsKind GetBinaryOperandsKind(this ICompoundAssignmentExpression compoundAssignment)
{
return(GetBinaryOperandsKind(compoundAssignment.BinaryOperationKind));
}
