public BuildNode PrependCurrentNode(
                SyntaxNode prependedSyntax,
                DisplayNodeConfig displayConfig = DisplayNodeConfig.Ignore,
                bool isFinal = false)
            {
                // The syntaxes will be swaped subsequently
                var prependedCurrent = isFinal
                    ? this.CurrentNode
                    : this.ReenqueueCurrentNode(this.CurrentNode.Syntax);
                var newCurrent = this.AddFinalNode(prependedSyntax);

                // Swaping contents will change the outgoing edges, i.a.
                newCurrent.SwapContents(prependedCurrent);
                prependedCurrent.AddEdge(newCurrent);

                this.CurrentNode = newCurrent;

                if (displayConfig == DisplayNodeConfig.CreateNew)
                {
                    prependedCurrent.DisplayNode = this.AddDisplayNode(prependedSyntax.Span);
                }
                else if (displayConfig == DisplayNodeConfig.Inherit)
                {
                    prependedCurrent.DisplayNode = this.CurrentNode.DisplayNode;
                }

                return(prependedCurrent);
            }
            public BuildNode EnqueueNode(SyntaxNode syntax, DisplayNodeConfig displayConfig = DisplayNodeConfig.Ignore)
            {
                var node = this.Graph.AddNode(syntax);

                this.builder.readyQueue.Enqueue(node);

                if (displayConfig == DisplayNodeConfig.CreateNew)
                {
                    node.DisplayNode = this.AddDisplayNode(syntax.Span);
                }
                else if (displayConfig == DisplayNodeConfig.Inherit)
                {
                    node.DisplayNode = this.CurrentNode.DisplayNode;
                }

                return(node);
            }
Esempio n. 3
0
        protected void ProcessSequentially <TSyntax>(
            IReadOnlyList <TSyntax> syntaxes,
            DisplayNodeConfig displayConfig = DisplayNodeConfig.Ignore)
            where TSyntax : SyntaxNode
        {
            if (syntaxes.Count > 0)
            {
                var precedingStatement = this.Context.ReenqueueCurrentNode(
                    syntaxes.First(),
                    createDisplayNode: displayConfig == DisplayNodeConfig.CreateNew);

                if (syntaxes.Count > 1)
                {
                    var outEdges = precedingStatement.OutgoingEdges.ToArray();
                    precedingStatement.OutgoingEdges.Clear();

                    for (int i = 1; i < syntaxes.Count; i++)
                    {
                        var syntax           = syntaxes[i];
                        var currentStatement = this.Context.EnqueueNode(syntax);
                        precedingStatement.AddEdge(currentStatement);

                        if (displayConfig == DisplayNodeConfig.CreateNew)
                        {
                            currentStatement.DisplayNode = this.Context.AddDisplayNode(syntax.Span);
                        }
                        else if (displayConfig == DisplayNodeConfig.Inherit)
                        {
                            currentStatement.DisplayNode = precedingStatement.DisplayNode;
                        }

                        precedingStatement = currentStatement;
                    }

                    precedingStatement.OutgoingEdges.AddRange(outEdges);
                }
            }
        }