Rollup merge of rust-lang#120272 - long-long-float:suppress-suggestions-in-derive-macro, r=oli-obk

Suppress suggestions in derive macro

close rust-lang#118809

I suppress warnings inside derive macros.

For example, the compiler emits following error by a program described in rust-lang#118809 (comment) with a suggestion that indicates invalid syntax.

```
error[E0308]: `?` operator has incompatible types
 --> src/main.rs:3:17
  |
3 | #[derive(Debug, Deserialize)]
  |                 ^^^^^^^^^^^ expected `u32`, found `u64`
  |
  = note: `?` operator cannot convert from `u64` to `u32`
  = note: this error originates in the derive macro `Deserialize` (in Nightly builds, run with -Z macro-backtrace for more info)
help: you can convert a `u64` to a `u32` and panic if the converted value doesn't fit
  |
3 | #[derive(Debug, Deserialize.try_into().unwrap())]
  |                            ++++++++++++++++++++

For more information about this error, try `rustc --explain E0308`.
error: could not compile `serde_test` (bin "serde_test") due to 2 previous errors
```

In this PR, suggestions to cast are suppressed.

```
error[E0308]: `?` operator has incompatible types
 --> src/main.rs:3:17
  |
3 | #[derive(Debug, Deserialize)]
  |                 ^^^^^^^^^^^ expected `u32`, found `u64`
  |
  = note: `?` operator cannot convert from `u64` to `u32`
  = note: this error originates in the derive macro `Deserialize` (in Nightly builds, run with -Z macro-backtrace for more info)

For more information about this error, try `rustc --explain E0308`.
error: could not compile `serde_test` (bin "serde_test") due to 2 previous errors
```

Author: matthiaskrgr

compiler/rustc_errors/src/diagnostic.rs

@@ -516,6 +516,17 @@ impl Diagnostic {
 
     /// Helper for pushing to `self.suggestions`, if available (not disable).
     fn push_suggestion(&mut self, suggestion: CodeSuggestion) {
+        for subst in &suggestion.substitutions {
+            for part in &subst.parts {
+                let span = part.span;
+                let call_site = span.ctxt().outer_expn_data().call_site;
+                if span.in_derive_expansion() && span.overlaps_or_adjacent(call_site) {
+                    // Ignore if spans is from derive macro.
+                    return;
+                }
+            }
+        }
+
         if let Ok(suggestions) = &mut self.suggestions {
             suggestions.push(suggestion);
         }

compiler/rustc_span/src/lib.rs

@@ -625,6 +625,13 @@ impl Span {
         span.lo < other.hi && other.lo < span.hi
     }
 
+    /// Returns `true` if `self` touches or adjoins `other`.
+    pub fn overlaps_or_adjacent(self, other: Span) -> bool {
+        let span = self.data();
+        let other = other.data();
+        span.lo <= other.hi && other.lo <= span.hi
+    }
+
     /// Returns `true` if the spans are equal with regards to the source text.
     ///
     /// Use this instead of `==` when either span could be generated code,

tests/ui/proc-macro/auxiliary/issue-118809.rs

@@ -0,0 +1,20 @@
+// force-host
+// no-prefer-dynamic
+
+#![crate_type = "proc-macro"]
+
+extern crate proc_macro;
+use proc_macro::TokenStream;
+
+#[proc_macro_derive(Deserialize)]
+pub fn deserialize_derive(input: TokenStream) -> TokenStream {
+    "impl Build {
+        fn deserialize() -> Option<u64> {
+            let x: Option<u32> = Some(0);
+            Some(x? + 1)
+        }
+    }
+    "
+    .parse()
+    .unwrap()
+}

tests/ui/proc-macro/issue-118809.rs

@@ -0,0 +1,10 @@
+// aux-build: issue-118809.rs
+
+#[macro_use]
+extern crate issue_118809;
+
+#[derive(Deserialize)] //~ ERROR mismatched types [E0308]
+pub struct Build {
+}
+
+fn main() {}

tests/ui/proc-macro/issue-118809.stderr

@@ -0,0 +1,21 @@
+error[E0308]: mismatched types
+  --> $DIR/issue-118809.rs:6:10
+   |
+LL | #[derive(Deserialize)]
+   |          ^^^^^^^^^^^
+   |          |
+   |          expected `u64`, found `u32`
+   |          arguments to this enum variant are incorrect
+   |
+help: the type constructed contains `u32` due to the type of the argument passed
+  --> $DIR/issue-118809.rs:6:10
+   |
+LL | #[derive(Deserialize)]
+   |          ^^^^^^^^^^^ this argument influences the type of `Some`
+note: tuple variant defined here
+  --> $SRC_DIR/core/src/option.rs:LL:COL
+   = note: this error originates in the derive macro `Deserialize` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.