C# SyntaxNode.GetAncestor方法代码示例

        public bool IsImport(SyntaxNode node, out string importFullName)
        {
            importFullName = string.Empty;

            if (node.GetAncestor<IfDirectiveTriviaSyntax>() != null
                || node.GetAncestor<ElifDirectiveTriviaSyntax>() != null)
            {
                return false;
            }

            var usingDirective = node.GetAncestor<UsingDirectiveSyntax>();
            importFullName = usingDirective == null ? null : usingDirective.Name.ToString();
            return usingDirective != null;
        }

        public bool IsType(SyntaxNode node)
        {
            if (node.GetAncestor<UsingDirectiveSyntax>() != null
                || node.Parent is NameMemberCrefSyntax
                || node.Parent is XmlCrefAttributeSyntax
                || node.Parent is XmlNameAttributeSyntax
                || node.Parent is MemberBindingExpressionSyntax
                || node.Parent is ConditionalAccessExpressionSyntax)
            {
                return false;
            }

            if (node.Parent is MemberAccessExpressionSyntax)
            {
                if (!node.Parent.ChildNodes().First().Equals(node))
                {                    
                    return false;
                }
            }

            return true;
        }

 public override SyntaxNode GetEffectiveParentForAttribute(SyntaxNode node)
 {
     if (node.HasAncestor<BaseFieldDeclarationSyntax>())
     {
         return node.GetAncestor<BaseFieldDeclarationSyntax>().Declaration.Variables.FirstOrDefault();
     }
     else if (node.HasAncestor<ParameterSyntax>())
     {
         return node.GetAncestor<ParameterSyntax>();
     }
     else
     {
         return node.Parent;
     }
 }

 public override SyntaxNode GetNodeWithAttributes(SyntaxNode node)
 {
     return node is VariableDeclaratorSyntax
            ? node.GetAncestor<MemberDeclarationSyntax>()
            : node;
 }

        internal override bool IsAddMethodContext(SyntaxNode node, SemanticModel semanticModel)
        {
            if (node.Parent.IsKind(SyntaxKind.CollectionInitializerExpression))
            {
                var objectCreationExpressionSyntax = node.GetAncestor<ObjectCreationExpressionSyntax>();
                if (objectCreationExpressionSyntax == null)
                {
                    return false;
                }

                return true;
            }

            return false;
        }

        protected override bool IsViableExtensionMethod(IMethodSymbol method, SyntaxNode expression, SemanticModel semanticModel, ISyntaxFactsService syntaxFacts, CancellationToken cancellationToken)
        {
            var leftExpression = syntaxFacts.GetExpressionOfMemberAccessExpression(expression) ?? syntaxFacts.GetExpressionOfConditionalMemberAccessExpression(expression);
            if (leftExpression == null)
            {
                if (expression.IsKind(SyntaxKind.CollectionInitializerExpression))
                {
                    leftExpression = expression.GetAncestor<ObjectCreationExpressionSyntax>();
                }
                else
                {
                    return false;
                }
            }

            var semanticInfo = semanticModel.GetTypeInfo(leftExpression, cancellationToken);
            var leftExpressionType = semanticInfo.Type;

            return leftExpressionType != null && method.ReduceExtensionMethod(leftExpressionType) != null;
        }

 private bool UsingsAreContainedInNamespace(SyntaxNode contextNode)
 {
     return contextNode.GetAncestor<NamespaceDeclarationSyntax>()?.DescendantNodes().OfType<UsingDirectiveSyntax>().FirstOrDefault() != null;
 }

        protected override bool CanAddImportForMethod(Diagnostic diagnostic, ISyntaxFactsService syntaxFacts, ref SyntaxNode node)
        {
            switch (diagnostic.Id)
            {
                case CS1061:
                    if (node.IsKind(SyntaxKind.ConditionalAccessExpression))
                    {
                        node = (node as ConditionalAccessExpressionSyntax).WhenNotNull;
                    }
                    else if (node.IsKind(SyntaxKind.MemberBindingExpression))
                    {
                        node = (node as MemberBindingExpressionSyntax).Name;
                    }
                    else if (node.Parent.IsKind(SyntaxKind.CollectionInitializerExpression))
                    {
                        return true;
                    }

                    break;
                case CS0122:
                case CS1501:
                    if (node is SimpleNameSyntax)
                    {
                        break;
                    }
                    else if (node is MemberBindingExpressionSyntax)
                    {
                        node = (node as MemberBindingExpressionSyntax).Name;
                    }
                    break;
                case CS1929:
                    var memberAccessName = (node.Parent as MemberAccessExpressionSyntax)?.Name;
                    var conditionalAccessName = (((node.Parent as ConditionalAccessExpressionSyntax)?.WhenNotNull as InvocationExpressionSyntax)?.Expression as MemberBindingExpressionSyntax)?.Name;
                    if (memberAccessName == null && conditionalAccessName == null)
                    {
                        return false;
                    }

                    node = memberAccessName ?? conditionalAccessName;
                    break;

                case CS1503:
                    //// look up its corresponding method name
                    var parent = node.GetAncestor<InvocationExpressionSyntax>();
                    if (parent == null)
                    {
                        return false;
                    }

                    var method = parent.Expression as MemberAccessExpressionSyntax;
                    if (method != null)
                    {
                        node = method.Name;
                    }

                    break;

                default:
                    return false;
            }

            var simpleName = node as SimpleNameSyntax;
            if (!simpleName.IsParentKind(SyntaxKind.SimpleMemberAccessExpression) &&
                !simpleName.IsParentKind(SyntaxKind.MemberBindingExpression))
            {
                return false;
            }

            var memberAccess = simpleName.Parent as MemberAccessExpressionSyntax;
            var memberBinding = simpleName.Parent as MemberBindingExpressionSyntax;
            if (memberAccess.IsParentKind(SyntaxKind.SimpleMemberAccessExpression) ||
                memberAccess.IsParentKind(SyntaxKind.ElementAccessExpression) ||
                memberBinding.IsParentKind(SyntaxKind.SimpleMemberAccessExpression) ||
                memberBinding.IsParentKind(SyntaxKind.ElementAccessExpression))
            {
                return false;
            }

            if (!syntaxFacts.IsMemberAccessExpressionName(node))
            {
                return false;
            }

            return true;
        }

 public bool IsExtension(SyntaxNode node)
 {
     return (node.Parent is MemberAccessExpressionSyntax)
         && node.GetAncestor<UsingDirectiveSyntax>() == null
         && !node.Parent.ChildNodes().First().Equals(node);
 }

 public bool IsAttribute(SyntaxNode node)
 {
     return  node.GetAncestor<AttributeSyntax>() != null;
 }

        static CodeAction Handle(Document document, Microsoft.CodeAnalysis.Text.TextSpan span, SyntaxNode root, SyntaxNode node, ExpressionSyntax iterateOver, bool replaceNode)
        {
            return CodeActionFactory.Create(
                span,
                DiagnosticSeverity.Info,
                "Iterate via 'foreach'",
                ct =>
                {
                    ForEachStatementSyntax foreachStmt = BuildForeach(iterateOver);

                    SyntaxNode newRoot;
                    var ancestor = node.GetAncestor<StatementSyntax>();
                    if (replaceNode)
                    {
                        newRoot = root.ReplaceNode(ancestor, new[] { foreachStmt.WithTrailingTrivia(ancestor.GetTrailingTrivia()) });
                    }
                    else
                    {
                        newRoot = root.InsertNodesAfter(ancestor, new[] { foreachStmt.WithTrailingTrivia(ancestor.GetTrailingTrivia()) });
                    }
                    return Task.FromResult(document.WithSyntaxRoot(newRoot));
                }
            );
        }

 CodeAction GetAction(Document document, SemanticModel model, SyntaxNode root, SyntaxNode node, MethodDeclarationSyntax method)
 {
     return CodeActionFactory.Create(node.Span, DiagnosticSeverity.Info, GettextCatalog.GetString("Extract anonymous method"), t2 =>
     {
         var identifier = SyntaxFactory.IdentifierName(NameGenerator.EnsureUniqueness("Method", model.LookupSymbols(node.SpanStart).Select(s => s.Name)));
         var surroundingMemberDeclaration = node.GetAncestor<MemberDeclarationSyntax>();
         var rootWithTrackedMember = root.TrackNodes(node, surroundingMemberDeclaration);
         var newRoot = rootWithTrackedMember.ReplaceNode(rootWithTrackedMember.GetCurrentNode(node), identifier);
         newRoot = newRoot
             .InsertNodesBefore(newRoot.GetCurrentNode(surroundingMemberDeclaration),
             new[] { method.WithTrailingTrivia(surroundingMemberDeclaration.GetTrailingTrivia()) });
         return Task.FromResult(document.WithSyntaxRoot(newRoot));
     });
 }