Wrap multi-bound impl/dyn after prefix type constructors

`&impl A + B`, `&mut impl A + B`, `*const impl A + B`,
`*mut impl A + B`, `&dyn A + B` and similar shapes parse as the
ambiguous `(&impl A) + B` and are rejected by the parser, so
diagnostics that surface them produce non-compilable Rust.
`refining_impl_trait` machine-applicable suggestions are the
user-visible failure.

In the `ty::Ref` and `ty::RawPtr` arms of `pretty_print_type`, wrap
the inner type in parens when it would print with `+`-joined bounds.
For `&mut`, emit the mutability prefix before the parens so the
output is `&mut (impl A + B)`, not the ill-formed
`&(mut impl A + B)`. `ty::Dynamic` already self-wraps under an
explicit region, so that case is skipped. `opaque_has_multiple_bounds`
mirrors `pretty_print_opaque_impl_type`'s sizedness handling, so
`?Sized` and the synthetic `Sized` suffix are counted correctly.

`LegacySymbolMangler` and `TypeNamePrinter` override
`add_disambiguating_parens_in_prefix_position` to `false`, keeping
mangled symbols and `std::any::type_name` output byte-identical.

Author: onehr

compiler/rustc_const_eval/src/util/type_name.rs

@@ -203,6 +203,12 @@ impl<'tcx> PrettyPrinter<'tcx> for TypeNamePrinter<'tcx> {
         // `std::any::type_name` should never print verbose type names
         false
     }
+
+    // `type_name` output is user-observable; keep it byte-stable here even
+    // though the docs permit drift.
+    fn add_disambiguating_parens_in_prefix_position(&self) -> bool {
+        false
+    }
 }
 
 impl Write for TypeNamePrinter<'_> {

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -352,6 +352,15 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
     /// will always be printed.)
     fn should_print_optional_region(&self, region: ty::Region<'tcx>) -> bool;
 
+    /// Whether `pretty_print_type` should wrap a multi-bound `impl` / `dyn`
+    /// inner in parens after a prefix type constructor (`&`, `&mut`, `*const`,
+    /// `*mut`), so the output is `&(impl A + B)` rather than the parser-
+    /// ambiguous `&impl A + B`. Byte-stable printers (mangling, `type_name`)
+    /// override this to `false`.
+    fn add_disambiguating_parens_in_prefix_position(&self) -> bool {
+        true
+    }
+
     fn reset_type_limit(&mut self) {}
 
     // Defaults (should not be overridden):
@@ -723,15 +732,17 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
             }
             ty::RawPtr(ty, mutbl) => {
                 write!(self, "*{} ", mutbl.ptr_str())?;
-                ty.print(self)?;
+                self.print_inner_with_disambiguating_parens(ty)?;
             }
             ty::Ref(r, ty, mutbl) => {
                 write!(self, "&")?;
                 if self.should_print_optional_region(r) {
                     r.print(self)?;
                     write!(self, " ")?;
                 }
-                ty::TypeAndMut { ty, mutbl }.print(self)?;
+                // `&mut (impl A + B)`, not `&(mut impl A + B)`: emit `mut ` before the parens.
+                write!(self, "{}", mutbl.prefix_str())?;
+                self.print_inner_with_disambiguating_parens(ty)?;
             }
             ty::Never => write!(self, "!")?,
             ty::Tuple(tys) => {
@@ -1071,6 +1082,121 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
         Ok(())
     }
 
+    /// Prints `ty` after a prefix type constructor, wrapping in parens iff
+    /// [`Self::inner_needs_disambiguating_parens`] returns `true`.
+    fn print_inner_with_disambiguating_parens(&mut self, ty: Ty<'tcx>) -> Result<(), PrintError> {
+        let need_paren = self.inner_needs_disambiguating_parens(ty);
+        if need_paren {
+            write!(self, "(")?;
+        }
+        ty.print(self)?;
+        if need_paren {
+            write!(self, ")")?;
+        }
+        Ok(())
+    }
+
+    /// Whether `ty`, sitting right after a prefix type constructor, would
+    /// print with a top-level `+`. Without the wrap, `&impl A + B` parses as
+    /// the ambiguous `(&impl A) + B`.
+    fn inner_needs_disambiguating_parens(&self, ty: Ty<'tcx>) -> bool {
+        if !self.add_disambiguating_parens_in_prefix_position() || self.should_print_verbose() {
+            return false;
+        }
+        match ty.kind() {
+            // RPITIT trait-side appears as `Projection`, not `Opaque`.
+            ty::Alias(ty::AliasTy { kind: ty::Opaque { def_id }, args, .. }) => {
+                self.opaque_has_multiple_bounds(*def_id, args)
+            }
+            ty::Alias(ty::AliasTy { kind: ty::Projection { def_id }, args, .. })
+                if self.tcx().is_impl_trait_in_trait(*def_id) =>
+            {
+                self.opaque_has_multiple_bounds(*def_id, args)
+            }
+            ty::Dynamic(predicates, region) => {
+                if self.should_print_optional_region(*region) {
+                    // `ty::Dynamic` self-wraps when it has an explicit region.
+                    false
+                } else {
+                    // Projections inline into the principal as `<Item = X>`;
+                    // only principal/auto traits produce a top-level `+`.
+                    predicates
+                        .iter()
+                        .filter(|pred| {
+                            matches!(
+                                pred.skip_binder(),
+                                ty::ExistentialPredicate::Trait(_)
+                                    | ty::ExistentialPredicate::AutoTrait(_)
+                            )
+                        })
+                        .count()
+                        > 1
+                }
+            }
+            _ => false,
+        }
+    }
+
+    /// Whether `Alias(Opaque)` would print with more than one top-level
+    /// `+`-joined component. Must stay in sync with
+    /// `pretty_print_opaque_impl_type`'s sized-bound handling. `?Sized` and
+    /// the synthetic `Sized` / `?Sized` / `MetaSized` / `PointeeSized` suffix
+    /// each contribute one top-level joinable component. Regressions land in
+    /// `tests/ui/impl-trait/in-trait/refine-rustfix-parens.rs`.
+    fn opaque_has_multiple_bounds(&self, def_id: DefId, args: ty::GenericArgsRef<'tcx>) -> bool {
+        let tcx = self.tcx();
+        let bounds = tcx.explicit_item_bounds(def_id);
+
+        // Mirror `pretty_print_opaque_impl_type`'s sized-bound handling:
+        // positive `Sized` and `MetaSized` are absorbed into the synthetic
+        // suffix below; negative `Sized` (`?Sized`) falls through and is
+        // printed inline.
+        let mut trait_emits = 0usize;
+        let mut lifetimes_count = 0usize;
+        let mut has_sized_bound = false;
+        let mut has_negative_sized_bound = false;
+        let mut has_meta_sized_bound = false;
+
+        for (predicate, _) in
+            bounds.iter_instantiated_copied(tcx, args).map(Unnormalized::skip_norm_wip)
+        {
+            match predicate.kind().skip_binder() {
+                ty::ClauseKind::Trait(pred) => match tcx.as_lang_item(pred.def_id()) {
+                    Some(LangItem::Sized) => match pred.polarity {
+                        ty::PredicatePolarity::Positive => {
+                            has_sized_bound = true;
+                        }
+                        ty::PredicatePolarity::Negative => {
+                            has_negative_sized_bound = true;
+                            trait_emits += 1;
+                        }
+                    },
+                    Some(LangItem::MetaSized) => {
+                        has_meta_sized_bound = true;
+                    }
+                    Some(LangItem::PointeeSized) => {}
+                    _ => trait_emits += 1,
+                },
+                ty::ClauseKind::TypeOutlives(_) => lifetimes_count += 1,
+                _ => {}
+            }
+        }
+
+        // The synthetic suffix in `pretty_print_opaque_impl_type` emits at most
+        // one extra bound (`Sized` / `?Sized` / `MetaSized` / `PointeeSized`).
+        let using_sized_hierarchy = tcx.features().sized_hierarchy();
+        let add_sized = has_sized_bound && (trait_emits == 0 || has_negative_sized_bound);
+        let add_maybe_sized =
+            has_meta_sized_bound && !has_negative_sized_bound && !using_sized_hierarchy;
+        let has_pointee_sized =
+            !has_sized_bound && !has_meta_sized_bound && !has_negative_sized_bound;
+        let synthetic = add_sized
+            || add_maybe_sized
+            || (using_sized_hierarchy && (has_meta_sized_bound || has_pointee_sized));
+
+        trait_emits + lifetimes_count + usize::from(synthetic) > 1
+    }
+
     fn pretty_print_opaque_impl_type(
         &mut self,
         def_id: DefId,

compiler/rustc_symbol_mangling/src/legacy.rs

@@ -477,6 +477,12 @@ impl<'tcx> PrettyPrinter<'tcx> for LegacySymbolMangler<'tcx> {
         false
     }
 
+    // Mangled symbols are ABI-stable; don't pick up the default printer's
+    // parser-disambiguating parens.
+    fn add_disambiguating_parens_in_prefix_position(&self) -> bool {
+        false
+    }
+
     // Identical to `PrettyPrinter::comma_sep` except there is no space after each comma.
     fn comma_sep<T>(&mut self, mut elems: impl Iterator<Item = T>) -> Result<(), PrintError>
     where

src/tools/miri/tests/fail/dyn-upcast-nop-wrong-trait.stderr

@@ -1,4 +1,4 @@
-error: Undefined Behavior: constructing invalid value of type *const dyn std::fmt::Debug + std::marker::Send + std::marker::Sync: wrong trait in wide pointer vtable: expected `std::fmt::Debug + std::marker::Send + std::marker::Sync`, but encountered `std::fmt::Display`
+error: Undefined Behavior: constructing invalid value of type *const (dyn std::fmt::Debug + std::marker::Send + std::marker::Sync): wrong trait in wide pointer vtable: expected `std::fmt::Debug + std::marker::Send + std::marker::Sync`, but encountered `std::fmt::Display`
   --> tests/fail/dyn-upcast-nop-wrong-trait.rs:LL:CC
    |
 LL |     let ptr: *const (dyn fmt::Debug + Send + Sync) = unsafe { std::mem::transmute(ptr) };

src/tools/miri/tests/fail/tail_calls/cc-mismatch.stderr

@@ -13,13 +13,13 @@ LL |     extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
                at RUSTLIB/std/src/sys/backtrace.rs:LL:CC
            2: std::rt::lang_start::<()>::{closure#0}
                at RUSTLIB/std/src/rt.rs:LL:CC
-           3: std::ops::function::impls::<impl std::ops::FnOnce<()> for &dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe>::call_once
+           3: std::ops::function::impls::<impl std::ops::FnOnce<()> for &(dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe)>::call_once
                at RUSTLIB/core/src/ops/function.rs:LL:CC
-           4: std::panicking::catch_unwind::do_call::<&dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe, i32>
+           4: std::panicking::catch_unwind::do_call::<&(dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe), i32>
                at RUSTLIB/std/src/panicking.rs:LL:CC
-           5: std::panicking::catch_unwind::<i32, &dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe>
+           5: std::panicking::catch_unwind::<i32, &(dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe)>
                at RUSTLIB/std/src/panicking.rs:LL:CC
-           6: std::panic::catch_unwind::<&dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe, i32>
+           6: std::panic::catch_unwind::<&(dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe), i32>
                at RUSTLIB/std/src/panic.rs:LL:CC
            7: std::rt::lang_start_internal::{closure#0}
                at RUSTLIB/std/src/rt.rs:LL:CC

src/tools/miri/tests/pass/backtrace/backtrace-global-alloc.stderr

@@ -6,13 +6,13 @@
              at RUSTLIB/std/src/sys/backtrace.rs:LL:CC
    3: std::rt::lang_start::<()>::{closure#0}
              at RUSTLIB/std/src/rt.rs:LL:CC
-   4: std::ops::function::impls::<impl std::ops::FnOnce<()> for &dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe>::call_once
+   4: std::ops::function::impls::<impl std::ops::FnOnce<()> for &(dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe)>::call_once
              at RUSTLIB/core/src/ops/function.rs:LL:CC
-   5: std::panicking::catch_unwind::do_call::<&dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe, i32>
+   5: std::panicking::catch_unwind::do_call::<&(dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe), i32>
              at RUSTLIB/std/src/panicking.rs:LL:CC
-   6: std::panicking::catch_unwind::<i32, &dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe>
+   6: std::panicking::catch_unwind::<i32, &(dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe)>
              at RUSTLIB/std/src/panicking.rs:LL:CC
-   7: std::panic::catch_unwind::<&dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe, i32>
+   7: std::panic::catch_unwind::<&(dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe), i32>
              at RUSTLIB/std/src/panic.rs:LL:CC
    8: std::rt::lang_start_internal::{closure#0}
              at RUSTLIB/std/src/rt.rs:LL:CC

src/tools/miri/tests/pass/backtrace/backtrace-std.stderr

@@ -14,13 +14,13 @@
              at RUSTLIB/std/src/sys/backtrace.rs:LL:CC
    7: std::rt::lang_start::<()>::{closure#0}
              at RUSTLIB/std/src/rt.rs:LL:CC
-   8: std::ops::function::impls::<impl std::ops::FnOnce<()> for &dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe>::call_once
+   8: std::ops::function::impls::<impl std::ops::FnOnce<()> for &(dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe)>::call_once
              at RUSTLIB/core/src/ops/function.rs:LL:CC
-   9: std::panicking::catch_unwind::do_call::<&dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe, i32>
+   9: std::panicking::catch_unwind::do_call::<&(dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe), i32>
              at RUSTLIB/std/src/panicking.rs:LL:CC
-  10: std::panicking::catch_unwind::<i32, &dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe>
+  10: std::panicking::catch_unwind::<i32, &(dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe)>
              at RUSTLIB/std/src/panicking.rs:LL:CC
-  11: std::panic::catch_unwind::<&dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe, i32>
+  11: std::panic::catch_unwind::<&(dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe), i32>
              at RUSTLIB/std/src/panic.rs:LL:CC
   12: std::rt::lang_start_internal::{closure#0}
              at RUSTLIB/std/src/rt.rs:LL:CC

tests/ui/argument-suggestions/display-is-suggestable.stderr

@@ -2,7 +2,7 @@ error[E0061]: this function takes 1 argument but 0 arguments were supplied
   --> $DIR/display-is-suggestable.rs:6:5
    |
 LL |     foo();
-   |     ^^^-- argument #1 of type `&dyn std::fmt::Display + Send` is missing
+   |     ^^^-- argument #1 of type `&(dyn std::fmt::Display + Send)` is missing
    |
 note: function defined here
   --> $DIR/display-is-suggestable.rs:3:4
@@ -11,8 +11,8 @@ LL | fn foo(x: &(dyn Display + Send)) {}
    |    ^^^ ------------------------
 help: provide the argument
    |
-LL |     foo(/* &dyn std::fmt::Display + Send */);
-   |         +++++++++++++++++++++++++++++++++++
+LL |     foo(/* &(dyn std::fmt::Display + Send) */);
+   |         +++++++++++++++++++++++++++++++++++++
 
 error: aborting due to 1 previous error
 

tests/ui/cast/casts-differing-anon.stderr

@@ -1,4 +1,4 @@
-error[E0606]: casting `*mut impl Debug + ?Sized` as `*mut impl Debug + ?Sized` is invalid
+error[E0606]: casting `*mut (impl Debug + ?Sized)` as `*mut (impl Debug + ?Sized)` is invalid
   --> $DIR/casts-differing-anon.rs:21:13
    |
 LL |     b_raw = f_raw as *mut _;