1 files changed, 60 insertions, 1 deletions

diff --git a/crates/ra_ssr/src/tests.rs b/crates/ra_ssr/src/tests.rs
index 3ee1e74e9..7a3141be8 100644
--- a/crates/ra_ssr/src/tests.rs
+++ b/crates/ra_ssr/src/tests.rs
@@ -209,6 +209,11 @@ fn assert_ssr_transform(rule: &str, input: &str, result: &str) {
     assert_ssr_transforms(&[rule], input, result);
 }
 
+fn normalize_code(code: &str) -> String {
+    let (db, file_id) = single_file(code);
+    db.file_text(file_id).to_string()
+}
+
 fn assert_ssr_transforms(rules: &[&str], input: &str, result: &str) {
     let (db, file_id) = single_file(input);
     let mut match_finder = MatchFinder::new(&db);
@@ -217,8 +222,13 @@ fn assert_ssr_transforms(rules: &[&str], input: &str, result: &str) {
         match_finder.add_rule(rule);
     }
     if let Some(edits) = match_finder.edits_for_file(file_id) {
-        let mut after = input.to_string();
+        // Note, db.file_text is not necessarily the same as `input`, since fixture parsing alters
+        // stuff.
+        let mut after = db.file_text(file_id).to_string();
         edits.apply(&mut after);
+        // Likewise, we need to make sure that whatever transformations fixture parsing applies,
+        // also get appplied to our expected result.
+        let result = normalize_code(result);
         assert_eq!(after, result);
     } else {
         panic!("No edits were made");
@@ -355,6 +365,18 @@ fn match_nested_method_calls() {
     );
 }
 
+// Make sure that our node matching semantics don't differ within macro calls.
+#[test]
+fn match_nested_method_calls_with_macro_call() {
+    assert_matches(
+        "$a.z().z().z()",
+        r#"
+            macro_rules! m1 { ($a:expr) => {$a}; }
+            fn f() {m1!(h().i().j().z().z().z().d().e())}"#,
+        &["h().i().j().z().z().z()"],
+    );
+}
+
 #[test]
 fn match_complex_expr() {
     let code = "fn f() -> i32 {foo(bar(40, 2), 42)}";
@@ -547,3 +569,40 @@ fn multiple_rules() {
         "fn f() -> i32 {add_one(add(3, 2))}",
     )
 }
+
+#[test]
+fn match_within_macro_invocation() {
+    let code = r#"
+            macro_rules! foo {
+                ($a:stmt; $b:expr) => {
+                    $b
+                };
+            }
+            struct A {}
+            impl A {
+                fn bar() {}
+            }
+            fn f1() {
+                let aaa = A {};
+                foo!(macro_ignores_this(); aaa.bar());
+            }
+        "#;
+    assert_matches("$a.bar()", code, &["aaa.bar()"]);
+}
+
+#[test]
+fn replace_within_macro_expansion() {
+    assert_ssr_transform(
+        "$a.foo() ==>> bar($a)",
+        r#"
+            macro_rules! macro1 {
+                ($a:expr) => {$a}
+            }
+            fn f() {macro1!(5.x().foo().o2())}"#,
+        r#"
+            macro_rules! macro1 {
+                ($a:expr) => {$a}
+            }
+            fn f() {macro1!(bar(5.x()).o2())}"#,
+    )
+}