move test

Cargo.lock

@@ -1023,9 +1023,9 @@ dependencies = [
 name = "ra_mbe"
 version = "0.1.0"
 dependencies = [
+ "ra_syntax 0.1.0",
  "ra_tt 0.1.0",
  "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "smol_str 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -1058,7 +1058,6 @@ dependencies = [
 name = "ra_tt"
 version = "0.1.0"
 dependencies = [
- "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "smol_str 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 

crates/ra_hir/src/macros.rs

@@ -11,7 +11,6 @@ use std::sync::Arc;
 
 use ra_syntax::{
     TextRange, TextUnit, SourceFile, AstNode, SyntaxNode, TreeArc, SyntaxNodePtr,
-    SyntaxKind::*,
     ast::{self, NameOwner},
 };
 
@@ -196,116 +195,3 @@ pub(crate) fn expand_macro_invocation(
     let (def, input) = MacroDef::from_call(macro_call)?;
     def.expand(input).map(Arc::new)
 }
-
-fn macro_call_to_tt(call: &ast::MacroCall) -> Option<tt::Subtree> {
-    let tt = call.token_tree()?;
-    convert_tt(tt.syntax())
-}
-
-fn convert_tt(tt: &SyntaxNode) -> Option<tt::Subtree> {
-    let first_child = tt.first_child()?;
-    let last_child = tt.last_child()?;
-    let delimiter = match (first_child.kind(), last_child.kind()) {
-        (L_PAREN, R_PAREN) => tt::Delimiter::Parenthesis,
-        (L_CURLY, R_CURLY) => tt::Delimiter::Brace,
-        (L_BRACK, R_BRACK) => tt::Delimiter::Bracket,
-        _ => return None,
-    };
-    let mut token_trees = Vec::new();
-    for child in tt.children().skip(1) {
-        if child == first_child || child == last_child || child.kind().is_trivia() {
-            continue;
-        }
-        if child.kind().is_punct() {
-            let mut prev = None;
-            for char in child.leaf_text().unwrap().chars() {
-                if let Some(char) = prev {
-                    token_trees.push(
-                        tt::Leaf::from(tt::Punct {
-                            char,
-                            spacing: tt::Spacing::Joint,
-                        })
-                        .into(),
-                    );
-                }
-                prev = Some(char)
-            }
-            if let Some(char) = prev {
-                token_trees.push(
-                    tt::Leaf::from(tt::Punct {
-                        char,
-                        spacing: tt::Spacing::Alone,
-                    })
-                    .into(),
-                );
-            }
-        } else {
-            let child: tt::TokenTree = if child.kind() == TOKEN_TREE {
-                convert_tt(child)?.into()
-            } else if child.kind().is_keyword() || child.kind() == IDENT {
-                let text = child.leaf_text().unwrap().clone();
-                tt::Leaf::from(tt::Ident { text }).into()
-            } else if child.kind().is_literal() {
-                tt::Leaf::from(tt::Literal {
-                    text: child.leaf_text().unwrap().clone(),
-                })
-                .into()
-            } else {
-                log::error!("unknown kind: {:?}", child);
-                return None;
-            };
-            token_trees.push(child)
-        }
-    }
-
-    let res = tt::Subtree {
-        delimiter,
-        token_trees,
-    };
-    Some(res)
-}
-
-#[test]
-fn test_convert_tt() {
-    let macro_definition = r#"
-macro_rules! impl_froms {
-    ($e:ident: $($v:ident),*) => {
-        $(
-            impl From<$v> for $e {
-                fn from(it: $v) -> $e {
-                    $e::$v(it)
-                }
-            }
-        )*
-    }
-}
-"#;
-
-    let macro_invocation = r#"
-impl_froms!(TokenTree: Leaf, Subtree);
-"#;
-
-    let source_file = ast::SourceFile::parse(macro_definition);
-    let macro_definition = source_file
-        .syntax()
-        .descendants()
-        .find_map(ast::MacroCall::cast)
-        .unwrap();
-
-    let source_file = ast::SourceFile::parse(macro_invocation);
-    let macro_invocation = source_file
-        .syntax()
-        .descendants()
-        .find_map(ast::MacroCall::cast)
-        .unwrap();
-
-    let definition_tt = macro_call_to_tt(macro_definition).unwrap();
-    let invocation_tt = macro_call_to_tt(macro_invocation).unwrap();
-    let mbe = mbe::parse(&definition_tt).unwrap();
-    let expansion = mbe::exapnd(&mbe, &invocation_tt).unwrap();
-    assert_eq!(
-        expansion.to_string(),
-        "{(impl From < Leaf > for TokenTree {fn from (it : Leaf) -> TokenTree {TokenTree :: Leaf (it)}}) \
-          (impl From < Subtree > for TokenTree {fn from (it : Subtree) -> TokenTree {TokenTree :: Subtree (it)}})}"
-    )
-}

crates/ra_mbe/Cargo.toml

@@ -5,6 +5,7 @@ version = "0.1.0"
 authors = ["Aleksey Kladov <aleksey.kladov@gmail.com>"]
 
 [dependencies]
+ra_syntax = { path = "../ra_syntax" }
 tt = { path = "../ra_tt", package = "ra_tt" }
+
 rustc-hash = "1.0.0"
-smol_str = "0.1.9"

crates/ra_mbe/src/lib.rs

@@ -1,3 +1,8 @@
+/// `mbe` (short for Macro By Example) crate contains code for handling
+/// `macro_rules` macros. It uses `TokenTree` (from `ra_tt` package) as the
+/// interface, although it contains some code to bridge `SyntaxNode`s and
+/// `TokenTree`s as well!
+
 macro_rules! impl_froms {
     ($e:ident: $($v:ident), *) => {
         $(
@@ -13,14 +18,16 @@ macro_rules! impl_froms {
 mod tt_cursor;
 mod mbe_parser;
 mod mbe_expander;
+mod syntax_bridge;
 
-use smol_str::SmolStr;
+use ra_syntax::SmolStr;
 
 pub use tt::{Delimiter, Punct};
 
 pub use crate::{
     mbe_parser::parse,
     mbe_expander::exapnd,
+    syntax_bridge::macro_call_to_tt,
 };
 
 #[derive(Debug)]

crates/ra_mbe/src/mbe_expander.rs

@@ -1,5 +1,5 @@
 use rustc_hash::FxHashMap;
-use smol_str::SmolStr;
+use ra_syntax::SmolStr;
 
 use crate::{self as mbe, tt_cursor::TtCursor};
 

crates/ra_mbe/src/syntax_bridge.rs

@@ -0,0 +1,113 @@
+use ra_syntax::{ast, AstNode, SyntaxNode, SyntaxKind::*};
+
+pub fn macro_call_to_tt(call: &ast::MacroCall) -> Option<tt::Subtree> {
+    let tt = call.token_tree()?;
+    convert_tt(tt.syntax())
+}
+
+fn convert_tt(tt: &SyntaxNode) -> Option<tt::Subtree> {
+    let first_child = tt.first_child()?;
+    let last_child = tt.last_child()?;
+    let delimiter = match (first_child.kind(), last_child.kind()) {
+        (L_PAREN, R_PAREN) => tt::Delimiter::Parenthesis,
+        (L_CURLY, R_CURLY) => tt::Delimiter::Brace,
+        (L_BRACK, R_BRACK) => tt::Delimiter::Bracket,
+        _ => return None,
+    };
+    let mut token_trees = Vec::new();
+    for child in tt.children().skip(1) {
+        if child == first_child || child == last_child || child.kind().is_trivia() {
+            continue;
+        }
+        if child.kind().is_punct() {
+            let mut prev = None;
+            for char in child.leaf_text().unwrap().chars() {
+                if let Some(char) = prev {
+                    token_trees.push(
+                        tt::Leaf::from(tt::Punct {
+                            char,
+                            spacing: tt::Spacing::Joint,
+                        })
+                        .into(),
+                    );
+                }
+                prev = Some(char)
+            }
+            if let Some(char) = prev {
+                token_trees.push(
+                    tt::Leaf::from(tt::Punct {
+                        char,
+                        spacing: tt::Spacing::Alone,
+                    })
+                    .into(),
+                );
+            }
+        } else {
+            let child: tt::TokenTree = if child.kind() == TOKEN_TREE {
+                convert_tt(child)?.into()
+            } else if child.kind().is_keyword() || child.kind() == IDENT {
+                let text = child.leaf_text().unwrap().clone();
+                tt::Leaf::from(tt::Ident { text }).into()
+            } else if child.kind().is_literal() {
+                tt::Leaf::from(tt::Literal {
+                    text: child.leaf_text().unwrap().clone(),
+                })
+                .into()
+            } else {
+                return None;
+            };
+            token_trees.push(child)
+        }
+    }
+
+    let res = tt::Subtree {
+        delimiter,
+        token_trees,
+    };
+    Some(res)
+}
+
+#[test]
+fn test_convert_tt() {
+    let macro_definition = r#"
+macro_rules! impl_froms {
+    ($e:ident: $($v:ident),*) => {
+        $(
+            impl From<$v> for $e {
+                fn from(it: $v) -> $e {
+                    $e::$v(it)
+                }
+            }
+        )*
+    }
+}
+"#;
+
+    let macro_invocation = r#"
+impl_froms!(TokenTree: Leaf, Subtree);
+"#;
+
+    let source_file = ast::SourceFile::parse(macro_definition);
+    let macro_definition = source_file
+        .syntax()
+        .descendants()
+        .find_map(ast::MacroCall::cast)
+        .unwrap();
+
+    let source_file = ast::SourceFile::parse(macro_invocation);
+    let macro_invocation = source_file
+        .syntax()
+        .descendants()
+        .find_map(ast::MacroCall::cast)
+        .unwrap();
+
+    let definition_tt = macro_call_to_tt(macro_definition).unwrap();
+    let invocation_tt = macro_call_to_tt(macro_invocation).unwrap();
+    let mbe = crate::parse(&definition_tt).unwrap();
+    let expansion = crate::exapnd(&mbe, &invocation_tt).unwrap();
+    assert_eq!(
+        expansion.to_string(),
+        "{(impl From < Leaf > for TokenTree {fn from (it : Leaf) -> TokenTree {TokenTree :: Leaf (it)}}) \
+          (impl From < Subtree > for TokenTree {fn from (it : Subtree) -> TokenTree {TokenTree :: Subtree (it)}})}"
+    )
+}

crates/ra_tt/Cargo.toml

@@ -5,5 +5,4 @@ version = "0.1.0"
 authors = ["Aleksey Kladov <aleksey.kladov@gmail.com>"]
 
 [dependencies]
-rustc-hash = "1.0.0"
 smol_str = "0.1.9"

crates/ra_tt/src/lib.rs

@@ -1,3 +1,7 @@
+/// `tt` crate defines a `TokenTree` datastructure: this is the interface (both
+/// input and output) of macros. It closely mirrors `proc_macro` crate's
+/// `TokenTree`.
+
 macro_rules! impl_froms {
     ($e:ident: $($v:ident), *) => {
         $(