fix: Inline precedence operators in DSL parser codegen

crates/solidity/inputs/language/src/grammar.rs

@@ -148,6 +148,8 @@ impl GrammarConstructorDslV2 for Grammar {
                 GrammarElement::ParserDefinition(Rc::new(NamedParserThunk {
                     name: parser_name.to_string().leak(),
                     context: lex_ctx.to_string().leak(),
+                    // Must be outlined for the codegen to include referred by it keywords in the trie.
+                    is_inline: false,
                     def: OnceCell::from(def),
                 })),
             );
@@ -214,6 +216,7 @@ impl TriviaParserDefinition for NamedTriviaParser {
 struct NamedParserThunk {
     name: &'static str,
     context: &'static str,
+    is_inline: bool,
     def: OnceCell<ParserDefinitionNode>,
 }
 
@@ -227,21 +230,7 @@ impl ParserDefinition for NamedParserThunk {
     }
 
     fn is_inline(&self) -> bool {
-        // HACK(#638): Make sure all keywords are referred to by a parser, so that codegen includes them in the trie.
-        if self.name().ends_with("AllKeywords") {
-            return false;
-        }
-
-        // The DSL v2 definition already inlines the elements, however `Enum`s
-        // are not but should be, since they only have a single reference per variant.
-        match self.node() {
-            ParserDefinitionNode::Versioned(node, _) => match **node {
-                ParserDefinitionNode::Choice(_) => true,
-                _ => false,
-            },
-            ParserDefinitionNode::Choice(_) => true,
-            _ => false,
-        }
+        self.is_inline
     }
 
     fn node(&self) -> &ParserDefinitionNode {
@@ -346,6 +335,8 @@ fn resolve_grammar_element(ident: &Identifier, ctx: &mut ResolveCtx) -> GrammarE
             let thunk = Rc::new(NamedParserThunk {
                 name: ident.to_string().leak(),
                 context: lex_ctx,
+                // Enums have a single reference per variant, so they should be inlined.
+                is_inline: matches!(elem.as_ref(), Item::Enum { .. }),
                 def: OnceCell::new(),
             });
             ctx.resolved.insert(
@@ -798,6 +789,8 @@ fn resolve_precedence(
         let thunk = Rc::new(NamedParserThunk {
             name: name.to_string().leak(),
             context: lex_ctx,
+            // The operators are inlined but should be exposed under grouping `rule_name` below
+            is_inline: true,
             def: OnceCell::new(),
         });