private void ReportDiagnostics(CompilationAnalysisContext context)
{
foreach (AttributeSyntax entityTrigger in entityTriggerAttributes)
{
SemanticModel semanticModel = context.Compilation.GetSemanticModel(entityTrigger.SyntaxTree);
if (SyntaxNodeUtils.TryGetFunctionNameAndNode(semanticModel, entityTrigger, out SyntaxNode attributeArgument, out string functionName))
{
if (!classNames.Contains(functionName))
{
if (SyntaxNodeUtils.TryGetClosestString(functionName, classNames, out string closestName))
{
var diagnostic = Diagnostic.Create(ClassNameCloseRule, attributeArgument.GetLocation(), functionName, closestName);
context.ReportDiagnostic(diagnostic);
}
else
{
var diagnostic = Diagnostic.Create(ClassNameMissingRule, attributeArgument.GetLocation(), functionName);
context.ReportDiagnostic(diagnostic);
}
}
}
}
}
public void FindActivityFunction(SyntaxNodeAnalysisContext context)
{
var attribute = context.Node as AttributeSyntax;
if (SyntaxNodeUtils.IsActivityTriggerAttribute(attribute))
{
if (!SyntaxNodeUtils.TryGetFunctionNameAndNode(attribute, out SyntaxNode attributeArgument, out string functionName))
{
//Do not store ActivityFunctionDefinition if there is no function name
return;
}
if (!SyntaxNodeUtils.TryGetMethodReturnTypeNode(attribute, out SyntaxNode returnTypeNode))
{
//Do not store ActivityFunctionDefinition if there is no return type
return;
}
SyntaxNodeUtils.TryGetParameterNodeNextToAttribute(context, attribute, out SyntaxNode parameterNode);
availableFunctions.Add(new ActivityFunctionDefinition
{
FunctionName = functionName,
ParameterNode = parameterNode,
ReturnTypeNode = returnTypeNode
});
}
}
private void AnalyzeDispatchAndFindMethodDeclarations(SyntaxNodeAnalysisContext context)
{
if (context.Node is MemberAccessExpressionSyntax expression &&
SyntaxNodeUtils.IsInsideFunction(expression))
{
var name = expression.Name;
if (name.ToString().StartsWith("DispatchAsync"))
{
if (SyntaxNodeUtils.TryGetMethodDeclaration(expression, out SyntaxNode methodDeclaration))
{
methodDeclarations.Add(methodDeclaration);
}
if (SyntaxNodeUtils.TryGetTypeArgumentNode(expression, out SyntaxNode identifierNode))
{
if (SyntaxNodeUtils.TryGetFunctionNameAndNode(expression, out SyntaxNode attributeArgument, out string functionName))
{
var identifierName = identifierNode.ToString();
if (!string.Equals(identifierName, functionName))
{
var diagnostic = Diagnostic.Create(Rule, identifierNode.GetLocation(), identifierNode, functionName);
context.ReportDiagnostic(diagnostic);
}
}
}
}
}
}
private static bool IsInEntityClass(SyntaxNode methodDeclaration)
{
if (SyntaxNodeUtils.TryGetFunctionNameAndNode(methodDeclaration, out SyntaxNode attributeArgument, out string functionName))
{
if (SyntaxNodeUtils.TryGetClassName(methodDeclaration, out string className))
{
if (string.Equals(className, functionName))
{
return(true);
}
}
}
return(false);
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
var diagnostic = context.Diagnostics.First();
var diagnosticSpan = diagnostic.Location.SourceSpan;
var identifierNode = root.FindNode(diagnosticSpan);
SemanticModel semanticModel = await context.Document.GetSemanticModelAsync();
if (SyntaxNodeUtils.TryGetFunctionNameAndNode(identifierNode, out SyntaxNode functionAttribute, out string functionName))
{
context.RegisterCodeFix(
CodeAction.Create(FixDispatchEntityCall.ToString(), cancellationToken => CodeFixProviderUtils.ReplaceWithIdentifierAsync(context.Document, identifierNode, cancellationToken, functionName), nameof(DispatchEntityNameCodeFixProvider)),
diagnostic);
}
}
