protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var methodDeclaration = (MethodStatementSyntax)c.Node;
if (!FieldNameChecker.IsRegexMatch(methodDeclaration.Identifier.ValueText, Pattern))
{
c.ReportDiagnostic(Diagnostic.Create(Rule, methodDeclaration.Identifier.GetLocation(),
"function", methodDeclaration.Identifier.ValueText, Pattern));
}
},
SyntaxKind.FunctionStatement);
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var methodDeclaration = (MethodStatementSyntax)c.Node;
if (!FieldNameChecker.IsRegexMatch(methodDeclaration.Identifier.ValueText, Pattern) &&
!EventHandlerName.IsEventHandler(methodDeclaration, c.SemanticModel))
{
c.ReportDiagnostic(Diagnostic.Create(Rule, methodDeclaration.Identifier.GetLocation(),
"procedure", methodDeclaration.Identifier.ValueText, Pattern));
}
},
SyntaxKind.SubStatement);
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxTreeActionInNonGenerated(
c =>
{
var root = c.Tree.GetRoot();
var rootExpressions =
root
.DescendantNodes(e2 => !(e2 is ExpressionSyntax))
.Where(
e =>
e is ExpressionSyntax &&
!IsCompoundExpression(e));
var compoundExpressionsDescendants =
root
.DescendantNodes()
.Where(IsCompoundExpression)
.SelectMany(
e =>
e
.DescendantNodes(
e2 =>
e == e2 ||
!(e2 is ExpressionSyntax))
.Where(
e2 =>
e2 is ExpressionSyntax &&
!IsCompoundExpression(e2)));
var expressionsToCheck = rootExpressions.Concat(compoundExpressionsDescendants);
var complexExpressions =
expressionsToCheck
.Select(
e =>
new
{
Expression = e,
Complexity =
e
.DescendantNodesAndSelf(e2 => !IsCompoundExpression(e2))
.Count(
e2 =>
e2.IsKind(SyntaxKind.ConditionalExpression) ||
e2.IsKind(SyntaxKind.LogicalAndExpression) ||
e2.IsKind(SyntaxKind.LogicalOrExpression))
})
.Where(e => e.Complexity > Maximum);
foreach (var complexExpression in complexExpressions)
{
c.ReportDiagnostic(Diagnostic.Create(Rule, complexExpression.Expression.GetLocation(), Maximum, complexExpression.Complexity));
}
});
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxTreeActionInNonGenerated(
c =>
{
foreach (var line in c.Tree.GetText().Lines
.Where(line => line.Span.Length > Maximum))
{
c.ReportDiagnostic(Diagnostic.Create(Rule, c.Tree.GetLocation(line.Span), Maximum, line.Span.Length));
}
});
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var enumDeclaration = (EnumStatementSyntax)c.Node;
if (!FieldNameChecker.IsRegexMatch(enumDeclaration.Identifier.ValueText, Pattern))
{
c.ReportDiagnostic(Diagnostic.Create(Rule, enumDeclaration.Identifier.GetLocation(), Pattern));
}
},
SyntaxKind.EnumStatement);
}
protected sealed override void Initialize(SonarAnalysisContext context)
{
var analysisContext = new ParameterLoadingAnalysisContext(context);
Initialize(analysisContext);
context.RegisterCompilationStartAction(
cac =>
{
ParameterLoader.SetParameterValues(this, cac.Options);
foreach (var compilationStartActions in analysisContext.CompilationStartActions)
{
compilationStartActions(cac);
}
});
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var declaration = (NamespaceStatementSyntax)c.Node;
var declarationName = declaration.Name?.ToString();
if (declarationName != null &&
!FieldNameChecker.IsRegexMatch(declarationName, Pattern))
{
c.ReportDiagnostic(Diagnostic.Create(Rule, declaration.Name.GetLocation(), Pattern));
}
},
SyntaxKind.NamespaceStatement);
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxTreeActionInNonGenerated(
c =>
{
var root = c.Tree.GetRoot();
var lines = root.GetLocation().GetLineSpan().EndLinePosition.Line + 1;
if (lines > Maximum)
{
var firstLine = c.Tree.GetText().Lines.First();
c.ReportDiagnostic(Diagnostic.Create(Rule, c.Tree.GetLocation(firstLine.Span), Maximum, lines));
}
});
}
protected sealed override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var fieldDeclaration = (FieldDeclarationSyntax)c.Node;
foreach (var name in fieldDeclaration.Declarators.SelectMany(v => v.Names).Where(n => n != null))
{
var symbol = c.SemanticModel.GetDeclaredSymbol(name) as IFieldSymbol;
if (symbol != null &&
IsCandidateSymbol(symbol) &&
!IsRegexMatch(symbol.Name, Pattern))
{
c.ReportDiagnostic(Diagnostic.Create(SupportedDiagnostics.First(), name.GetLocation(), symbol.Name, Pattern));
}
}
},
SyntaxKind.FieldDeclaration);
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var parameterListNode = (ParameterListSyntax)c.Node;
var parameters = parameterListNode.Parameters.Count;
string declarationName;
if (parameters > Maximum &&
parameterListNode.Parent != null &&
Mapping.TryGetValue(parameterListNode.Parent.Kind(), out declarationName))
{
c.ReportDiagnostic(Diagnostic.Create(Rule, parameterListNode.GetLocation(),
Maximum, parameters, declarationName));
}
},
SyntaxKind.ParameterList);
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c => CheckComplexity <MethodDeclarationSyntax>(c, m => m, m => m.Identifier.GetLocation(),
"method", Threshold),
SyntaxKind.MethodDeclaration);
// Here, we only care about arrowed properties, others will be handled by the accessor.
context.RegisterSyntaxNodeActionInNonGenerated(
c => CheckComplexity <PropertyDeclarationSyntax>(c, p => p.ExpressionBody, p => p.Identifier.GetLocation(),
"property", PropertyThreshold),
SyntaxKind.PropertyDeclaration);
context.RegisterSyntaxNodeActionInNonGenerated(
c => CheckComplexity <ConstructorDeclarationSyntax>(c, co => co, co => co.Identifier.GetLocation(),
"constructor", Threshold),
SyntaxKind.ConstructorDeclaration);
context.RegisterSyntaxNodeActionInNonGenerated(
c => CheckComplexity <DestructorDeclarationSyntax>(c, d => d, d => d.Identifier.GetLocation(),
"destructor", Threshold),
SyntaxKind.DestructorDeclaration);
context.RegisterSyntaxNodeActionInNonGenerated(
c => CheckComplexity <OperatorDeclarationSyntax>(c, o => o, o => o.OperatorToken.GetLocation(),
"operator", Threshold),
SyntaxKind.OperatorDeclaration);
context.RegisterSyntaxNodeActionInNonGenerated(
c => CheckComplexity <AccessorDeclarationSyntax>(c, a => a, a => a.Keyword.GetLocation(),
"accessor", PropertyThreshold),
SyntaxKind.GetAccessorDeclaration,
SyntaxKind.SetAccessorDeclaration,
SyntaxKind.AddAccessorDeclaration,
SyntaxKind.RemoveAccessorDeclaration);
context.RegisterSyntaxNodeActionInNonGenerated(
c => CheckComplexity <FieldDeclarationSyntax>(c, m => m, m => m.Declaration.Variables[0].Identifier.GetLocation(),
"field", Threshold),
SyntaxKind.FieldDeclaration);
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxTreeActionInNonGenerated(
GeneratedCodeRecognizer,
stac =>
{
var linesCount = stac.Tree
.GetRoot()
.DescendantTokens()
.Where(token => !IsEndOfFileToken(token))
.SelectMany(token => token.GetLineNumbers(isZeroBasedCount: false))
.Distinct()
.LongCount();
if (linesCount > Maximum)
{
stac.ReportDiagnosticWhenActive(Diagnostic.Create(SupportedDiagnostics[0], Location.Create(stac.Tree,
TextSpan.FromBounds(0, 0)), Maximum, linesCount));
}
});
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var parameterListNode = (ParameterListSyntax)c.Node;
var parameters = parameterListNode.Parameters.Count;
string declarationName;
if (parameters > Maximum &&
parameterListNode.Parent != null &&
CanBeChanged(parameterListNode.Parent, c.SemanticModel) &&
Mapping.TryGetValue(parameterListNode.Parent.Kind(), out declarationName))
{
c.ReportDiagnostic(Diagnostic.Create(Rule, parameterListNode.GetLocation(),
Maximum, parameters, declarationName));
}
},
SyntaxKind.ParameterList);
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var caseBlock = (CaseBlockSyntax)c.Node;
if (caseBlock.IsMissing)
{
return;
}
var statementsCount = caseBlock.Statements.SelectMany(GetInnerStatements).Count();
if (statementsCount > Threshold)
{
c.ReportDiagnosticWhenActive(Diagnostic.Create(rule, caseBlock.CaseStatement.GetLocation(),
"'Case' block", statementsCount, Threshold, "procedure"));
}
},
SyntaxKind.CaseBlock,
SyntaxKind.CaseElseBlock);
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var typeDeclaration = (TypeDeclarationSyntax)c.Node;
if (c.ContainingSymbol.Kind != SymbolKind.NamedType ||
typeDeclaration.TypeParameterList == null ||
typeDeclaration.TypeParameterList.Parameters.Count <= MaxNumberOfGenericParametersInClass)
{
return;
}
c.ReportDiagnosticWhenActive(Diagnostic.Create(Rule, typeDeclaration.Identifier.GetLocation(),
typeDeclaration.Identifier.ValueText, GetTypeKeyword(typeDeclaration), MaxNumberOfGenericParametersInClass));
},
SyntaxKind.ClassDeclaration,
SyntaxKind.StructDeclaration,
SyntaxKind.InterfaceDeclaration,
SyntaxKindEx.RecordDeclaration);
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var methodDeclaration = (MethodDeclarationSyntax)c.Node;
if (methodDeclaration.TypeParameterList == null ||
methodDeclaration.TypeParameterList.Parameters.Count <= MaxNumberOfGenericParametersInMethod)
{
return;
}
c.ReportDiagnosticWhenActive(Diagnostic.Create(Rule, methodDeclaration.Identifier.GetLocation(),
$"{GetEnclosingTypeName(methodDeclaration)}.{methodDeclaration.Identifier.ValueText}", "method",
MaxNumberOfGenericParametersInMethod));
},
SyntaxKind.MethodDeclaration);
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var switchNode = (SwitchStatementSyntax)c.Node;
var type = c.SemanticModel.GetTypeInfo(switchNode.Expression).Type;
if (type == null ||
type.TypeKind == TypeKind.Enum)
{
return;
}
var numberOfSections = switchNode.Sections.Count;
if (numberOfSections > Maximum)
{
c.ReportDiagnosticWhenActive(Diagnostic.Create(rule, switchNode.SwitchKeyword.GetLocation(), Maximum, numberOfSections));
}
},
SyntaxKind.SwitchStatement);
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxTreeActionInNonGenerated(stac =>
{
if (HeaderFormat == null)
{
return;
}
if (IsRegularExpression && !IsRegexPatternValid(HeaderFormat))
{
throw new ArgumentException($"Invalid regular expression: {HeaderFormat}", HeaderFormatRuleParameterKey);
}
var firstNode = stac.Tree.GetRoot().ChildTokens().FirstOrDefault().Parent;
if (!HasValidLicenseHeader(firstNode))
{
var properties = CreateDiagnosticProperties();
stac.ReportDiagnostic(Diagnostic.Create(rule, Location.Create(stac.Tree, TextSpan.FromBounds(0, 0)), properties));
}
});
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var switchSection = (SwitchSectionSyntax)c.Node;
if (switchSection.IsMissing ||
switchSection.Labels.Count <= 0)
{
return;
}
var statementsCount = switchSection.Statements.SelectMany(GetSubStatements).Count();
if (statementsCount > Threshold)
{
c.ReportDiagnosticWhenActive(Diagnostic.Create(rule, switchSection.Labels.First().GetLocation(),
statementsCount, Threshold));
}
},
SyntaxKind.SwitchSection);
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(c =>
{
if (Max < 2)
{
throw new ArgumentOutOfRangeException(
$"Invalid rule parameter: maximum number of lines = {Max}. Must be at least 2.");
}
if (c.IsTest())
{
return;
}
var baseMethodSyntax = (BaseMethodDeclarationSyntax)c.Node;
var identifierLocation = baseMethodSyntax?.FindIdentifierLocation();
if (identifierLocation == null)
{
return;
}
var linesCount = GetBodyTokens(baseMethodSyntax)
.SelectMany(token => token.GetLineNumbers())
.Distinct()
.LongCount();
if (linesCount > Max)
{
c.ReportDiagnosticWhenActive(Diagnostic.Create(rule, identifierLocation,
GetDescription(baseMethodSyntax), linesCount, Max));
}
},
SyntaxKind.MethodDeclaration,
SyntaxKind.ConstructorDeclaration,
SyntaxKind.DestructorDeclaration);
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var classDeclaration = (ClassDeclarationSyntax)c.Node;
if (c.IsTest() ||
classDeclaration.Identifier.IsMissing)
{
return;
}
var allFieldsCoupling = classDeclaration.Members
.OfType <FieldDeclarationSyntax>()
.SelectMany(field => CollectCoupledClasses(field, c.SemanticModel));
var allPropertiesCoupling = classDeclaration.Members
.OfType <BasePropertyDeclarationSyntax>()
.SelectMany(property => CollectCoupledClasses(property, c.SemanticModel));
var allMethodsCoupling = classDeclaration.Members
.OfType <BaseMethodDeclarationSyntax>()
.SelectMany(baseMethod => CollectCoupledClasses(baseMethod, c.SemanticModel));
var totalClassCoupling = Enumerable.Empty <ITypeSymbol>()
.Union(allFieldsCoupling)
.Union(allPropertiesCoupling)
.Union(allMethodsCoupling);
var classCouplingCount = FilterAndCountCoupling(totalClassCoupling);
if (classCouplingCount > Threshold)
{
c.ReportDiagnosticWhenActive(Diagnostic.Create(rule, classDeclaration.Identifier.GetLocation(),
classCouplingCount, Threshold));
}
}, SyntaxKind.ClassDeclaration);
}
protected override void InitializeActions(ParameterLoadingAnalysisContext context)
{
context.RegisterCompilationStartAction(
c =>
{
if (!IsEnabled(c.Options))
{
return;
}
c.RegisterSyntaxNodeActionInNonGenerated(
new VariableDeclarationBannedWordsFinder(this).GetAnalysisAction(rule),
SyntaxKind.VariableDeclarator);
c.RegisterSyntaxNodeActionInNonGenerated(
new AssignmentExpressionBannedWordsFinder(this).GetAnalysisAction(rule),
SyntaxKind.SimpleAssignmentStatement);
c.RegisterSyntaxNodeActionInNonGenerated(
new StringLiteralBannedWordsFinder(this).GetAnalysisAction(rule),
SyntaxKind.StringLiteralExpression);
});
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var switchNode = (SwitchStatementSyntax)c.Node;
var type = c.SemanticModel.GetTypeInfo(switchNode.Expression).Type;
if (type == null ||
type.TypeKind == TypeKind.Enum)
{
return;
}
var labels = NumberOfLabels(switchNode);
if (labels > Maximum)
{
c.ReportDiagnostic(Diagnostic.Create(Rule, switchNode.SwitchKeyword.GetLocation(), Maximum, labels));
}
},
SyntaxKind.SwitchStatement);
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(c =>
{
var classDeclaration = (ClassDeclarationSyntax)c.Node;
var classSymbol = c.SemanticModel.GetDeclaredSymbol(classDeclaration);
if (classSymbol == null ||
classSymbol.TypeArguments.Length <= Maximum)
{
return;
}
c.ReportDiagnostic(Diagnostic.Create(rule, classDeclaration.Identifier.GetLocation(),
classSymbol.Name, "class", Maximum));
},
SyntaxKind.ClassDeclaration);
context.RegisterSyntaxNodeActionInNonGenerated(c =>
{
var methodDeclaration = (MethodDeclarationSyntax)c.Node;
var methodSymbol = c.SemanticModel.GetDeclaredSymbol(methodDeclaration);
if (methodSymbol == null ||
methodSymbol.TypeArguments.Length <= Maximum)
{
return;
}
c.ReportDiagnostic(Diagnostic.Create(rule, methodDeclaration.Identifier.GetLocation(),
$"{methodSymbol.ContainingType.Name}.{methodSymbol.Name}", "method", Maximum));
},
SyntaxKind.MethodDeclaration);
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(
GeneratedCodeRecognizer,
c =>
{
var switchNode = (TSwitchStatementSyntax)c.Node;
var type = c.SemanticModel.GetTypeInfo(GetExpression(switchNode)).Type;
if (type == null ||
type.TypeKind == TypeKind.Enum)
{
return;
}
var sectionsCount = GetSectionsCount(switchNode);
if (sectionsCount > Maximum)
{
c.ReportDiagnosticWhenActive(
Diagnostic.Create(Rule, GetKeywordLocation(switchNode), Maximum, sectionsCount));
}
},
SyntaxKinds);
}
protected override void Initialize(ParameterLoadingAnalysisContext context) => context.RegisterSyntaxNodeActionInNonGenerated(c => CheckFunctionNestingDepth(c), FunctionKinds);
protected abstract void Initialize(ParameterLoadingAnalysisContext context);
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
context.RegisterSyntaxNodeActionInNonGenerated(VerifyDeclaration, SyntaxKind.VariableDeclaration);
context.RegisterSyntaxNodeActionInNonGenerated(VerifyAssignment, SyntaxKind.SimpleAssignmentExpression);
}
protected override void Initialize(ParameterLoadingAnalysisContext context)
{
throw new NotImplementedException();
}
protected abstract void Initialize(ParameterLoadingAnalysisContext context);
protected override void Initialize(ParameterLoadingAnalysisContext context) =>
context.RegisterSyntaxNodeActionInNonGenerated(c => CheckFunctionNestingDepth(c), FunctionKinds);
