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 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 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     fn param_env(&self) -> ty::ParamEnv<'tcx> {
  40         self.param_env
  41     }
  42     fn a_is_expected(&self) -> bool {
  43         true
  44     } // irrelevant
  45
  46     fn relate_with_variance<T: Relate<'tcx>>(
  47         &mut self,
  48         _: ty::Variance,
  49         a: T,
  50         b: T,
  51     ) -> RelateResult<'tcx, T> {
  52         self.relate(a, b)
  53     }
  54
  55     fn regions(
  56         &mut self,
  57         a: ty::Region<'tcx>,
  58         b: ty::Region<'tcx>,
  59     ) -> RelateResult<'tcx, ty::Region<'tcx>> {
  60         debug!("{}.regions({:?}, {:?})", self.tag(), a, b);
  61         Ok(a)
  62     }
  63
  64     fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
  65         debug!("{}.tys({:?}, {:?})", self.tag(), a, b);
  66         if a == b {
  67             return Ok(a);
  68         }
  69
  70         match (a.kind(), b.kind()) {
  71             (
  72                 _,
  73                 &ty::Infer(ty::FreshTy(_))
  74                 | &ty::Infer(ty::FreshIntTy(_))
  75                 | &ty::Infer(ty::FreshFloatTy(_)),
  76             ) => Ok(a),
  77
  78             (&ty::Infer(_), _) | (_, &ty::Infer(_)) => {
  79                 Err(TypeError::Sorts(relate::expected_found(self, &a, &b)))
  80             }
  81
  82             (&ty::Error(_), _) | (_, &ty::Error(_)) => Ok(self.tcx().ty_error()),
  83
  84             _ => relate::super_relate_tys(self, a, b),
  85         }
  86     }
  87
  88     fn consts(
  89         &mut self,
  90         a: &'tcx ty::Const<'tcx>,
  91         b: &'tcx ty::Const<'tcx>,
  92     ) -> RelateResult<'tcx, &'tcx ty::Const<'tcx>> {
  93         debug!("{}.consts({:?}, {:?})", self.tag(), a, b);
  94         if a == b {
  95             return Ok(a);
  96         }
  97
  98         match (a.val, b.val) {
  99             (_, ty::ConstKind::Infer(InferConst::Fresh(_))) => {
 100                 return Ok(a);
 101             }
 102
 103             (ty::ConstKind::Infer(_), _) | (_, ty::ConstKind::Infer(_)) => {
 104                 return Err(TypeError::ConstMismatch(relate::expected_found(self, &a, &b)));
 105             }
 106
 107             _ => {}
 108         }
 109
 110         relate::super_relate_consts(self, a, b)
 111     }
 112
 113     fn binders<T>(
 114         &mut self,
 115         a: ty::Binder<T>,
 116         b: ty::Binder<T>,
 117     ) -> RelateResult<'tcx, ty::Binder<T>>
 118     where
 119         T: Relate<'tcx>,
 120     {
 121         Ok(ty::Binder::bind(self.relate(a.skip_binder(), b.skip_binder())?))
 122     }
 123 }