Auto merge of rust-lang#125083 - matthiaskrgr:rollup-lfduxod, r=matthiaskrgr

Rollup of 5 pull requests

Successful merges:

 - rust-lang#119515 (style-guide: Format single associated type `where` clauses on the same line)
 - rust-lang#119959 ([meta] Clarify prioritization alert)
 - rust-lang#123817 (Stabilize `seek_seek_relative`)
 - rust-lang#124532 (elaborate obligations in coherence)
 - rust-lang#125063 (Don't call `env::set_var` in `rustc_driver::install_ice_hook`)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_driver_impl/src/lib.rs

@@ -11,6 +11,7 @@
 #![allow(internal_features)]
 #![feature(decl_macro)]
 #![feature(let_chains)]
+#![feature(panic_backtrace_config)]
 #![feature(panic_update_hook)]
 #![feature(result_flattening)]
 
@@ -1317,8 +1318,8 @@ pub fn install_ice_hook(
     // by the user. Compiler developers and other rustc users can
     // opt in to less-verbose backtraces by manually setting "RUST_BACKTRACE"
     // (e.g. `RUST_BACKTRACE=1`)
-    if std::env::var_os("RUST_BACKTRACE").is_none() {
-        std::env::set_var("RUST_BACKTRACE", "full");
+    if env::var_os("RUST_BACKTRACE").is_none() {
+        panic::set_backtrace_style(panic::BacktraceStyle::Full);
     }
 
     let using_internal_features = Arc::new(std::sync::atomic::AtomicBool::default());

compiler/rustc_middle/src/traits/select.rs

@@ -121,7 +121,18 @@ pub enum SelectionCandidate<'tcx> {
     /// Implementation of transmutability trait.
     TransmutabilityCandidate,
 
-    ParamCandidate(ty::PolyTraitPredicate<'tcx>),
+    /// A candidate from the `ParamEnv`.
+    ParamCandidate {
+        /// The actual `where`-bound, e.g. `T: Trait`.
+        predicate: ty::PolyTraitPredicate<'tcx>,
+        /// `true` if the where-bound has no bound vars and does
+        /// not refer to any parameters or inference variables.
+        ///
+        /// We prefer all other candidates over global where-bounds.
+        /// Notably, global where-bounds do not shadow impls.
+        is_global: bool,
+    },
+
     ImplCandidate(DefId),
     AutoImplCandidate,
 

compiler/rustc_trait_selection/src/traits/coherence.rs

@@ -359,9 +359,12 @@ fn impl_intersection_has_impossible_obligation<'a, 'cx, 'tcx>(
 ) -> IntersectionHasImpossibleObligations<'tcx> {
     let infcx = selcx.infcx;
 
+    // Elaborate obligations in case the current obligation is unknowable,
+    // but its super trait bound is not. See #124532 for more details.
+    let obligations = util::elaborate(infcx.tcx, obligations.iter().cloned());
     if infcx.next_trait_solver() {
         let ocx = ObligationCtxt::new(infcx);
-        ocx.register_obligations(obligations.iter().cloned());
+        ocx.register_obligations(obligations);
         let errors_and_ambiguities = ocx.select_all_or_error();
         // We only care about the obligations that are *definitely* true errors.
         // Ambiguities do not prove the disjointness of two impls.
@@ -388,7 +391,7 @@ fn impl_intersection_has_impossible_obligation<'a, 'cx, 'tcx>(
         for obligation in obligations {
             // We use `evaluate_root_obligation` to correctly track intercrate
             // ambiguity clauses.
-            let evaluation_result = selcx.evaluate_root_obligation(obligation);
+            let evaluation_result = selcx.evaluate_root_obligation(&obligation);
 
             match evaluation_result {
                 Ok(result) => {

compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs

@@ -252,16 +252,18 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             all_bounds.filter(|p| p.def_id() == stack.obligation.predicate.def_id());
 
         // Keep only those bounds which may apply, and propagate overflow if it occurs.
-        for bound in matching_bounds {
-            if bound.skip_binder().polarity != stack.obligation.predicate.skip_binder().polarity {
+        for predicate in matching_bounds {
+            if predicate.skip_binder().polarity != stack.obligation.predicate.skip_binder().polarity
+            {
                 continue;
             }
 
             // FIXME(oli-obk): it is suspicious that we are dropping the constness and
             // polarity here.
-            let wc = self.where_clause_may_apply(stack, bound.map_bound(|t| t.trait_ref))?;
+            let wc = self.where_clause_may_apply(stack, predicate.map_bound(|t| t.trait_ref))?;
             if wc.may_apply() {
-                candidates.vec.push(ParamCandidate(bound));
+                let is_global = predicate.is_global() && !predicate.has_bound_vars();
+                candidates.vec.push(ParamCandidate { predicate, is_global });
             }
         }
 

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -57,9 +57,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 ImplSource::Builtin(BuiltinImplSource::Misc, data)
             }
 
-            ParamCandidate(param) => {
+            ParamCandidate { predicate, is_global: _ } => {
                 let obligations =
-                    self.confirm_param_candidate(obligation, param.map_bound(|t| t.trait_ref));
+                    self.confirm_param_candidate(obligation, predicate.map_bound(|t| t.trait_ref));
                 ImplSource::Param(obligations)
             }
 

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -1577,7 +1577,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             return false;
         }
         match result {
-            Ok(Some(SelectionCandidate::ParamCandidate(trait_ref))) => !trait_ref.has_infer(),
+            Ok(Some(SelectionCandidate::ParamCandidate { predicate, .. })) => {
+                !predicate.has_infer()
+            }
             _ => true,
         }
     }
@@ -1829,31 +1831,35 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             return DropVictim::Yes;
         }
 
-        // Check if a bound would previously have been removed when normalizing
-        // the param_env so that it can be given the lowest priority. See
-        // #50825 for the motivation for this.
-        let is_global =
-            |cand: &ty::PolyTraitPredicate<'tcx>| cand.is_global() && !cand.has_bound_vars();
-
-        // (*) Prefer `BuiltinCandidate { has_nested: false }`, `PointeeCandidate`,
-        // `DiscriminantKindCandidate`, `ConstDestructCandidate`
-        // to anything else.
-        //
-        // This is a fix for #53123 and prevents winnowing from accidentally extending the
-        // lifetime of a variable.
         match (&other.candidate, &victim.candidate) {
-            // FIXME(@jswrenn): this should probably be more sophisticated
-            (TransmutabilityCandidate, _) | (_, TransmutabilityCandidate) => DropVictim::No,
-
-            // (*)
+            // Prefer `BuiltinCandidate { has_nested: false }`, `ConstDestructCandidate`
+            // to anything else.
+            //
+            // This is a fix for #53123 and prevents winnowing from accidentally extending the
+            // lifetime of a variable.
+            (
+                BuiltinCandidate { has_nested: false } | ConstDestructCandidate(_),
+                BuiltinCandidate { has_nested: false } | ConstDestructCandidate(_),
+            ) => bug!("two trivial builtin candidates: {other:?} {victim:?}"),
             (BuiltinCandidate { has_nested: false } | ConstDestructCandidate(_), _) => {
                 DropVictim::Yes
             }
             (_, BuiltinCandidate { has_nested: false } | ConstDestructCandidate(_)) => {
                 DropVictim::No
             }
 
-            (ParamCandidate(other), ParamCandidate(victim)) => {
+            // Global bounds from the where clause should be ignored
+            // here (see issue #50825).
+            (ParamCandidate { is_global: true, .. }, ParamCandidate { is_global: true, .. }) => {
+                DropVictim::No
+            }
+            (_, ParamCandidate { is_global: true, .. }) => DropVictim::Yes,
+            (ParamCandidate { is_global: true, .. }, _) => DropVictim::No,
+
+            (
+                ParamCandidate { is_global: false, predicate: other },
+                ParamCandidate { is_global: false, predicate: victim },
+            ) => {
                 let same_except_bound_vars = other.skip_binder().trait_ref
                     == victim.skip_binder().trait_ref
                     && other.skip_binder().polarity == victim.skip_binder().polarity
@@ -1870,68 +1876,8 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 }
             }
 
-            // Drop otherwise equivalent non-const fn pointer candidates
-            (FnPointerCandidate { .. }, FnPointerCandidate { fn_host_effect }) => {
-                DropVictim::drop_if(*fn_host_effect == self.tcx().consts.true_)
-            }
-
-            (
-                ParamCandidate(ref other_cand),
-                ImplCandidate(..)
-                | AutoImplCandidate
-                | ClosureCandidate { .. }
-                | AsyncClosureCandidate
-                | AsyncFnKindHelperCandidate
-                | CoroutineCandidate
-                | FutureCandidate
-                | IteratorCandidate
-                | AsyncIteratorCandidate
-                | FnPointerCandidate { .. }
-                | BuiltinObjectCandidate
-                | BuiltinUnsizeCandidate
-                | TraitUpcastingUnsizeCandidate(_)
-                | BuiltinCandidate { .. }
-                | TraitAliasCandidate
-                | ObjectCandidate(_)
-                | ProjectionCandidate(_),
-            ) => {
-                // We have a where clause so don't go around looking
-                // for impls. Arbitrarily give param candidates priority
-                // over projection and object candidates.
-                //
-                // Global bounds from the where clause should be ignored
-                // here (see issue #50825).
-                DropVictim::drop_if(!is_global(other_cand))
-            }
-            (ObjectCandidate(_) | ProjectionCandidate(_), ParamCandidate(ref victim_cand)) => {
-                // Prefer these to a global where-clause bound
-                // (see issue #50825).
-                if is_global(victim_cand) { DropVictim::Yes } else { DropVictim::No }
-            }
-            (
-                ImplCandidate(_)
-                | AutoImplCandidate
-                | ClosureCandidate { .. }
-                | AsyncClosureCandidate
-                | AsyncFnKindHelperCandidate
-                | CoroutineCandidate
-                | FutureCandidate
-                | IteratorCandidate
-                | AsyncIteratorCandidate
-                | FnPointerCandidate { .. }
-                | BuiltinObjectCandidate
-                | BuiltinUnsizeCandidate
-                | TraitUpcastingUnsizeCandidate(_)
-                | BuiltinCandidate { has_nested: true }
-                | TraitAliasCandidate,
-                ParamCandidate(ref victim_cand),
-            ) => {
-                // Prefer these to a global where-clause bound
-                // (see issue #50825).
-                DropVictim::drop_if(
-                    is_global(victim_cand) && other.evaluation.must_apply_modulo_regions(),
-                )
-            }
+            (ParamCandidate { is_global: false, .. }, _) => DropVictim::Yes,
+            (_, ParamCandidate { is_global: false, .. }) => DropVictim::No,
 
             (ProjectionCandidate(i), ProjectionCandidate(j))
             | (ObjectCandidate(i), ObjectCandidate(j)) => {
@@ -1944,44 +1890,18 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 bug!("Have both object and projection candidate")
             }
 
-            // Arbitrarily give projection and object candidates priority.
-            (
-                ObjectCandidate(_) | ProjectionCandidate(_),
-                ImplCandidate(..)
-                | AutoImplCandidate
-                | ClosureCandidate { .. }
-                | AsyncClosureCandidate
-                | AsyncFnKindHelperCandidate
-                | CoroutineCandidate
-                | FutureCandidate
-                | IteratorCandidate
-                | AsyncIteratorCandidate
-                | FnPointerCandidate { .. }
-                | BuiltinObjectCandidate
-                | BuiltinUnsizeCandidate
-                | TraitUpcastingUnsizeCandidate(_)
-                | BuiltinCandidate { .. }
-                | TraitAliasCandidate,
-            ) => DropVictim::Yes,
+            // Arbitrarily give projection candidates priority.
+            (ProjectionCandidate(_), _) => DropVictim::Yes,
+            (_, ProjectionCandidate(_)) => DropVictim::No,
 
-            (
-                ImplCandidate(..)
-                | AutoImplCandidate
-                | ClosureCandidate { .. }
-                | AsyncClosureCandidate
-                | AsyncFnKindHelperCandidate
-                | CoroutineCandidate
-                | FutureCandidate
-                | IteratorCandidate
-                | AsyncIteratorCandidate
-                | FnPointerCandidate { .. }
-                | BuiltinObjectCandidate
-                | BuiltinUnsizeCandidate
-                | TraitUpcastingUnsizeCandidate(_)
-                | BuiltinCandidate { .. }
-                | TraitAliasCandidate,
-                ObjectCandidate(_) | ProjectionCandidate(_),
-            ) => DropVictim::No,
+            // Need to prioritize builtin trait object impls as
+            // `<dyn Any as Any>::type_id` should use the vtable method
+            // and not the method provided by the user-defined impl
+            // `impl<T: ?Sized> Any for T { .. }`.
+            //
+            // cc #57893
+            (ObjectCandidate(_), _) => DropVictim::Yes,
+            (_, ObjectCandidate(_)) => DropVictim::No,
 
             (&ImplCandidate(other_def), &ImplCandidate(victim_def)) => {
                 // See if we can toss out `victim` based on specialization.
@@ -2061,49 +1981,25 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 }
             }
 
-            (AutoImplCandidate, ImplCandidate(_)) | (ImplCandidate(_), AutoImplCandidate) => {
-                DropVictim::No
-            }
-
-            (AutoImplCandidate, _) | (_, AutoImplCandidate) => {
-                bug!(
-                    "default implementations shouldn't be recorded \
-                    when there are other global candidates: {:?} {:?}",
-                    other,
-                    victim
-                );
-            }
-
-            // Everything else is ambiguous
+            // Treat all non-trivial builtin impls and user-defined impls the same way.
             (
                 ImplCandidate(_)
-                | ClosureCandidate { .. }
-                | AsyncClosureCandidate
-                | AsyncFnKindHelperCandidate
-                | CoroutineCandidate
-                | FutureCandidate
-                | IteratorCandidate
-                | AsyncIteratorCandidate
-                | FnPointerCandidate { .. }
-                | BuiltinObjectCandidate
-                | BuiltinUnsizeCandidate
-                | TraitUpcastingUnsizeCandidate(_)
+                | AutoImplCandidate
                 | BuiltinCandidate { has_nested: true }
-                | TraitAliasCandidate,
-                ImplCandidate(_)
-                | ClosureCandidate { .. }
                 | AsyncClosureCandidate
                 | AsyncFnKindHelperCandidate
                 | CoroutineCandidate
                 | FutureCandidate
                 | IteratorCandidate
                 | AsyncIteratorCandidate
                 | FnPointerCandidate { .. }
-                | BuiltinObjectCandidate
+                | ClosureCandidate { .. }
+                | TraitAliasCandidate
                 | BuiltinUnsizeCandidate
                 | TraitUpcastingUnsizeCandidate(_)
-                | BuiltinCandidate { has_nested: true }
-                | TraitAliasCandidate,
+                | TransmutabilityCandidate
+                | BuiltinObjectCandidate,
+                _,
             ) => DropVictim::No,
         }
     }

library/std/src/io/mod.rs

@@ -2044,7 +2044,6 @@ pub trait Seek {
     /// # Example
     ///
     /// ```no_run
-    /// #![feature(seek_seek_relative)]
     /// use std::{
     ///     io::{self, Seek},
     ///     fs::File,
@@ -2059,7 +2058,7 @@ pub trait Seek {
     /// ```
     ///
     /// [`BufReader`]: crate::io::BufReader
-    #[unstable(feature = "seek_seek_relative", issue = "117374")]
+    #[stable(feature = "seek_seek_relative", since = "CURRENT_RUSTC_VERSION")]
     fn seek_relative(&mut self, offset: i64) -> Result<()> {
         self.seek(SeekFrom::Current(offset))?;
         Ok(())

src/doc/style-guide/src/editions.md

@@ -43,6 +43,7 @@ include:
 - Miscellaneous `rustfmt` bugfixes.
 - Use version-sort (sort `x8`, `x16`, `x32`, `x64`, `x128` in that order).
 - Change "ASCIIbetical" sort to Unicode-aware "non-lowercase before lowercase".
+- Format single associated type `where` clauses on the same line if they fit.
 
 ## Rust 2015/2018/2021 style edition