Remove Const::kind method in favor of field access via the Deref impl

Author: oli-obk

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -381,7 +381,7 @@ fn check_opaque_type_parameter_valid(
             GenericArgKind::Lifetime(lt) => {
                 matches!(*lt, ty::ReEarlyBound(_) | ty::ReFree(_))
             }
-            GenericArgKind::Const(ct) => matches!(ct.kind(), ty::ConstKind::Param(_)),
+            GenericArgKind::Const(ct) => matches!(ct.kind, ty::ConstKind::Param(_)),
         };
 
         if arg_is_param {

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -353,7 +353,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
         } else {
             let tcx = self.tcx();
             let maybe_uneval = match constant.literal {
-                ConstantKind::Ty(ct) => match ct.kind() {
+                ConstantKind::Ty(ct) => match ct.kind {
                     ty::ConstKind::Unevaluated(_) => {
                         bug!("should not encounter unevaluated ConstantKind::Ty here, got {:?}", ct)
                     }

compiler/rustc_codegen_cranelift/src/base.rs

@@ -722,7 +722,7 @@ fn codegen_stmt<'tcx>(
                     let times = fx
                         .monomorphize(times)
                         .eval(fx.tcx, ParamEnv::reveal_all())
-                        .kind()
+                        .kind
                         .try_to_bits(fx.tcx.data_layout.pointer_size)
                         .unwrap();
                     if operand.layout().size.bytes() == 0 {

compiler/rustc_codegen_cranelift/src/constant.rs

@@ -71,7 +71,7 @@ pub(crate) fn eval_mir_constant<'tcx>(
 ) -> Option<(ConstValue<'tcx>, Ty<'tcx>)> {
     let constant_kind = fx.monomorphize(constant.literal);
     let uv = match constant_kind {
-        ConstantKind::Ty(const_) => match const_.kind() {
+        ConstantKind::Ty(const_) => match const_.kind {
             ty::ConstKind::Unevaluated(uv) => uv.expand(),
             ty::ConstKind::Value(val) => {
                 return Some((fx.tcx.valtree_to_const_val((const_.ty, val)), const_.ty));

compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs

@@ -178,15 +178,15 @@ fn push_debuginfo_type_name<'tcx>(
             if cpp_like_debuginfo {
                 output.push_str("array$<");
                 push_debuginfo_type_name(tcx, inner_type, true, output, visited);
-                match len.kind() {
+                match len.kind {
                     ty::ConstKind::Param(param) => write!(output, ",{}>", param.name).unwrap(),
                     _ => write!(output, ",{}>", len.eval_usize(tcx, ty::ParamEnv::reveal_all()))
                         .unwrap(),
                 }
             } else {
                 output.push('[');
                 push_debuginfo_type_name(tcx, inner_type, true, output, visited);
-                match len.kind() {
+                match len.kind {
                     ty::ConstKind::Param(param) => write!(output, "; {}]", param.name).unwrap(),
                     _ => write!(output, "; {}]", len.eval_usize(tcx, ty::ParamEnv::reveal_all()))
                         .unwrap(),
@@ -635,7 +635,7 @@ fn push_generic_params_internal<'tcx>(
 }
 
 fn push_const_param<'tcx>(tcx: TyCtxt<'tcx>, ct: ty::Const<'tcx>, output: &mut String) {
-    match ct.kind() {
+    match ct.kind {
         ty::ConstKind::Param(param) => {
             write!(output, "{}", param.name)
         }

compiler/rustc_codegen_ssa/src/mir/constant.rs

@@ -26,7 +26,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     ) -> Result<ConstValue<'tcx>, ErrorHandled> {
         let ct = self.monomorphize(constant.literal);
         let uv = match ct {
-            mir::ConstantKind::Ty(ct) => match ct.kind() {
+            mir::ConstantKind::Ty(ct) => match ct.kind {
                 ty::ConstKind::Unevaluated(uv) => uv.expand(),
                 ty::ConstKind::Value(val) => {
                     return Ok(self.cx.tcx().valtree_to_const_val((ct.ty, val)));

compiler/rustc_const_eval/src/interpret/operand.rs

@@ -557,7 +557,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         val: ty::Const<'tcx>,
         span: Option<Span>,
     ) -> InterpResult<'tcx, ValTree<'tcx>> {
-        Ok(match val.kind() {
+        Ok(match val.kind {
             ty::ConstKind::Param(_) | ty::ConstKind::Placeholder(..) => {
                 throw_inval!(TooGeneric)
             }

compiler/rustc_const_eval/src/interpret/util.rs

@@ -57,7 +57,7 @@ where
         }
 
         fn visit_const(&mut self, c: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {
-            match c.kind() {
+            match c.kind {
                 ty::ConstKind::Param(..) => ControlFlow::Break(FoundParam),
                 _ => c.super_visit_with(self),
             }

compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs

@@ -348,7 +348,7 @@ where
     // way for type and mir constants.
     let uneval = match constant.literal {
         ConstantKind::Ty(ct)
-            if matches!(ct.kind(), ty::ConstKind::Param(_) | ty::ConstKind::Error(_)) =>
+            if matches!(ct.kind, ty::ConstKind::Param(_) | ty::ConstKind::Error(_)) =>
         {
             None
         }

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -1417,7 +1417,7 @@ fn check_where_clauses<'tcx>(wfcx: &WfCheckingCtxt<'_, 'tcx>, span: Span, def_id
                 }
 
                 fn visit_const(&mut self, c: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {
-                    if let ty::ConstKind::Param(param) = c.kind() {
+                    if let ty::ConstKind::Param(param) = c.kind {
                         self.params.insert(param.index);
                     }
                     c.super_visit_with(self)