Make refining_impl_trait suggestion wrap referenced impl-trait in parens

Author: onehr

compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs

@@ -359,8 +359,31 @@ fn report_mismatched_rpitit_signature<'tcx>(
     // the type before creating the diagnostic, we need to avoid this query. This is the
     // standard approach used elsewhere in the compiler for formatting types in suggestions
     // (e.g., see `rustc_hir_typeck/src/demand.rs`).
-    let return_ty_suggestion =
-        with_no_trimmed_paths!(with_types_for_signature!(format!("{return_ty}")));
+    //
+    // Reference-to-opaque types need special handling: when the trait return type is
+    // e.g. `&(impl A + B)`, the default printer emits `&impl A + B`, which parses as the
+    // ambiguous `(&impl A) + B` and triggers "ambiguous `+` in a type" once the
+    // suggestion is applied (cf. https://github.com/rust-lang/rust/issues/144401). Wrap
+    // the inner opaque in parens when its printed form contains `+`-joined bounds.
+    // Bare `impl A + B` at the top level is already syntactically valid and is left
+    // alone; this branch only triggers for references.
+    let return_ty_suggestion = with_no_trimmed_paths!(with_types_for_signature!({
+        let printed = format!("{return_ty}");
+        if let ty::Ref(_, inner, _) = return_ty.kind() {
+            let inner_printed = format!("{inner}");
+            if inner_printed.contains(" + ") && printed.ends_with(&inner_printed) {
+                // Splice parens around the opaque part, keeping the original
+                // `&`/lifetime/mutability prefix verbatim from the existing printer.
+                let prefix_len = printed.len() - inner_printed.len();
+                let prefix = &printed[..prefix_len];
+                format!("{prefix}({inner_printed})")
+            } else {
+                printed
+            }
+        } else {
+            printed
+        }
+    }));
 
     let span = unmatched_bound.unwrap_or(span);
     tcx.emit_node_span_lint(

tests/ui/impl-trait/in-trait/refine-rustfix-parens.fixed

@@ -0,0 +1,44 @@
+//@ run-rustfix
+
+// Verify that the `refining_impl_trait_reachable` lint's suggestion wraps an
+// `impl A + B` in parens when it appears behind a reference, so that applying
+// the suggestion produces syntactically valid code rather than the ambiguous
+// `&impl A + B`. The bare position (`impl A + B` directly) must keep emitting
+// the suggestion without parens.
+//
+// https://github.com/rust-lang/rust/issues/144401
+
+#![allow(unused)]
+#![deny(refining_impl_trait)]
+
+pub trait BarA {}
+impl<T> BarA for T {}
+
+pub trait BarB {}
+impl<T> BarB for T {}
+
+pub struct Fool;
+
+pub trait BehindRef {
+    fn bar(&self) -> &(impl BarA + BarB);
+}
+
+impl BehindRef for Fool {
+    fn bar(&self) -> &(impl BarA + BarB) {
+        //~^ ERROR impl trait in impl method signature does not match trait method signature
+        &Fool
+    }
+}
+
+pub trait BarePosition {
+    fn baz() -> impl BarA + BarB;
+}
+
+impl BarePosition for Fool {
+    fn baz() -> impl BarA + BarB {
+        //~^ ERROR impl trait in impl method signature does not match trait method signature
+        Fool
+    }
+}
+
+fn main() {}

tests/ui/impl-trait/in-trait/refine-rustfix-parens.rs

@@ -0,0 +1,44 @@
+//@ run-rustfix
+
+// Verify that the `refining_impl_trait_reachable` lint's suggestion wraps an
+// `impl A + B` in parens when it appears behind a reference, so that applying
+// the suggestion produces syntactically valid code rather than the ambiguous
+// `&impl A + B`. The bare position (`impl A + B` directly) must keep emitting
+// the suggestion without parens.
+//
+// https://github.com/rust-lang/rust/issues/144401
+
+#![allow(unused)]
+#![deny(refining_impl_trait)]
+
+pub trait BarA {}
+impl<T> BarA for T {}
+
+pub trait BarB {}
+impl<T> BarB for T {}
+
+pub struct Fool;
+
+pub trait BehindRef {
+    fn bar(&self) -> &(impl BarA + BarB);
+}
+
+impl BehindRef for Fool {
+    fn bar(&self) -> &Fool {
+        //~^ ERROR impl trait in impl method signature does not match trait method signature
+        &Fool
+    }
+}
+
+pub trait BarePosition {
+    fn baz() -> impl BarA + BarB;
+}
+
+impl BarePosition for Fool {
+    fn baz() -> Fool {
+        //~^ ERROR impl trait in impl method signature does not match trait method signature
+        Fool
+    }
+}
+
+fn main() {}

tests/ui/impl-trait/in-trait/refine-rustfix-parens.stderr

@@ -0,0 +1,42 @@
+error: impl trait in impl method signature does not match trait method signature
+  --> $DIR/refine-rustfix-parens.rs:27:22
+   |
+LL |     fn bar(&self) -> &(impl BarA + BarB);
+   |                      ------------------- return type from trait method defined here
+...
+LL |     fn bar(&self) -> &Fool {
+   |                      ^^^^^
+   |
+   = note: add `#[allow(refining_impl_trait)]` if it is intended for this to be part of the public API of this crate
+   = note: we are soliciting feedback, see issue #121718 <https://github.com/rust-lang/rust/issues/121718> for more information
+note: the lint level is defined here
+  --> $DIR/refine-rustfix-parens.rs:12:9
+   |
+LL | #![deny(refining_impl_trait)]
+   |         ^^^^^^^^^^^^^^^^^^^
+   = note: `#[deny(refining_impl_trait_reachable)]` implied by `#[deny(refining_impl_trait)]`
+help: replace the return type so that it matches the trait
+   |
+LL -     fn bar(&self) -> &Fool {
+LL +     fn bar(&self) -> &(impl BarA + BarB) {
+   |
+
+error: impl trait in impl method signature does not match trait method signature
+  --> $DIR/refine-rustfix-parens.rs:38:17
+   |
+LL |     fn baz() -> impl BarA + BarB;
+   |                 ---------------- return type from trait method defined here
+...
+LL |     fn baz() -> Fool {
+   |                 ^^^^
+   |
+   = note: add `#[allow(refining_impl_trait)]` if it is intended for this to be part of the public API of this crate
+   = note: we are soliciting feedback, see issue #121718 <https://github.com/rust-lang/rust/issues/121718> for more information
+help: replace the return type so that it matches the trait
+   |
+LL -     fn baz() -> Fool {
+LL +     fn baz() -> impl BarA + BarB {
+   |
+
+error: aborting due to 2 previous errors
+