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,
                 );
             }
             // `ConstIfConst` is only interested in `~const` bounds.
@@ -347,6 +348,7 @@ fn opaque_type_bounds<'tcx>(
                     hir_bounds,
                     None,
                     span,
+                    opaque_def_id,
                 );
             }
             //`ConstIfConst` is only interested in `~const` bounds.

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -230,6 +230,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
                     &[],
                     Some((param.def_id, hir_generics.predicates)),
                     param.span,
+                    def_id,
                 );
                 trace!(?bounds);
                 predicates.extend(bounds);

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -23,18 +23,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()
     }
 }
 
@@ -82,27 +83,37 @@ fn collect_sizedness_bounds<'tcx>(
                 unbounds.push(ptr);
             }
 
+            let has_constness = matches!(
+                ptr.modifiers.constness,
+                hir::BoundConstness::Always(_) | hir::BoundConstness::Maybe(_)
+            );
+
             if ptr.trait_ref.path.res == Res::Def(DefKind::Trait, sized_did) {
+                sized.constness = has_constness;
                 match ptr.modifiers.polarity {
-                    hir::BoundPolarity::Maybe(_) => sized.maybe = true,
-                    hir::BoundPolarity::Negative(_) => sized.negative = true,
-                    hir::BoundPolarity::Positive => sized.positive = true,
+                    hir::BoundPolarity::Maybe(_) => sized.maybe = Some(hir_bound.span()),
+                    hir::BoundPolarity::Negative(_) => sized.negative = Some(hir_bound.span()),
+                    hir::BoundPolarity::Positive => sized.positive = Some(hir_bound.span()),
                 }
             }
 
             if ptr.trait_ref.path.res == Res::Def(DefKind::Trait, metasized_did) {
+                metasized.constness = has_constness;
                 match ptr.modifiers.polarity {
-                    hir::BoundPolarity::Maybe(_) => metasized.maybe = true,
-                    hir::BoundPolarity::Negative(_) => metasized.negative = true,
-                    hir::BoundPolarity::Positive => metasized.positive = true,
+                    hir::BoundPolarity::Maybe(_) => metasized.maybe = Some(hir_bound.span()),
+                    hir::BoundPolarity::Negative(_) => metasized.negative = Some(hir_bound.span()),
+                    hir::BoundPolarity::Positive => metasized.positive = Some(hir_bound.span()),
                 }
             }
 
             if ptr.trait_ref.path.res == Res::Def(DefKind::Trait, pointeesized_did) {
+                pointeesized.constness = has_constness;
                 match ptr.modifiers.polarity {
-                    hir::BoundPolarity::Maybe(_) => pointeesized.maybe = true,
-                    hir::BoundPolarity::Negative(_) => pointeesized.negative = true,
-                    hir::BoundPolarity::Positive => pointeesized.positive = true,
+                    hir::BoundPolarity::Maybe(_) => pointeesized.maybe = Some(hir_bound.span()),
+                    hir::BoundPolarity::Negative(_) => {
+                        pointeesized.negative = Some(hir_bound.span())
+                    }
+                    hir::BoundPolarity::Positive => pointeesized.positive = Some(hir_bound.span()),
                 }
             }
         }
@@ -201,21 +212,36 @@ 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 metasized_did = tcx.require_lang_item(LangItem::MetaSized, Some(span));
         let pointeesized_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 == pointeesized_did {
             // Never add a default supertrait to `PointeeSized`.
             return;
         }
 
         let (collected, _unbounds) = collect_sizedness_bounds(tcx, hir_bounds, None, span);
-        if !collected.any() && trait_did != pointeesized_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_metasized_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, metasized_did, span);
             add_host_effect_predicate(tcx, bounds, self_ty, metasized_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, bounds, self_ty, sized_did, bound_span);
         }
 
         // See doc comment on `adjust_sizedness_predicates`.
@@ -232,6 +258,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,
     ) {
         let tcx = self.tcx();
 
@@ -241,21 +268,37 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
         let (collected, unbounds) =
             collect_sizedness_bounds(tcx, hir_bounds, self_ty_where_predicates, span);
-        self.check_and_report_invalid_unbounds_on_param(unbounds);
+        let trait_hir_id = tcx.local_def_id_to_hir_id(trait_did);
+        self.check_and_report_invalid_unbounds_on_param(trait_hir_id, unbounds);
 
-        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.metasized.any()
             && !collected.pointeesized.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, metasized_did, span);
             add_host_effect_predicate(tcx, bounds, self_ty, metasized_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, 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, 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, bounds, self_ty, sized_did, span);
+            }
         }
 
         // See doc comment on `adjust_sizedness_predicates`.

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,12 +64,35 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         }
 
         for unbound in unbounds {
-            if let Res::Def(DefKind::Trait, did) = unbound.trait_ref.path.res
-                && (did == sized_did)
-            {
+            let is_sized = matches!(
+                unbound.trait_ref.path.res,
+                Res::Def(DefKind::Trait, did) if did == sized_did
+            );
+            if is_sized && !tcx.features().sized_hierarchy() {
                 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;
+            }
+
+            // There was a `?Trait` bound, but it was not `?Sized`.
             self.dcx().span_err(
                 unbound.span,
                 "relaxing a default bound only does something for `?Sized`; all other traits \
@@ -76,6 +101,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_metasized_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(

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -1156,6 +1156,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                 }
                             });
                         for param in generics.params {
+                            debug!(?param, ?param.span, ?cause_span, ?sized_pred);
                             if param.span == cause_span && sized_pred {
                                 let (sp, sugg) = match param.colon_span {
                                     Some(sp) => (sp.shrink_to_hi(), " ?Sized +"),

compiler/rustc_lint_defs/src/builtin.rs

@@ -97,6 +97,7 @@ declare_lint_pass! {
         SELF_CONSTRUCTOR_FROM_OUTER_ITEM,
         SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
         SINGLE_USE_LIFETIMES,
+        SIZED_HIERARCHY_MIGRATION,
         SOFT_UNSTABLE,
         STABLE_FEATURES,
         SUPERTRAIT_ITEM_SHADOWING_DEFINITION,
@@ -5125,3 +5126,41 @@ declare_lint! {
         reference: "issue #116558 <https://github.com/rust-lang/rust/issues/116558>",
     };
 }
+
+declare_lint! {
+    /// The `sized_hierarchy_migration` lint detects uses of the `Sized` trait which must be
+    /// migrated with the introduction of a hierarchy of sizedness traits.
+    ///
+    /// ### Example
+    /// ```rust,edition_2024,compile_fail
+    /// #![feature(sized_hierarchy)]
+    /// #![deny(sized_hierarchy_migration)]
+    ///
+    /// pub fn foo<T: ?Sized>() {}
+    ///
+    /// pub trait Foo {}
+    ///
+    /// pub fn bar<T>() {}
+    ///
+    /// pub fn qux<T: Sized>() {}
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    /// In order to preserve backwards compatibility when a hierarchy of sizedness traits is
+    /// introduced, various migrations are necessary:
+    ///
+    /// - `Sized` becomes `const Sized`
+    /// - `?Sized` becomes `const MetaSized`
+    /// - Traits have a `const MetaSized` supertrait
+    ///
+    /// See [RFC #3729](https://github.com/rust-lang/rfcs/pull/3729) for more details.
+    pub SIZED_HIERARCHY_MIGRATION,
+    Warn,
+    "new sized traits are being introduced which require migration to maintain backwards compat",
+    @future_incompatible = FutureIncompatibleInfo {
+        reason: FutureIncompatibilityReason::EditionError(Edition::EditionFuture),
+        reference: "<https://doc.rust-lang.org/nightly/edition-guide/rust-future/sized-hierarchy.html>",
+    };
+}