Auto merge of rust-lang#105012 - WaffleLapkin:into, r=oli-obk

bors · bors · commit e0098a5cc3a8 · 2022-11-29T13:28:44.000Z
Make `tcx.mk_const` more permissive wrt `kind` argument (`impl Into`)

r? `@oli-obk` you've asked for this &gt;:)
diff --git a/Cargo.lock b/Cargo.lock
@@ -870,6 +870,12 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "convert_case"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
+
 [[package]]
 name = "core"
 version = "0.0.0"
@@ -1060,6 +1066,19 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "derive_more"
+version = "0.99.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn",
+]
+
 [[package]]
 name = "diff"
 version = "0.1.13"
@@ -3979,6 +3998,7 @@ version = "0.0.0"
 dependencies = [
  "bitflags",
  "chalk-ir",
+ "derive_more",
  "either",
  "gsgdt",
  "polonius-engine",
diff --git a/compiler/rustc_infer/src/infer/canonical/mod.rs b/compiler/rustc_infer/src/infer/canonical/mod.rs
@@ -147,7 +147,7 @@ impl<'tcx> InferCtxt<'tcx> {
             CanonicalVarKind::PlaceholderConst(ty::PlaceholderConst { universe, name }, ty) => {
                 let universe_mapped = universe_map(universe);
                 let placeholder_mapped = ty::PlaceholderConst { universe: universe_mapped, name };
-                self.tcx.mk_const(ty::ConstKind::Placeholder(placeholder_mapped), ty).into()
+                self.tcx.mk_const(placeholder_mapped, ty).into()
             }
         }
     }
diff --git a/compiler/rustc_infer/src/infer/combine.rs b/compiler/rustc_infer/src/infer/combine.rs
@@ -753,7 +753,7 @@ impl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
                                 origin: var_value.origin,
                                 val: ConstVariableValue::Unknown { universe: self.for_universe },
                             });
-                            Ok(self.tcx().mk_const_var(new_var_id, c.ty()))
+                            Ok(self.tcx().mk_const(new_var_id, c.ty()))
                         }
                     }
                 }
@@ -765,10 +765,7 @@ impl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
                     substs,
                     substs,
                 )?;
-                Ok(self.tcx().mk_const(
-                    ty::ConstKind::Unevaluated(ty::UnevaluatedConst { def, substs }),
-                    c.ty(),
-                ))
+                Ok(self.tcx().mk_const(ty::UnevaluatedConst { def, substs }, c.ty()))
             }
             _ => relate::super_relate_consts(self, c, c),
         }
@@ -975,7 +972,7 @@ impl<'tcx> TypeRelation<'tcx> for ConstInferUnifier<'_, 'tcx> {
                                         },
                                     },
                                 );
-                            Ok(self.tcx().mk_const_var(new_var_id, c.ty()))
+                            Ok(self.tcx().mk_const(new_var_id, c.ty()))
                         }
                     }
                 }
@@ -988,10 +985,7 @@ impl<'tcx> TypeRelation<'tcx> for ConstInferUnifier<'_, 'tcx> {
                     substs,
                 )?;
 
-                Ok(self.tcx().mk_const(
-                    ty::ConstKind::Unevaluated(ty::UnevaluatedConst { def, substs }),
-                    c.ty(),
-                ))
+                Ok(self.tcx().mk_const(ty::UnevaluatedConst { def, substs }, c.ty()))
             }
             _ => relate::super_relate_consts(self, c, c),
         }
diff --git a/compiler/rustc_infer/src/infer/freshen.rs b/compiler/rustc_infer/src/infer/freshen.rs
@@ -102,7 +102,7 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
             Entry::Vacant(entry) => {
                 let index = self.const_freshen_count;
                 self.const_freshen_count += 1;
-                let ct = self.infcx.tcx.mk_const_infer(freshener(index), ty);
+                let ct = self.infcx.tcx.mk_const(freshener(index), ty);
                 entry.insert(ct);
                 ct
             }
diff --git a/compiler/rustc_infer/src/infer/higher_ranked/mod.rs b/compiler/rustc_infer/src/infer/higher_ranked/mod.rs
@@ -94,13 +94,8 @@ impl<'tcx> InferCtxt<'tcx> {
                 }))
             },
             consts: &mut |bound_var: ty::BoundVar, ty| {
-                self.tcx.mk_const(
-                    ty::ConstKind::Placeholder(ty::PlaceholderConst {
-                        universe: next_universe,
-                        name: bound_var,
-                    }),
-                    ty,
-                )
+                self.tcx
+                    .mk_const(ty::PlaceholderConst { universe: next_universe, name: bound_var }, ty)
             },
         };
 
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
@@ -1065,7 +1065,7 @@ impl<'tcx> InferCtxt<'tcx> {
     }
 
     pub fn next_const_var(&self, ty: Ty<'tcx>, origin: ConstVariableOrigin) -> ty::Const<'tcx> {
-        self.tcx.mk_const_var(self.next_const_var_id(origin), ty)
+        self.tcx.mk_const(self.next_const_var_id(origin), ty)
     }
 
     pub fn next_const_var_in_universe(
@@ -1079,7 +1079,7 @@ impl<'tcx> InferCtxt<'tcx> {
             .borrow_mut()
             .const_unification_table()
             .new_key(ConstVarValue { origin, val: ConstVariableValue::Unknown { universe } });
-        self.tcx.mk_const_var(vid, ty)
+        self.tcx.mk_const(vid, ty)
     }
 
     pub fn next_const_var_id(&self, origin: ConstVariableOrigin) -> ConstVid<'tcx> {
@@ -1195,7 +1195,7 @@ impl<'tcx> InferCtxt<'tcx> {
                         origin,
                         val: ConstVariableValue::Unknown { universe: self.universe() },
                     });
-                self.tcx.mk_const_var(const_var_id, self.tcx.type_of(param.def_id)).into()
+                self.tcx.mk_const(const_var_id, self.tcx.type_of(param.def_id)).into()
             }
         }
     }
@@ -1580,7 +1580,7 @@ impl<'tcx> InferCtxt<'tcx> {
         span: Option<Span>,
     ) -> Result<ty::Const<'tcx>, ErrorHandled> {
         match self.const_eval_resolve(param_env, unevaluated, span) {
-            Ok(Some(val)) => Ok(ty::Const::from_value(self.tcx, val, ty)),
+            Ok(Some(val)) => Ok(self.tcx.mk_const(val, ty)),
             Ok(None) => {
                 let tcx = self.tcx;
                 let def_id = unevaluated.def.did;
@@ -2049,10 +2049,10 @@ fn replace_param_and_infer_substs_with_placeholder<'tcx>(
                     bug!("const `{ct}`'s type should not reference params or types");
                 }
                 tcx.mk_const(
-                    ty::ConstKind::Placeholder(ty::PlaceholderConst {
+                    ty::PlaceholderConst {
                         universe: ty::UniverseIndex::ROOT,
                         name: ty::BoundVar::from_usize(idx),
-                    }),
+                    },
                     ty,
                 )
                 .into()
diff --git a/compiler/rustc_infer/src/infer/nll_relate/mod.rs b/compiler/rustc_infer/src/infer/nll_relate/mod.rs
@@ -1087,7 +1087,7 @@ where
                             origin: var_value.origin,
                             val: ConstVariableValue::Unknown { universe: self.universe },
                         });
-                        Ok(self.tcx().mk_const_var(new_var_id, a.ty()))
+                        Ok(self.tcx().mk_const(new_var_id, a.ty()))
                     }
                 }
             }
diff --git a/compiler/rustc_middle/Cargo.toml b/compiler/rustc_middle/Cargo.toml
@@ -8,6 +8,7 @@ edition = "2021"
 [dependencies]
 bitflags = "1.2.1"
 chalk-ir = "0.87.0"
+derive_more = "0.99.17"
 either = "1.5.0"
 gsgdt = "0.1.2"
 polonius-engine = "0.13.0"
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
@@ -2527,8 +2527,7 @@ impl<'tcx> ConstantKind<'tcx> {
                 let generics = tcx.generics_of(item_def_id);
                 let index = generics.param_def_id_to_index[&def_id];
                 let name = tcx.item_name(def_id);
-                let ty_const =
-                    tcx.mk_const(ty::ConstKind::Param(ty::ParamConst::new(index, name)), ty);
+                let ty_const = tcx.mk_const(ty::ParamConst::new(index, name), ty);
                 debug!(?ty_const);
 
                 return Self::Ty(ty_const);
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
@@ -76,10 +76,10 @@ impl<'tcx> Const<'tcx> {
         match Self::try_eval_lit_or_param(tcx, ty, expr) {
             Some(v) => v,
             None => tcx.mk_const(
-                ty::ConstKind::Unevaluated(ty::UnevaluatedConst {
+                ty::UnevaluatedConst {
                     def: def.to_global(),
                     substs: InternalSubsts::identity_for_item(tcx, def.did.to_def_id()),
-                }),
+                },
                 ty,
             ),
         }
@@ -134,18 +134,12 @@ impl<'tcx> Const<'tcx> {
                 let generics = tcx.generics_of(item_def_id);
                 let index = generics.param_def_id_to_index[&def_id];
                 let name = tcx.item_name(def_id);
-                Some(tcx.mk_const(ty::ConstKind::Param(ty::ParamConst::new(index, name)), ty))
+                Some(tcx.mk_const(ty::ParamConst::new(index, name), ty))
             }
             _ => None,
         }
     }
 
-    /// Interns the given value as a constant.
-    #[inline]
-    pub fn from_value(tcx: TyCtxt<'tcx>, val: ty::ValTree<'tcx>, ty: Ty<'tcx>) -> Self {
-        tcx.mk_const(ConstKind::Value(val), ty)
-    }
-
     /// Panics if self.kind != ty::ConstKind::Value
     pub fn to_valtree(self) -> ty::ValTree<'tcx> {
         match self.kind() {
@@ -154,26 +148,23 @@ impl<'tcx> Const<'tcx> {
         }
     }
 
-    pub fn from_scalar_int(tcx: TyCtxt<'tcx>, i: ScalarInt, ty: Ty<'tcx>) -> Self {
-        let valtree = ty::ValTree::from_scalar_int(i);
-        Self::from_value(tcx, valtree, ty)
-    }
-
     #[inline]
     /// Creates a constant with the given integer value and interns it.
     pub fn from_bits(tcx: TyCtxt<'tcx>, bits: u128, ty: ParamEnvAnd<'tcx, Ty<'tcx>>) -> Self {
         let size = tcx
             .layout_of(ty)
             .unwrap_or_else(|e| panic!("could not compute layout for {:?}: {:?}", ty, e))
             .size;
-        Self::from_scalar_int(tcx, ScalarInt::try_from_uint(bits, size).unwrap(), ty.value)
+        tcx.mk_const(
+            ty::ValTree::from_scalar_int(ScalarInt::try_from_uint(bits, size).unwrap()),
+            ty.value,
+        )
     }
 
     #[inline]
     /// Creates an interned zst constant.
     pub fn zero_sized(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Self {
-        let valtree = ty::ValTree::zst();
-        Self::from_value(tcx, valtree, ty)
+        tcx.mk_const(ty::ValTree::zst(), ty)
     }
 
     #[inline]
@@ -220,7 +211,7 @@ impl<'tcx> Const<'tcx> {
     pub fn eval(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> Const<'tcx> {
         if let Some(val) = self.kind().try_eval_for_typeck(tcx, param_env) {
             match val {
-                Ok(val) => Const::from_value(tcx, val, self.ty()),
+                Ok(val) => tcx.mk_const(val, self.ty()),
                 Err(guar) => tcx.const_error_with_guaranteed(self.ty(), guar),
             }
         } else {
diff --git a/compiler/rustc_middle/src/ty/consts/kind.rs b/compiler/rustc_middle/src/ty/consts/kind.rs
@@ -49,6 +49,7 @@ impl<'tcx> UnevaluatedConst<'tcx> {
 /// Represents a constant in Rust.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, TyEncodable, TyDecodable)]
 #[derive(Hash, HashStable, TypeFoldable, TypeVisitable)]
+#[derive(derive_more::From)]
 pub enum ConstKind<'tcx> {
     /// A const generic parameter.
     Param(ty::ParamConst),
@@ -71,12 +72,19 @@ pub enum ConstKind<'tcx> {
 
     /// A placeholder for a const which could not be computed; this is
     /// propagated to avoid useless error messages.
+    #[from(ignore)]
     Error(ErrorGuaranteed),
 
     /// Expr which contains an expression which has partially evaluated items.
     Expr(Expr<'tcx>),
 }
 
+impl<'tcx> From<ty::ConstVid<'tcx>> for ConstKind<'tcx> {
+    fn from(const_vid: ty::ConstVid<'tcx>) -> Self {
+        InferConst::Var(const_vid).into()
+    }
+}
+
 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
 #[derive(HashStable, TyEncodable, TyDecodable, TypeVisitable, TypeFoldable)]
 pub enum Expr<'tcx> {
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -17,8 +17,8 @@ use crate::traits;
 use crate::ty::query::{self, TyCtxtAt};
 use crate::ty::{
     self, AdtDef, AdtDefData, AdtKind, Binder, BindingMode, BoundVar, CanonicalPolyFnSig,
-    ClosureSizeProfileData, Const, ConstS, ConstVid, DefIdTree, FloatTy, FloatVar, FloatVid,
-    GenericParamDefKind, InferConst, InferTy, IntTy, IntVar, IntVid, List, ParamConst, ParamTy,
+    ClosureSizeProfileData, Const, ConstS, DefIdTree, FloatTy, FloatVar, FloatVid,
+    GenericParamDefKind, InferTy, IntTy, IntVar, IntVid, List, ParamConst, ParamTy,
     PolyExistentialPredicate, PolyFnSig, Predicate, PredicateKind, PredicateS, ProjectionTy,
     Region, RegionKind, ReprOptions, TraitObjectVisitor, Ty, TyKind, TyS, TyVar, TyVid, TypeAndMut,
     UintTy, Visibility,
@@ -2604,13 +2604,8 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     #[inline]
-    pub fn mk_const(self, kind: ty::ConstKind<'tcx>, ty: Ty<'tcx>) -> Const<'tcx> {
-        self.mk_const_internal(ty::ConstS { kind, ty })
-    }
-
-    #[inline]
-    pub fn mk_const_var(self, v: ConstVid<'tcx>, ty: Ty<'tcx>) -> Const<'tcx> {
-        self.mk_const(ty::ConstKind::Infer(InferConst::Var(v)), ty)
+    pub fn mk_const(self, kind: impl Into<ty::ConstKind<'tcx>>, ty: Ty<'tcx>) -> Const<'tcx> {
+        self.mk_const_internal(ty::ConstS { kind: kind.into(), ty })
     }
 
     #[inline]
@@ -2628,30 +2623,23 @@ impl<'tcx> TyCtxt<'tcx> {
         self.mk_ty(Infer(it))
     }
 
-    #[inline]
-    pub fn mk_const_infer(self, ic: InferConst<'tcx>, ty: Ty<'tcx>) -> ty::Const<'tcx> {
-        self.mk_const(ty::ConstKind::Infer(ic), ty)
-    }
-
     #[inline]
     pub fn mk_ty_param(self, index: u32, name: Symbol) -> Ty<'tcx> {
         self.mk_ty(Param(ParamTy { index, name }))
     }
 
-    #[inline]
-    pub fn mk_const_param(self, index: u32, name: Symbol, ty: Ty<'tcx>) -> Const<'tcx> {
-        self.mk_const(ty::ConstKind::Param(ParamConst { index, name }), ty)
-    }
-
     pub fn mk_param_from_def(self, param: &ty::GenericParamDef) -> GenericArg<'tcx> {
         match param.kind {
             GenericParamDefKind::Lifetime => {
                 self.mk_region(ty::ReEarlyBound(param.to_early_bound_region_data())).into()
             }
             GenericParamDefKind::Type { .. } => self.mk_ty_param(param.index, param.name).into(),
-            GenericParamDefKind::Const { .. } => {
-                self.mk_const_param(param.index, param.name, self.type_of(param.def_id)).into()
-            }
+            GenericParamDefKind::Const { .. } => self
+                .mk_const(
+                    ParamConst { index: param.index, name: param.name },
+                    self.type_of(param.def_id),
+                )
+                .into(),
         }
     }
 
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -1468,8 +1468,7 @@ pub trait PrettyPrinter<'tcx>:
             }
             // Aggregates, printed as array/tuple/struct/variant construction syntax.
             (ty::ValTree::Branch(_), ty::Array(..) | ty::Tuple(..) | ty::Adt(..)) => {
-                let contents =
-                    self.tcx().destructure_const(ty::Const::from_value(self.tcx(), valtree, ty));
+                let contents = self.tcx().destructure_const(self.tcx().mk_const(valtree, ty));
                 let fields = contents.fields.iter().copied();
                 match *ty.kind() {
                     ty::Array(..) => {
diff --git a/compiler/rustc_middle/src/ty/relate.rs b/compiler/rustc_middle/src/ty/relate.rs
@@ -663,10 +663,7 @@ pub fn super_relate_consts<'tcx, R: TypeRelation<'tcx>>(
                 au.substs,
                 bu.substs,
             )?;
-            return Ok(tcx.mk_const(
-                ty::ConstKind::Unevaluated(ty::UnevaluatedConst { def: au.def, substs }),
-                a.ty(),
-            ));
+            return Ok(tcx.mk_const(ty::UnevaluatedConst { def: au.def, substs }, a.ty()));
         }
         // Before calling relate on exprs, it is necessary to ensure that the nested consts
         // have identical types.
diff --git a/compiler/rustc_mir_build/src/build/expr/as_constant.rs b/compiler/rustc_mir_build/src/build/expr/as_constant.rs
@@ -77,7 +77,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 Constant { user_ty, span, literal }
             }
             ExprKind::ConstParam { param, def_id: _ } => {
-                let const_param = tcx.mk_const(ty::ConstKind::Param(param), expr.ty);
+                let const_param = tcx.mk_const(param, expr.ty);
                 let literal = ConstantKind::Ty(const_param);
 
                 Constant { user_ty: None, span, literal }
diff --git a/compiler/rustc_mir_build/src/thir/constant.rs b/compiler/rustc_mir_build/src/thir/constant.rs
@@ -61,5 +61,5 @@ pub(crate) fn lit_to_const<'tcx>(
         _ => return Err(LitToConstError::TypeError),
     };
 
-    Ok(ty::Const::from_value(tcx, valtree, ty))
+    Ok(tcx.mk_const(valtree, ty))
 }
diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
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_ty_utils/src/consts.rs b/compiler/rustc_ty_utils/src/consts.rs
diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs

Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ impl<'tcx> InferCtxt<'tcx> {`
`147`	`147`	`CanonicalVarKind::PlaceholderConst(ty::PlaceholderConst { universe, name }, ty) => {`
`148`	`148`	`let universe_mapped = universe_map(universe);`
`149`	`149`	`let placeholder_mapped = ty::PlaceholderConst { universe: universe_mapped, name };`
`150`		`- self.tcx.mk_const(ty::ConstKind::Placeholder(placeholder_mapped), ty).into()`
	`150`	`+ self.tcx.mk_const(placeholder_mapped, ty).into()`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`	`}`
Original file line number	Diff line number	Diff line change
`@@ -753,7 +753,7 @@ impl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx> {`
`753`	`753`	`origin: var_value.origin,`
`754`	`754`	`val: ConstVariableValue::Unknown { universe: self.for_universe },`
`755`	`755`	`});`
`756`		`- Ok(self.tcx().mk_const_var(new_var_id, c.ty()))`
	`756`	`+ Ok(self.tcx().mk_const(new_var_id, c.ty()))`
`757`	`757`	`}`
`758`	`758`	`}`
`759`	`759`	`}`
`@@ -765,10 +765,7 @@ impl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx> {`
`765`	`765`	`substs,`
`766`	`766`	`substs,`
`767`	`767`	`)?;`
`768`		`- Ok(self.tcx().mk_const(`
`769`		`- ty::ConstKind::Unevaluated(ty::UnevaluatedConst { def, substs }),`
`770`		`- c.ty(),`
`771`		`- ))`
	`768`	`+ Ok(self.tcx().mk_const(ty::UnevaluatedConst { def, substs }, c.ty()))`
`772`	`769`	`}`
`773`	`770`	`_ => relate::super_relate_consts(self, c, c),`
`774`	`771`	`}`
`@@ -975,7 +972,7 @@ impl<'tcx> TypeRelation<'tcx> for ConstInferUnifier<'_, 'tcx> {`
`975`	`972`	`},`
`976`	`973`	`},`
`977`	`974`	`);`
`978`		`- Ok(self.tcx().mk_const_var(new_var_id, c.ty()))`
	`975`	`+ Ok(self.tcx().mk_const(new_var_id, c.ty()))`
`979`	`976`	`}`
`980`	`977`	`}`
`981`	`978`	`}`
`@@ -988,10 +985,7 @@ impl<'tcx> TypeRelation<'tcx> for ConstInferUnifier<'_, 'tcx> {`
`988`	`985`	`substs,`
`989`	`986`	`)?;`
`990`	`987`
`991`		`- Ok(self.tcx().mk_const(`
`992`		`- ty::ConstKind::Unevaluated(ty::UnevaluatedConst { def, substs }),`
`993`		`- c.ty(),`
`994`		`- ))`
	`988`	`+ Ok(self.tcx().mk_const(ty::UnevaluatedConst { def, substs }, c.ty()))`
`995`	`989`	`}`
`996`	`990`	`_ => relate::super_relate_consts(self, c, c),`
`997`	`991`	`}`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {`
`102`	`102`	`Entry::Vacant(entry) => {`
`103`	`103`	`let index = self.const_freshen_count;`
`104`	`104`	`self.const_freshen_count += 1;`
`105`		`- let ct = self.infcx.tcx.mk_const_infer(freshener(index), ty);`
	`105`	`+ let ct = self.infcx.tcx.mk_const(freshener(index), ty);`
`106`	`106`	`entry.insert(ct);`
`107`	`107`	`ct`
`108`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1065,7 +1065,7 @@ impl<'tcx> InferCtxt<'tcx> {`
`1065`	`1065`	`}`
`1066`	`1066`
`1067`	`1067`	`pub fn next_const_var(&self, ty: Ty<'tcx>, origin: ConstVariableOrigin) -> ty::Const<'tcx> {`
`1068`		`- self.tcx.mk_const_var(self.next_const_var_id(origin), ty)`
	`1068`	`+ self.tcx.mk_const(self.next_const_var_id(origin), ty)`
`1069`	`1069`	`}`
`1070`	`1070`
`1071`	`1071`	`pub fn next_const_var_in_universe(`
`@@ -1079,7 +1079,7 @@ impl<'tcx> InferCtxt<'tcx> {`
`1079`	`1079`	`.borrow_mut()`
`1080`	`1080`	`.const_unification_table()`
`1081`	`1081`	`.new_key(ConstVarValue { origin, val: ConstVariableValue::Unknown { universe } });`
`1082`		`- self.tcx.mk_const_var(vid, ty)`
	`1082`	`+ self.tcx.mk_const(vid, ty)`
`1083`	`1083`	`}`
`1084`	`1084`
`1085`	`1085`	`pub fn next_const_var_id(&self, origin: ConstVariableOrigin) -> ConstVid<'tcx> {`
`@@ -1195,7 +1195,7 @@ impl<'tcx> InferCtxt<'tcx> {`
`1195`	`1195`	`origin,`
`1196`	`1196`	`val: ConstVariableValue::Unknown { universe: self.universe() },`
`1197`	`1197`	`});`
`1198`		`- self.tcx.mk_const_var(const_var_id, self.tcx.type_of(param.def_id)).into()`
	`1198`	`+ self.tcx.mk_const(const_var_id, self.tcx.type_of(param.def_id)).into()`
`1199`	`1199`	`}`
`1200`	`1200`	`}`
`1201`	`1201`	`}`
`@@ -1580,7 +1580,7 @@ impl<'tcx> InferCtxt<'tcx> {`
`1580`	`1580`	`span: Option<Span>,`
`1581`	`1581`	`) -> Result<ty::Const<'tcx>, ErrorHandled> {`
`1582`	`1582`	`match self.const_eval_resolve(param_env, unevaluated, span) {`
`1583`		`- Ok(Some(val)) => Ok(ty::Const::from_value(self.tcx, val, ty)),`
	`1583`	`+ Ok(Some(val)) => Ok(self.tcx.mk_const(val, ty)),`
`1584`	`1584`	`Ok(None) => {`
`1585`	`1585`	`let tcx = self.tcx;`
`1586`	`1586`	`let def_id = unevaluated.def.did;`
`@@ -2049,10 +2049,10 @@ fn replace_param_and_infer_substs_with_placeholder<'tcx>(`
`2049`	`2049`	bug!("const `{ct}`'s type should not reference params or types");
`2050`	`2050`	`}`
`2051`	`2051`	`tcx.mk_const(`
`2052`		`- ty::ConstKind::Placeholder(ty::PlaceholderConst {`
	`2052`	`+ ty::PlaceholderConst {`
`2053`	`2053`	`universe: ty::UniverseIndex::ROOT,`
`2054`	`2054`	`name: ty::BoundVar::from_usize(idx),`
`2055`		`- }),`
	`2055`	`+ },`
`2056`	`2056`	`ty,`
`2057`	`2057`	`)`
`2058`	`2058`	`.into()`
Original file line number	Diff line number	Diff line change
`@@ -1087,7 +1087,7 @@ where`
`1087`	`1087`	`origin: var_value.origin,`
`1088`	`1088`	`val: ConstVariableValue::Unknown { universe: self.universe },`
`1089`	`1089`	`});`
`1090`		`- Ok(self.tcx().mk_const_var(new_var_id, a.ty()))`
	`1090`	`+ Ok(self.tcx().mk_const(new_var_id, a.ty()))`
`1091`	`1091`	`}`
`1092`	`1092`	`}`
`1093`	`1093`	`}`