private static void AnalyzeAttributeClassName(SyntaxNodeAnalysisContext context)
{
var attributeExpression = context.Node as AttributeSyntax;
if (attributeExpression != null && attributeExpression.ChildNodes().First().ToString() == "EntityTrigger")
{
if (SyntaxNodeUtils.TryGetFunctionAttribute(attributeExpression, out SyntaxNode functionAttribute))
{
if (SyntaxNodeUtils.TryGetFunctionName(functionAttribute, out SyntaxNode attributeArgument))
{
var functionName = attributeArgument.ToString().Trim('"');
if (SyntaxNodeUtils.TryGetClassSymbol(attributeExpression, context.SemanticModel, out INamedTypeSymbol classSymbol))
{
var className = classSymbol.Name.ToString();
if (!ClassNameMatchesFunctionName(classSymbol, functionName))
{
var diagnosticClassName = Diagnostic.Create(Rule, classSymbol.Locations[0], className, functionName);
var diagnosticAttribute = Diagnostic.Create(Rule, attributeArgument.GetLocation(), className, functionName);
context.ReportDiagnostic(diagnosticClassName);
context.ReportDiagnostic(diagnosticAttribute);
}
}
}
}
}
}
public void FindActivityFunction(SyntaxNodeAnalysisContext context)
{
var attribute = context.Node as AttributeSyntax;
if (SyntaxNodeUtils.IsActivityTriggerAttribute(attribute))
{
if (!SyntaxNodeUtils.TryGetFunctionName(context.SemanticModel, attribute, 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
});
}
}
public void FindActivityFunctionDefinition(SyntaxNodeAnalysisContext context)
{
var semanticModel = context.SemanticModel;
if (context.Node is AttributeSyntax attribute &&
SyntaxNodeUtils.IsActivityTriggerAttribute(attribute))
{
if (!SyntaxNodeUtils.TryGetFunctionName(semanticModel, attribute, 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.TryGetITypeSymbol(semanticModel, returnTypeNode, out ITypeSymbol returnType);
SyntaxNodeUtils.TryGetParameterNodeNextToAttribute(attribute, out SyntaxNode parameterNode);
TryGetDefinitionInputType(semanticModel, parameterNode, out ITypeSymbol inputType);
availableFunctions.Add(new ActivityFunctionDefinition
{
FunctionName = functionName,
ParameterNode = parameterNode,
InputType = inputType,
ReturnTypeNode = returnTypeNode,
ReturnType = returnType
});
}
}
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);
}
}
}
}
}
}
private static bool IsInEntityClass(SemanticModel semanticModel, SyntaxNode methodDeclaration)
{
if (SyntaxNodeUtils.TryGetFunctionName(semanticModel, methodDeclaration, 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.TryGetFunctionName(semanticModel, identifierNode, out string functionName))
{
context.RegisterCodeFix(
CodeAction.Create(FixDispatchEntityCall.ToString(), cancellationToken => CodeFixProviderUtils.ReplaceWithIdentifierAsync(context.Document, identifierNode, cancellationToken, functionName), nameof(DispatchEntityNameCodeFixProvider)),
diagnostic);
}
}
public void FindActivities(SyntaxNodeAnalysisContext context)
{
var attributeExpression = context.Node as AttributeSyntax;
if (attributeExpression != null && attributeExpression.ChildNodes().First().ToString() == "ActivityTrigger")
{
if (SyntaxNodeUtils.TryGetFunctionAttribute(attributeExpression, out SyntaxNode functionAttribute))
{
if (SyntaxNodeUtils.TryGetFunctionName(functionAttribute, out SyntaxNode attributeArgument))
{
var functionName = attributeArgument.ToString().Trim('"');
if (SyntaxNodeUtils.TryGetParameterNodeNextToAttribute(attributeExpression, context, out SyntaxNode inputTypeNode))
{
ITypeSymbol inputType = context.SemanticModel.GetTypeInfo(inputTypeNode).Type;
if (inputType.ToString().Equals("Microsoft.Azure.WebJobs.IDurableActivityContext") || inputType.ToString().Equals("Microsoft.Azure.WebJobs.DurableActivityContext"))
{
if (!TryGetInputTypeFromDurableContextCall(out inputType, context, attributeExpression))
{
return;
}
}
if (SyntaxNodeUtils.TryGetReturnType(attributeExpression, context, out ITypeSymbol returnType))
{
availableFunctions.Add(new ActivityFunctionDefinition
{
FunctionName = functionName,
InputType = GetQualifiedTypeName(inputType),
ReturnType = GetQualifiedTypeName(returnType)
});
}
}
}
}
}
}
