]>
Commit | Line | Data |
---|---|---|
92a42be0 SL |
1 | // Copyright 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 | ||
92a42be0 | 11 | use cstore; |
92a42be0 | 12 | use encoder; |
ea8adc8c XL |
13 | use link_args; |
14 | use native_libs; | |
0531ce1d | 15 | use foreign_modules; |
9e0c209e | 16 | use schema; |
92a42be0 | 17 | |
041b39d2 | 18 | use rustc::ty::maps::QueryConfig; |
ea8adc8c XL |
19 | use rustc::middle::cstore::{CrateStore, DepKind, |
20 | MetadataLoader, LinkMeta, | |
ff7c6d11 | 21 | LoadedMacro, EncodedMetadata, NativeLibraryKind}; |
0531ce1d | 22 | use rustc::middle::exported_symbols::ExportedSymbol; |
ea8adc8c | 23 | use rustc::middle::stability::DeprecationEntry; |
7cac9316 | 24 | use rustc::hir::def; |
abe05a73 | 25 | use rustc::session::{CrateDisambiguator, Session}; |
8bb4bdeb XL |
26 | use rustc::ty::{self, TyCtxt}; |
27 | use rustc::ty::maps::Providers; | |
ea8adc8c | 28 | use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE, CRATE_DEF_INDEX}; |
3b2f2976 | 29 | use rustc::hir::map::{DefKey, DefPath, DefPathHash}; |
041b39d2 | 30 | use rustc::hir::map::blocks::FnLikeNode; |
ea8adc8c | 31 | use rustc::hir::map::definitions::DefPathTable; |
0531ce1d | 32 | use rustc::util::nodemap::DefIdMap; |
92a42be0 | 33 | |
8bb4bdeb | 34 | use std::any::Any; |
0531ce1d XL |
35 | use rustc_data_structures::sync::Lrc; |
36 | use std::sync::Arc; | |
8bb4bdeb | 37 | |
92a42be0 SL |
38 | use syntax::ast; |
39 | use syntax::attr; | |
0531ce1d | 40 | use syntax::codemap; |
041b39d2 | 41 | use syntax::ext::base::SyntaxExtension; |
8bb4bdeb | 42 | use syntax::parse::filemap_to_stream; |
476ff2be | 43 | use syntax::symbol::Symbol; |
ff7c6d11 | 44 | use syntax_pos::{Span, NO_EXPANSION, FileName}; |
ea8adc8c | 45 | use rustc_data_structures::indexed_set::IdxSetBuf; |
54a0048b | 46 | use rustc::hir; |
92a42be0 | 47 | |
8bb4bdeb | 48 | macro_rules! provide { |
ea8adc8c XL |
49 | (<$lt:tt> $tcx:ident, $def_id:ident, $other:ident, $cdata:ident, |
50 | $($name:ident => $compute:block)*) => { | |
abe05a73 | 51 | pub fn provide_extern<$lt>(providers: &mut Providers<$lt>) { |
ea8adc8c | 52 | $(fn $name<'a, $lt:$lt, T>($tcx: TyCtxt<'a, $lt, $lt>, def_id_arg: T) |
8bb4bdeb | 53 | -> <ty::queries::$name<$lt> as |
83c7162d | 54 | QueryConfig<$lt>>::Value |
ea8adc8c XL |
55 | where T: IntoArgs, |
56 | { | |
57 | #[allow(unused_variables)] | |
58 | let ($def_id, $other) = def_id_arg.into_args(); | |
8bb4bdeb XL |
59 | assert!(!$def_id.is_local()); |
60 | ||
ea8adc8c XL |
61 | let def_path_hash = $tcx.def_path_hash(DefId { |
62 | krate: $def_id.krate, | |
63 | index: CRATE_DEF_INDEX | |
64 | }); | |
65 | let dep_node = def_path_hash | |
66 | .to_dep_node(::rustc::dep_graph::DepKind::CrateMetadata); | |
67 | // The DepNodeIndex of the DepNode::CrateMetadata should be | |
68 | // cached somewhere, so that we can use read_index(). | |
041b39d2 | 69 | $tcx.dep_graph.read(dep_node); |
8bb4bdeb | 70 | |
ea8adc8c | 71 | let $cdata = $tcx.crate_data_as_rc_any($def_id.krate); |
8bb4bdeb XL |
72 | let $cdata = $cdata.downcast_ref::<cstore::CrateMetadata>() |
73 | .expect("CrateStore crated ata is not a CrateMetadata"); | |
74 | $compute | |
75 | })* | |
76 | ||
77 | *providers = Providers { | |
78 | $($name,)* | |
79 | ..*providers | |
80 | }; | |
81 | } | |
9e0c209e | 82 | } |
8bb4bdeb | 83 | } |
9e0c209e | 84 | |
ea8adc8c XL |
85 | // small trait to work around different signature queries all being defined via |
86 | // the macro above. | |
87 | trait IntoArgs { | |
88 | fn into_args(self) -> (DefId, DefId); | |
89 | } | |
90 | ||
91 | impl IntoArgs for DefId { | |
92 | fn into_args(self) -> (DefId, DefId) { (self, self) } | |
93 | } | |
94 | ||
95 | impl IntoArgs for CrateNum { | |
96 | fn into_args(self) -> (DefId, DefId) { (self.as_def_id(), self.as_def_id()) } | |
97 | } | |
98 | ||
99 | impl IntoArgs for (CrateNum, DefId) { | |
100 | fn into_args(self) -> (DefId, DefId) { (self.0.as_def_id(), self.1) } | |
101 | } | |
102 | ||
103 | provide! { <'tcx> tcx, def_id, other, cdata, | |
7cac9316 | 104 | type_of => { cdata.get_type(def_id.index, tcx) } |
abe05a73 XL |
105 | generics_of => { |
106 | tcx.alloc_generics(cdata.get_generics(def_id.index, tcx.sess)) | |
107 | } | |
7cac9316 XL |
108 | predicates_of => { cdata.get_predicates(def_id.index, tcx) } |
109 | super_predicates_of => { cdata.get_super_predicates(def_id.index, tcx) } | |
8bb4bdeb | 110 | trait_def => { |
abe05a73 | 111 | tcx.alloc_trait_def(cdata.get_trait_def(def_id.index, tcx.sess)) |
476ff2be | 112 | } |
8bb4bdeb XL |
113 | adt_def => { cdata.get_adt_def(def_id.index, tcx) } |
114 | adt_destructor => { | |
115 | let _ = cdata; | |
116 | tcx.calculate_dtor(def_id, &mut |_,_| Ok(())) | |
92a42be0 | 117 | } |
0531ce1d | 118 | variances_of => { Lrc::new(cdata.get_item_variances(def_id.index)) } |
8bb4bdeb XL |
119 | associated_item_def_ids => { |
120 | let mut result = vec![]; | |
041b39d2 XL |
121 | cdata.each_child_of_item(def_id.index, |
122 | |child| result.push(child.def.def_id()), tcx.sess); | |
0531ce1d | 123 | Lrc::new(result) |
8bb4bdeb XL |
124 | } |
125 | associated_item => { cdata.get_associated_item(def_id.index) } | |
126 | impl_trait_ref => { cdata.get_impl_trait(def_id.index, tcx) } | |
cc61c64b XL |
127 | impl_polarity => { cdata.get_impl_polarity(def_id.index) } |
128 | coerce_unsized_info => { | |
129 | cdata.get_coerce_unsized_info(def_id.index).unwrap_or_else(|| { | |
130 | bug!("coerce_unsized_info: `{:?}` is missing its info", def_id); | |
8bb4bdeb | 131 | }) |
9cc50fc6 | 132 | } |
7cac9316 XL |
133 | optimized_mir => { |
134 | let mir = cdata.maybe_get_optimized_mir(tcx, def_id.index).unwrap_or_else(|| { | |
135 | bug!("get_optimized_mir: missing MIR for `{:?}`", def_id) | |
8bb4bdeb | 136 | }); |
9cc50fc6 | 137 | |
8bb4bdeb | 138 | let mir = tcx.alloc_mir(mir); |
54a0048b | 139 | |
8bb4bdeb | 140 | mir |
92a42be0 | 141 | } |
ea8adc8c | 142 | mir_const_qualif => { |
0531ce1d | 143 | (cdata.mir_const_qualif(def_id.index), Lrc::new(IdxSetBuf::new_empty(0))) |
ea8adc8c | 144 | } |
041b39d2 | 145 | fn_sig => { cdata.fn_sig(def_id.index, tcx) } |
0531ce1d | 146 | inherent_impls => { Lrc::new(cdata.get_inherent_implementations_for_type(def_id.index)) } |
041b39d2 | 147 | is_const_fn => { cdata.is_const_fn(def_id.index) } |
cc61c64b | 148 | is_foreign_item => { cdata.is_foreign_item(def_id.index) } |
7cac9316 XL |
149 | describe_def => { cdata.get_def(def_id.index) } |
150 | def_span => { cdata.get_span(def_id.index, &tcx.sess) } | |
ea8adc8c XL |
151 | lookup_stability => { |
152 | cdata.get_stability(def_id.index).map(|s| tcx.intern_stability(s)) | |
153 | } | |
154 | lookup_deprecation_entry => { | |
155 | cdata.get_deprecation(def_id.index).map(DeprecationEntry::external) | |
156 | } | |
abe05a73 | 157 | item_attrs => { cdata.get_item_attrs(def_id.index, tcx.sess) } |
7cac9316 XL |
158 | // FIXME(#38501) We've skipped a `read` on the `HirBody` of |
159 | // a `fn` when encoding, so the dep-tracking wouldn't work. | |
160 | // This is only used by rustdoc anyway, which shouldn't have | |
161 | // incremental recompilation ever enabled. | |
162 | fn_arg_names => { cdata.get_fn_arg_names(def_id.index) } | |
83c7162d | 163 | rendered_const => { cdata.get_rendered_const(def_id.index) } |
7cac9316 XL |
164 | impl_parent => { cdata.get_parent_impl(def_id.index) } |
165 | trait_of_item => { cdata.get_trait_of_item(def_id.index) } | |
7cac9316 XL |
166 | const_is_rvalue_promotable_to_static => { |
167 | cdata.const_is_rvalue_promotable_to_static(def_id.index) | |
168 | } | |
169 | is_mir_available => { cdata.is_item_mir_available(def_id.index) } | |
041b39d2 | 170 | |
0531ce1d | 171 | dylib_dependency_formats => { Lrc::new(cdata.get_dylib_dependency_formats()) } |
abe05a73 XL |
172 | is_panic_runtime => { cdata.is_panic_runtime(tcx.sess) } |
173 | is_compiler_builtins => { cdata.is_compiler_builtins(tcx.sess) } | |
ea8adc8c | 174 | has_global_allocator => { cdata.has_global_allocator() } |
abe05a73 XL |
175 | is_sanitizer_runtime => { cdata.is_sanitizer_runtime(tcx.sess) } |
176 | is_profiler_runtime => { cdata.is_profiler_runtime(tcx.sess) } | |
ea8adc8c | 177 | panic_strategy => { cdata.panic_strategy() } |
0531ce1d XL |
178 | extern_crate => { |
179 | let r = Lrc::new(*cdata.extern_crate.lock()); | |
180 | r | |
181 | } | |
abe05a73 | 182 | is_no_builtins => { cdata.is_no_builtins(tcx.sess) } |
ea8adc8c | 183 | impl_defaultness => { cdata.get_impl_defaultness(def_id.index) } |
0531ce1d XL |
184 | reachable_non_generics => { |
185 | let reachable_non_generics = tcx | |
186 | .exported_symbols(cdata.cnum) | |
187 | .iter() | |
83c7162d | 188 | .filter_map(|&(exported_symbol, export_level)| { |
0531ce1d | 189 | if let ExportedSymbol::NonGeneric(def_id) = exported_symbol { |
83c7162d | 190 | return Some((def_id, export_level)) |
0531ce1d XL |
191 | } else { |
192 | None | |
193 | } | |
194 | }) | |
195 | .collect(); | |
196 | ||
197 | Lrc::new(reachable_non_generics) | |
198 | } | |
199 | native_libraries => { Lrc::new(cdata.get_native_libraries(tcx.sess)) } | |
200 | foreign_modules => { Lrc::new(cdata.get_foreign_modules(tcx.sess)) } | |
ea8adc8c XL |
201 | plugin_registrar_fn => { |
202 | cdata.root.plugin_registrar_fn.map(|index| { | |
203 | DefId { krate: def_id.krate, index } | |
204 | }) | |
205 | } | |
206 | derive_registrar_fn => { | |
207 | cdata.root.macro_derive_registrar.map(|index| { | |
208 | DefId { krate: def_id.krate, index } | |
209 | }) | |
210 | } | |
211 | crate_disambiguator => { cdata.disambiguator() } | |
212 | crate_hash => { cdata.hash() } | |
213 | original_crate_name => { cdata.name() } | |
214 | ||
83c7162d XL |
215 | extra_filename => { cdata.root.extra_filename.clone() } |
216 | ||
217 | ||
ea8adc8c XL |
218 | implementations_of_trait => { |
219 | let mut result = vec![]; | |
220 | let filter = Some(other); | |
221 | cdata.get_implementations_for_trait(filter, &mut result); | |
0531ce1d | 222 | Lrc::new(result) |
ea8adc8c XL |
223 | } |
224 | ||
225 | all_trait_implementations => { | |
226 | let mut result = vec![]; | |
227 | cdata.get_implementations_for_trait(None, &mut result); | |
0531ce1d | 228 | Lrc::new(result) |
ea8adc8c XL |
229 | } |
230 | ||
ea8adc8c | 231 | visibility => { cdata.get_visibility(def_id.index) } |
0531ce1d XL |
232 | dep_kind => { |
233 | let r = *cdata.dep_kind.lock(); | |
234 | r | |
235 | } | |
ea8adc8c XL |
236 | crate_name => { cdata.name } |
237 | item_children => { | |
238 | let mut result = vec![]; | |
239 | cdata.each_child_of_item(def_id.index, |child| result.push(child), tcx.sess); | |
0531ce1d | 240 | Lrc::new(result) |
ea8adc8c | 241 | } |
0531ce1d XL |
242 | defined_lang_items => { Lrc::new(cdata.get_lang_items()) } |
243 | missing_lang_items => { Lrc::new(cdata.get_missing_lang_items()) } | |
ea8adc8c | 244 | |
ea8adc8c | 245 | missing_extern_crate_item => { |
0531ce1d | 246 | let r = match *cdata.extern_crate.borrow() { |
ea8adc8c XL |
247 | Some(extern_crate) if !extern_crate.direct => true, |
248 | _ => false, | |
0531ce1d XL |
249 | }; |
250 | r | |
ea8adc8c XL |
251 | } |
252 | ||
0531ce1d | 253 | used_crate_source => { Lrc::new(cdata.source.clone()) } |
ea8adc8c | 254 | |
0531ce1d XL |
255 | exported_symbols => { |
256 | let cnum = cdata.cnum; | |
257 | assert!(cnum != LOCAL_CRATE); | |
258 | ||
259 | // If this crate is a custom derive crate, then we're not even going to | |
260 | // link those in so we skip those crates. | |
261 | if cdata.root.macro_derive_registrar.is_some() { | |
262 | return Arc::new(Vec::new()) | |
263 | } | |
264 | ||
83c7162d | 265 | Arc::new(cdata.exported_symbols(tcx)) |
0531ce1d XL |
266 | } |
267 | ||
268 | wasm_custom_sections => { Lrc::new(cdata.wasm_custom_sections()) } | |
041b39d2 XL |
269 | } |
270 | ||
abe05a73 | 271 | pub fn provide<'tcx>(providers: &mut Providers<'tcx>) { |
041b39d2 XL |
272 | fn is_const_fn<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> bool { |
273 | let node_id = tcx.hir.as_local_node_id(def_id) | |
274 | .expect("Non-local call to local provider is_const_fn"); | |
275 | ||
276 | if let Some(fn_like) = FnLikeNode::from_node(tcx.hir.get(node_id)) { | |
277 | fn_like.constness() == hir::Constness::Const | |
278 | } else { | |
279 | false | |
280 | } | |
281 | } | |
282 | ||
ea8adc8c XL |
283 | // FIXME(#44234) - almost all of these queries have no sub-queries and |
284 | // therefore no actual inputs, they're just reading tables calculated in | |
285 | // resolve! Does this work? Unsure! That's what the issue is about | |
041b39d2 XL |
286 | *providers = Providers { |
287 | is_const_fn, | |
ea8adc8c XL |
288 | is_dllimport_foreign_item: |tcx, id| { |
289 | tcx.native_library_kind(id) == Some(NativeLibraryKind::NativeUnknown) | |
290 | }, | |
291 | is_statically_included_foreign_item: |tcx, id| { | |
292 | match tcx.native_library_kind(id) { | |
293 | Some(NativeLibraryKind::NativeStatic) | | |
294 | Some(NativeLibraryKind::NativeStaticNobundle) => true, | |
295 | _ => false, | |
296 | } | |
297 | }, | |
298 | native_library_kind: |tcx, id| { | |
299 | tcx.native_libraries(id.krate) | |
300 | .iter() | |
301 | .filter(|lib| native_libs::relevant_lib(&tcx.sess, lib)) | |
0531ce1d XL |
302 | .find(|lib| { |
303 | let fm_id = match lib.foreign_module { | |
304 | Some(id) => id, | |
305 | None => return false, | |
306 | }; | |
307 | tcx.foreign_modules(id.krate) | |
308 | .iter() | |
309 | .find(|m| m.def_id == fm_id) | |
310 | .expect("failed to find foreign module") | |
311 | .foreign_items | |
312 | .contains(&id) | |
313 | }) | |
ea8adc8c XL |
314 | .map(|l| l.kind) |
315 | }, | |
316 | native_libraries: |tcx, cnum| { | |
317 | assert_eq!(cnum, LOCAL_CRATE); | |
0531ce1d XL |
318 | Lrc::new(native_libs::collect(tcx)) |
319 | }, | |
320 | foreign_modules: |tcx, cnum| { | |
321 | assert_eq!(cnum, LOCAL_CRATE); | |
322 | Lrc::new(foreign_modules::collect(tcx)) | |
ea8adc8c XL |
323 | }, |
324 | link_args: |tcx, cnum| { | |
325 | assert_eq!(cnum, LOCAL_CRATE); | |
0531ce1d | 326 | Lrc::new(link_args::collect(tcx)) |
ea8adc8c XL |
327 | }, |
328 | ||
329 | // Returns a map from a sufficiently visible external item (i.e. an | |
330 | // external item that is visible from at least one local module) to a | |
331 | // sufficiently visible parent (considering modules that re-export the | |
332 | // external item to be parents). | |
333 | visible_parent_map: |tcx, cnum| { | |
334 | use std::collections::vec_deque::VecDeque; | |
335 | use std::collections::hash_map::Entry; | |
336 | ||
337 | assert_eq!(cnum, LOCAL_CRATE); | |
338 | let mut visible_parent_map: DefIdMap<DefId> = DefIdMap(); | |
339 | ||
ff7c6d11 XL |
340 | // Issue 46112: We want the map to prefer the shortest |
341 | // paths when reporting the path to an item. Therefore we | |
342 | // build up the map via a breadth-first search (BFS), | |
343 | // which naturally yields minimal-length paths. | |
344 | // | |
345 | // Note that it needs to be a BFS over the whole forest of | |
346 | // crates, not just each individual crate; otherwise you | |
347 | // only get paths that are locally minimal with respect to | |
348 | // whatever crate we happened to encounter first in this | |
349 | // traversal, but not globally minimal across all crates. | |
350 | let bfs_queue = &mut VecDeque::new(); | |
351 | ||
abe05a73 XL |
352 | // Preferring shortest paths alone does not guarantee a |
353 | // deterministic result; so sort by crate num to avoid | |
354 | // hashtable iteration non-determinism. This only makes | |
355 | // things as deterministic as crate-nums assignment is, | |
356 | // which is to say, its not deterministic in general. But | |
357 | // we believe that libstd is consistently assigned crate | |
358 | // num 1, so it should be enough to resolve #46112. | |
359 | let mut crates: Vec<CrateNum> = (*tcx.crates()).clone(); | |
360 | crates.sort(); | |
361 | ||
362 | for &cnum in crates.iter() { | |
ea8adc8c XL |
363 | // Ignore crates without a corresponding local `extern crate` item. |
364 | if tcx.missing_extern_crate_item(cnum) { | |
365 | continue | |
366 | } | |
367 | ||
ff7c6d11 XL |
368 | bfs_queue.push_back(DefId { |
369 | krate: cnum, | |
370 | index: CRATE_DEF_INDEX | |
371 | }); | |
372 | } | |
373 | ||
374 | // (restrict scope of mutable-borrow of `visible_parent_map`) | |
375 | { | |
ea8adc8c XL |
376 | let visible_parent_map = &mut visible_parent_map; |
377 | let mut add_child = |bfs_queue: &mut VecDeque<_>, | |
378 | child: &def::Export, | |
379 | parent: DefId| { | |
ff7c6d11 | 380 | if child.vis != ty::Visibility::Public { |
ea8adc8c XL |
381 | return; |
382 | } | |
383 | ||
ff7c6d11 XL |
384 | let child = child.def.def_id(); |
385 | ||
ea8adc8c XL |
386 | match visible_parent_map.entry(child) { |
387 | Entry::Occupied(mut entry) => { | |
388 | // If `child` is defined in crate `cnum`, ensure | |
389 | // that it is mapped to a parent in `cnum`. | |
390 | if child.krate == cnum && entry.get().krate != cnum { | |
391 | entry.insert(parent); | |
392 | } | |
393 | } | |
394 | Entry::Vacant(entry) => { | |
395 | entry.insert(parent); | |
396 | bfs_queue.push_back(child); | |
397 | } | |
398 | } | |
399 | }; | |
400 | ||
ea8adc8c XL |
401 | while let Some(def) = bfs_queue.pop_front() { |
402 | for child in tcx.item_children(def).iter() { | |
403 | add_child(bfs_queue, child, def); | |
404 | } | |
405 | } | |
406 | } | |
407 | ||
0531ce1d | 408 | Lrc::new(visible_parent_map) |
ea8adc8c XL |
409 | }, |
410 | ||
041b39d2 XL |
411 | ..*providers |
412 | }; | |
8bb4bdeb | 413 | } |
92a42be0 | 414 | |
8bb4bdeb | 415 | impl CrateStore for cstore::CStore { |
0531ce1d | 416 | fn crate_data_as_rc_any(&self, krate: CrateNum) -> Lrc<Any> { |
8bb4bdeb | 417 | self.get_crate_data(krate) |
92a42be0 SL |
418 | } |
419 | ||
7cac9316 XL |
420 | fn metadata_loader(&self) -> &MetadataLoader { |
421 | &*self.metadata_loader | |
92a42be0 SL |
422 | } |
423 | ||
ea8adc8c | 424 | fn visibility_untracked(&self, def: DefId) -> ty::Visibility { |
8bb4bdeb | 425 | self.get_crate_data(def.krate).get_visibility(def.index) |
32a655c1 SL |
426 | } |
427 | ||
abe05a73 XL |
428 | fn item_generics_cloned_untracked(&self, def: DefId, sess: &Session) -> ty::Generics { |
429 | self.get_crate_data(def.krate).get_generics(def.index, sess) | |
32a655c1 SL |
430 | } |
431 | ||
ea8adc8c | 432 | fn associated_item_cloned_untracked(&self, def: DefId) -> ty::AssociatedItem |
92a42be0 | 433 | { |
476ff2be | 434 | self.get_crate_data(def.krate).get_associated_item(def.index) |
92a42be0 SL |
435 | } |
436 | ||
ea8adc8c | 437 | fn dep_kind_untracked(&self, cnum: CrateNum) -> DepKind |
476ff2be | 438 | { |
0531ce1d XL |
439 | let data = self.get_crate_data(cnum); |
440 | let r = *data.dep_kind.lock(); | |
441 | r | |
476ff2be SL |
442 | } |
443 | ||
ea8adc8c | 444 | fn export_macros_untracked(&self, cnum: CrateNum) { |
7cac9316 | 445 | let data = self.get_crate_data(cnum); |
0531ce1d XL |
446 | let mut dep_kind = data.dep_kind.lock(); |
447 | if *dep_kind == DepKind::UnexportedMacrosOnly { | |
448 | *dep_kind = DepKind::MacrosOnly; | |
476ff2be SL |
449 | } |
450 | } | |
451 | ||
ea8adc8c | 452 | fn crate_name_untracked(&self, cnum: CrateNum) -> Symbol |
92a42be0 | 453 | { |
476ff2be | 454 | self.get_crate_data(cnum).name |
54a0048b SL |
455 | } |
456 | ||
abe05a73 | 457 | fn crate_disambiguator_untracked(&self, cnum: CrateNum) -> CrateDisambiguator |
54a0048b | 458 | { |
476ff2be | 459 | self.get_crate_data(cnum).disambiguator() |
54a0048b SL |
460 | } |
461 | ||
ea8adc8c | 462 | fn crate_hash_untracked(&self, cnum: CrateNum) -> hir::svh::Svh |
92a42be0 | 463 | { |
ea8adc8c | 464 | self.get_crate_data(cnum).hash() |
92a42be0 SL |
465 | } |
466 | ||
54a0048b SL |
467 | /// Returns the `DefKey` for a given `DefId`. This indicates the |
468 | /// parent `DefId` as well as some idea of what kind of data the | |
469 | /// `DefId` refers to. | |
32a655c1 | 470 | fn def_key(&self, def: DefId) -> DefKey { |
9e0c209e SL |
471 | // Note: loading the def-key (or def-path) for a def-id is not |
472 | // a *read* of its metadata. This is because the def-id is | |
473 | // really just an interned shorthand for a def-path, which is the | |
474 | // canonical name for an item. | |
475 | // | |
476 | // self.dep_graph.read(DepNode::MetaData(def)); | |
477 | self.get_crate_data(def.krate).def_key(def.index) | |
54a0048b SL |
478 | } |
479 | ||
32a655c1 | 480 | fn def_path(&self, def: DefId) -> DefPath { |
9e0c209e SL |
481 | // See `Note` above in `def_key()` for why this read is |
482 | // commented out: | |
483 | // | |
484 | // self.dep_graph.read(DepNode::MetaData(def)); | |
485 | self.get_crate_data(def.krate).def_path(def.index) | |
92a42be0 SL |
486 | } |
487 | ||
7cac9316 | 488 | fn def_path_hash(&self, def: DefId) -> DefPathHash { |
cc61c64b XL |
489 | self.get_crate_data(def.krate).def_path_hash(def.index) |
490 | } | |
491 | ||
0531ce1d | 492 | fn def_path_table(&self, cnum: CrateNum) -> Lrc<DefPathTable> { |
7cac9316 XL |
493 | self.get_crate_data(cnum).def_path_table.clone() |
494 | } | |
495 | ||
ea8adc8c | 496 | fn struct_field_names_untracked(&self, def: DefId) -> Vec<ast::Name> |
92a42be0 | 497 | { |
9e0c209e | 498 | self.get_crate_data(def.krate).get_struct_field_names(def.index) |
92a42be0 SL |
499 | } |
500 | ||
ea8adc8c | 501 | fn item_children_untracked(&self, def_id: DefId, sess: &Session) -> Vec<def::Export> |
92a42be0 SL |
502 | { |
503 | let mut result = vec![]; | |
9e0c209e | 504 | self.get_crate_data(def_id.krate) |
041b39d2 | 505 | .each_child_of_item(def_id.index, |child| result.push(child), sess); |
92a42be0 SL |
506 | result |
507 | } | |
508 | ||
ea8adc8c | 509 | fn load_macro_untracked(&self, id: DefId, sess: &Session) -> LoadedMacro { |
476ff2be SL |
510 | let data = self.get_crate_data(id.krate); |
511 | if let Some(ref proc_macros) = data.proc_macros { | |
2c00a5a8 | 512 | return LoadedMacro::ProcMacro(proc_macros[id.index.to_proc_macro_index()].1.clone()); |
041b39d2 XL |
513 | } else if data.name == "proc_macro" && |
514 | self.get_crate_data(id.krate).item_name(id.index) == "quote" { | |
515 | let ext = SyntaxExtension::ProcMacro(Box::new(::proc_macro::__internal::Quoter)); | |
0531ce1d | 516 | return LoadedMacro::ProcMacro(Lrc::new(ext)); |
476ff2be SL |
517 | } |
518 | ||
519 | let (name, def) = data.get_macro(id.index); | |
ff7c6d11 | 520 | let source_name = FileName::Macros(name.to_string()); |
476ff2be | 521 | |
7cac9316 | 522 | let filemap = sess.parse_sess.codemap().new_filemap(source_name, def.body); |
ea8adc8c | 523 | let local_span = Span::new(filemap.start_pos, filemap.end_pos, NO_EXPANSION); |
041b39d2 | 524 | let body = filemap_to_stream(&sess.parse_sess, filemap, None); |
476ff2be SL |
525 | |
526 | // Mark the attrs as used | |
abe05a73 | 527 | let attrs = data.get_item_attrs(id.index, sess); |
cc61c64b | 528 | for attr in attrs.iter() { |
476ff2be SL |
529 | attr::mark_used(attr); |
530 | } | |
531 | ||
532 | let name = data.def_key(id.index).disambiguated_data.data | |
533 | .get_opt_name().expect("no name in load_macro"); | |
534 | sess.imported_macro_spans.borrow_mut() | |
535 | .insert(local_span, (name.to_string(), data.get_span(id.index, sess))); | |
536 | ||
8bb4bdeb | 537 | LoadedMacro::MacroDef(ast::Item { |
83c7162d | 538 | ident: ast::Ident::from_str(&name.as_str()), |
476ff2be SL |
539 | id: ast::DUMMY_NODE_ID, |
540 | span: local_span, | |
cc61c64b | 541 | attrs: attrs.iter().cloned().collect(), |
7cac9316 XL |
542 | node: ast::ItemKind::MacroDef(ast::MacroDef { |
543 | tokens: body.into(), | |
544 | legacy: def.legacy, | |
545 | }), | |
0531ce1d | 546 | vis: codemap::respan(local_span.shrink_to_lo(), ast::VisibilityKind::Inherited), |
3b2f2976 | 547 | tokens: None, |
476ff2be SL |
548 | }) |
549 | } | |
550 | ||
ea8adc8c | 551 | fn crates_untracked(&self) -> Vec<CrateNum> |
92a42be0 SL |
552 | { |
553 | let mut result = vec![]; | |
554 | self.iter_crate_data(|cnum, _| result.push(cnum)); | |
555 | result | |
556 | } | |
557 | ||
ea8adc8c | 558 | fn extern_mod_stmt_cnum_untracked(&self, emod_id: ast::NodeId) -> Option<CrateNum> |
92a42be0 | 559 | { |
ea8adc8c | 560 | self.do_extern_mod_stmt_cnum(emod_id) |
92a42be0 SL |
561 | } |
562 | ||
ea8adc8c XL |
563 | fn postorder_cnums_untracked(&self) -> Vec<CrateNum> { |
564 | self.do_postorder_cnums_untracked() | |
92a42be0 SL |
565 | } |
566 | ||
cc61c64b XL |
567 | fn encode_metadata<'a, 'tcx>(&self, |
568 | tcx: TyCtxt<'a, 'tcx, 'tcx>, | |
0531ce1d | 569 | link_meta: &LinkMeta) |
ff7c6d11 | 570 | -> EncodedMetadata |
9e0c209e | 571 | { |
0531ce1d | 572 | encoder::encode_metadata(tcx, link_meta) |
92a42be0 SL |
573 | } |
574 | ||
575 | fn metadata_encoding_version(&self) -> &[u8] | |
576 | { | |
9e0c209e | 577 | schema::METADATA_HEADER |
92a42be0 SL |
578 | } |
579 | } |