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