public void FindEntityCalls(SyntaxNodeAnalysisContext context) { if (context.Node is MemberAccessExpressionSyntax expression && SyntaxNodeUtils.IsInsideFunction(context.SemanticModel, expression)) { var name = expression.Name; if (name.ToString().StartsWith("SignalEntityAsync")) { if (!SyntaxNodeUtils.TryGetTypeArgumentIdentifier(expression, out SyntaxNode typeArgument)) { return; } if (TryFindEntityInterface(context, typeArgument, out EntityInterface entityInterface)) { entityInterfacesList.Add(entityInterface); } else { var diagnostic = Diagnostic.Create(Rule, typeArgument.GetLocation(), typeArgument); context.ReportDiagnostic(diagnostic); } } } }
public void FindActivityCall(SyntaxNodeAnalysisContext context) { var semanticModel = context.SemanticModel; if (context.Node is InvocationExpressionSyntax invocationExpression && SyntaxNodeUtils.IsInsideFunction(semanticModel, invocationExpression) && IsActivityInvocation(invocationExpression)) { SetSemanticModel(context); if (!TryGetFunctionNameFromActivityInvocation(invocationExpression, out SyntaxNode functionNameNode, out string functionName)) { //Do not store ActivityFunctionCall if there is no function name return; } SyntaxNodeUtils.TryGetTypeArgumentNode((MemberAccessExpressionSyntax)invocationExpression.Expression, out SyntaxNode returnTypeNode); TryGetInputNodeFromCallActivityInvocation(invocationExpression, out SyntaxNode inputNode); calledFunctions.Add(new ActivityFunctionCall { Name = functionName, NameNode = functionNameNode, ParameterNode = inputNode, ReturnTypeNode = returnTypeNode, InvocationExpression = invocationExpression }); } }
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 void AnalyzeMethod(SyntaxNodeAnalysisContext context) { if (context.Node is MethodDeclarationSyntax declaration && SyntaxNodeUtils.IsInsideOrchestrator(declaration) && SyntaxNodeUtils.IsInsideFunction(context.SemanticModel, declaration)) { if (this.semanticModel == null) { this.semanticModel = context.SemanticModel; } this.orchestratorMethodDeclarations.Add(declaration); } }
private void AnalyzeMethod(SyntaxNodeAnalysisContext context) { var declaration = (MethodDeclarationSyntax)context.Node; if (!SyntaxNodeUtils.IsInsideOrchestrator(declaration) || !SyntaxNodeUtils.IsInsideFunction(declaration)) { return; } if (this.semanticModel == null) { this.semanticModel = context.SemanticModel; } this.orchestratorMethodDeclarations.Add(declaration); }
public void FindOrchestrationTriggers(SyntaxNodeAnalysisContext context) { if (SyntaxNodeUtils.IsInsideFunction(context.SemanticModel, context.Node) && context.Node is AttributeSyntax attribute) { var semanticModel = context.SemanticModel; version = SyntaxNodeUtils.GetDurableVersion(semanticModel); if (string.Equals(attribute.ToString(), "OrchestrationTrigger")) { if (SyntaxNodeUtils.TryGetParameterNodeNextToAttribute(attribute, out SyntaxNode parameterNode)) { if (!ParameterTypeIsCorrectDurableType(parameterNode)) { if (TryGetRuleFromVersion(out DiagnosticDescriptor rule)) { var diagnostic = Diagnostic.Create(rule, parameterNode.GetLocation(), parameterNode); context.ReportDiagnostic(diagnostic); } } } } } }