Rollup of 11 pull requests

Cargo.lock

@@ -3760,7 +3760,6 @@ dependencies = [
  "rustc_session",
  "rustc_span",
  "rustc_trait_selection",
- "rustc_traits",
  "smallvec",
  "tracing",
 ]

compiler/rustc_borrowck/Cargo.toml

@@ -22,7 +22,6 @@ rustc_mir_dataflow = { path = "../rustc_mir_dataflow" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
-rustc_traits = { path = "../rustc_traits" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
 tracing = "0.1"
 # tidy-alphabetical-end

compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs

@@ -20,7 +20,8 @@ use rustc_span::Span;
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::error_reporting::infer::nice_region_error::NiceRegionError;
 use rustc_trait_selection::traits::ObligationCtxt;
-use rustc_traits::{type_op_ascribe_user_type_with_span, type_op_prove_predicate_with_cause};
+use rustc_trait_selection::traits::query::type_op::ascribe_user_type::type_op_ascribe_user_type_with_span;
+use rustc_trait_selection::traits::query::type_op::prove_predicate::type_op_prove_predicate_with_cause;
 use tracing::{debug, instrument};
 
 use crate::MirBorrowckCtxt;

compiler/rustc_feature/src/unstable.rs

@@ -663,7 +663,7 @@ declare_features! (
     /// Allows `mut ref` and `mut ref mut` identifier patterns.
     (incomplete, mut_ref, "1.79.0", Some(123076)),
     /// Allows `mut(crate) field: Type` restrictions.
-    (incomplete, mut_restriction, "1.98.0", Some(105077)),
+    (unstable, mut_restriction, "CURRENT_RUSTC_VERSION", Some(105077)),
     /// Allows using `#[naked]` on `extern "Rust"` functions.
     (unstable, naked_functions_rustic_abi, "1.88.0", Some(138997)),
     /// Allows using `#[target_feature(enable = "...")]` on `#[naked]` on functions.

compiler/rustc_hir_analysis/src/collect.rs

@@ -835,6 +835,12 @@ fn lower_variant<'tcx>(
             did: f.def_id.to_def_id(),
             name: f.ident.name,
             vis: tcx.visibility(f.def_id),
+            mut_restriction: match f.mut_restriction.kind {
+                hir::RestrictionKind::Unrestricted => ty::RestrictionKind::Unrestricted,
+                hir::RestrictionKind::Restricted(path) => {
+                    ty::RestrictionKind::Restricted(path.res, f.mut_restriction.span)
+                }
+            },
             safety: f.safety,
             value: f.default.map(|v| v.def_id.to_def_id()),
         })
@@ -926,19 +932,16 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
             false,
             is_auto == hir::IsAuto::Yes,
             safety,
-            if let hir::RestrictionKind::Restricted(path) = impl_restriction.kind {
-                ty::trait_def::ImplRestrictionKind::Restricted(path.res, impl_restriction.span)
-            } else {
-                ty::trait_def::ImplRestrictionKind::Unrestricted
+            match impl_restriction.kind {
+                hir::RestrictionKind::Restricted(path) => {
+                    ty::RestrictionKind::Restricted(path.res, impl_restriction.span)
+                }
+                hir::RestrictionKind::Unrestricted => ty::RestrictionKind::Unrestricted,
             },
         ),
-        hir::ItemKind::TraitAlias(constness, ..) => (
-            constness,
-            true,
-            false,
-            hir::Safety::Safe,
-            ty::trait_def::ImplRestrictionKind::Unrestricted,
-        ),
+        hir::ItemKind::TraitAlias(constness, ..) => {
+            (constness, true, false, hir::Safety::Safe, ty::RestrictionKind::Unrestricted)
+        }
         _ => span_bug!(item.span, "trait_def_of_item invoked on non-trait"),
     };
 

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -24,8 +24,8 @@ use rustc_hir::diagnostic_items::DiagnosticItems;
 use rustc_index::Idx;
 use rustc_middle::middle::lib_features::LibFeatures;
 use rustc_middle::mir::interpret::{AllocDecodingSession, AllocDecodingState};
-use rustc_middle::ty::Visibility;
 use rustc_middle::ty::codec::TyDecoder;
+use rustc_middle::ty::{RestrictionKind, Visibility};
 use rustc_middle::{bug, implement_ty_decoder};
 use rustc_proc_macro::bridge::client::Client as ProcMacroClient;
 use rustc_serialize::opaque::MemDecoder;
@@ -1145,6 +1145,7 @@ impl CrateMetadata {
                         did,
                         name: self.item_name(did.index),
                         vis: self.get_visibility(tcx, did.index),
+                        mut_restriction: self.get_mut_restriction(tcx, did.index),
                         safety: self.get_safety(did.index),
                         value: self.get_default_field(tcx, did.index),
                     })
@@ -1207,6 +1208,15 @@ impl CrateMetadata {
             .map_id(|index| ModId::new_unchecked(self.local_def_id(index)))
     }
 
+    fn get_mut_restriction(&self, tcx: TyCtxt<'_>, id: DefIndex) -> RestrictionKind {
+        self.root
+            .tables
+            .mut_restriction
+            .get(self, id)
+            .unwrap_or_else(|| self.missing("mut_restriction", id))
+            .decode((self, tcx))
+    }
+
     fn get_safety(&self, id: DefIndex) -> Safety {
         self.root.tables.safety.get(self, id)
     }

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -501,14 +501,14 @@ pub(in crate::rmeta) fn provide(providers: &mut Providers) {
                 }
 
                 if let Some(def_id) = child.res.opt_def_id() {
+                    let mut fallback = false;
+
                     if child.ident.name == kw::Underscore {
-                        fallback_map.push((def_id, parent));
-                        return;
+                        fallback = true;
                     }
 
                     if tcx.is_doc_hidden(parent) {
-                        fallback_map.push((def_id, parent));
-                        return;
+                        fallback = true;
                     }
 
                     // If the re-export itself is `#[doc(hidden)]`, deprioritize it.
@@ -519,20 +519,30 @@ pub(in crate::rmeta) fn provide(providers: &mut Providers) {
                         .and_then(|r| r.id())
                         .is_some_and(|id| tcx.is_doc_hidden(id))
                     {
-                        fallback_map.push((def_id, parent));
-                        return;
+                        fallback = true;
                     }
 
                     match visible_parent_map.entry(def_id) {
                         Entry::Occupied(mut entry) => {
-                            // If `child` is defined in crate `cnum`, ensure
-                            // that it is mapped to a parent in `cnum`.
-                            if def_id.is_local() && entry.get().is_local() {
-                                entry.insert(parent);
+                            if !fallback {
+                                // If `child` is defined in crate `cnum`, ensure
+                                // that it is mapped to a parent in `cnum`.
+                                if def_id.is_local() && entry.get().is_local() {
+                                    entry.insert(parent);
+                                }
                             }
                         }
                         Entry::Vacant(entry) => {
-                            entry.insert(parent);
+                            if fallback {
+                                // We do all of the same steps to fallback entries as to
+                                // preferred entries, except for recording them in a separate map.
+                                // It is important to not return early in the fallback cases to
+                                // ensure that we extend the BFS to the children of fallback items.
+                                fallback_map.push((def_id, parent));
+                            } else {
+                                entry.insert(parent);
+                            }
+
                             if child.res.module_like_def_id().is_some() {
                                 bfs_queue.push_back(def_id);
                             }

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1698,6 +1698,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 
             for field in &variant.fields {
                 self.tables.safety.set(field.did.index, field.safety);
+                record!(
+                    self.tables.mut_restriction[field.did] <- field.mut_restriction
+                );
             }
 
             if let Some((CtorKind::Fn, ctor_def_id)) = variant.ctor {

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -484,6 +484,7 @@ define_tables! {
     associated_types_for_impl_traits_in_trait_or_impl: Table<DefIndex, LazyValue<DefIdMap<Vec<DefId>>>>,
     live_args_for_alias_from_outlives_bounds: Table<DefIndex, LazyValue<Option<ty::EarlyBinder<'static, Vec<ty::GenericArg<'static>>>>>>,
     args_known_to_outlive_alias_params: Table<DefIndex, LazyValue<ty::EarlyBinder<'static, Vec<(ty::Region<'static>, Vec<ty::GenericArg<'static>>)>>>>,
+    mut_restriction: Table<DefIndex, LazyValue<ty::RestrictionKind>>,
 }
 
 #[derive(TyEncodable, TyDecodable)]

compiler/rustc_metadata/src/rmeta/parameterized.rs

@@ -124,6 +124,7 @@ trivially_parameterized_over_tcx! {
     rustc_middle::ty::Generics,
     rustc_middle::ty::ImplTraitInTraitData,
     rustc_middle::ty::IntrinsicDef,
+    rustc_middle::ty::RestrictionKind,
     rustc_middle::ty::TraitDef,
     rustc_middle::ty::Variance,
     rustc_middle::ty::Visibility<DefIndex>,

compiler/rustc_middle/src/ty/mod.rs

@@ -121,6 +121,7 @@ use crate::ty::codec::{TyDecoder, TyEncoder};
 pub use crate::ty::diagnostics::*;
 use crate::ty::fast_reject::SimplifiedType;
 use crate::ty::layout::{FnAbiError, LayoutError};
+use crate::ty::print::{with_crate_prefix, with_no_trimmed_paths};
 use crate::ty::util::Discr;
 use crate::ty::walk::TypeWalker;
 
@@ -402,6 +403,66 @@ impl Visibility {
     }
 }
 
+#[derive(Debug, StableHash, PartialEq, Clone, Copy, Encodable, Decodable)]
+pub enum RestrictionKind {
+    Unrestricted,
+    Restricted(DefId, Span),
+}
+
+impl RestrictionKind {
+    /// Returns `true` if the behavior is allowed/unrestricted in the given module.
+    /// A value of `false` indicates that the behavior is prohibited.
+    pub fn is_allowed_in(self, module: DefId, tcx: TyCtxt<'_>) -> bool {
+        match self {
+            RestrictionKind::Unrestricted => true,
+            RestrictionKind::Restricted(restricted_to, _) => {
+                tcx.is_descendant_of(module, restricted_to)
+            }
+        }
+    }
+
+    /// Obtain the [`Span`] of the restriction. Panics if the restriction is unrestricted.
+    pub fn expect_span(self) -> Span {
+        match self {
+            RestrictionKind::Unrestricted => {
+                bug!("called `expect_span` on an unrestricted item")
+            }
+            RestrictionKind::Restricted(_, span) => span,
+        }
+    }
+
+    /// Obtain the path of the restriction. If unrestricted, an empty string is returned.
+    pub fn restriction_path(self, tcx: TyCtxt<'_>) -> String {
+        match self {
+            RestrictionKind::Unrestricted => String::new(),
+            RestrictionKind::Restricted(restricted_to, _) => {
+                if restricted_to.krate == rustc_hir::def_id::LOCAL_CRATE {
+                    with_crate_prefix!(with_no_trimmed_paths!(tcx.def_path_str(restricted_to)))
+                } else {
+                    tcx.def_path_str(restricted_to.krate.as_mod_id())
+                }
+            }
+        }
+    }
+
+    /// Obtain the stricter restriction between `self` and `rhs`.
+    /// Panics if the restrictions do not reference the same crate.
+    pub fn stricter_of(self, rhs: Self, tcx: TyCtxt<'_>) -> Self {
+        match (self, rhs) {
+            (RestrictionKind::Unrestricted, r) | (r, RestrictionKind::Unrestricted) => r,
+            (
+                RestrictionKind::Restricted(left_did, _),
+                RestrictionKind::Restricted(right_did, _),
+            ) => {
+                if left_did.krate != right_did.krate {
+                    bug!("stricter_of: left and right restriction do not reference the same crate");
+                }
+                if tcx.is_descendant_of(left_did, right_did) { self } else { rhs }
+            }
+        }
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Copy, Hash, TyEncodable, TyDecodable, StableHash)]
 #[derive(TypeFoldable, TypeVisitable)]
 pub struct ClosureSizeProfileData<'tcx> {
@@ -1537,6 +1598,7 @@ pub struct FieldDef {
     pub did: DefId,
     pub name: Symbol,
     pub vis: Visibility<ModId>,
+    pub mut_restriction: RestrictionKind,
     pub safety: hir::Safety,
     pub value: Option<DefId>,
 }
@@ -1551,16 +1613,18 @@ impl PartialEq for FieldDef {
         // of `FieldDef` changes, a compile-error will be produced, reminding
         // us to revisit this assumption.
 
-        let Self { did: lhs_did, name: _, vis: _, safety: _, value: _ } = &self;
+        let Self { did: lhs_did, name: _, vis: _, mut_restriction: _, safety: _, value: _ } = &self;
 
-        let Self { did: rhs_did, name: _, vis: _, safety: _, value: _ } = other;
+        let Self { did: rhs_did, name: _, vis: _, mut_restriction: _, safety: _, value: _ } = other;
 
         let res = lhs_did == rhs_did;
 
         // Double check that implicit assumption detailed above.
         if cfg!(debug_assertions) && res {
-            let deep =
-                self.name == other.name && self.vis == other.vis && self.safety == other.safety;
+            let deep = self.name == other.name
+                && self.vis == other.vis
+                && self.mut_restriction == other.mut_restriction
+                && self.safety == other.safety;
             assert!(deep, "FieldDef for the same def-id has differing data");
         }
 
@@ -1580,7 +1644,7 @@ impl Hash for FieldDef {
         // of `FieldDef` changes, a compile-error will be produced, reminding
         // us to revisit this assumption.
 
-        let Self { did, name: _, vis: _, safety: _, value: _ } = &self;
+        let Self { did, name: _, vis: _, mut_restriction: _, safety: _, value: _ } = &self;
 
         did.hash(s)
     }

compiler/rustc_middle/src/ty/trait_def.rs

@@ -13,16 +13,15 @@ use tracing::debug;
 use crate::query::LocalCrate;
 use crate::traits::specialization_graph;
 use crate::ty::fast_reject::{self, SimplifiedType, TreatParams};
-use crate::ty::print::{with_crate_prefix, with_no_trimmed_paths};
-use crate::ty::{self, Ident, Interner, Ty, TyCtxt, VisitorResult};
+use crate::ty::{self, Ident, Interner, RestrictionKind, Ty, TyCtxt, VisitorResult};
 
 /// A trait's definition with type information.
 #[derive(StableHash, Encodable, Decodable)]
 pub struct TraitDef {
     pub def_id: DefId,
 
     /// Restrictions on trait implementations.
-    pub impl_restriction: ImplRestrictionKind,
+    pub impl_restriction: RestrictionKind,
 
     pub safety: hir::Safety,
 
@@ -102,52 +101,6 @@ pub enum TraitSpecializationKind {
     AlwaysApplicable,
 }
 
-/// Whether the trait implementation is unrestricted or restricted within a specific module.
-#[derive(StableHash, PartialEq, Clone, Copy, Encodable, Decodable)]
-pub enum ImplRestrictionKind {
-    /// The restriction does not affect this trait, and it can be implemented anywhere.
-    Unrestricted,
-    /// This trait can only be implemented within the specified module.
-    Restricted(DefId, Span),
-}
-
-impl ImplRestrictionKind {
-    /// Returns `true` if the behavior is allowed/unrestricted in the given module.
-    /// A value of `false` indicates that the behavior is prohibited.
-    pub fn is_allowed_in(self, module: DefId, tcx: TyCtxt<'_>) -> bool {
-        match self {
-            ImplRestrictionKind::Unrestricted => true,
-            ImplRestrictionKind::Restricted(restricted_to, _) => {
-                tcx.is_descendant_of(module, restricted_to)
-            }
-        }
-    }
-
-    /// Obtain the [`Span`] of the restriction. Panics if the restriction is unrestricted.
-    pub fn expect_span(self) -> Span {
-        match self {
-            ImplRestrictionKind::Unrestricted => {
-                bug!("called `expect_span` on an unrestricted item")
-            }
-            ImplRestrictionKind::Restricted(_, span) => span,
-        }
-    }
-
-    /// Obtain the path of the restriction. If unrestricted, an empty string is returned.
-    pub fn restriction_path(self, tcx: TyCtxt<'_>) -> String {
-        match self {
-            ImplRestrictionKind::Unrestricted => String::new(),
-            ImplRestrictionKind::Restricted(restricted_to, _) => {
-                if restricted_to.krate == rustc_hir::def_id::LOCAL_CRATE {
-                    with_crate_prefix!(with_no_trimmed_paths!(tcx.def_path_str(restricted_to)))
-                } else {
-                    tcx.def_path_str(restricted_to.krate.as_mod_id())
-                }
-            }
-        }
-    }
-}
-
 #[derive(Default, Debug, StableHash)]
 pub struct TraitImpls {
     blanket_impls: Vec<DefId>,