コード例 #1
0
        public static ISyntaxToken GetLastToken(SyntaxNodeBase node, bool includeZeroLength, bool includeSkippedTokens)
        {
            var tokenPredicate  = GetTokenPredicate(includeZeroLength);
            var triviaPredicate = GetTriviaPredicate(includeSkippedTokens);

            return(GetLastToken(node, tokenPredicate, triviaPredicate));
        }
コード例 #2
0
        private static SyntaxTreeBase ComputeSyntaxTree(SyntaxNodeBase node)
        {
            ArrayBuilder <SyntaxNodeBase> nodes = null;
            SyntaxTreeBase tree = null;

            // Find the nearest parent with a non-null syntax tree
            while (true)
            {
                tree = node._syntaxTree;
                if (tree != null)
                {
                    break;
                }

                var parent = node.Parent;
                if (parent == null)
                {
                    // root node: unexpected, root node should have a tree.
                    //Interlocked.CompareExchange(ref node._syntaxTree, CSharpSyntaxTree.CreateWithoutClone(node), null);
                    //tree = node._syntaxTree;
                    break;
                }

                tree = parent._syntaxTree;
                if (tree != null)
                {
                    node._syntaxTree = tree;
                    break;
                }

                (nodes ?? (nodes = ArrayBuilder <SyntaxNodeBase> .GetInstance())).Add(node);
                node = parent;
            }

            // Propagate the syntax tree downwards if necessary
            if (nodes != null)
            {
                Debug.Assert(tree != null);

                foreach (var n in nodes)
                {
                    var existingTree = n._syntaxTree;
                    if (existingTree != null)
                    {
                        Debug.Assert(existingTree == tree, "how could this node belong to a different tree?");

                        // yield the race
                        break;
                    }
                    n._syntaxTree = tree;
                }

                nodes.Free();
            }

            return(tree);
        }
コード例 #3
0
        private static ISyntaxToken GetPreviousToken(SyntaxNodeBase node, Func <ISyntaxToken, bool> tokenPredicate, Func <SyntaxNodeBase, bool> triviaPredicate)
        {
            if (node.Parent != null && !node.IsStructuredTrivia)
            {
                var returnNext = false;

                foreach (var nodeOrToken in node.Parent.ChildNodes.Reverse())
                {
                    if (returnNext)
                    {
                        if (nodeOrToken.IsToken)
                        {
                            var t = GetLastToken((ISyntaxToken)nodeOrToken, tokenPredicate, triviaPredicate);
                            if (t != null)
                            {
                                return(t);
                            }
                        }
                        else
                        {
                            var t = GetLastToken(nodeOrToken, tokenPredicate, triviaPredicate);
                            if (t != null)
                            {
                                return(t);
                            }
                        }
                    }

                    if (!nodeOrToken.IsToken && nodeOrToken == node)
                    {
                        returnNext = true;
                    }
                }

                return(GetPreviousToken(node.Parent, tokenPredicate, triviaPredicate));
            }

            if (!node.IsStructuredTrivia)
            {
                return(null);
            }

            var trivia = node.Parent as ISyntaxToken;

            return(trivia == null
                ? null
                : GetPreviousTokenFromTrivia(trivia, tokenPredicate, triviaPredicate));
        }
コード例 #4
0
        public static IEnumerable <SyntaxNodeBase> DescendantNodesAndSelf(this SyntaxNodeBase root)
        {
            var stack = new Stack <SyntaxNodeBase>();

            stack.Push(root);

            while (stack.Count > 0)
            {
                var current = stack.Pop();
                yield return(current);

                foreach (var child in current.ChildNodes.Reverse())
                {
                    stack.Push(child);
                }
            }
        }
コード例 #5
0
        private static ISyntaxToken GetNextToken(SyntaxNodeBase node, Func <ISyntaxToken, bool> tokenPredicate, Func <SyntaxNodeBase, bool> triviaPredicate)
        {
            if (node.Parent != null)
            {
                var returnNext = false;

                foreach (var nodeOrToken in node.Parent.ChildNodes)
                {
                    if (returnNext)
                    {
                        if (nodeOrToken.IsToken)
                        {
                            var t = GetFirstToken((ISyntaxToken)nodeOrToken, tokenPredicate, triviaPredicate);
                            if (t != null)
                            {
                                return(t);
                            }
                        }
                        else
                        {
                            var t = GetFirstToken(nodeOrToken, tokenPredicate, triviaPredicate);
                            if (t != null)
                            {
                                return(t);
                            }
                        }
                    }

                    if (!nodeOrToken.IsToken && nodeOrToken == node)
                    {
                        returnNext = true;
                    }
                }

                return(GetNextToken(node.Parent, tokenPredicate, triviaPredicate));
            }

            return(null);
        }
コード例 #6
0
        private static ISyntaxToken GetLastToken(SyntaxNodeBase node, Func <ISyntaxToken, bool> tokenPredicate, Func <SyntaxNodeBase, bool> triviaPredicate)
        {
            foreach (var nodeOrToken in node.ChildNodes.Reverse())
            {
                if (nodeOrToken.IsToken)
                {
                    var t = GetLastToken((ISyntaxToken)nodeOrToken, tokenPredicate, triviaPredicate);
                    if (t != null)
                    {
                        return(t);
                    }
                }
                else
                {
                    var t = GetLastToken(nodeOrToken, tokenPredicate, triviaPredicate);
                    if (t != null)
                    {
                        return(t);
                    }
                }
            }

            return(null);
        }
コード例 #7
0
 public static IEnumerable <SyntaxNodeBase> DescendantNodes(this SyntaxNodeBase root)
 {
     return(root.DescendantNodesAndSelf().Skip(1));
 }
コード例 #8
0
 public static ISyntaxToken GetLastToken(this SyntaxNodeBase token, bool includeZeroLength = false, bool includeSkippedTokens = false)
 {
     return(SyntaxNavigator.GetLastToken(token, includeZeroLength, includeSkippedTokens));
 }