Streamline super_combine_consts.

By using `use` more to reduce the number of qualifiers needed.

Author: nnethercote

compiler/rustc_infer/src/infer/relate/combine.rs

@@ -22,7 +22,9 @@ use rustc_middle::bug;
 use rustc_middle::infer::unify_key::EffectVarValue;
 use rustc_middle::traits::solve::Goal;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
-use rustc_middle::ty::{self, InferConst, IntType, Ty, TyCtxt, TypeVisitableExt, UintType, Upcast};
+use rustc_middle::ty::{
+    self, ConstKind, InferConst, IntType, Ty, TyCtxt, TypeVisitableExt, UintType, Upcast,
+};
 pub use rustc_next_trait_solver::relate::combine::*;
 use tracing::debug;
 
@@ -177,6 +179,8 @@ impl<'tcx> InferCtxt<'tcx> {
     where
         R: PredicateEmittingRelation<InferCtxt<'tcx>>,
     {
+        use InferConst::*;
+
         debug!("super_combine_consts::<{}>({:?}, {:?})", std::any::type_name::<R>(), a, b);
         debug_assert!(!a.has_escaping_bound_vars());
         debug_assert!(!b.has_escaping_bound_vars());
@@ -189,55 +193,37 @@ impl<'tcx> InferCtxt<'tcx> {
         let b = self.shallow_resolve_const(b);
 
         match (a.kind(), b.kind()) {
-            (
-                ty::ConstKind::Infer(InferConst::Var(a_vid)),
-                ty::ConstKind::Infer(InferConst::Var(b_vid)),
-            ) => {
+            (ConstKind::Infer(Var(a_vid)), ConstKind::Infer(Var(b_vid))) => {
                 self.inner.borrow_mut().const_unification_table().union(a_vid, b_vid);
                 Ok(a)
             }
 
-            (
-                ty::ConstKind::Infer(InferConst::EffectVar(a_vid)),
-                ty::ConstKind::Infer(InferConst::EffectVar(b_vid)),
-            ) => {
+            (ConstKind::Infer(EffectVar(a_vid)), ConstKind::Infer(EffectVar(b_vid))) => {
                 self.inner.borrow_mut().effect_unification_table().union(a_vid, b_vid);
                 Ok(a)
             }
 
             // All other cases of inference with other variables are errors.
-            (
-                ty::ConstKind::Infer(InferConst::Var(_) | InferConst::EffectVar(_)),
-                ty::ConstKind::Infer(_),
-            )
-            | (
-                ty::ConstKind::Infer(_),
-                ty::ConstKind::Infer(InferConst::Var(_) | InferConst::EffectVar(_)),
-            ) => {
-                bug!(
-                    "tried to combine ConstKind::Infer/ConstKind::Infer(InferConst::Var): {a:?} and {b:?}"
-                )
+            (ConstKind::Infer(Var(_) | EffectVar(_)), ConstKind::Infer(_))
+            | (ConstKind::Infer(_), ConstKind::Infer(Var(_) | EffectVar(_))) => {
+                bug!("tried to combine ConstKind::Infer/ConstKind::Infer(Var): {a:?} and {b:?}")
             }
 
-            (ty::ConstKind::Infer(InferConst::Var(vid)), _) => {
+            (ConstKind::Infer(Var(vid)), _) => {
                 self.instantiate_const_var(relation, true, vid, b)?;
                 Ok(b)
             }
 
-            (_, ty::ConstKind::Infer(InferConst::Var(vid))) => {
+            (_, ConstKind::Infer(Var(vid))) => {
                 self.instantiate_const_var(relation, false, vid, a)?;
                 Ok(a)
             }
 
-            (ty::ConstKind::Infer(InferConst::EffectVar(vid)), _) => {
-                Ok(self.unify_effect_variable(vid, b))
-            }
+            (ConstKind::Infer(EffectVar(vid)), _) => Ok(self.unify_effect_variable(vid, b)),
 
-            (_, ty::ConstKind::Infer(InferConst::EffectVar(vid))) => {
-                Ok(self.unify_effect_variable(vid, a))
-            }
+            (_, ConstKind::Infer(EffectVar(vid))) => Ok(self.unify_effect_variable(vid, a)),
 
-            (ty::ConstKind::Unevaluated(..), _) | (_, ty::ConstKind::Unevaluated(..))
+            (ConstKind::Unevaluated(..), _) | (_, ConstKind::Unevaluated(..))
                 if self.tcx.features().generic_const_exprs || self.next_trait_solver() =>
             {
                 match relation.structurally_relate_aliases() {