No names in scanners

crates/codegen/parser/src/combinator_node.rs

@@ -86,12 +86,10 @@ impl<'context> CombinatorNode<'context> {
         tree: &'context CombinatorTree<'context>,
         scanner: &ScannerRef,
     ) -> &'context CombinatorNode<'context> {
-        let name = scanner.name.clone();
-
         if let Some(filter) = CharSet::from_scanner(tree, scanner.clone()) {
             return tree
                 .context
-                .alloc_node(Self::CharacterFilter { name, filter });
+                .alloc_node(Self::CharacterFilter { name: None, filter });
         }
 
         if let Some(trie) = trie::from_scanner(tree, scanner.clone()) {
@@ -128,7 +126,10 @@ impl<'context> CombinatorNode<'context> {
                 if elements.len() == 1 {
                     return elements.pop().unwrap();
                 } else {
-                    Self::Choice { name, elements }
+                    Self::Choice {
+                        name: None,
+                        elements,
+                    }
                 }
             }
 
@@ -137,7 +138,7 @@ impl<'context> CombinatorNode<'context> {
                 expression,
                 close,
             } => Self::DelimitedBy {
-                name,
+                name: None,
                 open: open.clone(),
                 expr: Self::from_scanner(tree, expression),
                 close: close.clone(),
@@ -153,14 +154,14 @@ impl<'context> CombinatorNode<'context> {
 
             ScannerDefinition::Not(_) => {
                 if let Some(filter) = CharSet::from_scanner(tree, scanner.clone()) {
-                    Self::CharacterFilter { name, filter }
+                    Self::CharacterFilter { name: None, filter }
                 } else {
                     unimplemented!("¬ is only supported on characters or sets thereof")
                 }
             }
 
             ScannerDefinition::OneOrMore(expr) => Self::OneOrMore {
-                name,
+                name: None,
                 expr: Self::from_scanner(tree, expr),
             },
 
@@ -169,7 +170,7 @@ impl<'context> CombinatorNode<'context> {
             },
 
             ScannerDefinition::Range { .. } => Self::CharacterFilter {
-                name,
+                name: None,
                 filter: CharSet::from_scanner(tree, scanner.clone()).unwrap(),
             },
 
@@ -182,7 +183,7 @@ impl<'context> CombinatorNode<'context> {
                 min,
                 max,
             } => Self::Repeated {
-                name,
+                name: None,
                 expr: Self::from_scanner(tree, expression),
                 min: *min,
                 max: *max,
@@ -192,19 +193,19 @@ impl<'context> CombinatorNode<'context> {
                 expression,
                 separator,
             } => Self::SeparatedBy {
-                name,
+                name: None,
                 expr: Self::from_scanner(tree, expression),
                 separator: separator.clone(),
             },
 
             ScannerDefinition::Sequence(exprs) => Self::Sequence {
-                name,
+                name: None,
                 elements: exprs.iter().map(|e| Self::from_scanner(tree, e)).collect(),
             },
 
             ScannerDefinition::Terminal(_) => {
                 if let Some(filter) = CharSet::from_scanner(tree, scanner.clone()) {
-                    Self::CharacterFilter { name, filter }
+                    Self::CharacterFilter { name: None, filter }
                 } else {
                     Self::TerminalTrie {
                         trie: trie::from_scanner(tree, scanner.clone()).unwrap(),
@@ -213,7 +214,7 @@ impl<'context> CombinatorNode<'context> {
             }
 
             ScannerDefinition::ZeroOrMore(expr) => Self::ZeroOrMore {
-                name,
+                name: None,
                 expr: Self::from_scanner(tree, expr),
             },
         })

crates/codegen/parser/src/trie.rs

@@ -61,14 +61,6 @@ impl<P: Clone + Debug> Trie<P> {
         self.subtries.is_empty() && self.payload.is_none()
     }
 
-    pub fn any_payload<F>(&self, f: F) -> bool
-    where
-        F: Fn(&P) -> bool,
-    {
-        // TODO: This is not efficient
-        self.iter().any(|(_, payload)| f(payload))
-    }
-
     pub fn iter(&self) -> TrieIterator<P> {
         TrieIterator {
             subtrie_iterators: vec![self.subtries.iter()],
@@ -120,23 +112,16 @@ pub fn from_scanner(tree: &CombinatorTree, scanner: ScannerRef) -> Option<Termin
         trie: &mut TerminalTrie,
         tree: &CombinatorTree,
         scanner: ScannerRef,
-        force_all_entries_to_be_named: bool,
     ) -> bool {
         match &scanner.definition {
             ScannerDefinition::Choice(exprs) => exprs.iter().fold(true, |accum, scanner| {
-                accum && collect_terminals(trie, tree, scanner.clone(), force_all_entries_to_be_named)
+                accum && collect_terminals(trie, tree, scanner.clone())
             }),
 
             ScannerDefinition::Terminal(string) => {
                 trie.insert(
                     &string,
-                    scanner.name.clone().or_else(|| {
-                        if !force_all_entries_to_be_named {
-                            None
-                        } else {
-                            Some(naming::name_of_terminal_string(&string))
-                        }
-                    }),
+                        None
                 );
                 true
             }
@@ -158,19 +143,14 @@ pub fn from_scanner(tree: &CombinatorTree, scanner: ScannerRef) -> Option<Termin
                         )
                     }
                 },
-                force_all_entries_to_be_named,
             ),
 
             _ => false,
         }
     }
 
     let mut trie = TerminalTrie::new();
-    if collect_terminals(&mut trie, tree, scanner.clone(), false) && !trie.is_empty() {
-        if trie.any_payload(Option::is_some) {
-            trie = TerminalTrie::new();
-            collect_terminals(&mut trie, tree, scanner, true);
-        }
+    if collect_terminals(&mut trie, tree, scanner.clone()) && !trie.is_empty() {
         Some(trie)
     } else {
         None

crates/codegen/schema/src/types/scanner.rs

@@ -6,8 +6,6 @@ pub type ScannerRef = std::rc::Rc<Scanner>;
 #[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, PartialEq, Eq, Hash)]
 #[serde(deny_unknown_fields)]
 pub struct Scanner {
-    #[serde(default)]
-    pub name: Option<String>,
     #[serde(default)]
     pub lookahead: Option<ScannerRef>,
     #[serde(flatten)]

crates/codegen/schema/src/validation/ast/scanner.rs

@@ -7,7 +7,6 @@ use super::{node::Node, production::ConcreteAbstractPair};
 pub type ScannerRef = Rc<Scanner>;
 
 pub struct Scanner {
-    pub name: Option<Node<String>>,
     pub lookahead: Option<ScannerRef>,
     pub definition: Node<ScannerDefinition>,
 }
@@ -17,9 +16,6 @@ impl ConcreteAbstractPair for Scanner {
 
     fn new(cst_node: &cst::NodeRef, value: Rc<Self::AbstractType>) -> Rc<Self> {
         return Rc::new(Self {
-            name: value.name.clone().and_then(|name| {
-                return Some(Node::new(cst_node.get("name"), name));
-            }),
             lookahead: value.lookahead.clone().and_then(|lookahead| {
                 return Some(Scanner::new(cst_node.get("lookahead"), lookahead));
             }),