/// <summary>
        /// Compute the LR(1) closure including lookaheads in the item sets (page 261 of Compilers 2nd Ed.)
        /// </summary>
        private LrItemSet Lr1Closure(SymbolMetaDictionary symbolMeta, LrItemSet items)
        {
            // Initialize the return set to the item set
            var newset = new LrItemSet(items)
            {
                IsClosed = true
            };
            var toAdd         = new List <LrItem>();
            var newLookaheads = new HashSet <SymbolId>();

            do
            {
                toAdd.Clear();
                // For each item in the set with a marker before a nonterminal
                foreach (var item in newset.Where(i => (i.Marker < i.Length) && (this.symbols[i.Rule.RuleSymbolIds[i.Marker]] == SymbolKind.Nonterminal)))
                {
                    var nonterminal = item.Rule.RuleSymbolIds[item.Marker];
                    // Get all the possible lookaheads past this symbol
                    newLookaheads.Clear();
                    foreach (var lookahead in item.LookaheadIds)
                    {
                        var followingSymbols = item.Rule.RuleSymbolIds.Skip(item.Marker + 1).Append(lookahead);
                        newLookaheads.UnionWith(symbolMeta.FirstOfAll(followingSymbols));
                    }
                    if (newLookaheads.Any())
                    {
                        // For each rule of the production past the marker for this item
                        toAdd.AddRange(this.ProductionRulesBySymbol[nonterminal].Select(rule => new LrItem(rule, 0, false, newLookaheads)));
                    }
                }
            } while ((toAdd.Count > 0) && newset.MergeWith(toAdd));
            return(newset);
        }
        /// <summary>
        /// Time- and space-optimized goto which returns gotos for all relevant symbols, storing kernels only.
        /// For this function, the input state must have its closure production heads computed (with LR0ComputeClosureNonterminals).
        /// The output states do not have closure productions.
        /// </summary>
        private Dictionary <SymbolId, LrItemSet> Lr0GotoKernels(LrItemSet itemSet)
        {
            if (itemSet.ClosureProductions == null)
            {
                throw new InvalidOperationException();
            }
            // Create new items by advancing the marker for the input kernels
            var kernelItems = itemSet
                              .Kernels
                              .Where(k => k.Marker < k.Length)
                              .Select(k => new KeyValuePair <SymbolId, LrItem>(k.Rule.RuleSymbolIds[k.Marker], new LrItem(k.Rule, k.Marker + 1, true)));
            // Create new items from the nonkernels (using closure production heads)
            // Since goto is to be computed for ALL symbols, advance the marker for all nonkernels
            // The first item in the rule is the goto symbol, and the marker is advanced past the first item
            var nonKernelItems = itemSet
                                 .ClosureProductions
                                 .SelectMany(n => this.ProductionRulesBySymbol[n])
                                 .Where(r => r.RuleSymbolIds.Count > 0)
                                 .Select(r => new KeyValuePair <SymbolId, LrItem>(r.RuleSymbolIds[0], new LrItem(r, 1, true)));

            // The dictionary will contain item sets for all possible goto symbols X, Y, and Z for the given input state
            return(kernelItems
                   .Concat(nonKernelItems)
                   .GroupBy(t => t.Key, t => t.Value)
                   .ToDictionary(g => g.Key, g => new LrItemSet(g)));
        }
        private void Lr0ComputeClosureNonterminals(LrItemSet itemSet)
        {
            if (itemSet.ClosureProductions != null)
            {
                return;
            }
            // Initialize the set with the next symbol at each marker
            var nonterminalSet = new HashSet <SymbolId>(MarkedSymbols(itemSet).Where(this.IsNonterminal));
            var queue          = new Queue <SymbolId>(nonterminalSet);

            while (queue.Count > 0)
            {
                var current = queue.Dequeue();
                // Get the first nonterminal from rules starting with these
                foreach (var nonterminal in FirstSymbols(this.ProductionRulesBySymbol[current]).Where(this.IsNonterminal).Distinct())
                {
                    if (nonterminalSet.Add(nonterminal))
                    {
                        // New production, add it to the closure
                        queue.Enqueue(nonterminal);
                    }
                }
            }
            itemSet.ClosureProductions = nonterminalSet;
        }
        private void ComputeLr0ItemSetKernelsAndGotoLookup(out LrItemSetCollection itemSets, out Dictionary <int, Dictionary <SymbolId, int> > gotos, out int acceptIndex)
        {
            itemSets = new LrItemSetCollection();
            gotos    = new Dictionary <int, Dictionary <SymbolId, int> >();
            var itemSetByKernels = new Dictionary <IEnumerable <LrItem>, LrItemSet>(SetEqualityComparer <LrItem> .Default);
            var queue            = new Queue <LrItemSet>();
            var startItem        = new LrItemSet(new LrItem(this.ProductionRulesBySymbol[this.Init].Single(), 0, true));

            this.Lr0ComputeClosureNonterminals(startItem);
            itemSets.StartState = startItem;
            acceptIndex         = this.ProductionRulesBySymbol[this.Init].Single().Index;
            startItem.Index     = itemSets.Count;
            itemSets.Add(startItem);
            itemSetByKernels.Add(startItem.Kernels.ToArray(), startItem);
            queue.Enqueue(startItem);
            while (queue.Count > 0)
            {
                var itemSet       = queue.Dequeue();
                var gotoLookup    = this.Lr0GotoKernels(itemSet);
                var gotosForState = new Dictionary <SymbolId, int>();
                gotos.Add(itemSet.Index, gotosForState);
                foreach (var symbol in gotoLookup.Keys)
                {
                    if (!itemSetByKernels.TryGetValue(gotoLookup[symbol].Kernels, out var gotoState))
                    {
                        gotoState = gotoLookup[symbol];
                        this.Lr0ComputeClosureNonterminals(gotoState);
                        gotoState.Index = itemSets.Count;
                        itemSets.Add(gotoState);
                        itemSetByKernels.Add(gotoState.Kernels.ToArray(), gotoState);
                        queue.Enqueue(gotoState);
                    }
                    gotosForState.Add(symbol, gotoState.Index);
                }
            }
        }
        private LrItemSetCollection ComputeItemSets(SymbolMetaDictionary symbolMeta, out int acceptIndex)
        {
            this.ComputeLr0ItemSetKernelsAndGotoLookup(out var itemSets, out var gotoSymbol, out acceptIndex);
            var dummyLookahead = new[] { this.Unknown };

            itemSets.StartState.Single().LookaheadIds.Add(this.Eof);
            var rulePropagations = new Dictionary <StateKey <LrItem>, HashSet <StateKey <LrItem> > >();

            foreach (var itemSet in itemSets)
            {
                var gotosForState = gotoSymbol[itemSet.Index];
                foreach (var kernelItem in itemSet)
                {
                    var itemKey = new StateKey <LrItem>(itemSet.Index, kernelItem);
                    // Create an item set with a dummy lookahead, based on the current item set
                    var dummyItem    = new LrItem(kernelItem.Rule, kernelItem.Marker, kernelItem.Marker > 0, dummyLookahead);
                    var dummyItemSet = new LrItemSet(dummyItem.Yield());
                    var j            = this.Lr1Closure(symbolMeta, dummyItemSet);
                    foreach (var gotoForState in gotosForState)
                    {
                        var gotoItemSet    = itemSets[gotoForState.Value];
                        var gotoItemLookup = gotoItemSet.ToDictionary(g => g, g => g);
                        // Find the items in the dummy set with the marker before this symbol
                        foreach (var b in j.Where(bb => (bb.Marker < bb.Length) && bb.Rule.RuleSymbolIds[bb.Marker].Equals(gotoForState.Key)))
                        {
                            // Get the item corresponding to the goto state with the marker past the current symbol
                            var gotoItem = gotoItemLookup[new LrItem(b.Rule, b.Marker + 1, true)];
                            if (b.LookaheadIds.Any(l => l == this.Unknown))
                            {
                                if (!rulePropagations.ContainsKey(itemKey))
                                {
                                    rulePropagations[itemKey] = new HashSet <StateKey <LrItem> >();
                                }
                                rulePropagations[itemKey].Add(new StateKey <LrItem>(gotoItemSet.Index, gotoItem));
                            }
                            gotoItem.LookaheadIds.UnionWith(b.LookaheadIds.Where(l => l != this.Unknown));
                        }
                    }
                }
            }
            bool changed;

            do
            {
                changed = false;
                foreach (var itemSet in itemSets)
                {
                    foreach (var item in itemSet)
                    {
                        var itemKey = new StateKey <LrItem>(itemSet.Index, item);
                        if (!rulePropagations.TryGetValue(itemKey, out var propagated))
                        {
                            continue;
                        }
                        foreach (var key in propagated)
                        {
                            if (key.Value.LookaheadIds.AddRange(item.LookaheadIds))
                            {
                                changed = true;
                            }
                        }
                    }
                }
            } while (changed);
            // Close all kernels
            for (var i = 0; i < itemSets.Count; i++)
            {
                itemSets[i]       = this.Lr1Closure(symbolMeta, itemSets[i]);
                itemSets[i].Index = i;
            }
            return(itemSets);
        }