private static bool TryGetInputFromDurableContextCall(SemanticModel semanticModel, SyntaxNode definitionInput, out SyntaxNode inputFromContext)
{
if (SyntaxNodeUtils.TryGetMethodDeclaration(definitionInput, out SyntaxNode methodDeclaration))
{
var memberAccessExpressionList = methodDeclaration.DescendantNodes().Where(x => x.IsKind(SyntaxKind.SimpleMemberAccessExpression));
foreach (var memberAccessExpression in memberAccessExpressionList)
{
var identifierName = memberAccessExpression.ChildNodes().Where(x => x.IsKind(SyntaxKind.IdentifierName)).FirstOrDefault();
if (identifierName != null)
{
var identifierNameType = SyntaxNodeUtils.GetSyntaxTreeSemanticModel(semanticModel, identifierName).GetTypeInfo(identifierName).Type.Name;
if (identifierNameType.Equals("IDurableActivityContext") || identifierNameType.Equals("DurableActivityContext") || identifierNameType.Equals("DurableActivityContextBase"))
{
var genericName = memberAccessExpression.ChildNodes().Where(x => x.IsKind(SyntaxKind.GenericName)).FirstOrDefault();
if (genericName != null)
{
var typeArgumentList = genericName.ChildNodes().Where(x => x.IsKind(SyntaxKind.TypeArgumentList)).FirstOrDefault();
if (typeArgumentList != null)
{
inputFromContext = typeArgumentList.ChildNodes().First();
return(true);
}
}
}
}
}
}
inputFromContext = null;
return(false);
}
private static bool TryGetInputTypeFromDurableContextCall(out ITypeSymbol inputTypeNode, SyntaxNodeAnalysisContext context, AttributeSyntax attributeExpression)
{
if (SyntaxNodeUtils.TryGetMethodDeclaration(attributeExpression, out SyntaxNode methodDeclaration))
{
var memberAccessExpressionList = methodDeclaration.DescendantNodes().Where(x => x.IsKind(SyntaxKind.SimpleMemberAccessExpression));
foreach (var memberAccessExpression in memberAccessExpressionList)
{
var identifierName = memberAccessExpression.ChildNodes().Where(x => x.IsKind(SyntaxKind.IdentifierName));
if (identifierName.Any())
{
var identifierNameType = context.SemanticModel.GetTypeInfo(identifierName.First()).Type.Name;
if (identifierNameType.Equals("IDurableActivityContext") || identifierNameType.Equals("DurableActivityContext"))
{
var genericName = memberAccessExpression.ChildNodes().Where(x => x.IsKind(SyntaxKind.GenericName));
if (genericName.Any())
{
var typeArgumentListEnumerable = genericName.First().ChildNodes().Where(x => x.IsKind(SyntaxKind.TypeArgumentList));
if (typeArgumentListEnumerable.Any())
{
inputTypeNode = context.SemanticModel.GetTypeInfo(typeArgumentListEnumerable.First().ChildNodes().First()).Type;
return(true);
}
}
}
}
}
}
inputTypeNode = null;
return(false);
}
public static bool TryGetDurableOrchestrationContextVariableName(SyntaxNode node, out string variableName)
{
if (SyntaxNodeUtils.TryGetMethodDeclaration(node, out SyntaxNode methodDeclaration))
{
var parameterList = methodDeclaration.ChildNodes().Where(x => x.IsKind(SyntaxKind.ParameterList)).First();
foreach (SyntaxNode parameter in parameterList.ChildNodes())
{
var attributeLists = parameter.ChildNodes().Where(x => x.IsKind(SyntaxKind.AttributeList));
foreach (SyntaxNode attributeList in attributeLists)
{
if (attributeList.ChildNodes().First().ToString().Equals("OrchestrationTrigger"))
{
var identifierName = parameter.ChildNodes().Where(x => x.IsKind(SyntaxKind.IdentifierName)).FirstOrDefault()?.ToString();
if (string.Equals(identifierName, "IDurableOrchestrationContext") || string.Equals(identifierName, "DurableOrchestrationContext") || string.Equals(identifierName, "DurableOrchestrationContextBase"))
{
//A parameter will always have an IdentifierToken
var identifierToken = parameter.ChildTokens().Where(x => x.IsKind(SyntaxKind.IdentifierToken)).First().ToString();
if (!string.Equals(identifierToken, ""))
{
variableName = identifierToken;
return(true);
}
}
}
}
}
}
variableName = null;
return(false);
}
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 TryGetDurableActivityContextExpression(SemanticModel semanticModel, SyntaxNode node, out SyntaxNode durableContextExpression)
{
if (SyntaxNodeUtils.TryGetMethodDeclaration(node, out SyntaxNode methodDeclaration))
{
var memberAccessExpressionList = methodDeclaration.DescendantNodes().Where(x => x.IsKind(SyntaxKind.SimpleMemberAccessExpression));
foreach (var memberAccessExpression in memberAccessExpressionList)
{
var identifierName = memberAccessExpression.ChildNodes().FirstOrDefault(x => x.IsKind(SyntaxKind.IdentifierName));
if (identifierName != null)
{
if (SyntaxNodeUtils.TryGetITypeSymbol(semanticModel, identifierName, out ITypeSymbol typeSymbol))
{
if (SyntaxNodeUtils.IsDurableActivityContext(typeSymbol))
{
durableContextExpression = memberAccessExpression;
return(true);
}
}
}
}
}
durableContextExpression = null;
return(false);
}
private static bool TryGetReturnType(SyntaxNodeAnalysisContext context, AttributeSyntax attributeExpression, out ITypeSymbol returnType)
{
if (SyntaxNodeUtils.TryGetMethodDeclaration(attributeExpression, out SyntaxNode methodDeclaration))
{
returnType = context.SemanticModel.GetTypeInfo((methodDeclaration as MethodDeclarationSyntax).ReturnType).Type;
return(true);
}
returnType = null;
return(false);
}
private async Task <Document> AddStaticModifierAsync(Document document, SyntaxNode identifierNode, CancellationToken cancellationToken)
{
var root = await document.GetSyntaxRootAsync(cancellationToken);
if (SyntaxNodeUtils.TryGetMethodDeclaration(identifierNode, out SyntaxNode methodDeclaration))
{
var newMethodDeclaration = ((MethodDeclarationSyntax)methodDeclaration).AddModifiers(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
var newRoot = root.ReplaceNode(methodDeclaration, newMethodDeclaration);
return(document.WithSyntaxRoot(newRoot));
}
return(document);
}
private static void AnalyzeAttributeClassName(SyntaxNodeAnalysisContext context)
{
var attributeExpression = context.Node as AttributeSyntax;
if (attributeExpression != null && attributeExpression.ChildNodes().First().ToString() == "EntityTrigger")
{
if (SyntaxNodeUtils.TryGetMethodDeclaration(attributeExpression, out SyntaxNode methodDeclaration))
{
var staticKeyword = methodDeclaration.ChildTokens().Where(x => x.IsKind(SyntaxKind.StaticKeyword));
if (!staticKeyword.Any())
{
var methodName = methodDeclaration.ChildTokens().Where(x => x.IsKind(SyntaxKind.IdentifierToken)).First();
var diagnostic = Diagnostic.Create(Rule, methodName.GetLocation(), methodName);
context.ReportDiagnostic(diagnostic);
}
}
}
}
