Remove the helper-methods for mk_substs_trait

oli-obk · fee1-dead · commit 1727172847c5 · 2022-07-15T06:32:04.000Z
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -2803,23 +2803,6 @@ impl<'tcx> TyCtxt<'tcx> {
         iter.intern_with(|xs| self.intern_place_elems(xs))
     }
 
-    pub fn mk_substs_trait_no_append(
-        self,
-        self_ty: Ty<'tcx>,
-        rest: &[GenericArg<'tcx>],
-    ) -> SubstsRef<'tcx> {
-        assert!(matches!(rest.last().unwrap().unpack(), GenericArgKind::Constness(_)));
-        self.mk_substs(iter::once(self_ty.into()).chain(rest.iter().cloned()))
-    }
-
-    pub fn mk_substs_trait_non_const(
-        self,
-        self_ty: Ty<'tcx>,
-        rest: &[GenericArg<'tcx>],
-    ) -> SubstsRef<'tcx> {
-        self.mk_substs_trait(self_ty, rest)
-    }
-
     pub fn mk_substs_trait(self, self_ty: Ty<'tcx>, rest: &[GenericArg<'tcx>]) -> SubstsRef<'tcx> {
         self.mk_substs(iter::once(self_ty.into()).chain(rest.iter().cloned()))
     }
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
@@ -699,7 +699,7 @@ impl<'tcx> Binder<'tcx, ExistentialPredicate<'tcx>> {
             ExistentialPredicate::AutoTrait(did) => {
                 let trait_ref = self.rebind(ty::TraitRef {
                     def_id: did,
-                    substs: tcx.mk_substs_trait_non_const(self_ty, &[]),
+                    substs: tcx.mk_substs_trait(self_ty, &[]),
                 });
                 trait_ref.to_predicate(tcx)
             }
diff --git a/compiler/rustc_trait_selection/src/autoderef.rs b/compiler/rustc_trait_selection/src/autoderef.rs
@@ -127,7 +127,7 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
         // <ty as Deref>
         let trait_ref = TraitRef {
             def_id: tcx.lang_items().deref_trait()?,
-            substs: tcx.mk_substs_trait_non_const(ty, &[]),
+            substs: tcx.mk_substs_trait(ty, &[]),
         };
 
         let cause = traits::ObligationCause::misc(self.span, self.body_id);
diff --git a/compiler/rustc_trait_selection/src/infer.rs b/compiler/rustc_trait_selection/src/infer.rs
@@ -108,10 +108,8 @@ impl<'cx, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'cx, 'tcx> {
             trait_def_id, ty, params, param_env
         );
 
-        let trait_ref = ty::TraitRef {
-            def_id: trait_def_id,
-            substs: self.tcx.mk_substs_trait_non_const(ty, params),
-        };
+        let trait_ref =
+            ty::TraitRef { def_id: trait_def_id, substs: self.tcx.mk_substs_trait(ty, params) };
 
         let obligation = traits::Obligation {
             cause: traits::ObligationCause::dummy(),
diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
@@ -85,8 +85,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_non_const(ty, &[]) };
+        let trait_ref = ty::TraitRef { def_id: trait_did, substs: tcx.mk_substs_trait(ty, &[]) };
 
         let trait_pred = ty::Binder::dummy(trait_ref);
 
@@ -298,7 +297,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
         predicates.push_back(ty::Binder::dummy(ty::TraitPredicate {
             trait_ref: ty::TraitRef {
                 def_id: trait_did,
-                substs: infcx.tcx.mk_substs_trait_non_const(ty, &[]),
+                substs: infcx.tcx.mk_substs_trait(ty, &[]),
             },
             // Auto traits are positive
             polarity: ty::ImplPolarity::Positive,
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
@@ -728,7 +728,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                             && fallback_has_occurred
                         {
                             let predicate = trait_predicate.map_bound(|mut trait_pred| {
-                                trait_pred.trait_ref.substs = self.tcx.mk_substs_trait_no_append(
+                                trait_pred.trait_ref.substs = self.tcx.mk_substs_trait(
                                     self.tcx.mk_unit(),
                                     &trait_pred.trait_ref.substs[1..],
                                 );
@@ -1934,7 +1934,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
     ) -> PredicateObligation<'tcx> {
         let trait_pred = trait_ref_and_ty.map_bound_ref(|(tr, new_self_ty)| ty::TraitPredicate {
             trait_ref: ty::TraitRef {
-                substs: self.tcx.mk_substs_trait_no_append(*new_self_ty, &tr.trait_ref.substs[1..]),
+                substs: self.tcx.mk_substs_trait(*new_self_ty, &tr.trait_ref.substs[1..]),
                 ..tr.trait_ref
             },
             ..*tr
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
@@ -2784,7 +2784,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                     self.tcx.mk_projection(
                         item_def_id,
                         // Future::Output has no substs
-                        self.tcx.mk_substs_trait(trait_pred.self_ty(), &[], ty::ConstnessArg::Not),
+                        self.tcx.mk_substs_trait(trait_pred.self_ty(), &[]),
                     )
                 });
                 let projection_ty = normalize_to(
@@ -2873,9 +2873,9 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                     let field_ty = field.ty(self.tcx, substs);
                     let trait_substs = match diagnostic_name {
                         sym::PartialEq | sym::PartialOrd => {
-                            self.tcx.mk_substs_trait_non_const(field_ty, &[field_ty.into()])
+                            self.tcx.mk_substs_trait(field_ty, &[field_ty.into()])
                         }
-                        _ => self.tcx.mk_substs_trait_non_const(field_ty, &[]),
+                        _ => self.tcx.mk_substs_trait(field_ty, &[]),
                     };
                     let trait_pred = trait_pred.map_bound_ref(|tr| ty::TraitPredicate {
                         trait_ref: ty::TraitRef {
diff --git a/compiler/rustc_trait_selection/src/traits/object_safety.rs b/compiler/rustc_trait_selection/src/traits/object_safety.rs
@@ -682,7 +682,7 @@ fn receiver_is_dispatchable<'tcx>(
         // Self: Unsize<U>
         let unsize_predicate = ty::Binder::dummy(ty::TraitRef {
             def_id: unsize_did,
-            substs: tcx.mk_substs_trait_non_const(tcx.types.self_param, &[unsized_self_ty.into()]),
+            substs: tcx.mk_substs_trait(tcx.types.self_param, &[unsized_self_ty.into()]),
         })
         .to_predicate(tcx);
 
@@ -712,7 +712,7 @@ fn receiver_is_dispatchable<'tcx>(
     let obligation = {
         let predicate = ty::Binder::dummy(ty::TraitRef {
             def_id: dispatch_from_dyn_did,
-            substs: tcx.mk_substs_trait_non_const(receiver_ty, &[unsized_receiver_ty.into()]),
+            substs: tcx.mk_substs_trait(receiver_ty, &[unsized_receiver_ty.into()]),
         })
         .to_predicate(tcx);
 
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -1563,7 +1563,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                             &obligation.with(
                                 ty::Binder::dummy(ty::TraitRef::new(
                                     selcx.tcx().require_lang_item(LangItem::Sized, None),
-                                    selcx.tcx().mk_substs_trait_non_const(self_ty, &[]),
+                                    selcx.tcx().mk_substs_trait(self_ty, &[]),
                                 ))
                                 .to_predicate(selcx.tcx()),
                             ),
@@ -1807,7 +1807,7 @@ fn confirm_pointee_candidate<'cx, 'tcx>(
     if check_is_sized {
         let sized_predicate = ty::Binder::dummy(ty::TraitRef::new(
             tcx.require_lang_item(LangItem::Sized, None),
-            tcx.mk_substs_trait_non_const(self_ty, &[]),
+            tcx.mk_substs_trait(self_ty, &[]),
         ))
         .to_poly_trait_predicate()
         .to_predicate(tcx);
diff --git a/compiler/rustc_trait_selection/src/traits/relationships.rs b/compiler/rustc_trait_selection/src/traits/relationships.rs
@@ -19,7 +19,7 @@ pub(crate) fn update<'tcx, T>(
         let new_self_ty = infcx.tcx.types.unit;
 
         let trait_ref = ty::TraitRef {
-            substs: infcx.tcx.mk_substs_trait_no_append(new_self_ty, &tpred.trait_ref.substs[1..]),
+            substs: infcx.tcx.mk_substs_trait(new_self_ty, &tpred.trait_ref.substs[1..]),
             ..tpred.trait_ref
         };
 
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -752,7 +752,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         // <ty as Deref>
         let trait_ref = ty::TraitRef {
             def_id: tcx.lang_items().deref_trait()?,
-            substs: tcx.mk_substs_trait_non_const(ty, &[]),
+            substs: tcx.mk_substs_trait(ty, &[]),
         };
 
         let obligation = traits::Obligation::new(
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -958,7 +958,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 // We can only make objects from sized types.
                 let tr = ty::Binder::dummy(ty::TraitRef::new(
                     tcx.require_lang_item(LangItem::Sized, None),
-                    tcx.mk_substs_trait_non_const(source, &[]),
+                    tcx.mk_substs_trait(source, &[]),
                 ));
                 nested.push(predicate_to_obligation(tr.to_predicate(tcx)));
 
diff --git a/compiler/rustc_trait_selection/src/traits/util.rs b/compiler/rustc_trait_selection/src/traits/util.rs
@@ -342,7 +342,7 @@ pub fn closure_trait_ref_and_return_type<'tcx>(
     debug_assert!(!self_ty.has_escaping_bound_vars());
     let trait_ref = ty::TraitRef {
         def_id: fn_trait_def_id,
-        substs: tcx.mk_substs_trait_non_const(self_ty, &[arguments_tuple.into()]),
+        substs: tcx.mk_substs_trait(self_ty, &[arguments_tuple.into()]),
     };
     sig.map_bound(|sig| (trait_ref, sig.output()))
 }
@@ -356,7 +356,7 @@ pub fn generator_trait_ref_and_outputs<'tcx>(
     debug_assert!(!self_ty.has_escaping_bound_vars());
     let trait_ref = ty::TraitRef {
         def_id: fn_trait_def_id,
-        substs: tcx.mk_substs_trait_non_const(self_ty, &[sig.skip_binder().resume_ty.into()]),
+        substs: tcx.mk_substs_trait(self_ty, &[sig.skip_binder().resume_ty.into()]),
     };
     sig.map_bound(|sig| (trait_ref, sig.yield_ty, sig.return_ty))
 }
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -411,7 +411,7 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
             let cause = self.cause(cause);
             let trait_ref = ty::TraitRef {
                 def_id: self.infcx.tcx.require_lang_item(LangItem::Sized, None),
-                substs: self.infcx.tcx.mk_substs_trait_non_const(subty, &[]),
+                substs: self.infcx.tcx.mk_substs_trait(subty, &[]),
             };
             self.out.push(traits::Obligation::with_depth(
                 cause,
diff --git a/compiler/rustc_traits/src/chalk/lowering.rs b/compiler/rustc_traits/src/chalk/lowering.rs
@@ -672,7 +672,7 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::Binders<chalk_ir::QuantifiedWhereClauses<Ru
                             trait_id: chalk_ir::TraitId(def_id),
                             substitution: interner
                                 .tcx
-                                .mk_substs_trait_non_const(self_ty, substs)
+                                .mk_substs_trait(self_ty, substs)
                                 .lower_into(interner),
                         }),
                     )
@@ -684,7 +684,7 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::Binders<chalk_ir::QuantifiedWhereClauses<Ru
                             associated_ty_id: chalk_ir::AssocTypeId(predicate.item_def_id),
                             substitution: interner
                                 .tcx
-                                .mk_substs_trait_non_const(self_ty, predicate.substs)
+                                .mk_substs_trait(self_ty, predicate.substs)
                                 .lower_into(interner),
                         }),
                         // FIXME(associated_const_equality): teach chalk about terms for alias eq.
@@ -697,7 +697,7 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::Binders<chalk_ir::QuantifiedWhereClauses<Ru
                         trait_id: chalk_ir::TraitId(def_id),
                         substitution: interner
                             .tcx
-                            .mk_substs_trait_non_const(self_ty, &[])
+                            .mk_substs_trait(self_ty, &[])
                             .lower_into(interner),
                     }),
                 ),
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
@@ -53,7 +53,7 @@ fn sized_constraint_for_ty<'tcx>(
             let Some(sized_trait) = tcx.lang_items().sized_trait() else { return vec![ty] };
             let sized_predicate = ty::Binder::dummy(ty::TraitRef {
                 def_id: sized_trait,
-                substs: tcx.mk_substs_trait_non_const(ty, &[]),
+                substs: tcx.mk_substs_trait(ty, &[]),
             })
             .to_predicate(tcx);
             let predicates = tcx.predicates_of(adtdef.did()).predicates;
diff --git a/compiler/rustc_typeck/src/bounds.rs b/compiler/rustc_typeck/src/bounds.rs
@@ -63,7 +63,7 @@ impl<'tcx> Bounds<'tcx> {
             tcx.lang_items().sized_trait().map(move |sized| {
                 let trait_ref = ty::Binder::dummy(ty::TraitRef {
                     def_id: sized,
-                    substs: tcx.mk_substs_trait_non_const(param_ty, &[]),
+                    substs: tcx.mk_substs_trait(param_ty, &[]),
                 });
                 (trait_ref.to_predicate(tcx), span)
             })
diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/suggestions.rs b/compiler/rustc_typeck/src/check/fn_ctxt/suggestions.rs
@@ -851,7 +851,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 recursion_depth: 0,
                 predicate: ty::Binder::dummy(ty::TraitRef {
                     def_id: clone_trait_did,
-                    substs: self.tcx.mk_substs_trait_non_const(expected_ty.into(), &[]),
+                    substs: self.tcx.mk_substs_trait(expected_ty.into(), &[]),
                 })
                 .to_predicate(self.tcx),
             })
diff --git a/compiler/rustc_typeck/src/collect.rs b/compiler/rustc_typeck/src/collect.rs
@@ -1763,6 +1763,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
     }
 
     if has_constness || parent_has_constness {
+        trace!("adding constness param");
         params.push(ty::GenericParamDef {
             name: Symbol::intern("<constness>"),
             index: type_start + i as u32,
@@ -1774,15 +1775,17 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
 
     let param_def_id_to_index = params.iter().map(|param| (param.def_id, param.index)).collect();
 
-    ty::Generics {
+    let generics = ty::Generics {
         parent: parent_def_id,
         parent_count,
         params,
         param_def_id_to_index,
         has_self: has_self || parent_has_self,
         has_constness: has_constness || parent_has_constness,
         has_late_bound_regions: has_late_bound_regions(tcx, node),
-    }
+    };
+    trace!("{:#?}", generics);
+    generics
 }
 
 fn are_suggestable_generic_args(generic_args: &[hir::GenericArg<'_>]) -> bool {

Original file line number	Diff line number	Diff line change
`@@ -699,7 +699,7 @@ impl<'tcx> Binder<'tcx, ExistentialPredicate<'tcx>> {`
`699`	`699`	`ExistentialPredicate::AutoTrait(did) => {`
`700`	`700`	`let trait_ref = self.rebind(ty::TraitRef {`
`701`	`701`	`def_id: did,`
`702`		`- substs: tcx.mk_substs_trait_non_const(self_ty, &[]),`
	`702`	`+ substs: tcx.mk_substs_trait(self_ty, &[]),`
`703`	`703`	`});`
`704`	`704`	`trait_ref.to_predicate(tcx)`
`705`	`705`	`}`