Move trait prototype

compiler/rustc_ast_lowering/src/item.rs

@@ -500,13 +500,21 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let constness = self.lower_constness(attrs, *constness);
                 let impl_restriction = self.lower_impl_restriction(impl_restriction, hir_id);
                 let ident = self.lower_ident(*ident);
+                // FIXME(move_trait): We likely want to not add an implicit `Move` super trait
+                // at which point we shouldn't allow relaxed bounds here. Even if we do, we should
+                // make sure to only allow `?Move`.
+                let policy = if self.tcx.features().move_trait() {
+                    RelaxedBoundPolicy::Allowed(&mut Default::default())
+                } else {
+                    RelaxedBoundPolicy::Forbidden(RelaxedBoundForbiddenReason::SuperTrait)
+                };
                 let (generics, (safety, items, bounds)) = self.lower_generics(
                     generics,
                     ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| {
                         let bounds = this.lower_param_bounds(
                             bounds,
-                            RelaxedBoundPolicy::Forbidden(RelaxedBoundForbiddenReason::SuperTrait),
+                            policy,
                             ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
                         );
                         let items = this.arena.alloc_from_iter(

compiler/rustc_attr_ir/src/lang_items.rs

@@ -277,6 +277,8 @@ language_item_table! {
     Unpin,                   sym::unpin,               unpin_trait,                Target::Trait,          GenericRequirement::None;
     Pin,                     kw::Pin,                  pin_type,                   Target::Struct,         GenericRequirement::None;
 
+    Move,                    sym::move_trait,          move_trait,                 Target::Trait,          GenericRequirement::None;
+
     OrderingEnum,            sym::Ordering,            ordering_enum,              Target::Enum,           GenericRequirement::Exact(0);
     PartialEq,               sym::eq,                  eq_trait,                   Target::Trait,          GenericRequirement::Exact(1);
     PartialOrd,              sym::partial_ord,         partial_ord_trait,          Target::Trait,          GenericRequirement::Exact(1);

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -53,6 +53,7 @@ impl<'tcx> ConstraintDescription for ConstraintCategory<'tcx> {
             ConstraintCategory::TypeAnnotation(AnnotationSource::GenericArg) => "generic argument ",
             ConstraintCategory::TypeAnnotation(_) => "type annotation ",
             ConstraintCategory::SizedBound => "proving this value is `Sized` ",
+            ConstraintCategory::MoveBound => "proving this value is `Move` ",
             ConstraintCategory::CopyBound => "copying this value ",
             ConstraintCategory::OpaqueType => "opaque type ",
             ConstraintCategory::ClosureUpvar(_) => "closure capture ",

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -1752,6 +1752,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                 | ConstraintCategory::CallArgument(_)
                 | ConstraintCategory::CopyBound
                 | ConstraintCategory::SizedBound
+                | ConstraintCategory::MoveBound
                 | ConstraintCategory::Assignment
                 | ConstraintCategory::Usage
                 | ConstraintCategory::ClosureUpvar(_) => 2,

compiler/rustc_borrowck/src/type_check/canonical.rs

@@ -3,12 +3,13 @@ use std::fmt;
 use rustc_errors::ErrorGuaranteed;
 use rustc_infer::infer::canonical::Canonical;
 use rustc_infer::infer::outlives::env::RegionBoundPairs;
+use rustc_infer::traits::{Obligation, ObligationCause};
 use rustc_middle::bug;
 use rustc_middle::mir::{Body, ConstraintCategory};
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable, Unnormalized, Upcast};
 use rustc_span::Span;
 use rustc_span::def_id::DefId;
-use rustc_trait_selection::traits::ObligationCause;
+use rustc_trait_selection::traits::query::type_op::custom::FallibleCustomTypeOp;
 use rustc_trait_selection::traits::query::type_op::{self, TypeOpOutput};
 use tracing::{debug, instrument};
 
@@ -185,6 +186,31 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         );
     }
 
+    /// Certain proofs (e.g. `Move`) may error during MIR typeck, so handle them separately.
+    pub(super) fn prove_fallible_predicate(
+        &mut self,
+        predicate: impl Upcast<TyCtxt<'tcx>, ty::Predicate<'tcx>> + std::fmt::Debug,
+        locations: Locations,
+        category: ConstraintCategory<'tcx>,
+    ) {
+        let span = self.last_span;
+        let predicate = predicate.upcast(self.tcx());
+        let op = FallibleCustomTypeOp::new(
+            |ocx| {
+                ocx.register_obligation(Obligation::new(
+                    ocx.infcx.tcx,
+                    ObligationCause::dummy_with_span(span),
+                    self.infcx.param_env,
+                    predicate,
+                ));
+                Ok(())
+            },
+            "fallible type op",
+        );
+
+        let _: Result<_, ErrorGuaranteed> = self.fully_perform_op(locations, category, op);
+    }
+
     pub(super) fn normalize<T>(
         &mut self,
         value: Unnormalized<'tcx, T>,

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -18,9 +18,9 @@ use rustc_infer::infer::region_constraints::RegionConstraintData;
 use rustc_infer::infer::{
     BoundRegionConversionTime, InferCtxt, NllRegionVariableOrigin, RegionVariableOrigin,
 };
-use rustc_infer::traits::{Obligation, ObligationCause, PredicateObligations};
+use rustc_infer::traits::{Obligation, ObligationCause, PredicateObligations, ScrubbedTraitError};
 use rustc_middle::bug;
-use rustc_middle::mir::visit::{NonMutatingUseContext, PlaceContext, Visitor};
+use rustc_middle::mir::visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::traits::query::NoSolution;
 use rustc_middle::ty::adjustment::PointerCoercion;
@@ -1882,6 +1882,44 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
             // it must.
             self.prove_trait_ref(trait_ref, location.to_locations(), ConstraintCategory::CopyBound);
         }
+
+        if tcx.features().move_trait() {
+            match context {
+                PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy)
+                | PlaceContext::NonMutatingUse(NonMutatingUseContext::Move) => {
+                    let trait_ref = ty::TraitRef::new(
+                        tcx,
+                        tcx.require_lang_item(LangItem::Move, self.last_span),
+                        [place_ty.ty],
+                    );
+                    self.prove_fallible_predicate(
+                        trait_ref,
+                        location.to_locations(),
+                        ConstraintCategory::MoveBound,
+                    );
+                }
+                PlaceContext::NonUse(_)
+                | PlaceContext::NonMutatingUse(
+                    NonMutatingUseContext::FakeBorrow
+                    | NonMutatingUseContext::Inspect
+                    | NonMutatingUseContext::PlaceMention
+                    | NonMutatingUseContext::Projection
+                    | NonMutatingUseContext::RawBorrow
+                    | NonMutatingUseContext::SharedBorrow,
+                )
+                | PlaceContext::MutatingUse(
+                    MutatingUseContext::Store
+                    | MutatingUseContext::SetDiscriminant
+                    | MutatingUseContext::AsmOutput
+                    | MutatingUseContext::Call
+                    | MutatingUseContext::Yield
+                    | MutatingUseContext::Drop
+                    | MutatingUseContext::Borrow
+                    | MutatingUseContext::RawBorrow
+                    | MutatingUseContext::Projection,
+                ) => {}
+            }
+        }
     }
 
     fn visit_projection_elem(
@@ -2801,10 +2839,16 @@ impl<'tcx> TypeOp<'tcx> for InstantiateOpaqueType<'tcx> {
         span: Span,
     ) -> Result<TypeOpOutput<'tcx, Self>, ErrorGuaranteed> {
         let (mut output, region_constraints) =
-            scrape_region_constraints(infcx, root_def_id, "InstantiateOpaqueType", span, |ocx| {
-                ocx.register_obligations(self.obligations.clone());
-                Ok(())
-            })?;
+            scrape_region_constraints::<_, _, ScrubbedTraitError<'tcx>>(
+                infcx,
+                root_def_id,
+                "InstantiateOpaqueType",
+                span,
+                |ocx| {
+                    ocx.register_obligations(self.obligations.clone());
+                    Ok(())
+                },
+            )?;
         self.region_constraints = Some(region_constraints);
         output.error_info = Some(self);
         Ok(output)

compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs

@@ -234,7 +234,18 @@ fn push_debuginfo_type_name<'tcx>(
             }
         }
         ty::Dynamic(trait_data, ..) => {
-            let auto_traits: SmallVec<[DefId; 4]> = trait_data.auto_traits().collect();
+            let mut has_move_bound = false;
+            let auto_traits: SmallVec<[DefId; 4]> = trait_data
+                .auto_traits()
+                .filter(|def_id| {
+                    if tcx.is_move_trait(*def_id) {
+                        has_move_bound = true;
+                        false
+                    } else {
+                        true
+                    }
+                })
+                .collect();
 
             let has_enclosing_parens = if cpp_like_debuginfo {
                 output.push_str("dyn$<");
@@ -312,6 +323,13 @@ fn push_debuginfo_type_name<'tcx>(
                         push_item_name(tcx, def_id, true, &mut name);
                         name
                     })
+                    .chain((!has_move_bound).then(|| {
+                        let move_trait = tcx.lang_items().move_trait().unwrap();
+                        let mut name = String::with_capacity(21);
+                        name.push('?');
+                        push_item_name(tcx, move_trait, true, &mut name);
+                        name
+                    }))
                     .collect();
                 auto_traits.sort_unstable();
 

compiler/rustc_feature/src/unstable.rs

@@ -625,6 +625,8 @@ declare_features! (
     (unstable, more_qualified_paths, "1.54.0", Some(86935)),
     /// Allows `move(expr)` in closures.
     (incomplete, move_expr, "1.97.0", Some(155050)),
+    /// The `Move` autotrait.
+    (incomplete, move_trait, "CURRENT_RUSTC_VERSION", Some(149607)),
     /// The `movrs` target feature on x86.
     (unstable, movrs_target_feature, "1.88.0", Some(137976)),
     /// Allows the `multiple_supertrait_upcastable` lint.

compiler/rustc_hir_analysis/src/check/check.rs

@@ -2094,12 +2094,11 @@ fn check_type_alias_type_params_are_used<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalD
                     None
                 }
             })
-            // FIXME: This assumes that elaborated `Sized` bounds come first (which does hold at the
-            // time of writing). This is a bit fragile since we later use the span to detect elaborated
-            // `Sized` bounds. If they came last for example, this would break `Trait + /*elab*/Sized`
-            // since it would overwrite the span of the user-written bound. This could be fixed by
-            // folding the spans with `Span::to` which requires a bit of effort I think.
-            .collect::<FxIndexMap<_, _>>()
+            // keeping all values, we are in an error branch anyway
+            .fold(FxIndexMap::<_, Vec<_>>::default(), |mut map, (index, span)| {
+                map.entry(index).or_default().push(span);
+                map
+            })
     });
 
     let mut params_used = DenseBitSet::new_empty(generics.own_params.len());
@@ -2123,7 +2122,9 @@ fn check_type_alias_type_params_are_used<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalD
             // * check for emptiness to detect lone user-written `?Sized` bounds
             // * compare the param span to the pred span to detect lone user-written `Sized` bounds
             let has_explicit_bounds = bounded_params.is_empty()
-                || (*bounded_params).get(&param.index).is_some_and(|&&pred_sp| pred_sp != span);
+                || (*bounded_params)
+                    .get(&param.index)
+                    .is_some_and(|pred_spans| pred_spans.iter().any(|&&pred_sp| pred_sp != span));
             let const_param_help = !has_explicit_bounds;
 
             let mut diag = tcx.dcx().create_err(diagnostics::UnusedGenericParameter {

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -405,7 +405,10 @@ fn bounds_from_generic_clauses<'tcx>(
             ty::ClauseKind::Trait(trait_predicate) => {
                 let entry = types.entry(trait_predicate.self_ty()).or_default();
                 let def_id = trait_predicate.def_id();
-                if !tcx.is_default_trait(def_id) && !tcx.is_lang_item(def_id, LangItem::Sized) {
+                // nia: fixme: metasized
+                if !tcx.is_implicit_trait(def_id, ty::IncludingSized::No)
+                    && !tcx.is_lang_item(def_id, LangItem::Sized)
+                {
                     // Do not add that restriction to the list if it is a positive requirement.
                     entry.push(trait_predicate.def_id());
                 }

compiler/rustc_hir_analysis/src/collect/clauses_of.rs

@@ -7,7 +7,8 @@ use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::find_attr;
 use rustc_middle::ty::{
-    self, GenericClauses, ImplTraitInTraitData, Ty, TyCtxt, TypeVisitable, TypeVisitor, Upcast,
+    self, ClausePolarity, GenericClauses, ImplTraitInTraitData, Ty, TyCtxt, TypeVisitable,
+    TypeVisitor, Upcast,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_span::{DUMMY_SP, Ident, Span};
@@ -73,12 +74,26 @@ pub(super) fn clauses_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericClauses<'
         );
     }
 
+    // Optimization:
+    // If `#[feature(move_trait)]` is disabled, remove all `T: Move` clauses as they are trivial
+    if !tcx.features().move_trait()
+        && let Some(move_trait) = tcx.lang_items().move_trait()
+        && !result.clauses.is_empty()
+    {
+        result.clauses = tcx.arena.alloc_from_iter(result.clauses.iter().copied().filter(|p| {
+            !p.0.as_trait_clause().is_some_and(|p| {
+                p.polarity() == ClausePolarity::Positive && p.def_id() == move_trait
+            })
+        }));
+    }
+
     debug!("clauses_of({:?}) = {:?}", def_id, result);
     result
 }
 
 /// Returns a list of user-specified type clauses for the definition with ID `def_id`.
-/// N.B., this does not include any implied/inferred constraints.
+/// N.B., this does not include any implied/inferred constraints,
+///       including instead default bounds like `Move`
 #[instrument(level = "trace", skip(tcx), ret)]
 fn gather_explicit_clauses_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::GenericClauses<'_> {
     use rustc_hir::*;
@@ -196,19 +211,13 @@ fn gather_explicit_clauses_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generi
             PredicateFilter::All,
             OverlappingAsssocItemConstraints::Allowed,
         );
-        icx.lowerer().add_implicit_sizedness_bounds(
-            &mut bounds,
-            tcx.types.self_param,
-            self_bounds,
-            ImpliedBoundsContext::TraitDef(def_id),
-            span,
-        );
-        icx.lowerer().add_default_traits(
+        icx.lowerer().add_implicit_bounds(
             &mut bounds,
             tcx.types.self_param,
             self_bounds,
             ImpliedBoundsContext::TraitDef(def_id),
             span,
+            ty::IncludingSized::Yes,
         );
         clauses.extend(bounds);
     }
@@ -235,19 +244,13 @@ fn gather_explicit_clauses_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generi
                 let param_ty = icx.lowerer().lower_ty_param(param.hir_id);
                 let mut bounds = Vec::new();
                 // Implicit bounds are added to type params unless a `?Trait` bound is found
-                icx.lowerer().add_implicit_sizedness_bounds(
-                    &mut bounds,
-                    param_ty,
-                    &[],
-                    ImpliedBoundsContext::TyParam(param.def_id, hir_generics.predicates),
-                    param.span,
-                );
-                icx.lowerer().add_default_traits(
+                icx.lowerer().add_implicit_bounds(
                     &mut bounds,
                     param_ty,
                     &[],
                     ImpliedBoundsContext::TyParam(param.def_id, hir_generics.predicates),
                     param.span,
+                    ty::IncludingSized::Yes,
                 );
                 trace!(?bounds);
                 clauses.extend(bounds);
@@ -691,19 +694,13 @@ pub(super) fn implied_clauses_with_filter<'tcx>(
         | PredicateFilter::SelfOnly
         | PredicateFilter::SelfTraitThatDefines(_)
         | PredicateFilter::SelfAndAssociatedTypeBounds => {
-            icx.lowerer().add_implicit_sizedness_bounds(
-                &mut bounds,
-                self_param_ty,
-                superbounds,
-                ImpliedBoundsContext::TraitDef(trait_def_id),
-                item.span,
-            );
-            icx.lowerer().add_default_traits(
+            icx.lowerer().add_implicit_bounds(
                 &mut bounds,
                 self_param_ty,
                 superbounds,
                 ImpliedBoundsContext::TraitDef(trait_def_id),
                 item.span,
+                ty::IncludingSized::Yes,
             );
         }
         //`ConstIfConst` is only interested in `[const]` bounds.
@@ -993,19 +990,13 @@ impl<'tcx> ItemCtxt<'tcx> {
                 match param.kind {
                     hir::GenericParamKind::Type { .. } => {
                         let param_ty = self.lowerer().lower_ty_param(param.hir_id);
-                        self.lowerer().add_implicit_sizedness_bounds(
-                            &mut bounds,
-                            param_ty,
-                            &[],
-                            ImpliedBoundsContext::TyParam(param.def_id, hir_generics.predicates),
-                            param.span,
-                        );
-                        self.lowerer().add_default_traits(
+                        self.lowerer().add_implicit_bounds(
                             &mut bounds,
                             param_ty,
                             &[],
                             ImpliedBoundsContext::TyParam(param.def_id, hir_generics.predicates),
                             param.span,
+                            ty::IncludingSized::Yes,
                         );
                     }
                     hir::GenericParamKind::Lifetime { .. }