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);
}
}
}
}
private void AnalyzeDispatchAndFindMethodDeclarations(SyntaxNodeAnalysisContext context)
{
if (context.Node is MemberAccessExpressionSyntax expression &&
SyntaxNodeUtils.IsInsideFunction(context.SemanticModel, expression))
{
var name = expression.Name;
if (name.ToString().StartsWith("DispatchAsync"))
{
if (SyntaxNodeUtils.TryGetMethodDeclaration(expression, out SyntaxNode methodDeclaration))
{
methodDeclarations.Add(methodDeclaration);
}
if (SyntaxNodeUtils.TryGetTypeArgumentIdentifier(expression, out SyntaxNode identifierNode))
{
if (SyntaxNodeUtils.TryGetFunctionName(context.SemanticModel, expression, out string functionName))
{
var identifierName = identifierNode.ToString();
if (!string.Equals(identifierName, functionName))
{
var diagnostic = Diagnostic.Create(Rule, identifierNode.GetLocation(), identifierNode, functionName);
context.ReportDiagnostic(diagnostic);
}
}
}
}
}
}
public void FindActivityCall(SyntaxNodeAnalysisContext context)
{
SetSemanticModel(context);
var semanticModel = context.SemanticModel;
if (context.Node is InvocationExpressionSyntax invocationExpression &&
SyntaxNodeUtils.IsInsideFunction(semanticModel, invocationExpression) &&
IsActivityInvocation(invocationExpression))
{
if (!TryGetFunctionNameFromActivityInvocation(invocationExpression, out SyntaxNode functionNameNode, out string functionName))
{
//Do not store ActivityFunctionCall if there is no function name
return;
}
SyntaxNodeUtils.TryGetTypeArgumentIdentifier((MemberAccessExpressionSyntax)invocationExpression.Expression, out SyntaxNode returnTypeNode);
TryGetInputNodeFromCallActivityInvocation(invocationExpression, out SyntaxNode inputNode);
calledFunctions.Add(new ActivityFunctionCall
{
FunctionName = functionName,
NameNode = functionNameNode,
ArgumentNode = inputNode,
ReturnTypeNode = returnTypeNode,
InvocationExpression = invocationExpression
});
}
}
private static bool TryGetInputTypeFromContext(SemanticModel semanticModel, SyntaxNode node, out ITypeSymbol definitionInputType)
{
if (TryGetDurableActivityContextExpression(semanticModel, node, out SyntaxNode durableContextExpression))
{
if (SyntaxNodeUtils.TryGetTypeArgumentIdentifier((MemberAccessExpressionSyntax)durableContextExpression, out SyntaxNode typeArgument))
{
return(SyntaxNodeUtils.TryGetITypeSymbol(semanticModel, typeArgument, out definitionInputType));
}
}
definitionInputType = null;
return(false);
}
private void FindActivityCalls()
{
var orchestratorMethods = this.orchestratorMethodCollector.GetOrchestratorMethods();
foreach (MethodInformation methodInformation in orchestratorMethods)
{
var declaration = methodInformation.Declaration;
if (declaration != null)
{
var invocationExpressions = declaration.DescendantNodes().OfType <InvocationExpressionSyntax>();
this.semanticModel = methodInformation.SemanticModel;
foreach (var invocation in invocationExpressions)
{
if (IsActivityInvocation(invocation))
{
if (!TryGetFunctionNameFromActivityInvocation(invocation, out SyntaxNode functionNameNode, out string functionName))
{
//Do not store ActivityFunctionCall if there is no function name
return;
}
SyntaxNodeUtils.TryGetTypeArgumentIdentifier((MemberAccessExpressionSyntax)invocation.Expression, out SyntaxNode returnTypeNode);
SyntaxNodeUtils.TryGetITypeSymbol(this.semanticModel, returnTypeNode, out ITypeSymbol returnType);
TryGetInputNodeFromCallActivityInvocation(this.semanticModel, invocation, out SyntaxNode inputNode);
SyntaxNodeUtils.TryGetITypeSymbol(this.semanticModel, inputNode, out ITypeSymbol inputType);
this.calledFunctions.Add(new ActivityFunctionCall
{
FunctionName = functionName,
NameNode = functionNameNode,
InputNode = inputNode,
InputType = inputType,
ReturnTypeNode = returnTypeNode,
ReturnType = returnType,
InvocationExpression = invocation
});
}
}
}
}
}
