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