Massively speedup parser table generation

Through avoidance of unnecessary work and better use of modern Python
data structures, I've been able to reduce the total build time of the
three EdgeDB parsers from ~200s to ~26s, a factor of 7.7!

Author: elprans

parsing/__init__.py

@@ -124,21 +124,23 @@
 
 
 __all__ = (
-    "SpecError",
-    "UnexpectedToken",
+    "Glr",
+    "Lr",
+    "ModuleSpecSource",
     "Nonterm",
+    "Parser",
     "Precedence",
     "Spec",
+    "SpecError",
+    "SpecSource",
+    "UnexpectedToken",
     "Token",
-    "Lr",
-    "Glr",
-    "ModuleSpecSource",
 )
 
-from parsing.ast import Nonterm, Token
 from parsing.automaton import Spec
-from parsing.grammar import Precedence
+from parsing.ast import Nonterm, Token, Precedence
 from parsing.errors import SpecError, UnexpectedToken
+from parsing.interfaces import Parser, SpecSource
 from parsing.module_spec import ModuleSpecSource
 from parsing.lrparser import Lr
 from parsing.glrparser import Glr

parsing/ast.py

@@ -9,7 +9,8 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from parsing.interfaces import Parser, SymbolSpec
+    from parsing.grammar import SymbolSpec
+    from parsing.interfaces import Parser
 
 
 class Symbol:
@@ -134,3 +135,75 @@ class id(Token):
 
     def __init__(self, parser: Parser) -> None:
         Symbol.__init__(self, parser.sym_spec(self), parser)
+
+
+class Precedence:
+    """
+    Precedences can be associated with tokens, non-terminals, and
+    productions.  Precedence isn't as important for GLR parsers as for LR
+    parsers, since GLR parsing allows for parse-time resolution of
+    ambiguity.  Still, precedence can be useful for reducing the volume of
+    ambiguities that must be dealt with at run-time.
+
+    There are five precedence types: %fail, %nonassoc, %left, %right, and
+    %split.  Each precedence can have relationships with other precedences:
+    <, >, or =.  These relationships specify a directed acyclic graph (DAG),
+    which is used to compute the transitive closures of relationships among
+    precedences.  If no path exists between two precedences that are
+    compared during conflict resolution, parser generation fails.  < and >
+    are reflexive; it does not matter which is used.  Conceptually, the =
+    relationship causes precedences to share a node in the DAG.
+
+    During conflict resolution, an error results if no path exists in the
+    DAG between the precedences under consideration.  When such a path
+    exists, the highest precedence non-terminal or production takes
+    precedence.  Associativity only comes into play for shift/reduce
+    conflicts, where the terminal and the production have equivalent
+    precedences (= relationship).  In this case, the non-terminal's
+    associativity determines how the conflict is resolved.
+
+    The %fail and %split associativities are special because they can be
+    mixed with other associativities.  During conflict resolution, if
+    another action has non-%fail associativity, then the %fail (lack of)
+    associativity is overridden.  Similarly, %split associativity overrides
+    any other associativity.  In contrast, any mixture of associativity
+    between %nonassoc/%left/%right causes an unresolvable conflict.
+
+        %fail : Any conflict is a parser-generation-time error.
+
+                A pre-defined precedence, [none], is provided.  It has
+                %fail associativity, and has no pre-defined precedence
+                relationships.
+
+    %nonassoc : Resolve shift/reduce conflicts by removing both
+                possibilities, thus making conflicts a parse-time error.
+
+        %left : Resolve shift/reduce conflicts by reducing.
+
+        %right : Resolve shift/reduce conflicts by shifting.
+
+        %split : Do not resolve conflicts; the GLR algorithm will split
+                the parse stack when necessary.
+
+                A pre-defined precedence, [split], is provided.  It has
+                %split associativity, and has no pre-defined precedence
+                relationships.
+
+    By default, all symbols have [none] precedence.  Each production
+    inherits the precedence of its left-hand-side nonterminal's precedence
+    unless a precedence is manually specified for the production.
+
+    Following are some examples of how to specify precedence classes:
+
+    class P1(Parsing.Precedence):
+        "%split p1"
+
+    class p2(Parsing.Precedence):
+        "%left" # Name implicitly same as class name.
+
+    class P3(Parsing.Precedence):
+        "%left p3 >p2" # No whitespace is allowed between > and p2.
+
+    class P4(Parsing.Precedence):
+        "%left p4 =p3" # No whitespace is allowed between = and p3.
+    """