compiler/rustc_middle/src/ty/_match.rs

   1 use crate::ty::error::TypeError;
   2 use crate::ty::relate::{self, Relate, RelateResult, TypeRelation};
   3 use crate::ty::{self, InferConst, Ty, TyCtxt};
   4
   5 /// A type "A" *matches* "B" if the fresh types in B could be
   6 /// substituted with values so as to make it equal to A. Matching is
   7 /// intended to be used only on freshened types, and it basically
   8 /// indicates if the non-freshened versions of A and B could have been
   9 /// unified.
  10 ///
  11 /// It is only an approximation. If it yields false, unification would
  12 /// definitely fail, but a true result doesn't mean unification would
  13 /// succeed. This is because we don't track the "side-constraints" on
  14 /// type variables, nor do we track if the same freshened type appears
  15 /// more than once. To some extent these approximations could be
  16 /// fixed, given effort.
  17 ///
  18 /// Like subtyping, matching is really a binary relation, so the only
  19 /// important thing about the result is Ok/Err. Also, matching never
  20 /// affects any type variables or unification state.
  21 pub struct Match<'tcx> {
  22     tcx: TyCtxt<'tcx>,
  23     param_env: ty::ParamEnv<'tcx>,
  24 }
  25
  26 impl<'tcx> Match<'tcx> {
  27     pub fn new(tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> Match<'tcx> {
  28         Match { tcx, param_env }
  29     }
  30 }
  31
  32 impl<'tcx> TypeRelation<'tcx> for Match<'tcx> {
  33     fn tag(&self) -> &'static str {
  34         "Match"
  35     }
  36     fn tcx(&self) -> TyCtxt<'tcx> {
  37         self.tcx
  38     }
  39
  40     fn intercrate(&self) -> bool {
  41         false
  42     }
  43
  44     fn param_env(&self) -> ty::ParamEnv<'tcx> {
  45         self.param_env
  46     }
  47     fn a_is_expected(&self) -> bool {
  48         true
  49     } // irrelevant
  50
  51     fn mark_ambiguous(&mut self) {
  52         bug!()
  53     }
  54
  55     fn relate_with_variance<T: Relate<'tcx>>(
  56         &mut self,
  57         _: ty::Variance,
  58         _: ty::VarianceDiagInfo<'tcx>,
  59         a: T,
  60         b: T,
  61     ) -> RelateResult<'tcx, T> {
  62         self.relate(a, b)
  63     }
  64
  65     #[instrument(skip(self), level = "debug")]
  66     fn regions(
  67         &mut self,
  68         a: ty::Region<'tcx>,
  69         b: ty::Region<'tcx>,
  70     ) -> RelateResult<'tcx, ty::Region<'tcx>> {
  71         Ok(a)
  72     }
  73
  74     #[instrument(skip(self), level = "debug")]
  75     fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
  76         if a == b {
  77             return Ok(a);
  78         }
  79
  80         match (a.kind(), b.kind()) {
  81             (
  82                 _,
  83                 &ty::Infer(ty::FreshTy(_))
  84                 | &ty::Infer(ty::FreshIntTy(_))
  85                 | &ty::Infer(ty::FreshFloatTy(_)),
  86             ) => Ok(a),
  87
  88             (&ty::Infer(_), _) | (_, &ty::Infer(_)) => {
  89                 Err(TypeError::Sorts(relate::expected_found(self, a, b)))
  90             }
  91
  92             (&ty::Error(_), _) | (_, &ty::Error(_)) => Ok(self.tcx().ty_error()),
  93
  94             _ => relate::super_relate_tys(self, a, b),
  95         }
  96     }
  97
  98     fn consts(
  99         &mut self,
 100         a: ty::Const<'tcx>,
 101         b: ty::Const<'tcx>,
 102     ) -> RelateResult<'tcx, ty::Const<'tcx>> {
 103         debug!("{}.consts({:?}, {:?})", self.tag(), a, b);
 104         if a == b {
 105             return Ok(a);
 106         }
 107
 108         match (a.kind(), b.kind()) {
 109             (_, ty::ConstKind::Infer(InferConst::Fresh(_))) => {
 110                 return Ok(a);
 111             }
 112
 113             (ty::ConstKind::Infer(_), _) | (_, ty::ConstKind::Infer(_)) => {
 114                 return Err(TypeError::ConstMismatch(relate::expected_found(self, a, b)));
 115             }
 116
 117             _ => {}
 118         }
 119
 120         relate::super_relate_consts(self, a, b)
 121     }
 122
 123     fn binders<T>(
 124         &mut self,
 125         a: ty::Binder<'tcx, T>,
 126         b: ty::Binder<'tcx, T>,
 127     ) -> RelateResult<'tcx, ty::Binder<'tcx, T>>
 128     where
 129         T: Relate<'tcx>,
 130     {
 131         Ok(a.rebind(self.relate(a.skip_binder(), b.skip_binder())?))
 132     }
 133 }