Remove constness arg from mk_substs_trait

oli-obk · fee1-dead · commit 56a16f8f7f99 · 2022-07-15T06:32:04.000Z
this is now handled in compiler/rustc_typeck/src/astconv/mod.rs
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -572,7 +572,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
             let tcx = self.tcx();
             let trait_ref = ty::TraitRef {
                 def_id: tcx.require_lang_item(LangItem::Copy, Some(self.last_span)),
-                substs: tcx.mk_substs_trait(place_ty.ty, &[], ty::ConstnessArg::Not),
+                substs: tcx.mk_substs_trait(place_ty.ty, &[]),
             };
 
             // To have a `Copy` operand, the type `T` of the
@@ -1304,7 +1304,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 if !self.unsized_feature_enabled() {
                     let trait_ref = ty::TraitRef {
                         def_id: tcx.require_lang_item(LangItem::Sized, Some(self.last_span)),
-                        substs: tcx.mk_substs_trait(place_ty, &[], ty::ConstnessArg::Not),
+                        substs: tcx.mk_substs_trait(place_ty, &[]),
                     };
                     self.prove_trait_ref(
                         trait_ref,
@@ -1894,7 +1894,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                             let ty = place.ty(body, tcx).ty;
                             let trait_ref = ty::TraitRef::new(
                                 tcx.require_lang_item(LangItem::Copy, Some(span)),
-                                tcx.mk_substs_trait(ty, &[], ty::ConstnessArg::Not),
+                                tcx.mk_substs_trait(ty, &[]),
                             );
 
                             self.prove_trait_ref(
@@ -1910,7 +1910,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             &Rvalue::NullaryOp(_, ty) => {
                 let trait_ref = ty::TraitRef {
                     def_id: tcx.require_lang_item(LangItem::Sized, Some(self.last_span)),
-                    substs: tcx.mk_substs_trait(ty, &[], ty::ConstnessArg::Not),
+                    substs: tcx.mk_substs_trait(ty, &[]),
                 };
 
                 self.prove_trait_ref(
@@ -1925,7 +1925,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
                 let trait_ref = ty::TraitRef {
                     def_id: tcx.require_lang_item(LangItem::Sized, Some(self.last_span)),
-                    substs: tcx.mk_substs_trait(*ty, &[], ty::ConstnessArg::Not),
+                    substs: tcx.mk_substs_trait(*ty, &[]),
                 };
 
                 self.prove_trait_ref(
@@ -2027,11 +2027,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                             def_id: tcx
                                 .require_lang_item(LangItem::CoerceUnsized, Some(self.last_span)),
                             // TODO: pick constness arg from context
-                            substs: tcx.mk_substs_trait(
-                                op.ty(body, tcx),
-                                &[ty.into()],
-                                ty::ConstnessArg::Not,
-                            ),
+                            substs: tcx.mk_substs_trait(op.ty(body, tcx), &[ty.into()]),
                         };
 
                         self.prove_trait_ref(
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs b/compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs
@@ -161,7 +161,7 @@ impl Qualif for NeedsNonConstDrop {
             ty::Binder::dummy(ty::TraitPredicate {
                 trait_ref: ty::TraitRef {
                     def_id: destruct,
-                    substs: cx.tcx.mk_substs_trait(ty, &[], ty::ConstnessArg::Required),
+                    substs: cx.tcx.mk_substs_trait(ty, &[ty::ConstnessArg::Required.into()]),
                 },
                 polarity: ty::ImplPolarity::Positive,
             }),
diff --git a/compiler/rustc_infer/src/traits/engine.rs b/compiler/rustc_infer/src/traits/engine.rs
@@ -27,10 +27,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, &[], ty::ConstnessArg::Param),
-        };
+        let trait_ref = ty::TraitRef { def_id, substs: infcx.tcx.mk_substs_trait(ty, &[]) };
         self.register_predicate_obligation(
             infcx,
             Obligation {
diff --git a/compiler/rustc_middle/src/ty/adjustment.rs b/compiler/rustc_middle/src/ty/adjustment.rs
@@ -129,7 +129,7 @@ impl<'tcx> OverloadedDeref<'tcx> {
             .find(|m| m.kind == ty::AssocKind::Fn)
             .unwrap()
             .def_id;
-        (method_def_id, tcx.mk_substs_trait(source, &[], ty::ConstnessArg::Not))
+        (method_def_id, tcx.mk_substs_trait(source, &[]))
     }
 }
 
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -2817,20 +2817,11 @@ impl<'tcx> TyCtxt<'tcx> {
         self_ty: Ty<'tcx>,
         rest: &[GenericArg<'tcx>],
     ) -> SubstsRef<'tcx> {
-        self.mk_substs_trait(self_ty, rest, ty::ConstnessArg::Not)
+        self.mk_substs_trait(self_ty, rest)
     }
 
-    pub fn mk_substs_trait(
-        self,
-        self_ty: Ty<'tcx>,
-        rest: &[GenericArg<'tcx>],
-        constness: ty::ConstnessArg,
-    ) -> SubstsRef<'tcx> {
-        self.mk_substs(
-            iter::once(self_ty.into())
-                .chain(rest.iter().cloned())
-                .chain(iter::once(constness.into())),
-        )
+    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()))
     }
 
     pub fn mk_bound_variable_kinds<
diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
@@ -537,7 +537,7 @@ impl<'tcx> Instance<'tcx> {
         let sig =
             tcx.try_normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), sig).ok()?;
         assert_eq!(sig.inputs().len(), 1);
-        let substs = tcx.mk_substs_trait(self_ty, &[sig.inputs()[0].into()], ty::ConstnessArg::Not);
+        let substs = tcx.mk_substs_trait(self_ty, &[sig.inputs()[0].into()]);
 
         debug!("fn_once_adapter_shim: self_ty={:?} sig={:?}", self_ty, sig);
         Some(Instance { def, substs })
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
@@ -916,10 +916,7 @@ impl<'tcx> ExistentialTraitRef<'tcx> {
         // otherwise the escaping vars would be captured by the binder
         // debug_assert!(!self_ty.has_escaping_bound_vars());
 
-        ty::TraitRef {
-            def_id: self.def_id,
-            substs: tcx.mk_substs_trait(self_ty, self.substs, ty::ConstnessArg::Not),
-        }
+        ty::TraitRef { def_id: self.def_id, substs: tcx.mk_substs_trait(self_ty, self.substs) }
     }
 }
 
@@ -1460,7 +1457,7 @@ impl<'tcx> ExistentialProjection<'tcx> {
         ty::ProjectionPredicate {
             projection_ty: ty::ProjectionTy {
                 item_def_id: self.item_def_id,
-                substs: tcx.mk_substs_trait(self_ty, self.substs, ty::ConstnessArg::Not),
+                substs: tcx.mk_substs_trait(self_ty, self.substs),
             },
             term: self.term,
         }
diff --git a/compiler/rustc_mir_build/src/build/matches/test.rs b/compiler/rustc_mir_build/src/build/matches/test.rs
@@ -820,7 +820,7 @@ fn trait_method<'tcx>(
     self_ty: Ty<'tcx>,
     params: &[GenericArg<'tcx>],
 ) -> ConstantKind<'tcx> {
-    let substs = tcx.mk_substs_trait(self_ty, params, ty::ConstnessArg::Not);
+    let substs = tcx.mk_substs_trait(self_ty, params);
 
     // The unhygienic comparison here is acceptable because this is only
     // used on known traits.
diff --git a/compiler/rustc_mir_dataflow/src/elaborate_drops.rs b/compiler/rustc_mir_dataflow/src/elaborate_drops.rs
@@ -616,7 +616,7 @@ where
         let drop_trait = tcx.require_lang_item(LangItem::Drop, None);
         let drop_fn = tcx.associated_item_def_ids(drop_trait)[0];
         let ty = self.place_ty(self.place);
-        let substs = tcx.mk_substs_trait(ty, &[], ty::ConstnessArg::Not);
+        let substs = tcx.mk_substs_trait(ty, &[]);
 
         let ref_ty =
             tcx.mk_ref(tcx.lifetimes.re_erased, ty::TypeAndMut { ty, mutbl: hir::Mutability::Mut });
diff --git a/compiler/rustc_mir_transform/src/shim.rs b/compiler/rustc_mir_transform/src/shim.rs
@@ -342,7 +342,7 @@ impl<'tcx> CloneShimBuilder<'tcx> {
         // we must subst the self_ty because it's
         // otherwise going to be TySelf and we can't index
         // or access fields of a Place of type TySelf.
-        let substs = tcx.mk_substs_trait(self_ty, &[], ty::ConstnessArg::Not);
+        let substs = tcx.mk_substs_trait(self_ty, &[]);
         let sig = tcx.bound_fn_sig(def_id).subst(tcx, substs);
         let sig = tcx.erase_late_bound_regions(sig);
         let span = tcx.def_span(def_id);
@@ -423,7 +423,7 @@ impl<'tcx> CloneShimBuilder<'tcx> {
     ) {
         let tcx = self.tcx;
 
-        let substs = tcx.mk_substs_trait(ty, &[], ty::ConstnessArg::Not);
+        let substs = tcx.mk_substs_trait(ty, &[]);
 
         // `func == Clone::clone(&ty) -> ty`
         let func_ty = tcx.mk_fn_def(self.def_id, substs);
@@ -529,8 +529,7 @@ fn build_call_shim<'tcx>(
 
         // Create substitutions for the `Self` and `Args` generic parameters of the shim body.
         let arg_tup = tcx.mk_tup(untuple_args.iter());
-        let sig_substs =
-            tcx.mk_substs_trait(ty, &[ty::subst::GenericArg::from(arg_tup)], ty::ConstnessArg::Not);
+        let sig_substs = tcx.mk_substs_trait(ty, &[ty::subst::GenericArg::from(arg_tup)]);
 
         (Some(sig_substs), Some(untuple_args))
     } else {
diff --git a/compiler/rustc_monomorphize/src/lib.rs b/compiler/rustc_monomorphize/src/lib.rs
@@ -29,7 +29,7 @@ fn custom_coerce_unsize_info<'tcx>(
 
     let trait_ref = ty::Binder::dummy(ty::TraitRef {
         def_id,
-        substs: tcx.mk_substs_trait(source_ty, &[target_ty.into()], ty::ConstnessArg::Not),
+        substs: tcx.mk_substs_trait(source_ty, &[target_ty.into()]),
     });
 
     match tcx.codegen_fulfill_obligation((ty::ParamEnv::reveal_all(), trait_ref)) {
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
@@ -1275,9 +1275,10 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
         &self,
         param_env: ty::ParamEnv<'tcx>,
         ty: ty::Binder<'tcx, Ty<'tcx>>,
-        constness: ty::ConstnessArg,
+        _constness: ty::ConstnessArg,
         polarity: ty::ImplPolarity,
     ) -> Result<(ty::ClosureKind, ty::Binder<'tcx, Ty<'tcx>>), ()> {
+        // TODO: handle constness once the fn traits are const_trait
         self.commit_if_ok(|_| {
             for trait_def_id in [
                 self.tcx.lang_items().fn_trait(),
@@ -1291,7 +1292,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                     span: DUMMY_SP,
                     kind: TypeVariableOriginKind::MiscVariable,
                 });
-                let substs = self.tcx.mk_substs_trait(ty.skip_binder(), &[var.into()], constness);
+                let substs = self.tcx.mk_substs_trait(ty.skip_binder(), &[var.into()]);
                 let obligation = Obligation::new(
                     ObligationCause::dummy(),
                     param_env,
diff --git a/compiler/rustc_trait_selection/src/traits/mod.rs b/compiler/rustc_trait_selection/src/traits/mod.rs
@@ -137,10 +137,8 @@ pub fn type_known_to_meet_bound_modulo_regions<'a, 'tcx>(
         infcx.tcx.def_path_str(def_id)
     );
 
-    let trait_ref = ty::Binder::dummy(ty::TraitRef {
-        def_id,
-        substs: infcx.tcx.mk_substs_trait(ty, &[], ty::ConstnessArg::Not),
-    });
+    let trait_ref =
+        ty::Binder::dummy(ty::TraitRef { def_id, substs: infcx.tcx.mk_substs_trait(ty, &[]) });
     let obligation = Obligation {
         param_env,
         cause: ObligationCause::misc(span, hir::CRATE_HIR_ID),
@@ -803,7 +801,7 @@ pub fn vtable_trait_upcasting_coercion_new_vptr_slot<'tcx>(
 
     let trait_ref = ty::TraitRef {
         def_id: unsize_trait_did,
-        substs: tcx.mk_substs_trait(source, &[target.into()], ty::ConstnessArg::Not),
+        substs: tcx.mk_substs_trait(source, &[target.into()]),
     };
     let obligation = Obligation::new(
         ObligationCause::dummy(),
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -1207,8 +1207,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                                             .require_lang_item(LangItem::Destruct, None),
                                         substs: self.tcx().mk_substs_trait(
                                             nested_ty,
-                                            &[],
-                                            ty::ConstnessArg::Required,
+                                            &[ty::ConstnessArg::Required.into()],
                                         ),
                                     },
                                     polarity: ty::ImplPolarity::Positive,
@@ -1236,8 +1235,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                                 def_id: self.tcx().require_lang_item(LangItem::Destruct, None),
                                 substs: self.tcx().mk_substs_trait(
                                     nested_ty,
-                                    &[],
-                                    ty::ConstnessArg::Required,
+                                    &[ty::ConstnessArg::Required.into()],
                                 ),
                             },
                             polarity: ty::ImplPolarity::Positive,
diff --git a/compiler/rustc_trait_selection/src/traits/util.rs b/compiler/rustc_trait_selection/src/traits/util.rs
@@ -268,10 +268,8 @@ pub fn predicate_for_trait_def<'tcx>(
     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, ty::ConstnessArg::Not),
-    };
+    let trait_ref =
+        ty::TraitRef { def_id: trait_def_id, substs: tcx.mk_substs_trait(self_ty, params) };
     predicate_for_trait_ref(tcx, cause, param_env, trait_ref, recursion_depth)
 }
 
diff --git a/compiler/rustc_typeck/src/check/_match.rs b/compiler/rustc_typeck/src/check/_match.rs
@@ -521,7 +521,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                 ty::Binder::dummy(ty::PredicateKind::Trait(ty::TraitPredicate {
                                     trait_ref: ty::TraitRef {
                                         def_id: t.def_id(),
-                                        substs: self.infcx.tcx.mk_substs_trait(outer_ty, &[], t.constness()),
+                                        substs: self.infcx.tcx.mk_substs_trait(outer_ty, &[]),
                                     },
                                     polarity: t.polarity,
                                 }));
diff --git a/compiler/rustc_typeck/src/check/cast.rs b/compiler/rustc_typeck/src/check/cast.rs
@@ -495,7 +495,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                         let ty = fcx.tcx.erase_regions(ty);
                         let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
                         let expr_ty = fcx.tcx.erase_regions(expr_ty);
-                        let ty_params = fcx.tcx.mk_substs_trait(expr_ty, &[], ty::ConstnessArg::Not);
+                        let ty_params = fcx.tcx.mk_substs_trait(expr_ty, &[]);
                         if fcx
                             .infcx
                             .type_implements_trait(from_trait, ty, ty_params, fcx.param_env)
diff --git a/compiler/rustc_typeck/src/check/method/probe.rs b/compiler/rustc_typeck/src/check/method/probe.rs
@@ -1781,7 +1781,13 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         // method yet. So create fresh variables here for those too,
         // if there are any.
         let generics = self.tcx.generics_of(method);
-        assert_eq!(substs.len(), generics.parent_count as usize);
+        assert_eq!(
+            substs.len(),
+            generics.parent_count as usize,
+            "{:#?} vs {:#?}",
+            substs,
+            generics.params
+        );
 
         let xform_fn_sig = if generics.params.is_empty() {
             fn_sig.subst(self.tcx, substs)
diff --git a/compiler/rustc_typeck/src/check/method/suggest.rs b/compiler/rustc_typeck/src/check/method/suggest.rs
@@ -67,7 +67,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                     span,
                                 })
                                 .into()],
-                            ty::ConstnessArg::Not,
                         );
                         let trait_ref = ty::TraitRef::new(fn_once, fn_once_substs);
                         let poly_trait_ref = ty::Binder::dummy(trait_ref);
diff --git a/compiler/rustc_typeck/src/check/upvar.rs b/compiler/rustc_typeck/src/check/upvar.rs
@@ -980,7 +980,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             .type_implements_trait(
                                 check_trait,
                                 ty,
-                                self.tcx.mk_substs_trait(ty, &[], ty::ConstnessArg::Not),
+                                self.tcx.mk_substs_trait(ty, &[]),
                                 self.param_env,
                             )
                             .must_apply_modulo_regions()
@@ -1009,7 +1009,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                 .type_implements_trait(
                                     check_trait,
                                     ty,
-                                    self.tcx.mk_substs_trait(ty, &[], ty::ConstnessArg::Not),
+                                    self.tcx.mk_substs_trait(ty, &[]),
                                     self.param_env,
                                 )
                                 .must_apply_modulo_regions()
@@ -1355,7 +1355,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let is_drop_defined_for_ty = |ty: Ty<'tcx>| {
             let drop_trait = self.tcx.require_lang_item(hir::LangItem::Drop, Some(closure_span));
-            let ty_params = self.tcx.mk_substs_trait(base_path_ty, &[], ty::ConstnessArg::Not);
+            let ty_params = self.tcx.mk_substs_trait(base_path_ty, &[]);
             self.infcx
                 .type_implements_trait(
                     drop_trait,
diff --git a/compiler/rustc_typeck/src/check/wfcheck.rs b/compiler/rustc_typeck/src/check/wfcheck.rs
@@ -1698,7 +1698,7 @@ fn receiver_is_implemented<'tcx>(
 ) -> bool {
     let trait_ref = ty::Binder::dummy(ty::TraitRef {
         def_id: receiver_trait_def_id,
-        substs: fcx.tcx.mk_substs_trait(receiver_ty, &[], ty::ConstnessArg::Not),
+        substs: fcx.tcx.mk_substs_trait(receiver_ty, &[]),
     });
 
     let obligation = traits::Obligation::new(cause, fcx.param_env, trait_ref.to_predicate(fcx.tcx));
diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
@@ -40,10 +40,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
         discard_positive_impl: bool,
     ) -> Option<Item> {
         let tcx = self.cx.tcx;
-        let trait_ref = ty::TraitRef {
-            def_id: trait_def_id,
-            substs: tcx.mk_substs_trait(ty, &[], ty::ConstnessArg::Not),
-        };
+        let trait_ref = ty::TraitRef { def_id: trait_def_id, substs: tcx.mk_substs_trait(ty, &[]) };
         if !self.cx.generated_synthetics.insert((ty, trait_def_id)) {
             debug!("get_auto_trait_impl_for({:?}): already generated, aborting", trait_ref);
             return None;
diff --git a/src/tools/clippy/clippy_lints/src/bool_assert_comparison.rs b/src/tools/clippy/clippy_lints/src/bool_assert_comparison.rs
@@ -59,7 +59,7 @@ fn is_impl_not_trait_with_bool_out(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
             )
         })
         .map_or(false, |assoc_item| {
-            let proj = cx.tcx.mk_projection(assoc_item.def_id, cx.tcx.mk_substs_trait(ty, &[], ty::ConstnessArg::Not));
+            let proj = cx.tcx.mk_projection(assoc_item.def_id, cx.tcx.mk_substs_trait(ty, &[]));
             let nty = cx.tcx.normalize_erasing_regions(cx.param_env, proj);
 
             nty.is_bool()
diff --git a/src/tools/clippy/clippy_utils/src/ty.rs b/src/tools/clippy/clippy_utils/src/ty.rs
@@ -80,7 +80,7 @@ pub fn get_associated_type<'tcx>(
         .associated_items(trait_id)
         .find_by_name_and_kind(cx.tcx, Ident::from_str(name), ty::AssocKind::Type, trait_id)
         .and_then(|assoc| {
-            let proj = cx.tcx.mk_projection(assoc.def_id, cx.tcx.mk_substs_trait(ty, &[], ty::ConstnessArg::Not));
+            let proj = cx.tcx.mk_projection(assoc.def_id, cx.tcx.mk_substs_trait(ty, &[]));
             cx.tcx.try_normalize_erasing_regions(cx.param_env, proj).ok()
         })
 }

Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ impl<'tcx> OverloadedDeref<'tcx> {`
`129`	`129`	`.find(\|m\| m.kind == ty::AssocKind::Fn)`
`130`	`130`	`.unwrap()`
`131`	`131`	`.def_id;`
`132`		`- (method_def_id, tcx.mk_substs_trait(source, &[], ty::ConstnessArg::Not))`
	`132`	`+ (method_def_id, tcx.mk_substs_trait(source, &[]))`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`
Original file line number	Diff line number	Diff line change
`@@ -916,10 +916,7 @@ impl<'tcx> ExistentialTraitRef<'tcx> {`
`916`	`916`	`// otherwise the escaping vars would be captured by the binder`
`917`	`917`	`// debug_assert!(!self_ty.has_escaping_bound_vars());`
`918`	`918`
`919`		`- ty::TraitRef {`
`920`		`- def_id: self.def_id,`
`921`		`- substs: tcx.mk_substs_trait(self_ty, self.substs, ty::ConstnessArg::Not),`
`922`		`- }`
	`919`	`+ ty::TraitRef { def_id: self.def_id, substs: tcx.mk_substs_trait(self_ty, self.substs) }`
`923`	`920`	`}`
`924`	`921`	`}`
`925`	`922`
`@@ -1460,7 +1457,7 @@ impl<'tcx> ExistentialProjection<'tcx> {`
`1460`	`1457`	`ty::ProjectionPredicate {`
`1461`	`1458`	`projection_ty: ty::ProjectionTy {`
`1462`	`1459`	`item_def_id: self.item_def_id,`
`1463`		`- substs: tcx.mk_substs_trait(self_ty, self.substs, ty::ConstnessArg::Not),`
	`1460`	`+ substs: tcx.mk_substs_trait(self_ty, self.substs),`
`1464`	`1461`	`},`
`1465`	`1462`	`term: self.term,`
`1466`	`1463`	`}`