Merge #11461

[rust.git] / crates / mbe / src / syntax_bridge.rs

diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs
index 7feaaaa62d8b1d6e769210e6995c7825d0866eae..7e12647cd86230d4703d2d844744914f28f058cb 100644 (file)
--- a/crates/mbe/src/syntax_bridge.rs
+++ b/crates/mbe/src/syntax_bridge.rs
@@ -15,24 +15,32 @@
 /// Convert the syntax node to a `TokenTree` (what macro
 /// will consume).
 pub fn syntax_node_to_token_tree(node: &SyntaxNode) -> (tt::Subtree, TokenMap) {
-    syntax_node_to_token_tree_censored(node, Default::default(), Default::default())
+    let (subtree, token_map, _) = syntax_node_to_token_tree_with_modifications(
+        node,
+        Default::default(),
+        0,
+        Default::default(),
+        Default::default(),
+    );
+    (subtree, token_map)
 }
 
-// TODO rename
 /// Convert the syntax node to a `TokenTree` (what macro will consume)
 /// with the censored range excluded.
-pub fn syntax_node_to_token_tree_censored(
+pub fn syntax_node_to_token_tree_with_modifications(
     node: &SyntaxNode,
+    existing_token_map: TokenMap,
+    next_id: u32,
     replace: FxHashMap<SyntaxNode, Vec<SyntheticToken>>,
     append: FxHashMap<SyntaxNode, Vec<SyntheticToken>>,
-) -> (tt::Subtree, TokenMap) {
+) -> (tt::Subtree, TokenMap, u32) {
     let global_offset = node.text_range().start();
-    let mut c = Convertor::new(node, global_offset, replace, append);
+    let mut c = Convertor::new(node, global_offset, existing_token_map, next_id, replace, append);
     let subtree = convert_tokens(&mut c);
     c.id_alloc.map.shrink_to_fit();
-    always!(c.replace.is_empty());
-    always!(c.append.is_empty());
-    (subtree, c.id_alloc.map)
+    always!(c.replace.is_empty(), "replace: {:?}", c.replace);
+    always!(c.append.is_empty(), "append: {:?}", c.append);
+    (subtree, c.id_alloc.map, c.id_alloc.next_id)
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@@ -184,7 +192,9 @@ struct StackEntry {
             continue;
         }
         let tt = if kind.is_punct() && kind != UNDERSCORE {
-            // assert_eq!(range.len(), TextSize::of('.'));
+            if synth_id.is_none() {
+                assert_eq!(range.len(), TextSize::of('.'));
+            }
 
             if let Some(delim) = subtree.delimiter {
                 let expected = match delim.kind {
@@ -511,6 +521,8 @@ impl Convertor {
     fn new(
         node: &SyntaxNode,
         global_offset: TextSize,
+        existing_token_map: TokenMap,
+        next_id: u32,
         mut replace: FxHashMap<SyntaxNode, Vec<SyntheticToken>>,
         mut append: FxHashMap<SyntaxNode, Vec<SyntheticToken>>,
     ) -> Convertor {
@@ -518,7 +530,7 @@ fn new(
         let mut preorder = node.preorder_with_tokens();
         let (first, synthetic) = Self::next_token(&mut preorder, &mut replace, &mut append);
         Convertor {
-            id_alloc: { TokenIdAlloc { map: TokenMap::default(), global_offset, next_id: 0 } },
+            id_alloc: { TokenIdAlloc { map: existing_token_map, global_offset, next_id } },
             current: first,
             current_synthetic: synthetic,
             preorder,
@@ -539,7 +551,6 @@ fn next_token(
                 WalkEvent::Enter(ele) => ele,
                 WalkEvent::Leave(SyntaxElement::Node(node)) => {
                     if let Some(mut v) = append.remove(&node) {
-                        eprintln!("after {:?}, appending {:?}", node, v);
                         if !v.is_empty() {
                             v.reverse();
                             return (None, v);
@@ -554,7 +565,6 @@ fn next_token(
                 SyntaxElement::Node(node) => {
                     if let Some(mut v) = replace.remove(&node) {
                         preorder.skip_subtree();
-                        eprintln!("replacing {:?} by {:?}", node, v);
                         if !v.is_empty() {
                             v.reverse();
                             return (None, v);
@@ -640,8 +650,8 @@ fn bump(&mut self) -> Option<(Self::Token, TextRange)> {
                 self.current = new_current;
                 self.current_synthetic = new_synth;
             }
-            // TODO fix range?
-            return Some((SynToken::Synthetic(synth_token), self.range));
+            let range = synth_token.range;
+            return Some((SynToken::Synthetic(synth_token), range));
         }
 
         let curr = self.current.clone()?;
@@ -675,7 +685,6 @@ fn peek(&self) -> Option<Self::Token> {
         }
 
         if let Some(synth_token) = self.current_synthetic.last() {
-            // TODO fix range?
             return Some(SynToken::Synthetic(synth_token.clone()));
         }