private bool TryGetParameterOfType(SyntaxNode argument, SemanticModel semanticModel, string typeToCompare, out string parameter)
{
if (TryGetIdentifierNameChildNodes(argument, out IEnumerable <SyntaxNode> node) ||
TryGetSimpleMemberAccessExpressionChildNodes(argument, out node) ||
TryGetObjectCreationExpressionChildNodes(argument, out node))
{
if (TryGetIdentifierNameChildNodes(node.FirstOrDefault(), out IEnumerable <SyntaxNode> identifiers))
{
var typeWithoutNamespace = GetTypeWithoutNamespace(typeToCompare);
foreach (SyntaxNode identifier in identifiers)
{
if (string.Equals(identifier.ToString(), typeWithoutNamespace) ||
SyntaxNodeUtils.TryGetITypeSymbol(semanticModel, identifier, out ITypeSymbol type) &&
string.Equals(type.ToString(), typeToCompare))
{
parameter = node.First().ToString();
return(true);
}
}
}
}
parameter = null;
return(false);
}
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);
}
public void FindActivityFunction(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(context, 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 static bool TryGetInvocationInputType(SemanticModel semanticModel, ActivityFunctionCall activityInvocation, out ITypeSymbol invocationInputType)
{
var activityInput = activityInvocation.ArgumentNode;
if (activityInput == null)
{
invocationInputType = null;
return(false);
}
return(SyntaxNodeUtils.TryGetITypeSymbol(semanticModel, activityInput, out invocationInputType));
}
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 static bool TryGetDefinitionInputType(SemanticModel semanticModel, SyntaxNode parameterNode, out ITypeSymbol definitionInputType)
{
if (SyntaxNodeUtils.TryGetITypeSymbol(semanticModel, parameterNode, out definitionInputType))
{
if (SyntaxNodeUtils.IsDurableActivityContext(definitionInputType))
{
return(TryGetInputTypeFromContext(semanticModel, parameterNode, out definitionInputType));
}
return(true);
}
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
});
}
}
}
}
}
private static bool TryGetDefinitionInputType(SemanticModel semanticModel, ActivityFunctionDefinition functionDefinition, out ITypeSymbol definitionInputType)
{
var definitionInput = functionDefinition.ParameterNode;
if (definitionInput == null)
{
definitionInputType = null;
return(false);
}
if (SyntaxNodeUtils.TryGetITypeSymbol(semanticModel, definitionInput, out definitionInputType))
{
if (SyntaxNodeUtils.IsDurableActivityContext(definitionInputType))
{
return(TryGetInputTypeFromContext(semanticModel, definitionInput, out definitionInputType));
}
return(true);
}
definitionInputType = null;
return(false);
}
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);
SyntaxNodeUtils.TryGetITypeSymbol(semanticModel, returnTypeNode, out ITypeSymbol returnType);
TryGetInputNodeFromCallActivityInvocation(invocationExpression, out SyntaxNode inputNode);
SyntaxNodeUtils.TryGetITypeSymbol(semanticModel, inputNode, out ITypeSymbol inputType);
calledFunctions.Add(new ActivityFunctionCall
{
FunctionName = functionName,
NameNode = functionNameNode,
InputNode = inputNode,
InputType = inputType,
ReturnTypeNode = returnTypeNode,
ReturnType = returnType,
InvocationExpression = invocationExpression
});
}
}
internal static bool RegisterDiagnostic(CompilationAnalysisContext context, SemanticModel semanticModel, SyntaxNode method)
{
var diagnosedIssue = false;
foreach (SyntaxNode descendant in method.DescendantNodes())
{
if (descendant is IdentifierNameSyntax identifierName)
{
if (SyntaxNodeUtils.TryGetITypeSymbol(semanticModel, identifierName, out ITypeSymbol type))
{
if (IsIOClass(type.ToString()))
{
var diagnostic = Diagnostic.Create(Rule, identifierName.Identifier.GetLocation(), type);
context.ReportDiagnostic(diagnostic);
diagnosedIssue = true;
}
}
}
}
return(diagnosedIssue);
}
private static bool TryGetDefinitionReturnType(SemanticModel semanticModel, ActivityFunctionDefinition functionDefinition, out ITypeSymbol definitionReturnType)
{
var definitionReturnNode = functionDefinition.ReturnTypeNode;
return(SyntaxNodeUtils.TryGetITypeSymbol(semanticModel, definitionReturnNode, out definitionReturnType));
}
private static bool TryGetInvocationReturnType(SemanticModel semanticModel, ActivityFunctionCall activityInvocation, out ITypeSymbol invocationReturnType)
{
var invocationReturnNode = activityInvocation.ReturnTypeNode;
return(SyntaxNodeUtils.TryGetITypeSymbol(semanticModel, invocationReturnNode, out invocationReturnType));
}
