src/librustc/ty/maps/keys.rs

   1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Defines the set of legal keys that can be used in queries.
  12
  13 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE, DefIndex};
  14 use traits::query::{CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal};
  15 use ty::{self, Ty, TyCtxt};
  16 use ty::subst::Substs;
  17 use ty::fast_reject::SimplifiedType;
  18 use mir;
  19
  20 use std::fmt::Debug;
  21 use std::hash::Hash;
  22 use syntax_pos::{Span, DUMMY_SP};
  23 use syntax_pos::symbol::InternedString;
  24
  25 /// The `Key` trait controls what types can legally be used as the key
  26 /// for a query.
  27 pub trait Key: Clone + Hash + Eq + Debug {
  28     /// Given an instance of this key, what crate is it referring to?
  29     /// This is used to find the provider.
  30     fn map_crate(&self) -> CrateNum;
  31
  32     /// In the event that a cycle occurs, if no explicit span has been
  33     /// given for a query with key `self`, what span should we use?
  34     fn default_span(&self, tcx: TyCtxt) -> Span;
  35 }
  36
  37 impl<'tcx> Key for ty::InstanceDef<'tcx> {
  38     fn map_crate(&self) -> CrateNum {
  39         LOCAL_CRATE
  40     }
  41
  42     fn default_span(&self, tcx: TyCtxt) -> Span {
  43         tcx.def_span(self.def_id())
  44     }
  45 }
  46
  47 impl<'tcx> Key for ty::Instance<'tcx> {
  48     fn map_crate(&self) -> CrateNum {
  49         LOCAL_CRATE
  50     }
  51
  52     fn default_span(&self, tcx: TyCtxt) -> Span {
  53         tcx.def_span(self.def_id())
  54     }
  55 }
  56
  57 impl<'tcx> Key for mir::interpret::GlobalId<'tcx> {
  58     fn map_crate(&self) -> CrateNum {
  59         self.instance.map_crate()
  60     }
  61
  62     fn default_span(&self, tcx: TyCtxt) -> Span {
  63         self.instance.default_span(tcx)
  64     }
  65 }
  66
  67 impl Key for CrateNum {
  68     fn map_crate(&self) -> CrateNum {
  69         *self
  70     }
  71     fn default_span(&self, _: TyCtxt) -> Span {
  72         DUMMY_SP
  73     }
  74 }
  75
  76 impl Key for DefIndex {
  77     fn map_crate(&self) -> CrateNum {
  78         LOCAL_CRATE
  79     }
  80     fn default_span(&self, _tcx: TyCtxt) -> Span {
  81         DUMMY_SP
  82     }
  83 }
  84
  85 impl Key for DefId {
  86     fn map_crate(&self) -> CrateNum {
  87         self.krate
  88     }
  89     fn default_span(&self, tcx: TyCtxt) -> Span {
  90         tcx.def_span(*self)
  91     }
  92 }
  93
  94 impl Key for (DefId, DefId) {
  95     fn map_crate(&self) -> CrateNum {
  96         self.0.krate
  97     }
  98     fn default_span(&self, tcx: TyCtxt) -> Span {
  99         self.1.default_span(tcx)
 100     }
 101 }
 102
 103 impl Key for (CrateNum, DefId) {
 104     fn map_crate(&self) -> CrateNum {
 105         self.0
 106     }
 107     fn default_span(&self, tcx: TyCtxt) -> Span {
 108         self.1.default_span(tcx)
 109     }
 110 }
 111
 112 impl Key for (DefId, SimplifiedType) {
 113     fn map_crate(&self) -> CrateNum {
 114         self.0.krate
 115     }
 116     fn default_span(&self, tcx: TyCtxt) -> Span {
 117         self.0.default_span(tcx)
 118     }
 119 }
 120
 121 impl<'tcx> Key for (DefId, &'tcx Substs<'tcx>) {
 122     fn map_crate(&self) -> CrateNum {
 123         self.0.krate
 124     }
 125     fn default_span(&self, tcx: TyCtxt) -> Span {
 126         self.0.default_span(tcx)
 127     }
 128 }
 129
 130 impl<'tcx> Key for (ty::ParamEnv<'tcx>, ty::PolyTraitRef<'tcx>) {
 131     fn map_crate(&self) -> CrateNum {
 132         self.1.def_id().krate
 133     }
 134     fn default_span(&self, tcx: TyCtxt) -> Span {
 135         tcx.def_span(self.1.def_id())
 136     }
 137 }
 138
 139 impl<'tcx> Key for ty::PolyTraitRef<'tcx>{
 140     fn map_crate(&self) -> CrateNum {
 141         self.def_id().krate
 142     }
 143     fn default_span(&self, tcx: TyCtxt) -> Span {
 144         tcx.def_span(self.def_id())
 145     }
 146 }
 147
 148 impl<'tcx> Key for Ty<'tcx> {
 149     fn map_crate(&self) -> CrateNum {
 150         LOCAL_CRATE
 151     }
 152     fn default_span(&self, _: TyCtxt) -> Span {
 153         DUMMY_SP
 154     }
 155 }
 156
 157 impl<'tcx> Key for ty::ParamEnv<'tcx> {
 158     fn map_crate(&self) -> CrateNum {
 159         LOCAL_CRATE
 160     }
 161     fn default_span(&self, _: TyCtxt) -> Span {
 162         DUMMY_SP
 163     }
 164 }
 165
 166 impl<'tcx, T: Key> Key for ty::ParamEnvAnd<'tcx, T> {
 167     fn map_crate(&self) -> CrateNum {
 168         self.value.map_crate()
 169     }
 170     fn default_span(&self, tcx: TyCtxt) -> Span {
 171         self.value.default_span(tcx)
 172     }
 173 }
 174
 175 impl Key for InternedString {
 176     fn map_crate(&self) -> CrateNum {
 177         LOCAL_CRATE
 178     }
 179     fn default_span(&self, _tcx: TyCtxt) -> Span {
 180         DUMMY_SP
 181     }
 182 }
 183
 184 impl<'tcx> Key for CanonicalProjectionGoal<'tcx> {
 185     fn map_crate(&self) -> CrateNum {
 186         LOCAL_CRATE
 187     }
 188
 189     fn default_span(&self, _tcx: TyCtxt) -> Span {
 190         DUMMY_SP
 191     }
 192 }
 193
 194 impl<'tcx> Key for CanonicalTyGoal<'tcx> {
 195     fn map_crate(&self) -> CrateNum {
 196         LOCAL_CRATE
 197     }
 198
 199     fn default_span(&self, _tcx: TyCtxt) -> Span {
 200         DUMMY_SP
 201     }
 202 }
 203
 204 impl<'tcx> Key for CanonicalPredicateGoal<'tcx> {
 205     fn map_crate(&self) -> CrateNum {
 206         LOCAL_CRATE
 207     }
 208
 209     fn default_span(&self, _tcx: TyCtxt) -> Span {
 210         DUMMY_SP
 211     }
 212 }