Infect mbe crate with generic span type parameter

Author: Veykril

crates/mbe/src/benchmark.rs

@@ -6,10 +6,11 @@ use syntax::{
     AstNode, SmolStr,
 };
 use test_utils::{bench, bench_fixture, skip_slow_tests};
+use tt::{Span, TokenId};
 
 use crate::{
     parser::{MetaVarKind, Op, RepeatKind, Separator},
-    syntax_node_to_token_tree, tt, DeclarativeMacro,
+    syntax_node_to_token_tree, DeclarativeMacro,
 };
 
 #[test]
@@ -54,7 +55,7 @@ fn macro_rules_fixtures() -> FxHashMap<String, DeclarativeMacro> {
         .collect()
 }
 
-fn macro_rules_fixtures_tt() -> FxHashMap<String, tt::Subtree> {
+fn macro_rules_fixtures_tt() -> FxHashMap<String, tt::Subtree<TokenId>> {
     let fixture = bench_fixture::numerous_macro_rules();
     let source_file = ast::SourceFile::parse(&fixture).ok().unwrap();
 
@@ -71,7 +72,9 @@ fn macro_rules_fixtures_tt() -> FxHashMap<String, tt::Subtree> {
 }
 
 /// Generate random invocation fixtures from rules
-fn invocation_fixtures(rules: &FxHashMap<String, DeclarativeMacro>) -> Vec<(String, tt::Subtree)> {
+fn invocation_fixtures(
+    rules: &FxHashMap<String, DeclarativeMacro>,
+) -> Vec<(String, tt::Subtree<TokenId>)> {
     let mut seed = 123456789;
     let mut res = Vec::new();
 
@@ -93,8 +96,8 @@ fn invocation_fixtures(rules: &FxHashMap<String, DeclarativeMacro>) -> Vec<(Stri
                 loop {
                     let mut subtree = tt::Subtree {
                         delimiter: tt::Delimiter {
-                            open: tt::TokenId::UNSPECIFIED,
-                            close: tt::TokenId::UNSPECIFIED,
+                            open: tt::TokenId::DUMMY,
+                            close: tt::TokenId::DUMMY,
                             kind: tt::DelimiterKind::Invisible,
                         },
                         token_trees: vec![],
@@ -116,7 +119,7 @@ fn invocation_fixtures(rules: &FxHashMap<String, DeclarativeMacro>) -> Vec<(Stri
     }
     return res;
 
-    fn collect_from_op(op: &Op, parent: &mut tt::Subtree, seed: &mut usize) {
+    fn collect_from_op(op: &Op<TokenId>, parent: &mut tt::Subtree<TokenId>, seed: &mut usize) {
         return match op {
             Op::Var { kind, .. } => match kind.as_ref() {
                 Some(MetaVarKind::Ident) => parent.token_trees.push(make_ident("foo")),
@@ -202,36 +205,30 @@ fn invocation_fixtures(rules: &FxHashMap<String, DeclarativeMacro>) -> Vec<(Stri
             *seed = usize::wrapping_add(usize::wrapping_mul(*seed, a), c);
             *seed
         }
-        fn make_ident(ident: &str) -> tt::TokenTree {
-            tt::Leaf::Ident(tt::Ident {
-                span: tt::TokenId::unspecified(),
-                text: SmolStr::new(ident),
-            })
-            .into()
+        fn make_ident(ident: &str) -> tt::TokenTree<TokenId> {
+            tt::Leaf::Ident(tt::Ident { span: tt::TokenId::DUMMY, text: SmolStr::new(ident) })
+                .into()
         }
-        fn make_punct(char: char) -> tt::TokenTree {
+        fn make_punct(char: char) -> tt::TokenTree<TokenId> {
             tt::Leaf::Punct(tt::Punct {
-                span: tt::TokenId::unspecified(),
+                span: tt::TokenId::DUMMY,
                 char,
                 spacing: tt::Spacing::Alone,
             })
             .into()
         }
-        fn make_literal(lit: &str) -> tt::TokenTree {
-            tt::Leaf::Literal(tt::Literal {
-                span: tt::TokenId::unspecified(),
-                text: SmolStr::new(lit),
-            })
-            .into()
+        fn make_literal(lit: &str) -> tt::TokenTree<TokenId> {
+            tt::Leaf::Literal(tt::Literal { span: tt::TokenId::DUMMY, text: SmolStr::new(lit) })
+                .into()
         }
         fn make_subtree(
             kind: tt::DelimiterKind,
-            token_trees: Option<Vec<tt::TokenTree>>,
-        ) -> tt::TokenTree {
+            token_trees: Option<Vec<tt::TokenTree<TokenId>>>,
+        ) -> tt::TokenTree<TokenId> {
             tt::Subtree {
                 delimiter: tt::Delimiter {
-                    open: tt::TokenId::unspecified(),
-                    close: tt::TokenId::unspecified(),
+                    open: tt::TokenId::DUMMY,
+                    close: tt::TokenId::DUMMY,
                     kind,
                 },
                 token_trees: token_trees.unwrap_or_default(),

crates/mbe/src/expander.rs

@@ -7,15 +7,16 @@ mod transcriber;
 
 use rustc_hash::FxHashMap;
 use syntax::SmolStr;
+use tt::Span;
 
-use crate::{parser::MetaVarKind, tt, ExpandError, ExpandResult};
+use crate::{parser::MetaVarKind, ExpandError, ExpandResult};
 
-pub(crate) fn expand_rules(
-    rules: &[crate::Rule],
-    input: &tt::Subtree,
+pub(crate) fn expand_rules<S: Span>(
+    rules: &[crate::Rule<S>],
+    input: &tt::Subtree<S>,
     is_2021: bool,
-) -> ExpandResult<tt::Subtree> {
-    let mut match_: Option<(matcher::Match, &crate::Rule)> = None;
+) -> ExpandResult<tt::Subtree<S>> {
+    let mut match_: Option<(matcher::Match<S>, &crate::Rule<S>)> = None;
     for rule in rules {
         let new_match = matcher::match_(&rule.lhs, input, is_2021);
 
@@ -47,7 +48,7 @@ pub(crate) fn expand_rules(
         ExpandResult { value, err: match_.err.or(transcribe_err) }
     } else {
         ExpandResult::new(
-            tt::Subtree { delimiter: tt::Delimiter::unspecified(), token_trees: vec![] },
+            tt::Subtree { delimiter: tt::Delimiter::UNSPECIFIED, token_trees: vec![] },
             ExpandError::NoMatchingRule,
         )
     }
@@ -98,31 +99,37 @@ pub(crate) fn expand_rules(
 /// In other words, `Bindings` is a *multi* mapping from `SmolStr` to
 /// `tt::TokenTree`, where the index to select a particular `TokenTree` among
 /// many is not a plain `usize`, but a `&[usize]`.
-#[derive(Debug, Default, Clone, PartialEq, Eq)]
-struct Bindings {
-    inner: FxHashMap<SmolStr, Binding>,
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct Bindings<S> {
+    inner: FxHashMap<SmolStr, Binding<S>>,
+}
+
+impl<S> Default for Bindings<S> {
+    fn default() -> Self {
+        Self { inner: Default::default() }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-enum Binding {
-    Fragment(Fragment),
-    Nested(Vec<Binding>),
+enum Binding<S> {
+    Fragment(Fragment<S>),
+    Nested(Vec<Binding<S>>),
     Empty,
     Missing(MetaVarKind),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-enum Fragment {
+enum Fragment<S> {
     /// token fragments are just copy-pasted into the output
-    Tokens(tt::TokenTree),
+    Tokens(tt::TokenTree<S>),
     /// Expr ast fragments are surrounded with `()` on insertion to preserve
     /// precedence. Note that this impl is different from the one currently in
     /// `rustc` -- `rustc` doesn't translate fragments into token trees at all.
     ///
     /// At one point in time, we tried to use "fake" delimiters here à la
     /// proc-macro delimiter=none. As we later discovered, "none" delimiters are
     /// tricky to handle in the parser, and rustc doesn't handle those either.
-    Expr(tt::TokenTree),
+    Expr(tt::TokenTree<S>),
     /// There are roughly two types of paths: paths in expression context, where a
     /// separator `::` between an identifier and its following generic argument list
     /// is mandatory, and paths in type context, where `::` can be omitted.
@@ -132,5 +139,5 @@ enum Fragment {
     /// and is trasncribed as an expression-context path, verbatim transcription
     /// would cause a syntax error. We need to fix it up just before transcribing;
     /// see `transcriber::fix_up_and_push_path_tt()`.
-    Path(tt::TokenTree),
+    Path(tt::TokenTree<S>),
 }