public void Track(SonarAnalysisContext context, params Condition[] conditions)
{
context.RegisterCompilationStartAction(
c =>
{
if (IsEnabled(c.Options))
{
c.RegisterSymbolAction(TrackMethodDeclaration, SymbolKind.Method);
}
});
void TrackMethodDeclaration(SymbolAnalysisContext c)
{
if (IsTrackedMethod((IMethodSymbol)c.Symbol, c.Compilation))
{
foreach (var declaration in c.Symbol.DeclaringSyntaxReferences)
{
var methodIdentifier = GetMethodIdentifier(declaration.GetSyntax());
if (methodIdentifier.HasValue)
{
c.ReportDiagnosticWhenActive(Diagnostic.Create(Rule, methodIdentifier.Value.GetLocation()));
}
}
}
}
bool IsTrackedMethod(IMethodSymbol methodSymbol, Compilation compilation)
{
var conditionContext = new MethodDeclarationContext(methodSymbol, compilation);
return(conditions.All(c => c(conditionContext)));
}
}
public void Track(SonarAnalysisContext context, params ElementAccessCondition[] conditions)
{
context.RegisterCompilationStartAction(
c =>
{
if (IsEnabled(c.Options))
{
c.RegisterSyntaxNodeActionInNonGenerated(
GeneratedCodeRecognizer,
TrackElementAccess,
TrackedSyntaxKinds);
}
});
void TrackElementAccess(SyntaxNodeAnalysisContext c)
{
if (IsTrackedElementAccess(c.Node, c.SemanticModel))
{
c.ReportDiagnosticWhenActive(Diagnostic.Create(Rule, c.Node.GetLocation()));
}
}
bool IsTrackedElementAccess(SyntaxNode expression, SemanticModel semanticModel)
{
var conditionContext = new ElementAccessContext(expression, semanticModel);
return(conditions.All(c => c(conditionContext)));
}
}
public void Track(SonarAnalysisContext context, object[] diagnosticMessageArgs, params ObjectCreationCondition[] conditions)
{
context.RegisterCompilationStartAction(
c =>
{
if (IsEnabled(c.Options))
{
c.RegisterSyntaxNodeActionInNonGenerated(
GeneratedCodeRecognizer,
TrackObjectCreation,
TrackedSyntaxKinds);
}
});
void TrackObjectCreation(SyntaxNodeAnalysisContext c)
{
if (IsTrackedObjectCreation(c.Node, c.SemanticModel))
{
c.ReportDiagnosticWhenActive(Diagnostic.Create(Rule, c.Node.GetLocation(), diagnosticMessageArgs));
}
}
bool IsTrackedObjectCreation(SyntaxNode objectCreationExpression, SemanticModel semanticModel)
{
var objectCreationContext = new ObjectCreationContext(objectCreationExpression, semanticModel);
return(conditions.All(c => c(objectCreationContext)));
}
}
public void Track(SonarAnalysisContext context, object[] diagnosticMessageArgs, params Condition[] conditions)
{
context.RegisterCompilationStartAction(
c =>
{
if (IsEnabled(c.Options))
{
c.RegisterSyntaxNodeActionInNonGenerated(
GeneratedCodeRecognizer,
TrackAndReportIfNecessary,
TrackedSyntaxKinds);
}
});
void TrackAndReportIfNecessary(SyntaxNodeAnalysisContext c)
{
if (CreateContext(c) is { } trackingContext &&
conditions.All(c => c(trackingContext)) &&
trackingContext.PrimaryLocation != null &&
trackingContext.PrimaryLocation != Location.None)
{
c.ReportDiagnosticWhenActive(
Diagnostic.Create(Rule,
trackingContext.PrimaryLocation,
trackingContext.SecondaryLocations.ToAdditionalLocations(),
trackingContext.SecondaryLocations.ToProperties(),
diagnosticMessageArgs));
}
}
}
public static void RegisterSyntaxTreeActionInNonGenerated(this SonarAnalysisContext context, GeneratedCodeRecognizer generatedCodeRecognizer, Action <SyntaxTreeAnalysisContext> action) =>
context.RegisterCompilationStartAction(csac =>
csac.RegisterSyntaxTreeAction(c =>
{
if (ShouldAnalyze(context, generatedCodeRecognizer, c.GetSyntaxTree(), csac.Compilation, c.Options))
{
action(c);
}
}));
public void Track(SonarAnalysisContext context, params BaseClassCondition[] conditions)
{
context.RegisterCompilationStartAction(
c =>
{
if (IsEnabled(c.Options))
{
c.RegisterSyntaxNodeActionInNonGenerated(
GeneratedCodeRecognizer,
TrackInheritance,
TrackedSyntaxKinds);
}
});
void TrackInheritance(SyntaxNodeAnalysisContext c)
{
Location issueLocation;
if (IsTrackedRelationship(c.Node, c.SemanticModel, out issueLocation))
{
c.ReportDiagnosticWhenActive(Diagnostic.Create(Rule, issueLocation));
}
}
bool IsTrackedRelationship(SyntaxNode contextNode, SemanticModel semanticModel, out Location issueLocation)
{
var baseTypeList = GetBaseTypeNodes(contextNode);
if (baseTypeList == null || !baseTypeList.Any())
{
issueLocation = Location.None;
return(false);
}
var baseClassContext = new BaseTypeContext(contextNode, baseTypeList, semanticModel);
// We can't pass the issueLocation to the lambda directly so we need a temporary variable
Location locationToReport = null;
if (conditions.All(c => c(baseClassContext, out locationToReport)))
{
issueLocation = locationToReport;
return(true);
}
issueLocation = Location.None;
return(false);
}
}
public static void RegisterSyntaxTreeActionInNonGenerated(
this SonarAnalysisContext context,
GeneratedCodeRecognizer generatedCodeRecognizer,
Action <SyntaxTreeAnalysisContext> action)
{
context.RegisterCompilationStartAction(
csac =>
{
csac.RegisterSyntaxTreeAction(
c =>
{
if (!c.Tree.IsGenerated(generatedCodeRecognizer, csac.Compilation))
{
action(c);
}
});
});
}
public void Track(SonarAnalysisContext context, params PropertyAccessCondition[] conditions)
{
context.RegisterCompilationStartAction(
c =>
{
if (IsEnabled(c.Options))
{
c.RegisterSyntaxNodeActionInNonGenerated(
GeneratedCodeRecognizer,
TrackMemberAccess,
TrackedSyntaxKinds);
}
});
void TrackMemberAccess(SyntaxNodeAnalysisContext c)
{
if (IsTrackedProperty(c.Node, c.SemanticModel))
{
c.ReportDiagnosticWhenActive(Diagnostic.Create(Rule, c.Node.GetLocation()));
}
}
bool IsTrackedProperty(SyntaxNode expression, SemanticModel semanticModel)
{
// We register for both MemberAccess and IdentifierName and we want to
// avoid raising two times for the same identifier.
if (IsIdentifierWithinMemberAccess(expression))
{
return(false);
}
var propertyName = GetPropertyName(expression);
if (propertyName == null)
{
return(false);
}
var conditionContext = new PropertyAccessContext(expression, propertyName, semanticModel);
return(conditions.All(c => c(conditionContext)));
}
}
public void Track(SonarAnalysisContext context, params InvocationCondition[] conditions)
{
context.RegisterCompilationStartAction(
c =>
{
if (IsEnabled(c.Options))
{
c.RegisterSyntaxNodeActionInNonGenerated(
GeneratedCodeRecognizer,
TrackInvocationExpression,
TrackedSyntaxKinds);
}
});
void TrackInvocationExpression(SyntaxNodeAnalysisContext c)
{
if (IsTrackedMethod(c.Node, c.SemanticModel))
{
c.ReportDiagnosticWhenActive(Diagnostic.Create(Rule, c.Node.GetLocation()));
}
}
bool IsTrackedMethod(SyntaxNode invocation, SemanticModel semanticModel)
{
var methodName = GetMethodName(invocation);
if (methodName == null)
{
return(false);
}
var conditionContext = new InvocationContext(invocation, methodName, semanticModel);
return(conditions.All(c => c(conditionContext)));
}
}