hir_analysis: edition migration

Implement the edition migration required by these changes - `?Sized`
becoming `const MetaSized`, `Sized` becoming `const Sized` and a
`const MetaSized` supertrait.

Author: davidtwco

compiler/rustc_data_structures/src/lib.rs

@@ -10,6 +10,7 @@
 #![allow(internal_features)]
 #![allow(rustc::default_hash_types)]
 #![allow(rustc::potential_query_instability)]
+#![cfg_attr(not(bootstrap), allow(sized_hierarchy_migration))]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]

compiler/rustc_hir_analysis/src/collect/item_bounds.rs

@@ -51,6 +51,7 @@ fn associated_type_bounds<'tcx>(
                     hir_bounds,
                     None,
                     span,
+                    assoc_item_def_id,
                     filter,
                 );
             }
@@ -348,6 +349,7 @@ fn opaque_type_bounds<'tcx>(
                     hir_bounds,
                     None,
                     span,
+                    opaque_def_id,
                     filter,
                 );
             }

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -238,6 +238,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
                     &[],
                     Some((param.def_id, hir_generics.predicates)),
                     param.span,
+                    def_id,
                     PredicateFilter::All,
                 );
                 icx.lowerer().add_default_traits(

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -25,18 +25,19 @@ use crate::hir_ty_lowering::{
 
 #[derive(Debug, Default)]
 struct CollectedBound {
+    constness: bool,
     /// `Trait`
-    positive: bool,
+    positive: Option<Span>,
     /// `?Trait`
-    maybe: bool,
+    maybe: Option<Span>,
     /// `!Trait`
-    negative: bool,
+    negative: Option<Span>,
 }
 
 impl CollectedBound {
     /// Returns `true` if any of `Trait`, `?Trait` or `!Trait` were encountered.
     fn any(&self) -> bool {
-        self.positive || self.maybe || self.negative
+        self.positive.is_some() || self.maybe.is_some() || self.negative.is_some()
     }
 }
 
@@ -61,15 +62,15 @@ impl CollectedSizednessBounds {
 fn search_bounds_for<'tcx>(
     hir_bounds: &'tcx [hir::GenericBound<'tcx>],
     self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
-    mut f: impl FnMut(&'tcx PolyTraitRef<'tcx>),
+    mut f: impl FnMut(&'tcx PolyTraitRef<'tcx>, Span),
 ) {
     let mut search_bounds = |hir_bounds: &'tcx [hir::GenericBound<'tcx>]| {
         for hir_bound in hir_bounds {
             let hir::GenericBound::Trait(ptr) = hir_bound else {
                 continue;
             };
 
-            f(ptr)
+            f(ptr, hir_bound.span())
         }
     };
 
@@ -90,7 +91,7 @@ fn collect_unbounds<'tcx>(
     self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
 ) -> SmallVec<[&'tcx PolyTraitRef<'tcx>; 1]> {
     let mut unbounds: SmallVec<[_; 1]> = SmallVec::new();
-    search_bounds_for(hir_bounds, self_ty_where_predicates, |ptr| {
+    search_bounds_for(hir_bounds, self_ty_where_predicates, |ptr, _| {
         if matches!(ptr.modifiers.polarity, hir::BoundPolarity::Maybe(_)) {
             unbounds.push(ptr);
         }
@@ -104,15 +105,20 @@ fn collect_bounds<'a, 'tcx>(
     target_did: DefId,
 ) -> CollectedBound {
     let mut collect_into = CollectedBound::default();
-    search_bounds_for(hir_bounds, self_ty_where_predicates, |ptr| {
+    search_bounds_for(hir_bounds, self_ty_where_predicates, |ptr, span| {
         if !matches!(ptr.trait_ref.path.res, Res::Def(DefKind::Trait, did) if did == target_did) {
             return;
         }
 
+        collect_into.constness = matches!(
+            ptr.modifiers.constness,
+            hir::BoundConstness::Always(_) | hir::BoundConstness::Maybe(_)
+        );
+
         match ptr.modifiers.polarity {
-            hir::BoundPolarity::Maybe(_) => collect_into.maybe = true,
-            hir::BoundPolarity::Negative(_) => collect_into.negative = true,
-            hir::BoundPolarity::Positive => collect_into.positive = true,
+            hir::BoundPolarity::Maybe(_) => collect_into.maybe = Some(span),
+            hir::BoundPolarity::Negative(_) => collect_into.negative = Some(span),
+            hir::BoundPolarity::Positive => collect_into.positive = Some(span),
         }
     });
     collect_into
@@ -215,9 +221,11 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let tcx = self.tcx();
 
         let span = tcx.def_span(trait_did);
+        let sized_did = tcx.require_lang_item(LangItem::Sized, Some(span));
         let meta_sized_did = tcx.require_lang_item(LangItem::MetaSized, Some(span));
         let pointee_sized_did = tcx.require_lang_item(LangItem::PointeeSized, Some(span));
 
+        let trait_hir_id = tcx.local_def_id_to_hir_id(trait_did);
         let trait_did = trait_did.to_def_id();
         if trait_did == pointee_sized_did {
             // Never add a default supertrait to `PointeeSized`.
@@ -230,11 +238,24 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         }
 
         let collected = collect_sizedness_bounds(tcx, hir_bounds, None, span);
-        if !collected.any() && trait_did != pointee_sized_did {
-            // If there are no explicit sizedness bounds then add a default `const MetaSized`
-            // supertrait.
+        if !collected.any() && !tcx.sess.edition().at_least_edition_future() {
+            // Emit migration lint when the feature is enabled.
+            self.emit_implicit_const_meta_sized_supertrait_lint(trait_hir_id, span);
+
+            // If it is not Edition Future and there are no explicit sizedness bounds then add a
+            // default `const MetaSized` supertrait.
             add_trait_predicate(tcx, bounds, self_ty, meta_sized_did, span);
             add_host_effect_predicate(tcx, filter, bounds, self_ty, meta_sized_did, span);
+        } else if let Some(bound_span) = collected.sized.positive
+            && !collected.sized.constness
+            && !tcx.sess.edition().at_least_edition_future()
+        {
+            // Emit migration lint when the feature is enabled.
+            self.emit_sized_to_const_sized_lint(trait_hir_id, bound_span);
+
+            // If it is not Edition Future then `Sized` is equivalent to writing `const Sized`.
+            add_trait_predicate(tcx, bounds, self_ty, sized_did, bound_span);
+            add_host_effect_predicate(tcx, filter, bounds, self_ty, sized_did, bound_span);
         }
 
         // See doc comment on `adjust_sizedness_predicates`.
@@ -251,6 +272,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         hir_bounds: &'tcx [hir::GenericBound<'tcx>],
         self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
         span: Span,
+        trait_did: LocalDefId,
         filter: PredicateFilter,
     ) {
         let tcx = self.tcx();
@@ -260,23 +282,39 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let pointee_sized_did = tcx.require_lang_item(LangItem::PointeeSized, Some(span));
 
         // Report invalid unbounds.
+        let trait_hir_id = tcx.local_def_id_to_hir_id(trait_did);
         let unbounds = collect_unbounds(hir_bounds, self_ty_where_predicates);
-        self.check_and_report_invalid_unbounds_on_param(unbounds);
+        self.check_and_report_invalid_unbounds_on_param(trait_hir_id, unbounds);
 
         let collected = collect_sizedness_bounds(tcx, hir_bounds, self_ty_where_predicates, span);
-        if (collected.sized.maybe || collected.sized.negative)
-            && !collected.sized.positive
+        if (collected.sized.maybe.is_some() || collected.sized.negative.is_some())
+            && !collected.sized.positive.is_some()
             && !collected.meta_sized.any()
             && !collected.pointee_sized.any()
         {
             // `?Sized` is equivalent to `const MetaSized` (but only add the bound if there aren't
             // any other explicit ones)
             add_trait_predicate(tcx, bounds, self_ty, meta_sized_did, span);
             add_host_effect_predicate(tcx, filter, bounds, self_ty, meta_sized_did, span);
+        } else if let Some(bound_span) = collected.sized.positive
+            && !collected.sized.constness
+            && !tcx.sess.edition().at_least_edition_future()
+        {
+            // Emit migration lint when the feature is enabled.
+            self.emit_sized_to_const_sized_lint(trait_hir_id, bound_span);
+
+            // Replace `Sized` with `const Sized`.
+            add_trait_predicate(tcx, bounds, self_ty, sized_did, bound_span);
+            add_host_effect_predicate(tcx, filter, bounds, self_ty, sized_did, bound_span);
         } else if !collected.any() {
             // If there are no explicit sizedness bounds then add a default `const Sized` bound.
             add_trait_predicate(tcx, bounds, self_ty, sized_did, span);
-            add_host_effect_predicate(tcx, filter, bounds, self_ty, sized_did, span);
+
+            if !tcx.sess.edition().at_least_edition_future() {
+                self.emit_default_sized_to_const_sized_lint(trait_hir_id, span);
+
+                add_host_effect_predicate(tcx, filter, bounds, self_ty, sized_did, span);
+            }
         }
 
         // See doc comment on `adjust_sizedness_predicates`.
@@ -476,7 +514,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
     ) -> bool {
         let collected = collect_bounds(hir_bounds, self_ty_where_predicates, trait_def_id);
-        !(collected.positive || collected.maybe || collected.negative)
+        !(collected.positive.is_some() || collected.maybe.is_some() || collected.negative.is_some())
     }
 
     /// Lower HIR bounds into `bounds` given the self type `param_ty` and the overarching late-bound vars if any.

compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs

@@ -7,14 +7,15 @@ use rustc_errors::{
 };
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::{self as hir, LangItem, PolyTraitRef};
+use rustc_hir::{self as hir, HirId, LangItem, PolyTraitRef};
 use rustc_middle::bug;
 use rustc_middle::ty::fast_reject::{TreatParams, simplify_type};
 use rustc_middle::ty::print::{PrintPolyTraitRefExt as _, PrintTraitRefExt as _};
 use rustc_middle::ty::{
     self, AdtDef, GenericParamDefKind, Ty, TyCtxt, TypeVisitableExt,
     suggest_constraining_type_param,
 };
+use rustc_session::lint;
 use rustc_session::parse::feature_err;
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::{BytePos, DUMMY_SP, Ident, Span, Symbol, kw, sym};
@@ -32,9 +33,10 @@ use crate::fluent_generated as fluent;
 use crate::hir_ty_lowering::{AssocItemQSelf, HirTyLowerer};
 
 impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
-    /// Check for multiple relaxed default bounds and relaxed bounds of non-sizedness traits.
+    /// Check for multiple relaxed default bounds and relaxed bounds.
     pub(crate) fn check_and_report_invalid_unbounds_on_param(
         &self,
+        trait_hir_id: HirId,
         unbounds: SmallVec<[&PolyTraitRef<'_>; 1]>,
     ) {
         let tcx = self.tcx();
@@ -62,16 +64,41 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         }
 
         for unbound in unbounds {
-            if let Res::Def(DefKind::Trait, did) = unbound.trait_ref.path.res
-                && ((did == sized_did) || tcx.is_default_trait(did))
-            {
+            let (is_sized, is_default_trait) =
+                if let Res::Def(DefKind::Trait, did) = unbound.trait_ref.path.res {
+                    (did == sized_did, tcx.is_default_trait(did))
+                } else {
+                    (false, false)
+                };
+            if (is_sized && !tcx.features().sized_hierarchy()) || is_default_trait {
                 continue;
             }
 
+            if tcx.features().sized_hierarchy() && is_sized {
+                tcx.node_span_lint(
+                    lint::builtin::SIZED_HIERARCHY_MIGRATION,
+                    trait_hir_id,
+                    unbound.span,
+                    |lint| {
+                        lint.primary_message(
+                            "`?Sized` bound relaxations are being migrated to `const MetaSized`",
+                        );
+                        lint.span_suggestion(
+                            unbound.span,
+                            "replace `?Sized` with `const MetaSized`",
+                            "const MetaSized",
+                            Applicability::MachineApplicable,
+                        );
+                    },
+                );
+                return;
+            }
+
             let unbound_traits = match tcx.sess.opts.unstable_opts.experimental_default_bounds {
                 true => "`?Sized` and `experimental_default_bounds`",
                 false => "`?Sized`",
             };
+            // There was a `?Trait` bound, but it was not `?Sized`.
             self.dcx().span_err(
                 unbound.span,
                 format!(
@@ -83,6 +110,77 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         }
     }
 
+    /// Emit lint adding a `const MetaSized` supertrait as part of sized hierarchy migration.
+    pub(crate) fn emit_implicit_const_meta_sized_supertrait_lint(
+        &self,
+        trait_hir_id: HirId,
+        span: Span,
+    ) {
+        let tcx = self.tcx();
+        if tcx.features().sized_hierarchy() {
+            tcx.node_span_lint(
+                lint::builtin::SIZED_HIERARCHY_MIGRATION,
+                trait_hir_id,
+                span,
+                |lint| {
+                    lint.primary_message(
+                        "a `const MetaSized` supertrait is required to maintain backwards \
+                         compatibility",
+                    );
+                    lint.span_suggestion(
+                        span.shrink_to_hi(),
+                        "add an explicit `const MetaSized` supertrait",
+                        ": const MetaSized",
+                        Applicability::MachineApplicable,
+                    );
+                },
+            );
+        }
+    }
+
+    /// Emit lint changing `Sized` bounds to `const MetaSized` bounds as part of sized hierarchy
+    /// migration.
+    pub(crate) fn emit_sized_to_const_sized_lint(&self, trait_hir_id: HirId, span: Span) {
+        let tcx = self.tcx();
+        if tcx.features().sized_hierarchy() {
+            tcx.node_span_lint(
+                lint::builtin::SIZED_HIERARCHY_MIGRATION,
+                trait_hir_id,
+                span,
+                |lint| {
+                    lint.primary_message("`Sized` bounds are being migrated to `const Sized`");
+                    lint.span_suggestion(
+                        span,
+                        "replace `Sized` with `const Sized`",
+                        "const Sized",
+                        Applicability::MachineApplicable,
+                    );
+                },
+            );
+        }
+    }
+
+    /// Emit lint adding `const MetaSized` bound as part of sized hierarchy migration.
+    pub(crate) fn emit_default_sized_to_const_sized_lint(&self, trait_hir_id: HirId, span: Span) {
+        let tcx = self.tcx();
+        if tcx.features().sized_hierarchy() {
+            tcx.node_span_lint(
+                lint::builtin::SIZED_HIERARCHY_MIGRATION,
+                trait_hir_id,
+                span,
+                |lint| {
+                    lint.primary_message("default bounds are being migrated to `const Sized`");
+                    lint.span_suggestion(
+                        span.shrink_to_hi(),
+                        "add `const Sized`",
+                        ": const Sized",
+                        Applicability::MachineApplicable,
+                    );
+                },
+            );
+        }
+    }
+
     /// On missing type parameters, emit an E0393 error and provide a structured suggestion using
     /// the type parameter's name as a placeholder.
     pub(crate) fn complain_about_missing_type_params(