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 hir::def_id::{CrateNum, DefId, DefIndex};
  12 use ty::{self, Ty, TyCtxt};
  13 use ty::maps::queries;
  14 use ty::subst::Substs;
  15
  16 use std::hash::Hash;
  17 use syntax_pos::symbol::InternedString;
  18
  19 /// Query configuration and description traits.
  20
  21 pub trait QueryConfig {
  22     type Key: Eq + Hash + Clone;
  23     type Value;
  24 }
  25
  26 pub(super) trait QueryDescription: QueryConfig {
  27     fn describe(tcx: TyCtxt, key: Self::Key) -> String;
  28 }
  29
  30 impl<M: QueryConfig<Key=DefId>> QueryDescription for M {
  31     default fn describe(tcx: TyCtxt, def_id: DefId) -> String {
  32         if !tcx.sess.verbose() {
  33             format!("processing `{}`", tcx.item_path_str(def_id))
  34         } else {
  35             let name = unsafe { ::std::intrinsics::type_name::<M>() };
  36             format!("processing `{}` applied to `{:?}`", name, def_id)
  37         }
  38     }
  39 }
  40
  41 impl<'tcx> QueryDescription for queries::is_copy_raw<'tcx> {
  42     fn describe(_tcx: TyCtxt, env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> String {
  43         format!("computing whether `{}` is `Copy`", env.value)
  44     }
  45 }
  46
  47 impl<'tcx> QueryDescription for queries::is_sized_raw<'tcx> {
  48     fn describe(_tcx: TyCtxt, env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> String {
  49         format!("computing whether `{}` is `Sized`", env.value)
  50     }
  51 }
  52
  53 impl<'tcx> QueryDescription for queries::is_freeze_raw<'tcx> {
  54     fn describe(_tcx: TyCtxt, env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> String {
  55         format!("computing whether `{}` is freeze", env.value)
  56     }
  57 }
  58
  59 impl<'tcx> QueryDescription for queries::needs_drop_raw<'tcx> {
  60     fn describe(_tcx: TyCtxt, env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> String {
  61         format!("computing whether `{}` needs drop", env.value)
  62     }
  63 }
  64
  65 impl<'tcx> QueryDescription for queries::layout_raw<'tcx> {
  66     fn describe(_tcx: TyCtxt, env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> String {
  67         format!("computing layout of `{}`", env.value)
  68     }
  69 }
  70
  71 impl<'tcx> QueryDescription for queries::super_predicates_of<'tcx> {
  72     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
  73         format!("computing the supertraits of `{}`",
  74                 tcx.item_path_str(def_id))
  75     }
  76 }
  77
  78 impl<'tcx> QueryDescription for queries::erase_regions_ty<'tcx> {
  79     fn describe(_tcx: TyCtxt, ty: Ty<'tcx>) -> String {
  80         format!("erasing regions from `{:?}`", ty)
  81     }
  82 }
  83
  84 impl<'tcx> QueryDescription for queries::type_param_predicates<'tcx> {
  85     fn describe(tcx: TyCtxt, (_, def_id): (DefId, DefId)) -> String {
  86         let id = tcx.hir.as_local_node_id(def_id).unwrap();
  87         format!("computing the bounds for type parameter `{}`",
  88                 tcx.hir.ty_param_name(id))
  89     }
  90 }
  91
  92 impl<'tcx> QueryDescription for queries::coherent_trait<'tcx> {
  93     fn describe(tcx: TyCtxt, (_, def_id): (CrateNum, DefId)) -> String {
  94         format!("coherence checking all impls of trait `{}`",
  95                 tcx.item_path_str(def_id))
  96     }
  97 }
  98
  99 impl<'tcx> QueryDescription for queries::crate_inherent_impls<'tcx> {
 100     fn describe(_: TyCtxt, k: CrateNum) -> String {
 101         format!("all inherent impls defined in crate `{:?}`", k)
 102     }
 103 }
 104
 105 impl<'tcx> QueryDescription for queries::crate_inherent_impls_overlap_check<'tcx> {
 106     fn describe(_: TyCtxt, _: CrateNum) -> String {
 107         format!("check for overlap between inherent impls defined in this crate")
 108     }
 109 }
 110
 111 impl<'tcx> QueryDescription for queries::crate_variances<'tcx> {
 112     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 113         format!("computing the variances for items in this crate")
 114     }
 115 }
 116
 117 impl<'tcx> QueryDescription for queries::mir_shims<'tcx> {
 118     fn describe(tcx: TyCtxt, def: ty::InstanceDef<'tcx>) -> String {
 119         format!("generating MIR shim for `{}`",
 120                 tcx.item_path_str(def.def_id()))
 121     }
 122 }
 123
 124 impl<'tcx> QueryDescription for queries::privacy_access_levels<'tcx> {
 125     fn describe(_: TyCtxt, _: CrateNum) -> String {
 126         format!("privacy access levels")
 127     }
 128 }
 129
 130 impl<'tcx> QueryDescription for queries::typeck_item_bodies<'tcx> {
 131     fn describe(_: TyCtxt, _: CrateNum) -> String {
 132         format!("type-checking all item bodies")
 133     }
 134 }
 135
 136 impl<'tcx> QueryDescription for queries::reachable_set<'tcx> {
 137     fn describe(_: TyCtxt, _: CrateNum) -> String {
 138         format!("reachability")
 139     }
 140 }
 141
 142 impl<'tcx> QueryDescription for queries::const_eval<'tcx> {
 143     fn describe(tcx: TyCtxt, key: ty::ParamEnvAnd<'tcx, (DefId, &'tcx Substs<'tcx>)>) -> String {
 144         format!("const-evaluating `{}`", tcx.item_path_str(key.value.0))
 145     }
 146 }
 147
 148 impl<'tcx> QueryDescription for queries::mir_keys<'tcx> {
 149     fn describe(_: TyCtxt, _: CrateNum) -> String {
 150         format!("getting a list of all mir_keys")
 151     }
 152 }
 153
 154 impl<'tcx> QueryDescription for queries::symbol_name<'tcx> {
 155     fn describe(_tcx: TyCtxt, instance: ty::Instance<'tcx>) -> String {
 156         format!("computing the symbol for `{}`", instance)
 157     }
 158 }
 159
 160 impl<'tcx> QueryDescription for queries::describe_def<'tcx> {
 161     fn describe(_: TyCtxt, _: DefId) -> String {
 162         bug!("describe_def")
 163     }
 164 }
 165
 166 impl<'tcx> QueryDescription for queries::def_span<'tcx> {
 167     fn describe(_: TyCtxt, _: DefId) -> String {
 168         bug!("def_span")
 169     }
 170 }
 171
 172
 173 impl<'tcx> QueryDescription for queries::lookup_stability<'tcx> {
 174     fn describe(_: TyCtxt, _: DefId) -> String {
 175         bug!("stability")
 176     }
 177 }
 178
 179 impl<'tcx> QueryDescription for queries::lookup_deprecation_entry<'tcx> {
 180     fn describe(_: TyCtxt, _: DefId) -> String {
 181         bug!("deprecation")
 182     }
 183 }
 184
 185 impl<'tcx> QueryDescription for queries::item_attrs<'tcx> {
 186     fn describe(_: TyCtxt, _: DefId) -> String {
 187         bug!("item_attrs")
 188     }
 189 }
 190
 191 impl<'tcx> QueryDescription for queries::is_exported_symbol<'tcx> {
 192     fn describe(_: TyCtxt, _: DefId) -> String {
 193         bug!("is_exported_symbol")
 194     }
 195 }
 196
 197 impl<'tcx> QueryDescription for queries::fn_arg_names<'tcx> {
 198     fn describe(_: TyCtxt, _: DefId) -> String {
 199         bug!("fn_arg_names")
 200     }
 201 }
 202
 203 impl<'tcx> QueryDescription for queries::impl_parent<'tcx> {
 204     fn describe(_: TyCtxt, _: DefId) -> String {
 205         bug!("impl_parent")
 206     }
 207 }
 208
 209 impl<'tcx> QueryDescription for queries::trait_of_item<'tcx> {
 210     fn describe(_: TyCtxt, _: DefId) -> String {
 211         bug!("trait_of_item")
 212     }
 213 }
 214
 215 impl<'tcx> QueryDescription for queries::item_body_nested_bodies<'tcx> {
 216     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
 217         format!("nested item bodies of `{}`", tcx.item_path_str(def_id))
 218     }
 219 }
 220
 221 impl<'tcx> QueryDescription for queries::const_is_rvalue_promotable_to_static<'tcx> {
 222     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
 223         format!("const checking if rvalue is promotable to static `{}`",
 224             tcx.item_path_str(def_id))
 225     }
 226 }
 227
 228 impl<'tcx> QueryDescription for queries::rvalue_promotable_map<'tcx> {
 229     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
 230         format!("checking which parts of `{}` are promotable to static",
 231                 tcx.item_path_str(def_id))
 232     }
 233 }
 234
 235 impl<'tcx> QueryDescription for queries::is_mir_available<'tcx> {
 236     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
 237         format!("checking if item is mir available: `{}`",
 238             tcx.item_path_str(def_id))
 239     }
 240 }
 241
 242 impl<'tcx> QueryDescription for queries::trans_fulfill_obligation<'tcx> {
 243     fn describe(tcx: TyCtxt, key: (ty::ParamEnv<'tcx>, ty::PolyTraitRef<'tcx>)) -> String {
 244         format!("checking if `{}` fulfills its obligations", tcx.item_path_str(key.1.def_id()))
 245     }
 246 }
 247
 248 impl<'tcx> QueryDescription for queries::trait_impls_of<'tcx> {
 249     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
 250         format!("trait impls of `{}`", tcx.item_path_str(def_id))
 251     }
 252 }
 253
 254 impl<'tcx> QueryDescription for queries::is_object_safe<'tcx> {
 255     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
 256         format!("determine object safety of trait `{}`", tcx.item_path_str(def_id))
 257     }
 258 }
 259
 260 impl<'tcx> QueryDescription for queries::is_const_fn<'tcx> {
 261     fn describe(tcx: TyCtxt, def_id: DefId) -> String {
 262         format!("checking if item is const fn: `{}`", tcx.item_path_str(def_id))
 263     }
 264 }
 265
 266 impl<'tcx> QueryDescription for queries::dylib_dependency_formats<'tcx> {
 267     fn describe(_: TyCtxt, _: CrateNum) -> String {
 268         "dylib dependency formats of crate".to_string()
 269     }
 270 }
 271
 272 impl<'tcx> QueryDescription for queries::is_panic_runtime<'tcx> {
 273     fn describe(_: TyCtxt, _: CrateNum) -> String {
 274         "checking if the crate is_panic_runtime".to_string()
 275     }
 276 }
 277
 278 impl<'tcx> QueryDescription for queries::is_compiler_builtins<'tcx> {
 279     fn describe(_: TyCtxt, _: CrateNum) -> String {
 280         "checking if the crate is_compiler_builtins".to_string()
 281     }
 282 }
 283
 284 impl<'tcx> QueryDescription for queries::has_global_allocator<'tcx> {
 285     fn describe(_: TyCtxt, _: CrateNum) -> String {
 286         "checking if the crate has_global_allocator".to_string()
 287     }
 288 }
 289
 290 impl<'tcx> QueryDescription for queries::extern_crate<'tcx> {
 291     fn describe(_: TyCtxt, _: DefId) -> String {
 292         "getting crate's ExternCrateData".to_string()
 293     }
 294 }
 295
 296 impl<'tcx> QueryDescription for queries::lint_levels<'tcx> {
 297     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 298         format!("computing the lint levels for items in this crate")
 299     }
 300 }
 301
 302 impl<'tcx> QueryDescription for queries::specializes<'tcx> {
 303     fn describe(_tcx: TyCtxt, _: (DefId, DefId)) -> String {
 304         format!("computing whether impls specialize one another")
 305     }
 306 }
 307
 308 impl<'tcx> QueryDescription for queries::in_scope_traits_map<'tcx> {
 309     fn describe(_tcx: TyCtxt, _: DefIndex) -> String {
 310         format!("traits in scope at a block")
 311     }
 312 }
 313
 314 impl<'tcx> QueryDescription for queries::is_no_builtins<'tcx> {
 315     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 316         format!("test whether a crate has #![no_builtins]")
 317     }
 318 }
 319
 320 impl<'tcx> QueryDescription for queries::panic_strategy<'tcx> {
 321     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 322         format!("query a crate's configured panic strategy")
 323     }
 324 }
 325
 326 impl<'tcx> QueryDescription for queries::is_profiler_runtime<'tcx> {
 327     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 328         format!("query a crate is #![profiler_runtime]")
 329     }
 330 }
 331
 332 impl<'tcx> QueryDescription for queries::is_sanitizer_runtime<'tcx> {
 333     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 334         format!("query a crate is #![sanitizer_runtime]")
 335     }
 336 }
 337
 338 impl<'tcx> QueryDescription for queries::exported_symbol_ids<'tcx> {
 339     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 340         format!("looking up the exported symbols of a crate")
 341     }
 342 }
 343
 344 impl<'tcx> QueryDescription for queries::native_libraries<'tcx> {
 345     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 346         format!("looking up the native libraries of a linked crate")
 347     }
 348 }
 349
 350 impl<'tcx> QueryDescription for queries::plugin_registrar_fn<'tcx> {
 351     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 352         format!("looking up the plugin registrar for a crate")
 353     }
 354 }
 355
 356 impl<'tcx> QueryDescription for queries::derive_registrar_fn<'tcx> {
 357     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 358         format!("looking up the derive registrar for a crate")
 359     }
 360 }
 361
 362 impl<'tcx> QueryDescription for queries::crate_disambiguator<'tcx> {
 363     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 364         format!("looking up the disambiguator a crate")
 365     }
 366 }
 367
 368 impl<'tcx> QueryDescription for queries::crate_hash<'tcx> {
 369     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 370         format!("looking up the hash a crate")
 371     }
 372 }
 373
 374 impl<'tcx> QueryDescription for queries::original_crate_name<'tcx> {
 375     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 376         format!("looking up the original name a crate")
 377     }
 378 }
 379
 380 impl<'tcx> QueryDescription for queries::implementations_of_trait<'tcx> {
 381     fn describe(_tcx: TyCtxt, _: (CrateNum, DefId)) -> String {
 382         format!("looking up implementations of a trait in a crate")
 383     }
 384 }
 385
 386 impl<'tcx> QueryDescription for queries::all_trait_implementations<'tcx> {
 387     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 388         format!("looking up all (?) trait implementations")
 389     }
 390 }
 391
 392 impl<'tcx> QueryDescription for queries::link_args<'tcx> {
 393     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 394         format!("looking up link arguments for a crate")
 395     }
 396 }
 397
 398 impl<'tcx> QueryDescription for queries::named_region_map<'tcx> {
 399     fn describe(_tcx: TyCtxt, _: DefIndex) -> String {
 400         format!("looking up a named region")
 401     }
 402 }
 403
 404 impl<'tcx> QueryDescription for queries::is_late_bound_map<'tcx> {
 405     fn describe(_tcx: TyCtxt, _: DefIndex) -> String {
 406         format!("testing if a region is late boudn")
 407     }
 408 }
 409
 410 impl<'tcx> QueryDescription for queries::object_lifetime_defaults_map<'tcx> {
 411     fn describe(_tcx: TyCtxt, _: DefIndex) -> String {
 412         format!("looking up lifetime defaults for a region")
 413     }
 414 }
 415
 416 impl<'tcx> QueryDescription for queries::dep_kind<'tcx> {
 417     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 418         format!("fetching what a dependency looks like")
 419     }
 420 }
 421
 422 impl<'tcx> QueryDescription for queries::crate_name<'tcx> {
 423     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 424         format!("fetching what a crate is named")
 425     }
 426 }
 427
 428 impl<'tcx> QueryDescription for queries::get_lang_items<'tcx> {
 429     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 430         format!("calculating the lang items map")
 431     }
 432 }
 433
 434 impl<'tcx> QueryDescription for queries::defined_lang_items<'tcx> {
 435     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 436         format!("calculating the lang items defined in a crate")
 437     }
 438 }
 439
 440 impl<'tcx> QueryDescription for queries::missing_lang_items<'tcx> {
 441     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 442         format!("calculating the missing lang items in a crate")
 443     }
 444 }
 445
 446 impl<'tcx> QueryDescription for queries::visible_parent_map<'tcx> {
 447     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 448         format!("calculating the visible parent map")
 449     }
 450 }
 451
 452 impl<'tcx> QueryDescription for queries::missing_extern_crate_item<'tcx> {
 453     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 454         format!("seeing if we're missing an `extern crate` item for this crate")
 455     }
 456 }
 457
 458 impl<'tcx> QueryDescription for queries::used_crate_source<'tcx> {
 459     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 460         format!("looking at the source for a crate")
 461     }
 462 }
 463
 464 impl<'tcx> QueryDescription for queries::postorder_cnums<'tcx> {
 465     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 466         format!("generating a postorder list of CrateNums")
 467     }
 468 }
 469
 470 impl<'tcx> QueryDescription for queries::maybe_unused_extern_crates<'tcx> {
 471     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 472         format!("looking up all possibly unused extern crates")
 473     }
 474 }
 475
 476 impl<'tcx> QueryDescription for queries::stability_index<'tcx> {
 477     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 478         format!("calculating the stability index for the local crate")
 479     }
 480 }
 481
 482 impl<'tcx> QueryDescription for queries::all_crate_nums<'tcx> {
 483     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 484         format!("fetching all foreign CrateNum instances")
 485     }
 486 }
 487
 488 impl<'tcx> QueryDescription for queries::exported_symbols<'tcx> {
 489     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 490         format!("exported_symbols")
 491     }
 492 }
 493
 494 impl<'tcx> QueryDescription for queries::collect_and_partition_translation_items<'tcx> {
 495     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 496         format!("collect_and_partition_translation_items")
 497     }
 498 }
 499
 500 impl<'tcx> QueryDescription for queries::codegen_unit<'tcx> {
 501     fn describe(_tcx: TyCtxt, _: InternedString) -> String {
 502         format!("codegen_unit")
 503     }
 504 }
 505
 506 impl<'tcx> QueryDescription for queries::compile_codegen_unit<'tcx> {
 507     fn describe(_tcx: TyCtxt, _: InternedString) -> String {
 508         format!("compile_codegen_unit")
 509     }
 510 }
 511
 512 impl<'tcx> QueryDescription for queries::output_filenames<'tcx> {
 513     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 514         format!("output_filenames")
 515     }
 516 }
 517
 518 impl<'tcx> QueryDescription for queries::has_clone_closures<'tcx> {
 519     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 520         format!("seeing if the crate has enabled `Clone` closures")
 521     }
 522 }
 523
 524 impl<'tcx> QueryDescription for queries::vtable_methods<'tcx> {
 525     fn describe(tcx: TyCtxt, key: ty::PolyTraitRef<'tcx> ) -> String {
 526         format!("finding all methods for trait {}", tcx.item_path_str(key.def_id()))
 527     }
 528 }
 529
 530 impl<'tcx> QueryDescription for queries::has_copy_closures<'tcx> {
 531     fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
 532         format!("seeing if the crate has enabled `Copy` closures")
 533     }
 534 }
 535
 536 impl<'tcx> QueryDescription for queries::normalize_ty<'tcx> {
 537     fn describe(_tcx: TyCtxt, _: Ty) -> String {
 538         format!("normalizing types")
 539     }
 540 }