Prevent the creation of TraitRef without dedicated methods

oli-obk · oli-obk · commit 6af36387095b · 2022-12-14T15:36:39.000Z
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -570,7 +570,7 @@ fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, id: hir::ItemId) {
                             assoc_item,
                             assoc_item,
                             default.span,
-                            ty::TraitRef { def_id: it.owner_id.to_def_id(), substs: trait_substs },
+                            tcx.mk_trait_ref(it.owner_id.to_def_id(), trait_substs),
                         );
                     }
                     _ => {}
diff --git a/compiler/rustc_hir_analysis/src/variance/mod.rs b/compiler/rustc_hir_analysis/src/variance/mod.rs
@@ -160,7 +160,7 @@ fn variance_of_opaque(tcx: TyCtxt<'_>, item_def_id: LocalDefId) -> &[ty::Varianc
         // instead of requiring an additional `+ 'a`.
         match pred.kind().skip_binder() {
             ty::PredicateKind::Clause(ty::Clause::Trait(ty::TraitPredicate {
-                trait_ref: ty::TraitRef { def_id: _, substs },
+                trait_ref: ty::TraitRef { def_id: _, substs, .. },
                 constness: _,
                 polarity: _,
             })) => {
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -13,7 +13,7 @@ use rustc_hir_analysis::astconv::AstConv;
 use rustc_infer::infer;
 use rustc_infer::traits::{self, StatementAsExpression};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, Binder, DefIdTree, IsSuggestable, ToPredicate, Ty};
+use rustc_middle::ty::{self, Binder, DefIdTree, IsSuggestable, Ty};
 use rustc_session::errors::ExprParenthesesNeeded;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
@@ -1277,17 +1277,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // Check that we're in fact trying to clone into the expected type
             && self.can_coerce(*pointee_ty, expected_ty)
             // And the expected type doesn't implement `Clone`
-            && !self.predicate_must_hold_considering_regions(&traits::Obligation {
-                cause: traits::ObligationCause::dummy(),
-                param_env: self.param_env,
-                recursion_depth: 0,
-                predicate: ty::Binder::dummy(ty::TraitRef {
-                    def_id: clone_trait_did,
-                    substs: self.tcx.mk_substs([expected_ty.into()].iter()),
-                })
-                .without_const()
-                .to_predicate(self.tcx),
-            })
+            && !self.predicate_must_hold_considering_regions(&traits::Obligation::new(
+                self.tcx,
+                traits::ObligationCause::dummy(),
+                self.param_env,
+                ty::Binder::dummy(self.tcx.mk_trait_ref(
+                    clone_trait_did,
+                    [expected_ty],
+                )),
+            ))
         {
             diag.span_note(
                 callee_expr.span,
diff --git a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/placeholder_error.rs b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/placeholder_error.rs
@@ -226,13 +226,11 @@ impl<'tcx> NiceRegionError<'_, 'tcx> {
             false
         };
 
-        let expected_trait_ref = self.cx.resolve_vars_if_possible(ty::TraitRef {
-            def_id: trait_def_id,
-            substs: expected_substs,
-        });
-        let actual_trait_ref = self
+        let expected_trait_ref = self
             .cx
-            .resolve_vars_if_possible(ty::TraitRef { def_id: trait_def_id, substs: actual_substs });
+            .resolve_vars_if_possible(self.cx.tcx.mk_trait_ref(trait_def_id, expected_substs));
+        let actual_trait_ref =
+            self.cx.resolve_vars_if_possible(self.cx.tcx.mk_trait_ref(trait_def_id, actual_substs));
 
         // Search the expected and actual trait references to see (a)
         // whether the sub/sup placeholders appear in them (sometimes
diff --git a/compiler/rustc_middle/src/ty/relate.rs b/compiler/rustc_middle/src/ty/relate.rs
@@ -322,7 +322,7 @@ impl<'tcx> Relate<'tcx> for ty::TraitRef<'tcx> {
             Err(TypeError::Traits(expected_found(relation, a.def_id, b.def_id)))
         } else {
             let substs = relate_substs(relation, a.substs, b.substs)?;
-            Ok(ty::TraitRef { def_id: a.def_id, substs })
+            Ok(relation.tcx().mk_trait_ref(a.def_id, substs))
         }
     }
 }
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
@@ -816,11 +816,14 @@ impl<'tcx> List<ty::PolyExistentialPredicate<'tcx>> {
 pub struct TraitRef<'tcx> {
     pub def_id: DefId,
     pub substs: SubstsRef<'tcx>,
+    /// This field exists to prevent the creation of `TraitRef` without
+    /// calling [TyCtxt::mk_trait_ref].
+    _use_mk_trait_ref_instead: (),
 }
 
 impl<'tcx> TraitRef<'tcx> {
     pub fn new(def_id: DefId, substs: SubstsRef<'tcx>) -> TraitRef<'tcx> {
-        TraitRef { def_id, substs }
+        TraitRef { def_id, substs, _use_mk_trait_ref_instead: () }
     }
 
     pub fn with_self_ty(self, tcx: TyCtxt<'tcx>, self_ty: Ty<'tcx>) -> Self {
@@ -836,6 +839,7 @@ impl<'tcx> TraitRef<'tcx> {
         ty::Binder::dummy(TraitRef {
             def_id,
             substs: InternalSubsts::identity_for_item(tcx, def_id),
+            _use_mk_trait_ref_instead: (),
         })
     }
 
@@ -850,7 +854,11 @@ impl<'tcx> TraitRef<'tcx> {
         substs: SubstsRef<'tcx>,
     ) -> ty::TraitRef<'tcx> {
         let defs = tcx.generics_of(trait_id);
-        ty::TraitRef { def_id: trait_id, substs: tcx.intern_substs(&substs[..defs.params.len()]) }
+        ty::TraitRef {
+            def_id: trait_id,
+            substs: tcx.intern_substs(&substs[..defs.params.len()]),
+            _use_mk_trait_ref_instead: (),
+        }
     }
 }
 
@@ -1194,10 +1202,7 @@ impl<'tcx> AliasTy<'tcx> {
         let trait_def_id = self.trait_def_id(tcx);
         let trait_generics = tcx.generics_of(trait_def_id);
         (
-            ty::TraitRef {
-                def_id: trait_def_id,
-                substs: self.substs.truncate_to(tcx, trait_generics),
-            },
+            tcx.mk_trait_ref(trait_def_id, self.substs.truncate_to(tcx, trait_generics)),
             &self.substs[trait_generics.count()..],
         )
     }
@@ -1211,7 +1216,7 @@ impl<'tcx> AliasTy<'tcx> {
     /// as well.
     pub fn trait_ref(&self, tcx: TyCtxt<'tcx>) -> ty::TraitRef<'tcx> {
         let def_id = self.trait_def_id(tcx);
-        ty::TraitRef { def_id, substs: self.substs.truncate_to(tcx, tcx.generics_of(def_id)) }
+        tcx.mk_trait_ref(def_id, self.substs.truncate_to(tcx, tcx.generics_of(def_id)))
     }
 
     pub fn self_ty(&self) -> Ty<'tcx> {
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
@@ -110,26 +110,25 @@ where
     V: DefIdVisitor<'tcx> + ?Sized,
 {
     fn visit_trait(&mut self, trait_ref: TraitRef<'tcx>) -> ControlFlow<V::BreakTy> {
-        let TraitRef { def_id, substs } = trait_ref;
+        let TraitRef { def_id, substs, .. } = trait_ref;
         self.def_id_visitor.visit_def_id(def_id, "trait", &trait_ref.print_only_trait_path())?;
         if self.def_id_visitor.shallow() { ControlFlow::CONTINUE } else { substs.visit_with(self) }
     }
 
     fn visit_projection_ty(&mut self, projection: ty::AliasTy<'tcx>) -> ControlFlow<V::BreakTy> {
         let tcx = self.def_id_visitor.tcx();
-        let (trait_ref, assoc_substs) = if tcx.def_kind(projection.def_id)
-            != DefKind::ImplTraitPlaceholder
-        {
-            projection.trait_ref_and_own_substs(tcx)
-        } else {
-            // HACK(RPITIT): Remove this when RPITITs are lowered to regular assoc tys
-            let def_id = tcx.impl_trait_in_trait_parent(projection.def_id);
-            let trait_generics = tcx.generics_of(def_id);
-            (
-                ty::TraitRef { def_id, substs: projection.substs.truncate_to(tcx, trait_generics) },
-                &projection.substs[trait_generics.count()..],
-            )
-        };
+        let (trait_ref, assoc_substs) =
+            if tcx.def_kind(projection.def_id) != DefKind::ImplTraitPlaceholder {
+                projection.trait_ref_and_own_substs(tcx)
+            } else {
+                // HACK(RPITIT): Remove this when RPITITs are lowered to regular assoc tys
+                let def_id = tcx.impl_trait_in_trait_parent(projection.def_id);
+                let trait_generics = tcx.generics_of(def_id);
+                (
+                    tcx.mk_trait_ref(def_id, projection.substs.truncate_to(tcx, trait_generics)),
+                    &projection.substs[trait_generics.count()..],
+                )
+            };
         self.visit_trait(trait_ref)?;
         if self.def_id_visitor.shallow() {
             ControlFlow::CONTINUE
diff --git a/compiler/rustc_trait_selection/src/traits/object_safety.rs b/compiler/rustc_trait_selection/src/traits/object_safety.rs
@@ -703,9 +703,7 @@ fn receiver_is_dispatchable<'tcx>(
                     }
                 });
 
-            ty::Binder::dummy(ty::TraitRef { def_id: unsize_did, substs })
-                .without_const()
-                .to_predicate(tcx)
+            ty::Binder::dummy(tcx.mk_trait_ref(unsize_did, substs)).to_predicate(tcx)
         };
 
         let caller_bounds: Vec<Predicate<'tcx>> =
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -1309,8 +1309,7 @@ fn assemble_candidate_for_impl_trait_in_trait<'cx, 'tcx>(
         let trait_substs =
             obligation.predicate.substs.truncate_to(tcx, tcx.generics_of(trait_def_id));
         // FIXME(named-returns): Binders
-        let trait_predicate =
-            ty::Binder::dummy(ty::TraitRef { def_id: trait_def_id, substs: trait_substs });
+        let trait_predicate = ty::Binder::dummy(tcx.mk_trait_ref(trait_def_id, trait_substs));
 
         let _ = selcx.infcx.commit_if_ok(|_| {
             match selcx.select(&obligation.with(tcx, trait_predicate)) {

Original file line number	Diff line number	Diff line change
`@@ -570,7 +570,7 @@ fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, id: hir::ItemId) {`
`570`	`570`	`assoc_item,`
`571`	`571`	`assoc_item,`
`572`	`572`	`default.span,`
`573`		`- ty::TraitRef { def_id: it.owner_id.to_def_id(), substs: trait_substs },`
	`573`	`+ tcx.mk_trait_ref(it.owner_id.to_def_id(), trait_substs),`
`574`	`574`	`);`
`575`	`575`	`}`
`576`	`576`	`_ => {}`
Original file line number	Diff line number	Diff line change
`@@ -322,7 +322,7 @@ impl<'tcx> Relate<'tcx> for ty::TraitRef<'tcx> {`
`322`	`322`	`Err(TypeError::Traits(expected_found(relation, a.def_id, b.def_id)))`
`323`	`323`	`} else {`
`324`	`324`	`let substs = relate_substs(relation, a.substs, b.substs)?;`
`325`		`- Ok(ty::TraitRef { def_id: a.def_id, substs })`
	`325`	`+ Ok(relation.tcx().mk_trait_ref(a.def_id, substs))`
`326`	`326`	`}`
`327`	`327`	`}`
`328`	`328`	`}`
Original file line number	Diff line number	Diff line change
`@@ -816,11 +816,14 @@ impl<'tcx> List<ty::PolyExistentialPredicate<'tcx>> {`
`816`	`816`	`pub struct TraitRef<'tcx> {`
`817`	`817`	`pub def_id: DefId,`
`818`	`818`	`pub substs: SubstsRef<'tcx>,`
	`819`	+ /// This field exists to prevent the creation of `TraitRef` without
	`820`	`+ /// calling [TyCtxt::mk_trait_ref].`
	`821`	`+ _use_mk_trait_ref_instead: (),`
`819`	`822`	`}`
`820`	`823`
`821`	`824`	`impl<'tcx> TraitRef<'tcx> {`
`822`	`825`	`pub fn new(def_id: DefId, substs: SubstsRef<'tcx>) -> TraitRef<'tcx> {`
`823`		`- TraitRef { def_id, substs }`
	`826`	`+ TraitRef { def_id, substs, _use_mk_trait_ref_instead: () }`
`824`	`827`	`}`
`825`	`828`
`826`	`829`	`pub fn with_self_ty(self, tcx: TyCtxt<'tcx>, self_ty: Ty<'tcx>) -> Self {`
`@@ -836,6 +839,7 @@ impl<'tcx> TraitRef<'tcx> {`
`836`	`839`	`ty::Binder::dummy(TraitRef {`
`837`	`840`	`def_id,`
`838`	`841`	`substs: InternalSubsts::identity_for_item(tcx, def_id),`
	`842`	`+ _use_mk_trait_ref_instead: (),`
`839`	`843`	`})`
`840`	`844`	`}`
`841`	`845`
`@@ -850,7 +854,11 @@ impl<'tcx> TraitRef<'tcx> {`
`850`	`854`	`substs: SubstsRef<'tcx>,`
`851`	`855`	`) -> ty::TraitRef<'tcx> {`
`852`	`856`	`let defs = tcx.generics_of(trait_id);`
`853`		`- ty::TraitRef { def_id: trait_id, substs: tcx.intern_substs(&substs[..defs.params.len()]) }`
	`857`	`+ ty::TraitRef {`
	`858`	`+ def_id: trait_id,`
	`859`	`+ substs: tcx.intern_substs(&substs[..defs.params.len()]),`
	`860`	`+ _use_mk_trait_ref_instead: (),`
	`861`	`+ }`
`854`	`862`	`}`
`855`	`863`	`}`
`856`	`864`
`@@ -1194,10 +1202,7 @@ impl<'tcx> AliasTy<'tcx> {`
`1194`	`1202`	`let trait_def_id = self.trait_def_id(tcx);`
`1195`	`1203`	`let trait_generics = tcx.generics_of(trait_def_id);`
`1196`	`1204`	`(`
`1197`		`- ty::TraitRef {`
`1198`		`- def_id: trait_def_id,`
`1199`		`- substs: self.substs.truncate_to(tcx, trait_generics),`
`1200`		`- },`
	`1205`	`+ tcx.mk_trait_ref(trait_def_id, self.substs.truncate_to(tcx, trait_generics)),`
`1201`	`1206`	`&self.substs[trait_generics.count()..],`
`1202`	`1207`	`)`
`1203`	`1208`	`}`
`@@ -1211,7 +1216,7 @@ impl<'tcx> AliasTy<'tcx> {`
`1211`	`1216`	`/// as well.`
`1212`	`1217`	`pub fn trait_ref(&self, tcx: TyCtxt<'tcx>) -> ty::TraitRef<'tcx> {`
`1213`	`1218`	`let def_id = self.trait_def_id(tcx);`
`1214`		`- ty::TraitRef { def_id, substs: self.substs.truncate_to(tcx, tcx.generics_of(def_id)) }`
	`1219`	`+ tcx.mk_trait_ref(def_id, self.substs.truncate_to(tcx, tcx.generics_of(def_id)))`
`1215`	`1220`	`}`
`1216`	`1221`
`1217`	`1222`	`pub fn self_ty(&self) -> Ty<'tcx> {`
Original file line number	Diff line number	Diff line change
`@@ -703,9 +703,7 @@ fn receiver_is_dispatchable<'tcx>(`
`703`	`703`	`}`
`704`	`704`	`});`
`705`	`705`
`706`		`- ty::Binder::dummy(ty::TraitRef { def_id: unsize_did, substs })`
`707`		`- .without_const()`
`708`		`- .to_predicate(tcx)`
	`706`	`+ ty::Binder::dummy(tcx.mk_trait_ref(unsize_did, substs)).to_predicate(tcx)`
`709`	`707`	`};`
`710`	`708`
`711`	`709`	`let caller_bounds: Vec<Predicate<'tcx>> =`