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