C# SyntaxNode.DescendantNodes方法代码示例

        public override Token Get(SyntaxNode node)
        {
            var valueText = node
                .DescendantNodes()
                .OfType<IdentifierNameSyntax>()
                .Last()
                .Identifier.ValueText;

            if (valueText == null)
            {
                throw new NotImplementedException();
            }

            var args = node.ChildNodes().OfType<ArgumentListSyntax>().First()
                .ChildNodes().OfType<ArgumentSyntax>().ToArray();

            var whenClause = args[0].ChildNodes().First();

            var block = args[1]
                .ChildNodes().OfType<ParenthesizedLambdaExpressionSyntax>().First()
                .ChildNodes().OfType<BlockSyntax>().First();

            var details = new WhenClosureDetails(whenClause, block);

            return new Token("WhenClosure", details);
        }

        /* Get all the invocations of callee in the body of caller method. */
        public static IEnumerable<InvocationExpressionSyntax> GetAllInvocationsInMethod(SyntaxNode caller, SyntaxNode callee, SyntaxTree tree)
        {
            // Create semantic model of the given tree.
            SemanticModel model = CreateSemanticModel(tree);

            // Get the entry of callee in the symble table.
            Symbol calleeSymbol = model.GetDeclaredSymbol((MethodDeclarationSyntax)callee);

            // Get all the invocations in the caller.
            var allInvocations = caller.DescendantNodes().
                Where(n => n.Kind == SyntaxKind.InvocationExpression).
                    Select(n => (InvocationExpressionSyntax) n);

            // Among all the invocations, select the ones that are calling the callee symbol.
            return allInvocations.Where(i => model.GetSymbolInfo(i).Symbol == calleeSymbol);
        }

        public override Token Get(SyntaxNode node)
        {
            var valueText = node
                .DescendantNodes()
                .OfType<IdentifierNameSyntax>()
                .Last()
                .Identifier.ValueText;

            if (valueText == null)
            {
                throw new NotImplementedException();
            }

            valueText = Regex.Replace(valueText, "([a-z])([A-Z])", "$1 $2");
            return new Token("RuleFor", valueText);
        }

            protected override bool IsEmptyFinalizer(SyntaxNode node, SemanticModel model)
            {
                foreach (var exp in node.DescendantNodes().OfType<StatementSyntax>().Where(n => !n.IsKind(SyntaxKind.Block) && !n.IsKind(SyntaxKind.EmptyStatement)))
                {
                    // NOTE: FxCop only checks if there is any method call within a given destructor to decide an empty finalizer.
                    // Here in order to minimize false negatives, we conservatively treat it as non-empty finalizer if its body contains any statements.
                    // But, still conditional methods like Debug.Fail() will be considered as being empty as FxCop currently does.

                    var method = exp as ExpressionStatementSyntax;
                    if (method != null && HasConditionalAttribute(method.Expression, model))
                    {
                        continue;
                    }

                    return false;
                }

                return true;
            }

 public static IEnumerable<SyntaxNode> GetStatementsInNode(SyntaxNode block)
 {
     return block.DescendantNodes().Where(n => n is StatementSyntax);
 }

 /* Get all the method declarations contained in a root node. */
 public static IEnumerable<SyntaxNode> GetMethodsDeclarations(SyntaxNode root)
 {
     // Do not need to parse into the method.
     return root.DescendantNodes(n => n.Kind != SyntaxKind.MethodDeclaration).
         Where(n => n.Kind == SyntaxKind.MethodDeclaration);
 }

        protected internal sealed override IEnumerable<SyntaxNode> GetDescendants(SyntaxNode node)
        {
            if (node == _oldRoot || node == _newRoot)
            {
                Debug.Assert(_oldRoot != null && _newRoot != null);

                var rootChild = (node == _oldRoot) ? _oldRootChild : _newRootChild;

                if (HasLabel(rootChild))
                {
                    yield return rootChild;
                }

                node = rootChild;
            }

            // TODO: avoid allocation of closure
            foreach (var descendant in node.DescendantNodes(descendIntoChildren: c => !IsLeaf(c) && (c == node || !LambdaUtilities.IsLambdaBodyStatementOrExpression(c))))
            {
                if (!LambdaUtilities.IsLambdaBodyStatementOrExpression(descendant) && HasLabel(descendant))
                {
                    yield return descendant;
                }
            }
        }

        public static bool IsIteratorMethod(SyntaxNode declaration)
        {
            // lambdas and expression-bodied methods can't be iterators:
            if (!declaration.IsKind(SyntaxKind.MethodDeclaration))
            {
                return false;
            }

            // enumerate statements:
            return declaration.DescendantNodes(n => !(n is ExpressionSyntax))
                   .Any(n => n.IsKind(SyntaxKind.YieldBreakStatement) || n.IsKind(SyntaxKind.YieldReturnStatement));
        }

 protected override IEnumerable<SyntaxNode> GetNodes(SyntaxNode root)
 {
     return root.DescendantNodes().OfType<TypeDeclarationSyntax>();
 }

 private IEnumerable<SyntaxNode> GetInClassMethods(SyntaxNode root)
 {
     // Get the decendent whose type is method declaration, to do this, we do not need to
     // parse into the method.
     return root.DescendantNodes(n => n.Kind != SyntaxKind.MethodDeclaration).Where(
         n => n.Kind == SyntaxKind.MethodDeclaration);
 }

 private IEnumerable<SyntaxNode> GetDecendantOfKind(SyntaxNode parent, SyntaxKind kind)
 {
     return parent.DescendantNodes().Where(n => n.Kind == kind);
 }

 private IEnumerable<string> GetReturnedIdentifiers(SyntaxNode method)
 {
     var returnStatements = method.DescendantNodes().OfType<ReturnStatementSyntax>();
     return returnStatements.Select(s => s.Expression.GetText());
 }

 private SyntaxNode GetNodeInStructuredTrivia(SyntaxNode parent)
 {
     // Syntax references to nonterminals in structured trivia should be uncommon.
     // Provide more efficient implementation if that is not true
     var descendantsIntersectingSpan = parent.DescendantNodes(this.textSpan, descendIntoTrivia: true);
     return descendantsIntersectingSpan.First((node) => node.IsKind(this.kind) && node.Span == this.textSpan);
 }

#pragma warning restore 0414
    // ReSharper restore InconsistentNaming

    protected override SyntaxNode ComputeNewRootNode(SyntaxNode rootNode)
    {
      var namespaceDeclarations = rootNode.DescendantNodes().OfType<NamespaceDeclarationSyntax>();
      return rootNode.ReplaceNodes(namespaceDeclarations, (n1, n2) => ComputeNewNamespaceDeclarationNode(n1));
    }

 public static SyntaxNode GetBlockOfMethod(SyntaxNode method)
 {
     return method.DescendantNodes().FirstOrDefault(n => n.Kind == SyntaxKind.Block);
 }