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