rule: intern fields and store them in a tree matching the rule structure.

src/context.rs

@@ -1,4 +1,4 @@
-use crate::rule::Rule;
+use crate::rule::{Fields, Rule};
 use elsa::FrozenVec;
 use std::cell::RefCell;
 use std::collections::HashMap;
@@ -93,6 +93,7 @@ macro_rules! interners {
 interners! {
     IStr => str,
     IRule => Rule<Pat>,
+    IFields => Fields,
 }
 
 impl<Pat> InternInCx<Pat> for &'_ str {
@@ -117,3 +118,18 @@ impl<Pat: Eq + Hash> InternInCx<Pat> for Rule<Pat> {
         IRule(cx.interners.IRule.intern(self))
     }
 }
+
+// FIXME(eddyb) automate this away somehow.
+impl AsRef<Self> for Fields {
+    fn as_ref(&self) -> &Self {
+        self
+    }
+}
+
+impl<Pat> InternInCx<Pat> for Fields {
+    type Interned = IFields;
+
+    fn intern_in_cx(self, cx: &Context<Pat>) -> Self::Interned {
+        IFields(cx.interners.IFields.intern(self))
+    }
+}

src/lib.rs

@@ -35,7 +35,7 @@ use std::collections::HashMap;
 use std::hash::Hash;
 
 pub struct Grammar {
-    pub rules: IndexMap<IStr, rule::RuleWithNamedFields>,
+    pub rules: IndexMap<IStr, rule::RuleWithFields>,
 }
 
 impl Grammar {
@@ -44,7 +44,7 @@ impl Grammar {
             rules: IndexMap::new(),
         }
     }
-    pub fn define(&mut self, name: IStr, rule: rule::RuleWithNamedFields) {
+    pub fn define(&mut self, name: IStr, rule: rule::RuleWithFields) {
         self.rules.insert(name, rule);
     }
     pub fn extend(&mut self, other: Self) {
@@ -53,13 +53,13 @@ impl Grammar {
     pub fn insert_whitespace<Pat: Eq + Hash>(
         self,
         cx: &Context<Pat>,
-        whitespace: rule::RuleWithNamedFields,
+        whitespace: rule::RuleWithFields,
     ) -> Self {
         Grammar {
             rules: self
                 .rules
                 .into_iter()
-                .map(|(name, rule)| (name, rule.insert_whitespace(cx, whitespace.clone())))
+                .map(|(name, rule)| (name, rule.insert_whitespace(cx, whitespace)))
                 .collect(),
         }
     }

src/proc_macro.rs

@@ -13,7 +13,7 @@ pub fn builtin(cx: &Context) -> crate::Grammar {
     let mut g = crate::Grammar::new();
 
     let ident = eat(Pat(vec![FlatTokenPat::Ident(None)])).finish(cx);
-    g.define(cx.intern("IDENT"), ident.clone());
+    g.define(cx.intern("IDENT"), ident);
 
     g.define(
         cx.intern("LIFETIME"),
@@ -32,10 +32,10 @@ pub fn builtin(cx: &Context) -> crate::Grammar {
         joint: None,
     }]))
     .finish(cx);
-    g.define(cx.intern("PUNCT"), punct.clone());
+    g.define(cx.intern("PUNCT"), punct);
 
     let literal = eat(Pat(vec![FlatTokenPat::Literal])).finish(cx);
-    g.define(cx.intern("LITERAL"), literal.clone());
+    g.define(cx.intern("LITERAL"), literal);
 
     let delim = |c| eat(FlatTokenPat::Delim(c));
     let group = |open, close| delim(open) + call("TOKEN_TREE").repeat_many() + delim(close);