src/librustc/ty/maps/config.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 use dep_graph::SerializedDepNodeIndex;
  12 use dep_graph::DepNode;
  13 use hir::def_id::{CrateNum, DefId, DefIndex};
  14 use mir::interpret::{GlobalId, ConstValue};
  15 use traits::query::{CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal};
  16 use ty::{self, ParamEnvAnd, Ty, TyCtxt};
  17 use ty::subst::Substs;
  18 use ty::maps::queries;
  19 use ty::maps::Query;
  20 use ty::maps::QueryMap;
  21
  22 use std::hash::Hash;
  23 use std::fmt::Debug;
  24 use syntax_pos::symbol::InternedString;
  25 use rustc_data_structures::sync::Lock;
  26 use rustc_data_structures::stable_hasher::HashStable;
  27 use ich::StableHashingContext;
  28
  29 /// Query configuration and description traits.
  30
  31 pub trait QueryConfig<'tcx> {
  32     const NAME: &'static str;
  33
  34     type Key: Eq + Hash + Clone + Debug;
  35     type Value: Clone + for<'a> HashStable<StableHashingContext<'a>>;
  36
  37     fn query(key: Self::Key) -> Query<'tcx>;
  38
  39     // Don't use this method to access query results, instead use the methods on TyCtxt
  40     fn query_map<'a>(tcx: TyCtxt<'a, 'tcx, '_>) -> &'a Lock<QueryMap<'tcx, Self>>;
  41
  42     fn to_dep_node(tcx: TyCtxt<'_, 'tcx, '_>, key: &Self::Key) -> DepNode;
  43
  44     // Don't use this method to compute query results, instead use the methods on TyCtxt
  45     fn compute(tcx: TyCtxt<'_, 'tcx, '_>, key: Self::Key) -> Self::Value;
  46
  47     fn handle_cycle_error(tcx: TyCtxt<'_, 'tcx, '_>) -> Self::Value;
  48 }
  49
  50 pub trait QueryDescription<'tcx>: QueryConfig<'tcx> {
  51     fn describe(tcx: TyCtxt, key: Self::Key) -> String;
  52
  53     #[inline]
  54     fn cache_on_disk(_: Self::Key) -> bool {
  55         false
  56     }
  57
  58     fn try_load_from_disk(_: TyCtxt<'_, 'tcx, 'tcx>,
  59                           _: SerializedDepNodeIndex)
  60                           -> Option<Self::Value> {
  61         bug!("QueryDescription::load_from_disk() called for an unsupported query.")
  62     }
  63 }
  64
  65 impl<'tcx, M: QueryConfig<'tcx, Key=DefId>> QueryDescription<'tcx> for M {
  66     default fn describe(tcx: TyCtxt, def_id: DefId) -> String {
  67         if !tcx.sess.verbose() {
  68             format!("processing `{}`", tcx.item_path_str(def_id))
  69         } else {
  70             let name = unsafe { ::std::intrinsics::type_name::<M>() };
  71             format!("processing `{}` applied to `{:?}`", name, def_id)
  72         }
  73     }
  74 }
  75
  76 impl<'tcx> QueryDescription<'tcx> for queries::normalize_projection_ty<'tcx> {
  77     fn describe(
  78         _tcx: TyCtxt,
  79         goal: CanonicalProjectionGoal<'tcx>,
  80     ) -> String {
  81         format!("normalizing `{:?}`", goal)
  82     }
  83 }
  84
  85 impl<'tcx> QueryDescription<'tcx> for queries::dropck_outlives<'tcx> {
  86     fn describe(_tcx: TyCtxt, goal: CanonicalTyGoal<'tcx>) -> String {
  87         format!("computing dropck types for `{:?}`", goal)
  88     }
  89 }
  90
  91 impl<'tcx> QueryDescription<'tcx> for queries::normalize_ty_after_erasing_regions<'tcx> {
  92     fn describe(_tcx: TyCtxt, goal: ParamEnvAnd<'tcx, Ty<'tcx>>) -> String {
  93         format!("normalizing `{:?}`", goal)
  94     }
  95 }
  96
  97 impl<'tcx> QueryDescription<'tcx> for queries::evaluate_obligation<'tcx> {
  98     fn describe(_tcx: TyCtxt, goal: CanonicalPredicateGoal<'tcx>) -> String {
  99         format!("evaluating trait selection obligation `{}`", goal.value.value)
 100     }
 101 }
 102
 103 impl<'tcx> QueryDescription<'tcx> for queries::is_copy_raw<'tcx> {
 104     fn describe(_tcx: TyCtxt, env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> String {
 105         format!("computing whether `{}` is `Copy`", env.value)
 106     }
 107 }
 108
 109 impl<'tcx> QueryDescription<'tcx> for queries::is_sized_raw<'tcx> {
 110     fn describe(_tcx: TyCtxt, env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> String {
 111         format!("computing whether `{}` is `Sized`", env.value)
 112     }
 113 }
 114
 115 impl<'tcx> QueryDescription<'tcx> for queries::is_freeze_raw<'tcx> {
 116     fn describe(_tcx: TyCtxt, env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> String {
 117         format!("computing whether `{}` is freeze", env.value)
 118     }
 119 }
 120
 121 impl<'tcx> QueryDescription<'tcx> for queries::needs_drop_raw<'tcx> {
 122     fn describe(_tcx: TyCtxt, env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> String {
 123         format!("computing whether `{}` needs drop", env.value)
 124     }
 125 }
 126
 127 impl<'tcx> QueryDescription<'tcx> for queries::layout_raw<'tcx> {
 128     fn describe(_tcx: TyCtxt, env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> String {
 129         format!("computing layout of `{}`", env.value)
 130     }
 131 }
 132
 133 impl<'tcx> QueryDescription<'tcx> for queries::super_predicates_of<'tcx> {
 134     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
 135         format!("computing the supertraits of `{}`",
 136                 tcx.item_path_str(def_id))
 137     }
 138 }
 139
 140 impl<'tcx> QueryDescription<'tcx> for queries::const_value_to_allocation<'tcx> {
 141     fn describe(_tcx: TyCtxt, (val, ty): (ConstValue<'tcx>, Ty<'tcx>)) -> String {
 142         format!("converting value `{:?}` ({}) to an allocation", val, ty)
 143     }
 144 }
 145
 146 impl<'tcx> QueryDescription<'tcx> for queries::erase_regions_ty<'tcx> {
 147     fn describe(_tcx: TyCtxt, ty: Ty<'tcx>) -> String {
 148         format!("erasing regions from `{:?}`", ty)
 149     }
 150 }
 151
 152 impl<'tcx> QueryDescription<'tcx> for queries::type_param_predicates<'tcx> {
 153     fn describe(tcx: TyCtxt, (_, def_id): (DefId, DefId)) -> String {
 154         let id = tcx.hir.as_local_node_id(def_id).unwrap();
 155         format!("computing the bounds for type parameter `{}`",
 156                 tcx.hir.ty_param_name(id))
 157     }
 158 }
 159
 160 impl<'tcx> QueryDescription<'tcx> for queries::coherent_trait<'tcx> {
 161     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
 162         format!("coherence checking all impls of trait `{}`",
 163                 tcx.item_path_str(def_id))
 164     }
 165 }
 166
 167 impl<'tcx> QueryDescription<'tcx> for queries::upstream_monomorphizations<'tcx> {
 168     fn describe(_: TyCtxt, k: CrateNum) -> String {
 169         format!("collecting available upstream monomorphizations `{:?}`", k)
 170     }
 171 }
 172
 173 impl<'tcx> QueryDescription<'tcx> for queries::crate_inherent_impls<'tcx> {
 174     fn describe(_: TyCtxt, k: CrateNum) -> String {
 175         format!("all inherent impls defined in crate `{:?}`", k)
 176     }
 177 }
 178
 179 impl<'tcx> QueryDescription<'tcx> for queries::crate_inherent_impls_overlap_check<'tcx> {
 180     fn describe(_: TyCtxt, _: CrateNum) -> String {
 181         format!("check for overlap between inherent impls defined in this crate")
 182     }
 183 }
 184
 185 impl<'tcx> QueryDescription<'tcx> for queries::crate_variances<'tcx> {
 186     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 187         format!("computing the variances for items in this crate")
 188     }
 189 }
 190
 191 impl<'tcx> QueryDescription<'tcx> for queries::inferred_outlives_crate<'tcx> {
 192     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 193         format!("computing the inferred outlives predicates for items in this crate")
 194     }
 195 }
 196
 197 impl<'tcx> QueryDescription<'tcx> for queries::mir_shims<'tcx> {
 198     fn describe(tcx: TyCtxt, def: ty::InstanceDef<'tcx>) -> String {
 199         format!("generating MIR shim for `{}`",
 200                 tcx.item_path_str(def.def_id()))
 201     }
 202 }
 203
 204 impl<'tcx> QueryDescription<'tcx> for queries::privacy_access_levels<'tcx> {
 205     fn describe(_: TyCtxt, _: CrateNum) -> String {
 206         format!("privacy access levels")
 207     }
 208 }
 209
 210 impl<'tcx> QueryDescription<'tcx> for queries::typeck_item_bodies<'tcx> {
 211     fn describe(_: TyCtxt, _: CrateNum) -> String {
 212         format!("type-checking all item bodies")
 213     }
 214 }
 215
 216 impl<'tcx> QueryDescription<'tcx> for queries::reachable_set<'tcx> {
 217     fn describe(_: TyCtxt, _: CrateNum) -> String {
 218         format!("reachability")
 219     }
 220 }
 221
 222 impl<'tcx> QueryDescription<'tcx> for queries::const_eval<'tcx> {
 223     fn describe(tcx: TyCtxt, key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>) -> String {
 224         format!("const-evaluating `{}`", tcx.item_path_str(key.value.instance.def.def_id()))
 225     }
 226
 227     #[inline]
 228     fn cache_on_disk(_key: Self::Key) -> bool {
 229         true
 230     }
 231
 232     #[inline]
 233     fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 234                               id: SerializedDepNodeIndex)
 235                               -> Option<Self::Value> {
 236         tcx.on_disk_query_result_cache.try_load_query_result(tcx, id).map(Ok)
 237     }
 238 }
 239
 240 impl<'tcx> QueryDescription<'tcx> for queries::mir_keys<'tcx> {
 241     fn describe(_: TyCtxt, _: CrateNum) -> String {
 242         format!("getting a list of all mir_keys")
 243     }
 244 }
 245
 246 impl<'tcx> QueryDescription<'tcx> for queries::symbol_name<'tcx> {
 247     fn describe(_tcx: TyCtxt, instance: ty::Instance<'tcx>) -> String {
 248         format!("computing the symbol for `{}`", instance)
 249     }
 250
 251     #[inline]
 252     fn cache_on_disk(_: Self::Key) -> bool {
 253         true
 254     }
 255
 256     #[inline]
 257     fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 258                               id: SerializedDepNodeIndex)
 259                               -> Option<Self::Value> {
 260         tcx.on_disk_query_result_cache.try_load_query_result(tcx, id)
 261     }
 262 }
 263
 264 impl<'tcx> QueryDescription<'tcx> for queries::describe_def<'tcx> {
 265     fn describe(_: TyCtxt, _: DefId) -> String {
 266         bug!("describe_def")
 267     }
 268 }
 269
 270 impl<'tcx> QueryDescription<'tcx> for queries::def_span<'tcx> {
 271     fn describe(_: TyCtxt, _: DefId) -> String {
 272         bug!("def_span")
 273     }
 274 }
 275
 276
 277 impl<'tcx> QueryDescription<'tcx> for queries::lookup_stability<'tcx> {
 278     fn describe(_: TyCtxt, _: DefId) -> String {
 279         bug!("stability")
 280     }
 281 }
 282
 283 impl<'tcx> QueryDescription<'tcx> for queries::lookup_deprecation_entry<'tcx> {
 284     fn describe(_: TyCtxt, _: DefId) -> String {
 285         bug!("deprecation")
 286     }
 287 }
 288
 289 impl<'tcx> QueryDescription<'tcx> for queries::item_attrs<'tcx> {
 290     fn describe(_: TyCtxt, _: DefId) -> String {
 291         bug!("item_attrs")
 292     }
 293 }
 294
 295 impl<'tcx> QueryDescription<'tcx> for queries::is_reachable_non_generic<'tcx> {
 296     fn describe(_: TyCtxt, _: DefId) -> String {
 297         bug!("is_reachable_non_generic")
 298     }
 299 }
 300
 301 impl<'tcx> QueryDescription<'tcx> for queries::fn_arg_names<'tcx> {
 302     fn describe(_: TyCtxt, _: DefId) -> String {
 303         bug!("fn_arg_names")
 304     }
 305 }
 306
 307 impl<'tcx> QueryDescription<'tcx> for queries::impl_parent<'tcx> {
 308     fn describe(_: TyCtxt, _: DefId) -> String {
 309         bug!("impl_parent")
 310     }
 311 }
 312
 313 impl<'tcx> QueryDescription<'tcx> for queries::trait_of_item<'tcx> {
 314     fn describe(_: TyCtxt, _: DefId) -> String {
 315         bug!("trait_of_item")
 316     }
 317 }
 318
 319 impl<'tcx> QueryDescription<'tcx> for queries::const_is_rvalue_promotable_to_static<'tcx> {
 320     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
 321         format!("const checking if rvalue is promotable to static `{}`",
 322             tcx.item_path_str(def_id))
 323     }
 324
 325     #[inline]
 326     fn cache_on_disk(_: Self::Key) -> bool {
 327         true
 328     }
 329
 330     #[inline]
 331     fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 332                           id: SerializedDepNodeIndex)
 333                           -> Option<Self::Value> {
 334         tcx.on_disk_query_result_cache.try_load_query_result(tcx, id)
 335     }
 336 }
 337
 338 impl<'tcx> QueryDescription<'tcx> for queries::rvalue_promotable_map<'tcx> {
 339     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
 340         format!("checking which parts of `{}` are promotable to static",
 341                 tcx.item_path_str(def_id))
 342     }
 343 }
 344
 345 impl<'tcx> QueryDescription<'tcx> for queries::is_mir_available<'tcx> {
 346     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
 347         format!("checking if item is mir available: `{}`",
 348             tcx.item_path_str(def_id))
 349     }
 350 }
 351
 352 impl<'tcx> QueryDescription<'tcx> for queries::trans_fulfill_obligation<'tcx> {
 353     fn describe(tcx: TyCtxt, key: (ty::ParamEnv<'tcx>, ty::PolyTraitRef<'tcx>)) -> String {
 354         format!("checking if `{}` fulfills its obligations", tcx.item_path_str(key.1.def_id()))
 355     }
 356
 357     #[inline]
 358     fn cache_on_disk(_: Self::Key) -> bool {
 359         true
 360     }
 361
 362     #[inline]
 363     fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 364                               id: SerializedDepNodeIndex)
 365                               -> Option<Self::Value> {
 366         tcx.on_disk_query_result_cache.try_load_query_result(tcx, id)
 367     }
 368 }
 369
 370 impl<'tcx> QueryDescription<'tcx> for queries::trait_impls_of<'tcx> {
 371     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
 372         format!("trait impls of `{}`", tcx.item_path_str(def_id))
 373     }
 374 }
 375
 376 impl<'tcx> QueryDescription<'tcx> for queries::is_object_safe<'tcx> {
 377     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
 378         format!("determine object safety of trait `{}`", tcx.item_path_str(def_id))
 379     }
 380 }
 381
 382 impl<'tcx> QueryDescription<'tcx> for queries::is_const_fn<'tcx> {
 383     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
 384         format!("checking if item is const fn: `{}`", tcx.item_path_str(def_id))
 385     }
 386 }
 387
 388 impl<'tcx> QueryDescription<'tcx> for queries::dylib_dependency_formats<'tcx> {
 389     fn describe(_: TyCtxt, _: CrateNum) -> String {
 390         "dylib dependency formats of crate".to_string()
 391     }
 392 }
 393
 394 impl<'tcx> QueryDescription<'tcx> for queries::is_panic_runtime<'tcx> {
 395     fn describe(_: TyCtxt, _: CrateNum) -> String {
 396         "checking if the crate is_panic_runtime".to_string()
 397     }
 398 }
 399
 400 impl<'tcx> QueryDescription<'tcx> for queries::is_compiler_builtins<'tcx> {
 401     fn describe(_: TyCtxt, _: CrateNum) -> String {
 402         "checking if the crate is_compiler_builtins".to_string()
 403     }
 404 }
 405
 406 impl<'tcx> QueryDescription<'tcx> for queries::has_global_allocator<'tcx> {
 407     fn describe(_: TyCtxt, _: CrateNum) -> String {
 408         "checking if the crate has_global_allocator".to_string()
 409     }
 410 }
 411
 412 impl<'tcx> QueryDescription<'tcx> for queries::extern_crate<'tcx> {
 413     fn describe(_: TyCtxt, _: DefId) -> String {
 414         "getting crate's ExternCrateData".to_string()
 415     }
 416 }
 417
 418 impl<'tcx> QueryDescription<'tcx> for queries::lint_levels<'tcx> {
 419     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 420         format!("computing the lint levels for items in this crate")
 421     }
 422 }
 423
 424 impl<'tcx> QueryDescription<'tcx> for queries::specializes<'tcx> {
 425     fn describe(_tcx: TyCtxt, _: (DefId, DefId)) -> String {
 426         format!("computing whether impls specialize one another")
 427     }
 428 }
 429
 430 impl<'tcx> QueryDescription<'tcx> for queries::in_scope_traits_map<'tcx> {
 431     fn describe(_tcx: TyCtxt, _: DefIndex) -> String {
 432         format!("traits in scope at a block")
 433     }
 434 }
 435
 436 impl<'tcx> QueryDescription<'tcx> for queries::is_no_builtins<'tcx> {
 437     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 438         format!("test whether a crate has #![no_builtins]")
 439     }
 440 }
 441
 442 impl<'tcx> QueryDescription<'tcx> for queries::panic_strategy<'tcx> {
 443     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 444         format!("query a crate's configured panic strategy")
 445     }
 446 }
 447
 448 impl<'tcx> QueryDescription<'tcx> for queries::is_profiler_runtime<'tcx> {
 449     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 450         format!("query a crate is #![profiler_runtime]")
 451     }
 452 }
 453
 454 impl<'tcx> QueryDescription<'tcx> for queries::is_sanitizer_runtime<'tcx> {
 455     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 456         format!("query a crate is #![sanitizer_runtime]")
 457     }
 458 }
 459
 460 impl<'tcx> QueryDescription<'tcx> for queries::reachable_non_generics<'tcx> {
 461     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 462         format!("looking up the exported symbols of a crate")
 463     }
 464 }
 465
 466 impl<'tcx> QueryDescription<'tcx> for queries::native_libraries<'tcx> {
 467     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 468         format!("looking up the native libraries of a linked crate")
 469     }
 470 }
 471
 472 impl<'tcx> QueryDescription<'tcx> for queries::foreign_modules<'tcx> {
 473     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 474         format!("looking up the foreign modules of a linked crate")
 475     }
 476 }
 477
 478 impl<'tcx> QueryDescription<'tcx> for queries::plugin_registrar_fn<'tcx> {
 479     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 480         format!("looking up the plugin registrar for a crate")
 481     }
 482 }
 483
 484 impl<'tcx> QueryDescription<'tcx> for queries::derive_registrar_fn<'tcx> {
 485     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 486         format!("looking up the derive registrar for a crate")
 487     }
 488 }
 489
 490 impl<'tcx> QueryDescription<'tcx> for queries::crate_disambiguator<'tcx> {
 491     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 492         format!("looking up the disambiguator a crate")
 493     }
 494 }
 495
 496 impl<'tcx> QueryDescription<'tcx> for queries::crate_hash<'tcx> {
 497     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 498         format!("looking up the hash a crate")
 499     }
 500 }
 501
 502 impl<'tcx> QueryDescription<'tcx> for queries::original_crate_name<'tcx> {
 503     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 504         format!("looking up the original name a crate")
 505     }
 506 }
 507
 508 impl<'tcx> QueryDescription<'tcx> for queries::extra_filename<'tcx> {
 509     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 510         format!("looking up the extra filename for a crate")
 511     }
 512 }
 513
 514 impl<'tcx> QueryDescription<'tcx> for queries::implementations_of_trait<'tcx> {
 515     fn describe(_tcx: TyCtxt, _: (CrateNum, DefId)) -> String {
 516         format!("looking up implementations of a trait in a crate")
 517     }
 518 }
 519
 520 impl<'tcx> QueryDescription<'tcx> for queries::all_trait_implementations<'tcx> {
 521     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 522         format!("looking up all (?) trait implementations")
 523     }
 524 }
 525
 526 impl<'tcx> QueryDescription<'tcx> for queries::link_args<'tcx> {
 527     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 528         format!("looking up link arguments for a crate")
 529     }
 530 }
 531
 532 impl<'tcx> QueryDescription<'tcx> for queries::resolve_lifetimes<'tcx> {
 533     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 534         format!("resolving lifetimes")
 535     }
 536 }
 537
 538 impl<'tcx> QueryDescription<'tcx> for queries::named_region_map<'tcx> {
 539     fn describe(_tcx: TyCtxt, _: DefIndex) -> String {
 540         format!("looking up a named region")
 541     }
 542 }
 543
 544 impl<'tcx> QueryDescription<'tcx> for queries::is_late_bound_map<'tcx> {
 545     fn describe(_tcx: TyCtxt, _: DefIndex) -> String {
 546         format!("testing if a region is late boudn")
 547     }
 548 }
 549
 550 impl<'tcx> QueryDescription<'tcx> for queries::object_lifetime_defaults_map<'tcx> {
 551     fn describe(_tcx: TyCtxt, _: DefIndex) -> String {
 552         format!("looking up lifetime defaults for a region")
 553     }
 554 }
 555
 556 impl<'tcx> QueryDescription<'tcx> for queries::dep_kind<'tcx> {
 557     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 558         format!("fetching what a dependency looks like")
 559     }
 560 }
 561
 562 impl<'tcx> QueryDescription<'tcx> for queries::crate_name<'tcx> {
 563     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 564         format!("fetching what a crate is named")
 565     }
 566 }
 567
 568 impl<'tcx> QueryDescription<'tcx> for queries::get_lang_items<'tcx> {
 569     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 570         format!("calculating the lang items map")
 571     }
 572 }
 573
 574 impl<'tcx> QueryDescription<'tcx> for queries::defined_lang_items<'tcx> {
 575     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 576         format!("calculating the lang items defined in a crate")
 577     }
 578 }
 579
 580 impl<'tcx> QueryDescription<'tcx> for queries::missing_lang_items<'tcx> {
 581     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 582         format!("calculating the missing lang items in a crate")
 583     }
 584 }
 585
 586 impl<'tcx> QueryDescription<'tcx> for queries::visible_parent_map<'tcx> {
 587     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 588         format!("calculating the visible parent map")
 589     }
 590 }
 591
 592 impl<'tcx> QueryDescription<'tcx> for queries::missing_extern_crate_item<'tcx> {
 593     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 594         format!("seeing if we're missing an `extern crate` item for this crate")
 595     }
 596 }
 597
 598 impl<'tcx> QueryDescription<'tcx> for queries::used_crate_source<'tcx> {
 599     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 600         format!("looking at the source for a crate")
 601     }
 602 }
 603
 604 impl<'tcx> QueryDescription<'tcx> for queries::postorder_cnums<'tcx> {
 605     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 606         format!("generating a postorder list of CrateNums")
 607     }
 608 }
 609
 610 impl<'tcx> QueryDescription<'tcx> for queries::maybe_unused_extern_crates<'tcx> {
 611     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 612         format!("looking up all possibly unused extern crates")
 613     }
 614 }
 615
 616 impl<'tcx> QueryDescription<'tcx> for queries::stability_index<'tcx> {
 617     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 618         format!("calculating the stability index for the local crate")
 619     }
 620 }
 621
 622 impl<'tcx> QueryDescription<'tcx> for queries::all_traits<'tcx> {
 623     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 624         format!("fetching all foreign and local traits")
 625     }
 626 }
 627
 628 impl<'tcx> QueryDescription<'tcx> for queries::all_crate_nums<'tcx> {
 629     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 630         format!("fetching all foreign CrateNum instances")
 631     }
 632 }
 633
 634 impl<'tcx> QueryDescription<'tcx> for queries::exported_symbols<'tcx> {
 635     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 636         format!("exported_symbols")
 637     }
 638 }
 639
 640 impl<'tcx> QueryDescription<'tcx> for queries::collect_and_partition_translation_items<'tcx> {
 641     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 642         format!("collect_and_partition_translation_items")
 643     }
 644 }
 645
 646 impl<'tcx> QueryDescription<'tcx> for queries::codegen_unit<'tcx> {
 647     fn describe(_tcx: TyCtxt, _: InternedString) -> String {
 648         format!("codegen_unit")
 649     }
 650 }
 651
 652 impl<'tcx> QueryDescription<'tcx> for queries::compile_codegen_unit<'tcx> {
 653     fn describe(_tcx: TyCtxt, _: InternedString) -> String {
 654         format!("compile_codegen_unit")
 655     }
 656 }
 657
 658 impl<'tcx> QueryDescription<'tcx> for queries::output_filenames<'tcx> {
 659     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 660         format!("output_filenames")
 661     }
 662 }
 663
 664 impl<'tcx> QueryDescription<'tcx> for queries::vtable_methods<'tcx> {
 665     fn describe(tcx: TyCtxt, key: ty::PolyTraitRef<'tcx> ) -> String {
 666         format!("finding all methods for trait {}", tcx.item_path_str(key.def_id()))
 667     }
 668 }
 669
 670 impl<'tcx> QueryDescription<'tcx> for queries::features_query<'tcx> {
 671     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 672         format!("looking up enabled feature gates")
 673     }
 674 }
 675
 676 impl<'tcx> QueryDescription<'tcx> for queries::typeck_tables_of<'tcx> {
 677     #[inline]
 678     fn cache_on_disk(def_id: Self::Key) -> bool {
 679         def_id.is_local()
 680     }
 681
 682     fn try_load_from_disk(tcx: TyCtxt<'_, 'tcx, 'tcx>,
 683                           id: SerializedDepNodeIndex)
 684                           -> Option<Self::Value> {
 685         let typeck_tables: Option<ty::TypeckTables<'tcx>> = tcx
 686             .on_disk_query_result_cache
 687             .try_load_query_result(tcx, id);
 688
 689         typeck_tables.map(|tables| tcx.alloc_tables(tables))
 690     }
 691 }
 692
 693 impl<'tcx> QueryDescription<'tcx> for queries::optimized_mir<'tcx> {
 694     #[inline]
 695     fn cache_on_disk(def_id: Self::Key) -> bool {
 696         def_id.is_local()
 697     }
 698
 699     fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 700                               id: SerializedDepNodeIndex)
 701                               -> Option<Self::Value> {
 702         let mir: Option<::mir::Mir<'tcx>> = tcx.on_disk_query_result_cache
 703                                                .try_load_query_result(tcx, id);
 704         mir.map(|x| tcx.alloc_mir(x))
 705     }
 706 }
 707
 708 impl<'tcx> QueryDescription<'tcx> for queries::substitute_normalize_and_test_predicates<'tcx> {
 709     fn describe(tcx: TyCtxt, key: (DefId, &'tcx Substs<'tcx>)) -> String {
 710         format!("testing substituted normalized predicates:`{}`", tcx.item_path_str(key.0))
 711     }
 712 }
 713
 714 impl<'tcx> QueryDescription<'tcx> for queries::target_features_whitelist<'tcx> {
 715     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 716         format!("looking up the whitelist of target features")
 717     }
 718 }
 719
 720 impl<'tcx> QueryDescription<'tcx> for queries::instance_def_size_estimate<'tcx> {
 721     fn describe(tcx: TyCtxt, def: ty::InstanceDef<'tcx>) -> String {
 722         format!("estimating size for `{}`", tcx.item_path_str(def.def_id()))
 723     }
 724 }
 725
 726 impl<'tcx> QueryDescription<'tcx> for queries::wasm_custom_sections<'tcx> {
 727     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 728         format!("custom wasm sections for a crate")
 729     }
 730 }
 731
 732 impl<'tcx> QueryDescription<'tcx> for queries::generics_of<'tcx> {
 733     #[inline]
 734     fn cache_on_disk(def_id: Self::Key) -> bool {
 735         def_id.is_local()
 736     }
 737
 738     fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 739                               id: SerializedDepNodeIndex)
 740                               -> Option<Self::Value> {
 741         let generics: Option<ty::Generics> = tcx.on_disk_query_result_cache
 742                                                 .try_load_query_result(tcx, id);
 743         generics.map(|x| tcx.alloc_generics(x))
 744     }
 745 }
 746
 747 impl<'tcx> QueryDescription<'tcx> for queries::program_clauses_for<'tcx> {
 748     fn describe(_tcx: TyCtxt, _: DefId) -> String {
 749         format!("generating chalk-style clauses")
 750     }
 751 }
 752
 753 impl<'tcx> QueryDescription<'tcx> for queries::program_clauses_for_env<'tcx> {
 754     fn describe(_tcx: TyCtxt, _: ty::ParamEnv<'tcx>) -> String {
 755         format!("generating chalk-style clauses for param env")
 756     }
 757 }
 758
 759 impl<'tcx> QueryDescription<'tcx> for queries::wasm_import_module_map<'tcx> {
 760     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 761         format!("wasm import module map")
 762     }
 763 }
 764
 765 impl<'tcx> QueryDescription<'tcx> for queries::dllimport_foreign_items<'tcx> {
 766     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 767         format!("wasm import module map")
 768     }
 769 }
 770
 771 macro_rules! impl_disk_cacheable_query(
 772     ($query_name:ident, |$key:tt| $cond:expr) => {
 773         impl<'tcx> QueryDescription<'tcx> for queries::$query_name<'tcx> {
 774             #[inline]
 775             fn cache_on_disk($key: Self::Key) -> bool {
 776                 $cond
 777             }
 778
 779             #[inline]
 780             fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 781                                       id: SerializedDepNodeIndex)
 782                                       -> Option<Self::Value> {
 783                 tcx.on_disk_query_result_cache.try_load_query_result(tcx, id)
 784             }
 785         }
 786     }
 787 );
 788
 789 impl_disk_cacheable_query!(unsafety_check_result, |def_id| def_id.is_local());
 790 impl_disk_cacheable_query!(borrowck, |def_id| def_id.is_local());
 791 impl_disk_cacheable_query!(mir_borrowck, |def_id| def_id.is_local());
 792 impl_disk_cacheable_query!(mir_const_qualif, |def_id| def_id.is_local());
 793 impl_disk_cacheable_query!(check_match, |def_id| def_id.is_local());
 794 impl_disk_cacheable_query!(def_symbol_name, |_| true);
 795 impl_disk_cacheable_query!(type_of, |def_id| def_id.is_local());
 796 impl_disk_cacheable_query!(predicates_of, |def_id| def_id.is_local());
 797 impl_disk_cacheable_query!(used_trait_imports, |def_id| def_id.is_local());
 798 impl_disk_cacheable_query!(trans_fn_attrs, |_| true);
 799 impl_disk_cacheable_query!(specialization_graph_of, |_| true);