public override Location VisitSingleValueCaseClause([NotNull] ISingleValueCaseClause operation,
[CanBeNull] object argument)
{
var syntax = (SwitchLabelSyntax)operation.Syntax;
return(syntax.Keyword.GetLocation());
}
public override void VisitSingleValueCaseClause(ISingleValueCaseClause operation)
{
var caseKind = operation.CaseKind;
var equality = operation.Equality;
base.VisitSingleValueCaseClause(operation);
}
public override void VisitSingleValueCaseClause(ISingleValueCaseClause operation)
{
var caseKind = operation.CaseKind;
var equality = operation.Equality;
base.VisitSingleValueCaseClause(operation);
}
private bool ProcessAsField([NotNull] ISingleValueCaseClause caseClause)
{
if (caseClause.Value is IFieldReferenceExpression enumField)
{
caseClauseValues.Add(enumField.Field);
return(true);
}
return(false);
}
public override void VisitSingleValueCaseClause(ISingleValueCaseClause operation)
{
LogString(nameof(ISingleValueCaseClause));
var kindStr = $"{nameof(BinaryOperationKind)}.{operation.Equality}";
LogString($" (Equality operator kind: {kindStr})");
LogCaseClauseCommon(operation);
base.VisitSingleValueCaseClause(operation);
}
private bool ProcessAsLiteralSyntax([NotNull] SwitchAnalysisContext analysisContext,
[NotNull] ISingleValueCaseClause caseClause)
{
if (caseClause.Value.Syntax is LiteralExpressionSyntax literalSyntax)
{
if (ProcessLiteralSyntaxAsTrueKeyword(analysisContext, literalSyntax) ||
ProcessLiteralSyntaxAsFalseKeyword(analysisContext, literalSyntax) ||
ProcessLiteralSyntaxAsNullKeyword(literalSyntax))
{
return(true);
}
}
return(false);
}
private bool ProcessAsConversion([NotNull] SwitchAnalysisContext analysisContext,
[NotNull] ISingleValueCaseClause caseClause)
{
var conversion = caseClause.Value as IConversionExpression;
var memberSyntax = conversion?.Syntax as MemberAccessExpressionSyntax;
IFieldSymbol field = analysisContext.GetFieldOrNull(memberSyntax);
if (field != null)
{
caseClauseValues.Add(field);
return(true);
}
return(false);
}
public virtual void VisitSingleValueCaseClause(ISingleValueCaseClause operation)
{
DefaultVisit(operation);
}
public virtual void VisitSingleValueCaseClause(ISingleValueCaseClause operation)
{
DefaultVisit(operation);
}
public override void VisitSingleValueCaseClause(ISingleValueCaseClause operation)
{
Visit(operation.Value);
}
public sealed override void Initialize(AnalysisContext context)
{
context.RegisterOperationAction(
(operationContext) =>
{
ISwitchStatement switchOperation = (ISwitchStatement)operationContext.Operation;
long minCaseValue = long.MaxValue;
long maxCaseValue = long.MinValue;
long caseValueCount = 0;
foreach (ICase switchCase in switchOperation.Cases)
{
foreach (ICaseClause clause in switchCase.Clauses)
{
switch (clause.CaseKind)
{
case CaseKind.SingleValue:
{
ISingleValueCaseClause singleValueClause = (ISingleValueCaseClause)clause;
IExpression singleValueExpression = singleValueClause.Value;
if (singleValueExpression.ConstantValue != null &&
singleValueExpression.ResultType.SpecialType == SpecialType.System_Int32)
{
int singleValue = (int)singleValueExpression.ConstantValue;
caseValueCount += IncludeClause(singleValue, singleValue, ref minCaseValue, ref maxCaseValue);
}
else
{
return;
}
break;
}
case CaseKind.Range:
{
IRangeCaseClause rangeClause = (IRangeCaseClause)clause;
IExpression rangeMinExpression = rangeClause.MinimumValue;
IExpression rangeMaxExpression = rangeClause.MaximumValue;
if (rangeMinExpression.ConstantValue != null &&
rangeMinExpression.ResultType.SpecialType == SpecialType.System_Int32 &&
rangeMaxExpression.ConstantValue != null &&
rangeMaxExpression.ResultType.SpecialType == SpecialType.System_Int32)
{
int rangeMinValue = (int)rangeMinExpression.ConstantValue;
int rangeMaxValue = (int)rangeMaxExpression.ConstantValue;
caseValueCount += IncludeClause(rangeMinValue, rangeMaxValue, ref minCaseValue, ref maxCaseValue);
}
else
{
return;
}
break;
}
case CaseKind.Relational:
{
IRelationalCaseClause relationalClause = (IRelationalCaseClause)clause;
IExpression relationalValueExpression = relationalClause.Value;
if (relationalValueExpression.ConstantValue != null &&
relationalValueExpression.ResultType.SpecialType == SpecialType.System_Int32)
{
int rangeMinValue = int.MaxValue;
int rangeMaxValue = int.MinValue;
int relationalValue = (int)relationalValueExpression.ConstantValue;
switch (relationalClause.Relation)
{
case BinaryOperationKind.IntegerEquals:
rangeMinValue = relationalValue;
rangeMaxValue = relationalValue;
break;
case BinaryOperationKind.IntegerNotEquals:
return;
case BinaryOperationKind.IntegerLessThan:
rangeMinValue = int.MinValue;
rangeMaxValue = relationalValue - 1;
break;
case BinaryOperationKind.IntegerLessThanOrEqual:
rangeMinValue = int.MinValue;
rangeMaxValue = relationalValue;
break;
case BinaryOperationKind.IntegerGreaterThanOrEqual:
rangeMinValue = relationalValue;
rangeMaxValue = int.MaxValue;
break;
case BinaryOperationKind.IntegerGreaterThan:
rangeMinValue = relationalValue + 1;
rangeMaxValue = int.MaxValue;
break;
}
caseValueCount += IncludeClause(rangeMinValue, rangeMaxValue, ref minCaseValue, ref maxCaseValue);
}
else
{
return;
}
break;
}
case CaseKind.Default:
{
break;
}
}
}
}
long span = maxCaseValue - minCaseValue + 1;
if (caseValueCount == 0 || span / caseValueCount > 100)
{
Report(operationContext, switchOperation.Value.Syntax, SparseSwitchDescriptor);
}
},
OperationKind.SwitchStatement);
}
/// <inheritdoc />
public override IOperation VisitSingleValueCaseClause(ISingleValueCaseClause operation, object argument)
{
return(base.VisitSingleValueCaseClause(operation, argument));
}
public override IOperation VisitSingleValueCaseClause(ISingleValueCaseClause operation, object argument)
{
return(new SingleValueCaseClause(Visit(operation.Value), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit));
}
/// <inheritdoc />
public override Expression VisitSingleValueCaseClause(ISingleValueCaseClause operation, LocalBinder argument)
{
throw Unexpected(operation, nameof(VisitSwitchStatement));
}
