Auto merge of #68140 - ecstatic-morse:const-trait-bound-opt-out, r=<try>

Support `?const` opt-out for trait bounds

For now, such bounds are treated exactly the same as unprefixed ones in all contexts. [RFC 2632](rust-lang/rfcs#2632) does not specify whether such bounds are forbidden outside of `const` contexts, so they are allowed at the moment.

cc #67794

r? @oli-obk

Author: bors

src/librustc/infer/error_reporting/nice_region_error/placeholder_error.rs

@@ -215,14 +215,10 @@ impl NiceRegionError<'me, 'tcx> {
             false
         };
 
-        let expected_trait_ref = self.infcx.resolve_vars_if_possible(&ty::TraitRef {
-            def_id: trait_def_id,
-            substs: expected_substs,
-        });
-        let actual_trait_ref = self.infcx.resolve_vars_if_possible(&ty::TraitRef {
-            def_id: trait_def_id,
-            substs: actual_substs,
-        });
+        let expected_trait_ref =
+            self.infcx.resolve_vars_if_possible(&ty::TraitRef::new(trait_def_id, expected_substs));
+        let actual_trait_ref =
+            self.infcx.resolve_vars_if_possible(&ty::TraitRef::new(trait_def_id, actual_substs));
 
         // Search the expected and actual trait references to see (a)
         // whether the sub/sup placeholders appear in them (sometimes

src/librustc/traits/auto_trait.rs

@@ -83,7 +83,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
     ) -> AutoTraitResult<A> {
         let tcx = self.tcx;
 
-        let trait_ref = ty::TraitRef { def_id: trait_did, substs: tcx.mk_substs_trait(ty, &[]) };
+        let trait_ref = ty::TraitRef::new(trait_did, tcx.mk_substs_trait(ty, &[]));
 
         let trait_pred = ty::Binder::bind(trait_ref);
 
@@ -271,10 +271,7 @@ impl AutoTraitFinder<'tcx> {
         let mut already_visited = FxHashSet::default();
         let mut predicates = VecDeque::new();
         predicates.push_back(ty::Binder::bind(ty::TraitPredicate {
-            trait_ref: ty::TraitRef {
-                def_id: trait_did,
-                substs: infcx.tcx.mk_substs_trait(ty, &[]),
-            },
+            trait_ref: ty::TraitRef::new(trait_did, infcx.tcx.mk_substs_trait(ty, &[])),
         }));
 
         let mut computed_preds: FxHashSet<_> = param_env.caller_bounds.iter().cloned().collect();

src/librustc/traits/engine.rs

@@ -26,7 +26,7 @@ pub trait TraitEngine<'tcx>: 'tcx {
         def_id: DefId,
         cause: ObligationCause<'tcx>,
     ) {
-        let trait_ref = ty::TraitRef { def_id, substs: infcx.tcx.mk_substs_trait(ty, &[]) };
+        let trait_ref = ty::TraitRef::new(def_id, infcx.tcx.mk_substs_trait(ty, &[]));
         self.register_predicate_obligation(
             infcx,
             Obligation {

src/librustc/traits/error_reporting.rs

@@ -1340,8 +1340,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         cause: ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
     ) -> PredicateObligation<'tcx> {
-        let new_trait_ref =
-            ty::TraitRef { def_id, substs: self.tcx.mk_substs_trait(output_ty, &[]) };
+        let new_trait_ref = ty::TraitRef::new(def_id, self.tcx.mk_substs_trait(output_ty, &[]));
         Obligation::new(cause, param_env, new_trait_ref.to_predicate())
     }
 

src/librustc/traits/fulfill.rs

@@ -72,7 +72,7 @@ pub struct PendingPredicateObligation<'tcx> {
 
 // `PendingPredicateObligation` is used a lot. Make sure it doesn't unintentionally get bigger.
 #[cfg(target_arch = "x86_64")]
-static_assert_size!(PendingPredicateObligation<'_>, 136);
+static_assert_size!(PendingPredicateObligation<'_>, 144);
 
 impl<'a, 'tcx> FulfillmentContext<'tcx> {
     /// Creates a new fulfillment context.

src/librustc/traits/mod.rs

@@ -137,7 +137,7 @@ pub type TraitObligation<'tcx> = Obligation<'tcx, ty::PolyTraitPredicate<'tcx>>;
 
 // `PredicateObligation` is used a lot. Make sure it doesn't unintentionally get bigger.
 #[cfg(target_arch = "x86_64")]
-static_assert_size!(PredicateObligation<'_>, 112);
+static_assert_size!(PredicateObligation<'_>, 120);
 
 /// The reason why we incurred this obligation; used for error reporting.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -320,7 +320,7 @@ pub struct AssocTypeBoundData {
 
 // `ObligationCauseCode` is used a lot. Make sure it doesn't unintentionally get bigger.
 #[cfg(target_arch = "x86_64")]
-static_assert_size!(ObligationCauseCode<'_>, 32);
+static_assert_size!(ObligationCauseCode<'_>, 40);
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct MatchExpressionArmCause<'tcx> {
@@ -727,7 +727,7 @@ pub fn type_known_to_meet_bound_modulo_regions<'a, 'tcx>(
         infcx.tcx.def_path_str(def_id)
     );
 
-    let trait_ref = ty::TraitRef { def_id, substs: infcx.tcx.mk_substs_trait(ty, &[]) };
+    let trait_ref = ty::TraitRef::new(def_id, infcx.tcx.mk_substs_trait(ty, &[]));
     let obligation = Obligation {
         param_env,
         cause: ObligationCause::misc(span, hir::DUMMY_HIR_ID),

src/librustc/traits/object_safety.rs

@@ -579,10 +579,10 @@ fn receiver_is_dispatchable<'tcx>(
         let mut param_env = tcx.param_env(method.def_id);
 
         // Self: Unsize<U>
-        let unsize_predicate = ty::TraitRef {
-            def_id: unsize_did,
-            substs: tcx.mk_substs_trait(tcx.types.self_param, &[unsized_self_ty.into()]),
-        }
+        let unsize_predicate = ty::TraitRef::new(
+            unsize_did,
+            tcx.mk_substs_trait(tcx.types.self_param, &[unsized_self_ty.into()]),
+        )
         .to_predicate();
 
         // U: Trait<Arg1, ..., ArgN>
@@ -596,7 +596,7 @@ fn receiver_is_dispatchable<'tcx>(
                     }
                 });
 
-            ty::TraitRef { def_id: unsize_did, substs }.to_predicate()
+            ty::TraitRef::new(unsize_did, substs).to_predicate()
         };
 
         let caller_bounds: Vec<Predicate<'tcx>> = param_env
@@ -614,10 +614,10 @@ fn receiver_is_dispatchable<'tcx>(
 
     // Receiver: DispatchFromDyn<Receiver[Self => U]>
     let obligation = {
-        let predicate = ty::TraitRef {
-            def_id: dispatch_from_dyn_did,
-            substs: tcx.mk_substs_trait(receiver_ty, &[unsized_receiver_ty.into()]),
-        }
+        let predicate = ty::TraitRef::new(
+            dispatch_from_dyn_did,
+            tcx.mk_substs_trait(receiver_ty, &[unsized_receiver_ty.into()]),
+        )
         .to_predicate();
 
         Obligation::new(ObligationCause::dummy(), param_env, predicate)

src/librustc/traits/util.rs

@@ -557,8 +557,7 @@ pub fn predicate_for_trait_def(
     self_ty: Ty<'tcx>,
     params: &[GenericArg<'tcx>],
 ) -> PredicateObligation<'tcx> {
-    let trait_ref =
-        ty::TraitRef { def_id: trait_def_id, substs: tcx.mk_substs_trait(self_ty, params) };
+    let trait_ref = ty::TraitRef::new(trait_def_id, tcx.mk_substs_trait(self_ty, params));
     predicate_for_trait_ref(cause, param_env, trait_ref, recursion_depth)
 }
 
@@ -629,10 +628,8 @@ pub fn closure_trait_ref_and_return_type(
         TupleArgumentsFlag::No => sig.skip_binder().inputs()[0],
         TupleArgumentsFlag::Yes => tcx.intern_tup(sig.skip_binder().inputs()),
     };
-    let trait_ref = ty::TraitRef {
-        def_id: fn_trait_def_id,
-        substs: tcx.mk_substs_trait(self_ty, &[arguments_tuple.into()]),
-    };
+    let trait_ref =
+        ty::TraitRef::new(fn_trait_def_id, tcx.mk_substs_trait(self_ty, &[arguments_tuple.into()]));
     ty::Binder::bind((trait_ref, sig.skip_binder().output()))
 }
 
@@ -642,8 +639,7 @@ pub fn generator_trait_ref_and_outputs(
     self_ty: Ty<'tcx>,
     sig: ty::PolyGenSig<'tcx>,
 ) -> ty::Binder<(ty::TraitRef<'tcx>, Ty<'tcx>, Ty<'tcx>)> {
-    let trait_ref =
-        ty::TraitRef { def_id: fn_trait_def_id, substs: tcx.mk_substs_trait(self_ty, &[]) };
+    let trait_ref = ty::TraitRef::new(fn_trait_def_id, tcx.mk_substs_trait(self_ty, &[]));
     ty::Binder::bind((trait_ref, sig.skip_binder().yield_ty, sig.skip_binder().return_ty))
 }
 

src/librustc/traits/wf.rs

@@ -374,10 +374,10 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
     fn require_sized(&mut self, subty: Ty<'tcx>, cause: traits::ObligationCauseCode<'tcx>) {
         if !subty.has_escaping_bound_vars() {
             let cause = self.cause(cause);
-            let trait_ref = ty::TraitRef {
-                def_id: self.infcx.tcx.require_lang_item(lang_items::SizedTraitLangItem, None),
-                substs: self.infcx.tcx.mk_substs_trait(subty, &[]),
-            };
+            let trait_ref = ty::TraitRef::new(
+                self.infcx.tcx.require_lang_item(lang_items::SizedTraitLangItem, None),
+                self.infcx.tcx.mk_substs_trait(subty, &[]),
+            );
             self.out.push(traits::Obligation::new(cause, self.param_env, trait_ref.to_predicate()));
         }
     }

src/librustc/ty/mod.rs

@@ -2467,11 +2467,9 @@ impl<'tcx> AdtDef {
                     Some(x) => x,
                     _ => return vec![ty],
                 };
-                let sized_predicate = Binder::dummy(TraitRef {
-                    def_id: sized_trait,
-                    substs: tcx.mk_substs_trait(ty, &[]),
-                })
-                .to_predicate();
+                let sized_predicate =
+                    Binder::dummy(TraitRef::new(sized_trait, tcx.mk_substs_trait(ty, &[])))
+                        .to_predicate();
                 let predicates = tcx.predicates_of(self.did).predicates;
                 if predicates.iter().any(|(p, _)| *p == sized_predicate) {
                     vec![]