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