Update expand macro tests

crates/ra_ide/src/expand_macro.rs

@@ -2,7 +2,9 @@ use hir::Semantics;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::{find_node_at_offset, SyntaxRewriter},
-    ast, AstNode, NodeOrToken, SyntaxKind, SyntaxNode, WalkEvent, T,
+    ast, AstNode, NodeOrToken, SyntaxKind,
+    SyntaxKind::*,
+    SyntaxNode, WalkEvent, T,
 };
 
 use crate::FilePosition;
@@ -65,8 +67,6 @@ fn expand_macro_recur(
 // FIXME: It would also be cool to share logic here and in the mbe tests,
 // which are pretty unreadable at the moment.
 fn insert_whitespaces(syn: SyntaxNode) -> String {
-    use SyntaxKind::*;
-
     let mut res = String::new();
     let mut token_iter = syn
         .preorder_with_tokens()
@@ -120,175 +120,164 @@ fn insert_whitespaces(syn: SyntaxNode) -> String {
 
 #[cfg(test)]
 mod tests {
-    use insta::assert_snapshot;
+    use expect::{expect, Expect};
 
     use crate::mock_analysis::analysis_and_position;
 
-    use super::*;
+    fn check(ra_fixture: &str, expect: Expect) {
-
+        let (analysis, pos) = analysis_and_position(ra_fixture);
-    fn check_expand_macro(fixture: &str) -> ExpandedMacro {
+        let expansion = analysis.expand_macro(pos).unwrap().unwrap();
-        let (analysis, pos) = analysis_and_position(fixture);
+        let actual = format!("{}\n{}", expansion.name, expansion.expansion);
-        analysis.expand_macro(pos).unwrap().unwrap()
+        expect.assert_eq(&actual);
     }
 
     #[test]
     fn macro_expand_recursive_expansion() {
-        let res = check_expand_macro(
+        check(
             r#"
-        //- /lib.rs
+macro_rules! bar {
-        macro_rules! bar {
+    () => { fn  b() {} }
-            () => { fn  b() {} }
+}
-        }
+macro_rules! foo {
-        macro_rules! foo {
+    () => { bar!(); }
-            () => { bar!(); }
+}
-        }
+macro_rules! baz {
-        macro_rules! baz {
+    () => { foo!(); }
-            () => { foo!(); }
+}
-        }
+f<|>oo!();
-        f<|>oo!();
+"#,
-        "#,
+            expect![[r#"
+                foo
+                fn b(){}
+            "#]],
         );
-
-        assert_eq!(res.name, "foo");
-        assert_snapshot!(res.expansion, @r###"
-fn b(){}
-"###);
     }
 
     #[test]
     fn macro_expand_multiple_lines() {
-        let res = check_expand_macro(
+        check(
             r#"
-        //- /lib.rs
+macro_rules! foo {
-        macro_rules! foo {
+    () => {
-            () => {
+        fn some_thing() -> u32 {
-                fn some_thing() -> u32 {
+            let a = 0;
-                    let a = 0;
+            a + 10
-                    a + 10
-                }
-            }
         }
-        f<|>oo!();
+    }
-        "#,
-        );
-
-        assert_eq!(res.name, "foo");
-        assert_snapshot!(res.expansion, @r###"
-fn some_thing() -> u32 {
-  let a = 0;
-  a+10
 }
-"###);
+f<|>oo!();
+        "#,
+            expect![[r#"
+            foo
+            fn some_thing() -> u32 {
+              let a = 0;
+              a+10
+            }"#]],
+        );
     }
 
     #[test]
     fn macro_expand_match_ast() {
-        let res = check_expand_macro(
+        check(
             r#"
-        //- /lib.rs
+macro_rules! match_ast {
-        macro_rules! match_ast {
+    (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
-            (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
+    (match ($node:expr) {
-
+        $( ast::$ast:ident($it:ident) => $res:block, )*
-            (match ($node:expr) {
+        _ => $catch_all:expr $(,)?
-                $( ast::$ast:ident($it:ident) => $res:block, )*
+    }) => {{
-                _ => $catch_all:expr $(,)?
+        $( if let Some($it) = ast::$ast::cast($node.clone()) $res else )*
-            }) => {{
+        { $catch_all }
-                $( if let Some($it) = ast::$ast::cast($node.clone()) $res else )*
+    }};
-                { $catch_all }
-            }};
-        }
-
-        fn main() {
-            mat<|>ch_ast! {
-                match container {
-                    ast::TraitDef(it) => {},
-                    ast::ImplDef(it) => {},
-                    _ => { continue },
-                }
-            }
-        }
-        "#,
-        );
-
-        assert_eq!(res.name, "match_ast");
-        assert_snapshot!(res.expansion, @r###"
-{
-  if let Some(it) = ast::TraitDef::cast(container.clone()){}
-  else if let Some(it) = ast::ImplDef::cast(container.clone()){}
-  else {
-    {
-      continue
-    }
-  }
 }
-"###);
+
+fn main() {
+    mat<|>ch_ast! {
+        match container {
+            ast::TraitDef(it) => {},
+            ast::ImplDef(it) => {},
+            _ => { continue },
+        }
+    }
+}
+"#,
+            expect![[r#"
+       match_ast
+       {
+         if let Some(it) = ast::TraitDef::cast(container.clone()){}
+         else if let Some(it) = ast::ImplDef::cast(container.clone()){}
+         else {
+           {
+             continue
+           }
+         }
+       }"#]],
+        );
     }
 
     #[test]
     fn macro_expand_match_ast_inside_let_statement() {
-        let res = check_expand_macro(
+        check(
             r#"
-        //- /lib.rs
+macro_rules! match_ast {
-        macro_rules! match_ast {
+    (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
-            (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
+    (match ($node:expr) {}) => {{}};
-            (match ($node:expr) {}) => {{}};
+}
-        }
 
-        fn main() {
+fn main() {
-            let p = f(|it| {
+    let p = f(|it| {
-                let res = mat<|>ch_ast! { match c {}};
+        let res = mat<|>ch_ast! { match c {}};
-                Some(res)
+        Some(res)
-            })?;
+    })?;
-        }
+}
-        "#,
+"#,
+            expect![[r#"
+                match_ast
+                {}
+            "#]],
         );
-
-        assert_eq!(res.name, "match_ast");
-        assert_snapshot!(res.expansion, @r###"{}"###);
     }
 
     #[test]
     fn macro_expand_inner_macro_fail_to_expand() {
-        let res = check_expand_macro(
+        check(
             r#"
-        //- /lib.rs
+macro_rules! bar {
-        macro_rules! bar {
+    (BAD) => {};
-            (BAD) => {};
+}
-        }
+macro_rules! foo {
-        macro_rules! foo {
+    () => {bar!()};
-            () => {bar!()};
+}
-        }
 
-        fn main() {
+fn main() {
-            let res = fo<|>o!();
+    let res = fo<|>o!();
-        }
+}
-        "#,
+"#,
+            expect![[r#"
+                foo
+            "#]],
         );
-
-        assert_eq!(res.name, "foo");
-        assert_snapshot!(res.expansion, @r###""###);
     }
 
     #[test]
     fn macro_expand_with_dollar_crate() {
-        let res = check_expand_macro(
+        check(
             r#"
-        //- /lib.rs
+#[macro_export]
-        #[macro_export]
+macro_rules! bar {
-        macro_rules! bar {
+    () => {0};
-            () => {0};
+}
-        }
+macro_rules! foo {
-        macro_rules! foo {
+    () => {$crate::bar!()};
-            () => {$crate::bar!()};
+}
-        }
 
-        fn main() {
+fn main() {
-            let res = fo<|>o!();
+    let res = fo<|>o!();
-        }
+}
-        "#,
+"#,
+            expect![[r#"
+                foo
+                0 "#]],
         );
-
-        assert_eq!(res.name, "foo");
-        assert_snapshot!(res.expansion, @r###"0"###);
     }
 }