fix FP with MBEs

Author: ada4a

clippy_lints/src/needless_parens_on_range_literals.rs

@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher;
-use clippy_utils::source::{SpanRangeExt, snippet_with_applicability};
+use clippy_utils::source::{SpanRangeExt, snippet_with_context};
 
 use rustc_ast::ast;
 use rustc_errors::Applicability;
@@ -41,7 +41,8 @@ declare_clippy_lint! {
 declare_lint_pass!(NeedlessParensOnRangeLiterals => [NEEDLESS_PARENS_ON_RANGE_LITERALS]);
 
 fn check_for_parens(cx: &LateContext<'_>, e: &Expr<'_>, is_start: bool) {
-    if let ExprKind::Lit(literal) = e.kind
+    if !e.span.from_expansion()
+        && let ExprKind::Lit(literal) = e.kind
         // the indicator that parenthesis surround the literal is that the span of the expression and the literal differ
         && literal.span != e.span
         // inspect the source code of the expression for parenthesis
@@ -56,7 +57,7 @@ fn check_for_parens(cx: &LateContext<'_>, e: &Expr<'_>, is_start: bool) {
         }
 
         let mut applicability = Applicability::MachineApplicable;
-        let suggestion = snippet_with_applicability(cx, literal.span, "_", &mut applicability);
+        let suggestion = snippet_with_context(cx, literal.span, e.span.ctxt(), "_", &mut applicability).0;
         span_lint_and_sugg(
             cx,
             NEEDLESS_PARENS_ON_RANGE_LITERALS,

tests/ui/needless_parens_on_range_literals.fixed

@@ -18,4 +18,51 @@ fn main() {
     //~^ needless_parens_on_range_literals
     let _ = ..'z';
     //~^ needless_parens_on_range_literals
+
+    macro_rules! verbatim {
+        ($e:expr) => {
+            $e
+        };
+    }
+    macro_rules! add_paren {
+        ($e:expr) => {
+            ($e)
+        };
+    }
+
+    // lint: the paren was added by the user
+    let _ = verbatim!(0)..1;
+    //~^ needless_parens_on_range_literals
+    let _ = 0..verbatim!(1);
+    //~^ needless_parens_on_range_literals
+
+    // lint: the macro doesn't have anything to do with the paren
+    // NOTE: This doesn't actually work currently.
+    //
+    // If we have a case like this:
+    // ```
+    // macro_rules! zero {
+    //     () => {
+    //         0
+    //     };
+    // }
+    // let _ = (zero!())..1;
+    // ```
+    // then the lint doesn't trigger, because the span comes from expansion.
+    // "But surely the outer `()` don't come from an expansion!", I hear you say. But the thing is that
+    // those parens aren't present in the HIR in the first place, and so the expression we actually
+    // end up looking at is `zero!()`, which is in fact an expansion.
+    //
+    // And if we have a case like this:
+    // ```
+    // let _ = (verbatim!(0))..1;
+    // ```
+    // then the parens get ignored as described above, but in addition to that, the whole `verbatim!(0)`
+    // gets replaced with just `0`, which is something that we've written, so its span now gets
+    // doubly-incorrectly identified as not coming from an expansion, and so the lint fires.
+    // But the problem arises when we get to creating the suggestion -- as it _also_ doesn't see the
+    // `verbatim!`, our suggestion ends up being just `let _ = 0..1;`, which is of course incorrect.
+
+    // don't lint: the paren was added by the macro
+    let _ = add_paren!(0)..1;
 }

tests/ui/needless_parens_on_range_literals.rs

@@ -18,4 +18,51 @@ fn main() {
     //~^ needless_parens_on_range_literals
     let _ = ..('z');
     //~^ needless_parens_on_range_literals
+
+    macro_rules! verbatim {
+        ($e:expr) => {
+            $e
+        };
+    }
+    macro_rules! add_paren {
+        ($e:expr) => {
+            ($e)
+        };
+    }
+
+    // lint: the paren was added by the user
+    let _ = verbatim!((0))..1;
+    //~^ needless_parens_on_range_literals
+    let _ = 0..verbatim!((1));
+    //~^ needless_parens_on_range_literals
+
+    // lint: the macro doesn't have anything to do with the paren
+    // NOTE: This doesn't actually work currently.
+    //
+    // If we have a case like this:
+    // ```
+    // macro_rules! zero {
+    //     () => {
+    //         0
+    //     };
+    // }
+    // let _ = (zero!())..1;
+    // ```
+    // then the lint doesn't trigger, because the span comes from expansion.
+    // "But surely the outer `()` don't come from an expansion!", I hear you say. But the thing is that
+    // those parens aren't present in the HIR in the first place, and so the expression we actually
+    // end up looking at is `zero!()`, which is in fact an expansion.
+    //
+    // And if we have a case like this:
+    // ```
+    // let _ = (verbatim!(0))..1;
+    // ```
+    // then the parens get ignored as described above, but in addition to that, the whole `verbatim!(0)`
+    // gets replaced with just `0`, which is something that we've written, so its span now gets
+    // doubly-incorrectly identified as not coming from an expansion, and so the lint fires.
+    // But the problem arises when we get to creating the suggestion -- as it _also_ doesn't see the
+    // `verbatim!`, our suggestion ends up being just `let _ = 0..1;`, which is of course incorrect.
+
+    // don't lint: the paren was added by the macro
+    let _ = add_paren!(0)..1;
 }

tests/ui/needless_parens_on_range_literals.stderr

@@ -43,5 +43,17 @@ error: needless parenthesis on range literals can be removed
 LL |     let _ = ..('z');
    |               ^^^^^ help: try: `'z'`
 
-error: aborting due to 7 previous errors
+error: needless parenthesis on range literals can be removed
+  --> tests/ui/needless_parens_on_range_literals.rs:34:23
+   |
+LL |     let _ = verbatim!((0))..1;
+   |                       ^^^ help: try: `0`
+
+error: needless parenthesis on range literals can be removed
+  --> tests/ui/needless_parens_on_range_literals.rs:36:26
+   |
+LL |     let _ = 0..verbatim!((1));
+   |                          ^^^ help: try: `1`
+
+error: aborting due to 9 previous errors