Extended code analyzers (#293)

This commit is contained in:
Thorsten Sommer authored and GitHub committed 2025-02-25 19:58:17 +01:00
1 parent 99dac520cb
commit 5e3b632eee
22 files changed
+1099 -50

No files matched your search

@@ -0,0 +1,67 @@
using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
namespace SourceCodeRules.NamingAnalyzers;
#pragma warning disable RS1038
[DiagnosticAnalyzer(LanguageNames.CSharp)]
#pragma warning restore RS1038
public sealed class ConstStaticAnalyzer : DiagnosticAnalyzer
{
private const string DIAGNOSTIC_ID = Identifier.CONST_STATIC_ANALYZER;
private static readonly string TITLE = "Constant and static fields must be in UPPER_CASE";
private static readonly string MESSAGE_FORMAT = "Field '{0}' must be in UPPER_CASE";
private static readonly string DESCRIPTION = "All constant and static fields should be named using UPPER_CASE.";
private const string CATEGORY = "Naming";
private static readonly DiagnosticDescriptor RULE = new(DIAGNOSTIC_ID, TITLE, MESSAGE_FORMAT, CATEGORY, DiagnosticSeverity.Error, isEnabledByDefault: true, description: DESCRIPTION);
public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [RULE];
public override void Initialize(AnalysisContext context)
{
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
context.EnableConcurrentExecution();
context.RegisterSyntaxNodeAction(this.AnalyzeField, SyntaxKind.FieldDeclaration);
}
private void AnalyzeField(SyntaxNodeAnalysisContext context)
{
var fieldDeclaration = (FieldDeclarationSyntax)context.Node;
// Prüfen ob das Feld static oder const ist
if (!fieldDeclaration.Modifiers.Any(m => m.IsKind(SyntaxKind.StaticKeyword) || m.IsKind(SyntaxKind.ConstKeyword)))
return;
foreach (var variable in fieldDeclaration.Declaration.Variables)
{
var fieldName = variable.Identifier.Text;
// Prüfen ob der Name bereits in UPPER_CASE ist
if (!IsUpperCase(fieldName))
{
var diagnostic = Diagnostic.Create(
RULE,
variable.Identifier.GetLocation(),
fieldName);
context.ReportDiagnostic(diagnostic);
}
}
}
private static bool IsUpperCase(string name)
{
// Erlaubt: Nur Großbuchstaben, Zahlen und Unterstriche
return name.All(c => char.IsUpper(c) || char.IsDigit(c) || c == '_');
}
}
@@ -0,0 +1,63 @@
using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
namespace SourceCodeRules.NamingAnalyzers;
#pragma warning disable RS1038
[DiagnosticAnalyzer(LanguageNames.CSharp)]
#pragma warning restore RS1038
public sealed class LocalConstantsAnalyzer : DiagnosticAnalyzer
{
private const string DIAGNOSTIC_ID = Identifier.LOCAL_CONSTANTS_ANALYZER;
private static readonly string TITLE = "Local constant variables must be in UPPER_CASE";
private static readonly string MESSAGE_FORMAT = "Local constant variable '{0}' must be in UPPER_CASE";
private static readonly string DESCRIPTION = "All local constant variables should be named using UPPER_CASE with words separated by underscores.";
private const string CATEGORY = "Naming";
private static readonly DiagnosticDescriptor RULE = new(
DIAGNOSTIC_ID,
TITLE,
MESSAGE_FORMAT,
CATEGORY,
DiagnosticSeverity.Error,
isEnabledByDefault: true,
description: DESCRIPTION);
public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [RULE];
public override void Initialize(AnalysisContext context)
{
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
context.EnableConcurrentExecution();
context.RegisterSyntaxNodeAction(AnalyzeLocalDeclaration, SyntaxKind.LocalDeclarationStatement);
}
private static void AnalyzeLocalDeclaration(SyntaxNodeAnalysisContext context)
{
var localDeclaration = (LocalDeclarationStatementSyntax)context.Node;
if (!localDeclaration.Modifiers.Any(m => m.IsKind(SyntaxKind.ConstKeyword)))
return;
foreach (var variable in localDeclaration.Declaration.Variables)
{
var variableName = variable.Identifier.Text;
if (!IsUpperCase(variableName))
{
var diagnostic = Diagnostic.Create(RULE, variable.Identifier.GetLocation(), variableName);
context.ReportDiagnostic(diagnostic);
}
}
}
private static bool IsUpperCase(string name) => name.All(c => char.IsUpper(c) || char.IsDigit(c) || c == '_') &&
!string.IsNullOrEmpty(name) && name.Any(char.IsLetter);
}
@@ -0,0 +1,46 @@
using System.Collections.Immutable;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
namespace SourceCodeRules.NamingAnalyzers;
#pragma warning disable RS1038
[DiagnosticAnalyzer(LanguageNames.CSharp)]
#pragma warning restore RS1038
public sealed class UnderscorePrefixAnalyzer : DiagnosticAnalyzer
{
private const string DIAGNOSTIC_ID = Identifier.UNDERSCORE_PREFIX_ANALYZER;
private static readonly string TITLE = "Variable names cannot start with underscore";
private static readonly string MESSAGE_FORMAT = "The variable name '{0}' starts with an underscore which is not allowed";
private static readonly string DESCRIPTION = "Variable names cannot start with an underscore prefix.";
private const string CATEGORY = "Naming";
private static readonly DiagnosticDescriptor RULE = new(DIAGNOSTIC_ID, TITLE, MESSAGE_FORMAT, CATEGORY, DiagnosticSeverity.Error, isEnabledByDefault: true, description: DESCRIPTION);
public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [RULE];
public override void Initialize(AnalysisContext context)
{
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
context.EnableConcurrentExecution();
context.RegisterSyntaxNodeAction(AnalyzeVariableDeclaration, SyntaxKind.VariableDeclarator);
}
private static void AnalyzeVariableDeclaration(SyntaxNodeAnalysisContext context)
{
var variableDeclarator = (VariableDeclaratorSyntax)context.Node;
var variableName = variableDeclarator.Identifier.Text;
if (variableName.StartsWith("_"))
{
var diagnostic = Diagnostic.Create(RULE, variableDeclarator.Identifier.GetLocation(), variableName);
context.ReportDiagnostic(diagnostic);
}
}
}