Avoid needless copy of val

fee1-dead · fee1-dead · commit b824865e4d5a · 2021-11-18T22:42:04.000+08:00
diff --git a/compiler/rustc_codegen_cranelift/src/constant.rs b/compiler/rustc_codegen_cranelift/src/constant.rs
@@ -50,7 +50,7 @@ pub(crate) fn check_constants(fx: &mut FunctionCx<'_, '_, '_>) -> bool {
             ConstKind::Value(_) => {}
             ConstKind::Unevaluated(unevaluated) => {
                 if let Err(err) =
-                    fx.tcx.const_eval_resolve(ParamEnv::reveal_all(), unevaluated, None)
+                    fx.tcx.const_eval_resolve(ParamEnv::reveal_all(), *unevaluated, None)
                 {
                     all_constants_ok = false;
                     match err {
@@ -128,15 +128,15 @@ pub(crate) fn codegen_constant<'tcx>(
         ConstantKind::Val(val, ty) => return codegen_const_value(fx, val, ty),
     };
     let const_val = match const_.val() {
-        ConstKind::Value(const_val) => const_val,
+        ConstKind::Value(const_val) => *const_val,
         ConstKind::Unevaluated(uv) if fx.tcx.is_static(uv.def.did) => {
             assert!(uv.substs(fx.tcx).is_empty());
             assert!(uv.promoted.is_none());
 
             return codegen_static_ref(fx, uv.def.did, fx.layout_of(const_.ty())).to_cvalue(fx);
         }
         ConstKind::Unevaluated(unevaluated) => {
-            match fx.tcx.const_eval_resolve(ParamEnv::reveal_all(), unevaluated, None) {
+            match fx.tcx.const_eval_resolve(ParamEnv::reveal_all(), *unevaluated, None) {
                 Ok(const_val) => const_val,
                 Err(_) => {
                     span_bug!(constant.span, "erroneous constant not captured by required_consts");
diff --git a/compiler/rustc_codegen_ssa/src/mir/constant.rs b/compiler/rustc_codegen_ssa/src/mir/constant.rs
@@ -33,12 +33,12 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             ty::ConstKind::Unevaluated(ct) => self
                 .cx
                 .tcx()
-                .const_eval_resolve(ty::ParamEnv::reveal_all(), ct, None)
+                .const_eval_resolve(ty::ParamEnv::reveal_all(), *ct, None)
                 .map_err(|err| {
                     self.cx.tcx().sess.span_err(constant.span, "erroneous constant encountered");
                     err
                 }),
-            ty::ConstKind::Value(value) => Ok(value),
+            ty::ConstKind::Value(value) => Ok(*value),
             err => span_bug!(
                 constant.span,
                 "encountered bad ConstKind after monomorphizing: {:?}",
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -170,7 +170,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 };
                 let val =
                     self.tcx.const_eval_global_id(self.param_env, gid, Some(self.tcx.span))?;
-                let val = self.const_val_to_op(val, ty, Some(dest.layout))?;
+                let val = self.const_val_to_op(&val, ty, Some(dest.layout))?;
                 self.copy_op(&val, dest)?;
             }
 
diff --git a/compiler/rustc_const_eval/src/interpret/operand.rs b/compiler/rustc_const_eval/src/interpret/operand.rs
@@ -573,13 +573,13 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     ) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>> {
         match val {
             mir::ConstantKind::Ty(ct) => self.const_to_op(ct, layout),
-            mir::ConstantKind::Val(val, ty) => self.const_val_to_op(*val, ty, layout),
+            mir::ConstantKind::Val(val, ty) => self.const_val_to_op(val, ty, layout),
         }
     }
 
     crate fn const_val_to_op(
         &self,
-        val_val: ConstValue<'tcx>,
+        val_val: &ConstValue<'tcx>,
         ty: Ty<'tcx>,
         layout: Option<TyAndLayout<'tcx>>,
     ) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>> {
@@ -596,20 +596,20 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 let id = self.tcx.create_memory_alloc(alloc);
                 // We rely on mutability being set correctly in that allocation to prevent writes
                 // where none should happen.
-                let ptr = self.global_base_pointer(Pointer::new(id, offset))?;
+                let ptr = self.global_base_pointer(Pointer::new(id, *offset))?;
                 Operand::Indirect(MemPlace::from_ptr(ptr.into(), layout.align.abi))
             }
-            ConstValue::Scalar(x) => Operand::Immediate(tag_scalar(x)?.into()),
+            ConstValue::Scalar(x) => Operand::Immediate(tag_scalar(*x)?.into()),
             ConstValue::Slice { data, start, end } => {
                 // We rely on mutability being set correctly in `data` to prevent writes
                 // where none should happen.
                 let ptr = Pointer::new(
                     self.tcx.create_memory_alloc(data),
-                    Size::from_bytes(start), // offset: `start`
+                    Size::from_bytes(*start), // offset: `start`
                 );
                 Operand::Immediate(Immediate::new_slice(
                     Scalar::from_pointer(self.global_base_pointer(ptr)?, &*self.tcx),
-                    u64::try_from(end.checked_sub(start).unwrap()).unwrap(), // len: `end - start`
+                    u64::try_from(end.checked_sub(*start).unwrap()).unwrap(), // len: `end - start`
                     self,
                 ))
             }
diff --git a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
@@ -413,7 +413,7 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for Canonicalizer<'cx, 'tcx> {
         match ct.val() {
             ty::ConstKind::Infer(InferConst::Var(vid)) => {
                 debug!("canonical: const var found with vid {:?}", vid);
-                match self.infcx.probe_const_var(vid) {
+                match self.infcx.probe_const_var(*vid) {
                     Ok(c) => {
                         debug!("(resolved to {:?})", c);
                         return self.fold_const(c);
@@ -435,15 +435,15 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for Canonicalizer<'cx, 'tcx> {
                 bug!("encountered a fresh const during canonicalization")
             }
             ty::ConstKind::Bound(debruijn, _) => {
-                if debruijn >= self.binder_index {
+                if *debruijn >= self.binder_index {
                     bug!("escaping bound type during canonicalization")
                 } else {
                     return ct;
                 }
             }
             ty::ConstKind::Placeholder(placeholder) => {
                 return self.canonicalize_const_var(
-                    CanonicalVarInfo { kind: CanonicalVarKind::PlaceholderConst(placeholder) },
+                    CanonicalVarInfo { kind: CanonicalVarKind::PlaceholderConst(*placeholder) },
                     ct,
                 );
             }
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -442,8 +442,8 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
                         // ...in which case we would set `canonical_vars[0]` to `Some(const X)`.
 
                         // We only allow a `ty::INNERMOST` index in substitutions.
-                        assert_eq!(debrujin, ty::INNERMOST);
-                        opt_values[b] = Some(*original_value);
+                        assert_eq!(*debrujin, ty::INNERMOST);
+                        opt_values[*b] = Some(*original_value);
                     }
                 }
             }
diff --git a/compiler/rustc_infer/src/infer/combine.rs b/compiler/rustc_infer/src/infer/combine.rs
@@ -149,7 +149,7 @@ impl<'infcx, 'tcx> InferCtxt<'infcx, 'tcx> {
                 self.inner
                     .borrow_mut()
                     .const_unification_table()
-                    .unify_var_var(a_vid, b_vid)
+                    .unify_var_var(*a_vid, *b_vid)
                     .map_err(|e| const_unification_error(a_is_expected, e))?;
                 return Ok(a);
             }
@@ -161,11 +161,11 @@ impl<'infcx, 'tcx> InferCtxt<'infcx, 'tcx> {
             }
 
             (ty::ConstKind::Infer(InferConst::Var(vid)), _) => {
-                return self.unify_const_variable(relation.param_env(), vid, b, a_is_expected);
+                return self.unify_const_variable(relation.param_env(), *vid, b, a_is_expected);
             }
 
             (_, ty::ConstKind::Infer(InferConst::Var(vid))) => {
-                return self.unify_const_variable(relation.param_env(), vid, a, !a_is_expected);
+                return self.unify_const_variable(relation.param_env(), *vid, a, !a_is_expected);
             }
             (ty::ConstKind::Unevaluated(..), _) if self.tcx.lazy_normalization() => {
                 // FIXME(#59490): Need to remove the leak check to accommodate
@@ -726,7 +726,7 @@ impl TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
             ty::ConstKind::Infer(InferConst::Var(vid)) => {
                 let mut inner = self.infcx.inner.borrow_mut();
                 let variable_table = &mut inner.const_unification_table();
-                let var_value = variable_table.probe_value(vid);
+                let var_value = variable_table.probe_value(*vid);
                 match var_value.val {
                     ConstVariableValue::Known { value: u } => {
                         drop(inner);
@@ -963,13 +963,13 @@ impl TypeRelation<'tcx> for ConstInferUnifier<'_, 'tcx> {
                     .inner
                     .borrow_mut()
                     .const_unification_table()
-                    .unioned(self.target_vid, vid)
+                    .unioned(self.target_vid, *vid)
                 {
                     return Err(TypeError::CyclicConst(c));
                 }
 
                 let var_value =
-                    self.infcx.inner.borrow_mut().const_unification_table().probe_value(vid);
+                    self.infcx.inner.borrow_mut().const_unification_table().probe_value(*vid);
                 match var_value.val {
                     ConstVariableValue::Known { value: u } => self.consts(u, u),
                     ConstVariableValue::Unknown { universe } => {
diff --git a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs
@@ -392,7 +392,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
             GenericArgKind::Const(ct) => {
                 if let ty::ConstKind::Infer(InferConst::Var(vid)) = ct.val() {
                     let origin =
-                        self.inner.borrow_mut().const_unification_table().probe_value(vid).origin;
+                        self.inner.borrow_mut().const_unification_table().probe_value(*vid).origin;
                     if let ConstVariableOriginKind::ConstParameterDefinition(name, def_id) =
                         origin.kind
                     {
diff --git a/compiler/rustc_infer/src/infer/freshen.rs b/compiler/rustc_infer/src/infer/freshen.rs
@@ -229,18 +229,18 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> {
                     .inner
                     .borrow_mut()
                     .const_unification_table()
-                    .probe_value(v)
+                    .probe_value(*v)
                     .val
                     .known();
                 return self.freshen_const(
                     opt_ct,
-                    ty::InferConst::Var(v),
+                    ty::InferConst::Var(*v),
                     ty::InferConst::Fresh,
                     ct.ty(),
                 );
             }
             ty::ConstKind::Infer(ty::InferConst::Fresh(i)) => {
-                if i >= self.const_freshen_count {
+                if *i >= self.const_freshen_count {
                     bug!(
                         "Encountered a freshend const with id {} \
                             but our counter is only at {}",
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
@@ -1735,7 +1735,7 @@ impl TyOrConstInferVar<'tcx> {
     /// for constants other than `ty::ConstKind::Infer(_)` (or `InferConst::Fresh`).
     pub fn maybe_from_const(ct: &'tcx ty::Const<'tcx>) -> Option<Self> {
         match ct.val() {
-            ty::ConstKind::Infer(InferConst::Var(v)) => Some(TyOrConstInferVar::Const(v)),
+            ty::ConstKind::Infer(InferConst::Var(v)) => Some(TyOrConstInferVar::Const(*v)),
             _ => None,
         }
     }
@@ -1760,7 +1760,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for ShallowResolver<'a, 'tcx> {
                 .inner
                 .borrow_mut()
                 .const_unification_table()
-                .probe_value(vid)
+                .probe_value(*vid)
                 .val
                 .known()
                 .unwrap_or(ct)
diff --git a/compiler/rustc_infer/src/infer/nll_relate/mod.rs b/compiler/rustc_infer/src/infer/nll_relate/mod.rs
@@ -1008,7 +1008,7 @@ where
             ty::ConstKind::Infer(InferConst::Var(vid)) => {
                 let mut inner = self.infcx.inner.borrow_mut();
                 let variable_table = &mut inner.const_unification_table();
-                let var_value = variable_table.probe_value(vid);
+                let var_value = variable_table.probe_value(*vid);
                 match var_value.val.known() {
                     Some(u) => self.relate(u, u),
                     None => {
diff --git a/compiler/rustc_infer/src/infer/resolve.rs b/compiler/rustc_infer/src/infer/resolve.rs
@@ -241,7 +241,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> {
             let c = self.infcx.shallow_resolve(c);
             match c.val() {
                 ty::ConstKind::Infer(InferConst::Var(vid)) => {
-                    self.err = Some(FixupError::UnresolvedConst(vid));
+                    self.err = Some(FixupError::UnresolvedConst(*vid));
                     return self.tcx().const_error(c.ty());
                 }
                 ty::ConstKind::Infer(InferConst::Fresh(_)) => {
diff --git a/compiler/rustc_middle/src/infer/unify_key.rs b/compiler/rustc_middle/src/infer/unify_key.rs
@@ -173,7 +173,7 @@ where
     L: UndoLogs<snapshot_vec::UndoLog<unify::Delegate<ty::ConstVid<'tcx>>>>,
 {
     if let ty::ConstKind::Infer(InferConst::Var(vid)) = c.val() {
-        match table.probe_value(vid).val.known() {
+        match table.probe_value(*vid).val.known() {
             Some(c) => c,
             None => c,
         }
diff --git a/compiler/rustc_middle/src/mir/interpret/value.rs b/compiler/rustc_middle/src/mir/interpret/value.rs
@@ -587,12 +587,12 @@ impl<'tcx, Tag: Provenance> ScalarMaybeUninit<Tag> {
 }
 
 /// Gets the bytes of a constant slice value.
-pub fn get_slice_bytes<'tcx>(cx: &impl HasDataLayout, val: ConstValue<'tcx>) -> &'tcx [u8] {
+pub fn get_slice_bytes<'tcx>(cx: &impl HasDataLayout, val: &ConstValue<'tcx>) -> &'tcx [u8] {
     if let ConstValue::Slice { data, start, end } = val {
-        let len = end - start;
+        let len = *end - *start;
         data.get_bytes(
             cx,
-            AllocRange { start: Size::from_bytes(start), size: Size::from_bytes(len) },
+            AllocRange { start: Size::from_bytes(*start), size: Size::from_bytes(len) },
         )
         .unwrap_or_else(|err| bug!("const slice is invalid: {:?}", err))
     } else {
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
@@ -669,7 +669,7 @@ pub fn write_allocations<'tcx>(
     fn alloc_ids_from_alloc(alloc: &Allocation) -> impl DoubleEndedIterator<Item = AllocId> + '_ {
         alloc.relocations().values().map(|id| *id)
     }
-    fn alloc_ids_from_const(val: ConstValue<'_>) -> impl Iterator<Item = AllocId> + '_ {
+    fn alloc_ids_from_const<'a>(val: &'a ConstValue<'a>) -> impl Iterator<Item = AllocId> + 'a {
         match val {
             ConstValue::Scalar(interpret::Scalar::Ptr(ptr, _size)) => {
                 Either::Left(Either::Left(std::iter::once(ptr.provenance)))
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
@@ -38,8 +38,8 @@ impl<'tcx> Const<'tcx> {
     }
 
     #[inline]
-    pub fn val(&self) -> ConstKind<'tcx> {
-        self.val
+    pub fn val(&self) -> &ConstKind<'tcx> {
+        &self.val
     }
 
     /// Literals and const generic parameters are eagerly converted to a constant, everything else
diff --git a/compiler/rustc_middle/src/ty/relate.rs b/compiler/rustc_middle/src/ty/relate.rs
@@ -565,7 +565,7 @@ pub fn super_relate_consts<R: TypeRelation<'tcx>>(
     // Currently, the values that can be unified are primitive types,
     // and those that derive both `PartialEq` and `Eq`, corresponding
     // to structural-match types.
-    let is_match = match (a.val, b.val) {
+    let is_match = match (a.val(), b.val()) {
         (ty::ConstKind::Infer(_), _) | (_, ty::ConstKind::Infer(_)) => {
             // The caller should handle these cases!
             bug!("var types encountered in super_relate_consts: {:?} {:?}", a, b)
@@ -614,8 +614,8 @@ pub fn super_relate_consts<R: TypeRelation<'tcx>>(
 
 fn check_const_value_eq<R: TypeRelation<'tcx>>(
     relation: &mut R,
-    a_val: ConstValue<'tcx>,
-    b_val: ConstValue<'tcx>,
+    a_val: &ConstValue<'tcx>,
+    b_val: &ConstValue<'tcx>,
     // FIXME(oli-obk): these arguments should go away with valtrees
     a: &'tcx ty::Const<'tcx>,
     b: &'tcx ty::Const<'tcx>,
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
@@ -719,10 +719,10 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {
         let val = match literal {
             mir::ConstantKind::Val(val, _) => val,
             mir::ConstantKind::Ty(ct) => match ct.val() {
-                ty::ConstKind::Value(val) => val,
+                ty::ConstKind::Value(val) => *val,
                 ty::ConstKind::Unevaluated(ct) => {
                     let param_env = ty::ParamEnv::reveal_all();
-                    match self.tcx.const_eval_resolve(param_env, ct, None) {
+                    match self.tcx.const_eval_resolve(param_env, *ct, None) {
                         // The `monomorphize` call should have evaluated that constant already.
                         Ok(val) => val,
                         Err(ErrorHandled::Reported(ErrorReported) | ErrorHandled::Linted) => return,
@@ -747,9 +747,9 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {
         let param_env = ty::ParamEnv::reveal_all();
 
         match substituted_constant.val() {
-            ty::ConstKind::Value(val) => collect_const_value(self.tcx, val, self.output),
+            ty::ConstKind::Value(val) => collect_const_value(self.tcx, *val, self.output),
             ty::ConstKind::Unevaluated(unevaluated) => {
-                match self.tcx.const_eval_resolve(param_env, unevaluated, None) {
+                match self.tcx.const_eval_resolve(param_env, *unevaluated, None) {
                     // The `monomorphize` call should have evaluated that constant already.
                     Ok(val) => span_bug!(
                         self.body.source_info(location).span,
diff --git a/compiler/rustc_monomorphize/src/polymorphize.rs b/compiler/rustc_monomorphize/src/polymorphize.rs
@@ -300,7 +300,7 @@ impl<'a, 'tcx> TypeVisitor<'tcx> for MarkUsedGenericParams<'a, 'tcx> {
                 // If there is a promoted, don't look at the substs - since it will always contain
                 // the generic parameters, instead, traverse the promoted MIR.
                 let promoted = self.tcx.promoted_mir(def.did);
-                self.visit_body(&promoted[p]);
+                self.visit_body(&promoted[*p]);
                 ControlFlow::CONTINUE
             }
             ty::ConstKind::Unevaluated(uv)
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -632,7 +632,7 @@ impl Printer<'tcx> for &mut SymbolMangler<'tcx> {
                         // relocations (we have an active `str` reference here). We don't use this
                         // result to affect interpreter execution.
                         let slice =
-                            data.inspect_with_uninit_and_ptr_outside_interpreter(start..end);
+                            data.inspect_with_uninit_and_ptr_outside_interpreter(*start..*end);
                         let s = std::str::from_utf8(slice).expect("non utf8 str from miri");
 
                         self.push("e");
diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
@@ -809,7 +809,7 @@ impl AutoTraitFinder<'tcx> {
                         if let ty::ConstKind::Unevaluated(unevaluated) = c.val() {
                             match select.infcx().const_eval_resolve(
                                 obligation.param_env,
-                                unevaluated,
+                                *unevaluated,
                                 Some(obligation.cause.span),
                             ) {
                                 Ok(val) => Ok(ty::Const::from_value(select.tcx(), val, c.ty())),
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -598,7 +598,7 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {
                         if let ty::ConstKind::Unevaluated(unevaluated) = c.val() {
                             match self.selcx.infcx().const_eval_resolve(
                                 obligation.param_env,
-                                unevaluated,
+                                *unevaluated,
                                 Some(obligation.cause.span),
                             ) {
                                 Ok(val) => Ok(Const::from_value(self.selcx.tcx(), val, c.ty())),
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
diff --git a/compiler/rustc_trait_selection/src/traits/query/normalize.rs b/compiler/rustc_trait_selection/src/traits/query/normalize.rs
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
diff --git a/compiler/rustc_traits/src/chalk/lowering.rs b/compiler/rustc_traits/src/chalk/lowering.rs
diff --git a/compiler/rustc_typeck/src/constrained_generic_params.rs b/compiler/rustc_typeck/src/constrained_generic_params.rs
diff --git a/src/tools/clippy/clippy_utils/src/consts.rs b/src/tools/clippy/clippy_utils/src/consts.rs

Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`170`	`170`	`};`
`171`	`171`	`let val =`
`172`	`172`	`self.tcx.const_eval_global_id(self.param_env, gid, Some(self.tcx.span))?;`
`173`		`- let val = self.const_val_to_op(val, ty, Some(dest.layout))?;`
	`173`	`+ let val = self.const_val_to_op(&val, ty, Some(dest.layout))?;`
`174`	`174`	`self.copy_op(&val, dest)?;`
`175`	`175`	`}`
`176`	`176`
Original file line number	Diff line number	Diff line change
`@@ -442,8 +442,8 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {`
`442`	`442`	// ...in which case we would set `canonical_vars[0]` to `Some(const X)`.
`443`	`443`
`444`	`444`	// We only allow a `ty::INNERMOST` index in substitutions.
`445`		`- assert_eq!(debrujin, ty::INNERMOST);`
`446`		`- opt_values[b] = Some(*original_value);`
	`445`	`+ assert_eq!(*debrujin, ty::INNERMOST);`
	`446`	`+ opt_values[b] = Some(original_value);`
`447`	`447`	`}`
`448`	`448`	`}`
`449`	`449`	`}`
Original file line number	Diff line number	Diff line change
`@@ -392,7 +392,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {`
`392`	`392`	`GenericArgKind::Const(ct) => {`
`393`	`393`	`if let ty::ConstKind::Infer(InferConst::Var(vid)) = ct.val() {`
`394`	`394`	`let origin =`
`395`		`- self.inner.borrow_mut().const_unification_table().probe_value(vid).origin;`
	`395`	`+ self.inner.borrow_mut().const_unification_table().probe_value(*vid).origin;`
`396`	`396`	`if let ConstVariableOriginKind::ConstParameterDefinition(name, def_id) =`
`397`	`397`	`origin.kind`
`398`	`398`	`{`