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