nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-13 12:36:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Avoid more invocations of hir_crate query.

Browse Source
This commit is contained in:
Camille GILLOT 2021-09-12 01:11:22 +02:00
parent 11491938f8
commit db9fea508a
41 changed files with 123 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
compiler/rustc_hir/src/hir.rs
View File

@ -1,7 +1,7 @@
use crate::def::{CtorKind, DefKind, Res};
use crate::def_id::{DefId, CRATE_DEF_ID};
crate use crate::hir_id::{HirId, ItemLocalId};
use crate::{itemlikevisit, LangItem};
use crate::LangItem;
use rustc_ast::util::parser::ExprPrecedence;
use rustc_ast::{self as ast, CrateSugar, LlvmAsmDialect};
@ -10,7 +10,6 @@ pub use rustc_ast::{BorrowKind, ImplPolarity, IsAuto};
pub use rustc_ast::{CaptureBy, Movability, Mutability};
use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece};
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::sync::{par_for_each_in, Send, Sync};
use rustc_index::vec::IndexVec;
use rustc_macros::HashStable_Generic;
use rustc_span::source_map::Spanned;
@ -672,7 +671,7 @@ pub struct Crate<'hir> {
pub attrs: BTreeMap<HirId, &'hir [Attribute]>,
}
impl Crate<'hir> {
impl<'hir> Crate<'hir> {
pub fn module(&self) -> &'hir Mod<'hir> {
if let Some(OwnerNode::Crate(m)) = self.owners[CRATE_DEF_ID] { m } else { panic!() }
}
@ -698,52 +697,6 @@ impl Crate<'hir> {
}
}
impl Crate<'_> {
/// Visits all items in the crate in some deterministic (but
/// unspecified) order. If you just need to process every item,
/// but don't care about nesting, this method is the best choice.
///
/// If you do care about nesting -- usually because your algorithm
/// follows lexical scoping rules -- then you want a different
/// approach. You should override `visit_nested_item` in your
/// visitor and then call `intravisit::walk_crate` instead.
pub fn visit_all_item_likes<'hir, V>(&'hir self, visitor: &mut V)
where
V: itemlikevisit::ItemLikeVisitor<'hir>,
{
for owner in self.owners.iter().filter_map(Option::as_ref) {
match owner {
OwnerNode::Item(item) => visitor.visit_item(item),
OwnerNode::ForeignItem(item) => visitor.visit_foreign_item(item),
OwnerNode::ImplItem(item) => visitor.visit_impl_item(item),
OwnerNode::TraitItem(item) => visitor.visit_trait_item(item),
OwnerNode::Crate(_) => {}
}
}
}
/// A parallel version of `visit_all_item_likes`.
pub fn par_visit_all_item_likes<'hir, V>(&'hir self, visitor: &V)
where
V: itemlikevisit::ParItemLikeVisitor<'hir> + Sync + Send,
{
par_for_each_in(&self.owners.raw, |owner| match owner {
Some(OwnerNode::Item(item)) => visitor.visit_item(item),
Some(OwnerNode::ForeignItem(item)) => visitor.visit_foreign_item(item),
Some(OwnerNode::ImplItem(item)) => visitor.visit_impl_item(item),
Some(OwnerNode::TraitItem(item)) => visitor.visit_trait_item(item),
Some(OwnerNode::Crate(_)) | None => {}
})
}
pub fn items<'hir>(&'hir self) -> impl Iterator<Item = &'hir Item<'hir>> + 'hir {
self.owners.iter().filter_map(|owner| match owner {
Some(OwnerNode::Item(item)) => Some(*item),
_ => None,
})
}
}
/// A block of statements `{ .. }`, which may have a label (in this case the
/// `targeted_by_break` field will be `true`) and may be `unsafe` by means of
/// the `rules` being anything but `DefaultBlock`.

13
compiler/rustc_hir_pretty/src/lib.rs
View File

@ -51,19 +51,6 @@ pub struct NoAnn;
impl PpAnn for NoAnn {}
pub const NO_ANN: &dyn PpAnn = &NoAnn;
impl PpAnn for hir::Crate<'_> {
fn nested(&self, state: &mut State<'_>, nested: Nested) {
match nested {
Nested::Item(id) => state.print_item(self.item(id)),
Nested::TraitItem(id) => state.print_trait_item(self.trait_item(id)),
Nested::ImplItem(id) => state.print_impl_item(self.impl_item(id)),
Nested::ForeignItem(id) => state.print_foreign_item(self.foreign_item(id)),
Nested::Body(id) => state.print_expr(&self.body(id).value),
Nested::BodyParamPat(id, i) => state.print_pat(&self.body(id).params[i].pat),
}
}
}
/// Identical to the `PpAnn` implementation for `hir::Crate`,
/// except it avoids creating a dependency on the whole crate.
impl PpAnn for &dyn rustc_hir::intravisit::Map<'_> {

2
compiler/rustc_incremental/src/assert_dep_graph.rs
View File

@ -74,7 +74,7 @@ pub fn assert_dep_graph(tcx: TyCtxt<'_>) {
let mut visitor =
IfThisChanged { tcx, if_this_changed: vec![], then_this_would_need: vec![] };
visitor.process_attrs(hir::CRATE_HIR_ID);
tcx.hir().krate().visit_all_item_likes(&mut visitor.as_deep_visitor());
tcx.hir().visit_all_item_likes(&mut visitor.as_deep_visitor());
(visitor.if_this_changed, visitor.then_this_would_need)
};

3
compiler/rustc_incremental/src/persist/dirty_clean.rs
View File

@ -137,9 +137,8 @@ pub fn check_dirty_clean_annotations(tcx: TyCtxt<'_>) {
}
tcx.dep_graph.with_ignore(|| {
let krate = tcx.hir().krate();
let mut dirty_clean_visitor = DirtyCleanVisitor { tcx, checked_attrs: Default::default() };
krate.visit_all_item_likes(&mut dirty_clean_visitor);
tcx.hir().visit_all_item_likes(&mut dirty_clean_visitor);
let mut all_attrs = FindAllAttrs { tcx, found_attrs: vec![] };
tcx.hir().walk_attributes(&mut all_attrs);

2
compiler/rustc_interface/src/proc_macro_decls.rs
View File

@ -7,7 +7,7 @@ use rustc_span::symbol::sym;
fn proc_macro_decls_static(tcx: TyCtxt<'_>, (): ()) -> Option<LocalDefId> {
let mut finder = Finder { tcx, decls: None };
tcx.hir().krate().visit_all_item_likes(&mut finder);
tcx.hir().visit_all_item_likes(&mut finder);
finder.decls.map(|id| tcx.hir().local_def_id(id))
}

10
compiler/rustc_lint/src/builtin.rs
View File

@ -584,8 +584,14 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
self.doc_hidden_stack.pop().expect("empty doc_hidden_stack");
}
fn check_crate(&mut self, cx: &LateContext<'_>, krate: &hir::Crate<'_>) {
self.check_missing_docs_attrs(cx, CRATE_DEF_ID, krate.module().inner, "the", "crate");
fn check_crate(&mut self, cx: &LateContext<'_>, _: &hir::Crate<'_>) {
self.check_missing_docs_attrs(
cx,
CRATE_DEF_ID,
cx.tcx.def_span(CRATE_DEF_ID),
"the",
"crate",
);
}
fn check_item(&mut self, cx: &LateContext<'_>, it: &hir::Item<'_>) {

2
compiler/rustc_metadata/src/foreign_modules.rs
View File

@ -5,7 +5,7 @@ use rustc_middle::ty::TyCtxt;
crate fn collect(tcx: TyCtxt<'_>) -> Vec<ForeignModule> {
let mut collector = Collector { modules: Vec::new() };
tcx.hir().krate().visit_all_item_likes(&mut collector);
tcx.hir().visit_all_item_likes(&mut collector);
collector.modules
}

2
compiler/rustc_metadata/src/native_libs.rs
View File

@ -14,7 +14,7 @@ use rustc_target::spec::abi::Abi;
crate fn collect(tcx: TyCtxt<'_>) -> Vec<NativeLib> {
let mut collector = Collector { tcx, libs: Vec::new() };
tcx.hir().krate().visit_all_item_likes(&mut collector);
tcx.hir().visit_all_item_likes(&mut collector);
collector.process_command_line();
collector.libs
}

7
compiler/rustc_metadata/src/rmeta/encoder.rs
View File

@ -440,8 +440,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
}
fn encode_info_for_items(&mut self) {
let krate = self.tcx.hir().krate();
self.encode_info_for_mod(CRATE_DEF_ID, krate.module());
self.encode_info_for_mod(CRATE_DEF_ID, self.tcx.hir().root_module());
// Proc-macro crates only export proc-macro items, which are looked
// up using `proc_macro_data`
@ -449,7 +448,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
return;
}
krate.visit_all_item_likes(&mut self.as_deep_visitor());
self.tcx.hir().visit_all_item_likes(&mut self.as_deep_visitor());
}
fn encode_def_path_table(&mut self) {
@ -1782,7 +1781,7 @@ impl EncodeContext<'a, 'tcx> {
debug!("EncodeContext::encode_impls()");
let tcx = self.tcx;
let mut visitor = ImplVisitor { tcx, impls: FxHashMap::default() };
tcx.hir().krate().visit_all_item_likes(&mut visitor);
tcx.hir().visit_all_item_likes(&mut visitor);
let mut all_impls: Vec<_> = visitor.impls.into_iter().collect();

55
compiler/rustc_middle/src/hir/map/mod.rs
View File

@ -6,6 +6,7 @@ use rustc_ast as ast;
use rustc_data_structures::fingerprint::Fingerprint;
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_data_structures::svh::Svh;
use rustc_data_structures::sync::{par_for_each_in, Send, Sync};
use rustc_hir::def::{DefKind, Res};
use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, CRATE_DEF_ID, LOCAL_CRATE};
use rustc_hir::definitions::{DefKey, DefPath, DefPathHash};
@ -156,6 +157,21 @@ impl<'hir> Map<'hir> {
self.tcx.hir_crate(())
}
pub fn root_module(&self) -> &'hir Mod<'hir> {
match self.tcx.hir_owner(CRATE_DEF_ID).map(|o| o.node) {
Some(OwnerNode::Crate(item)) => item,
_ => panic!(),
}
}
crate fn items(&self) -> impl Iterator<Item = &'hir Item<'hir>> + 'hir {
let krate = self.krate();
krate.owners.iter().filter_map(|owner| match owner.as_ref()? {
OwnerNode::Item(item) => Some(*item),
_ => None,
})
}
pub fn def_key(&self, def_id: LocalDefId) -> DefKey {
// Accessing the DefKey is ok, since it is part of DefPathHash.
self.tcx.untracked_resolutions.definitions.def_key(def_id)
@ -531,6 +547,45 @@ impl<'hir> Map<'hir> {
}
}
/// Visits all items in the crate in some deterministic (but
/// unspecified) order. If you just need to process every item,
/// but don't care about nesting, this method is the best choice.
///
/// If you do care about nesting -- usually because your algorithm
/// follows lexical scoping rules -- then you want a different
/// approach. You should override `visit_nested_item` in your
/// visitor and then call `intravisit::walk_crate` instead.
pub fn visit_all_item_likes<V>(&self, visitor: &mut V)
where
V: itemlikevisit::ItemLikeVisitor<'hir>,
{
let krate = self.krate();
for owner in krate.owners.iter().filter_map(Option::as_ref) {
match owner {
OwnerNode::Item(item) => visitor.visit_item(item),
OwnerNode::ForeignItem(item) => visitor.visit_foreign_item(item),
OwnerNode::ImplItem(item) => visitor.visit_impl_item(item),
OwnerNode::TraitItem(item) => visitor.visit_trait_item(item),
OwnerNode::Crate(_) => {}
}
}
}
/// A parallel version of `visit_all_item_likes`.
pub fn par_visit_all_item_likes<V>(&self, visitor: &V)
where
V: itemlikevisit::ParItemLikeVisitor<'hir> + Sync + Send,
{
let krate = self.krate();
par_for_each_in(&krate.owners.raw, |owner| match owner.as_ref() {
Some(OwnerNode::Item(item)) => visitor.visit_item(item),
Some(OwnerNode::ForeignItem(item)) => visitor.visit_foreign_item(item),
Some(OwnerNode::ImplItem(item)) => visitor.visit_impl_item(item),
Some(OwnerNode::TraitItem(item)) => visitor.visit_trait_item(item),
Some(OwnerNode::Crate(_)) | None => {}
})
}
pub fn visit_item_likes_in_module<V>(&self, module: LocalDefId, visitor: &mut V)
where
V: ItemLikeVisitor<'hir>,

2
compiler/rustc_middle/src/ty/print/pretty.rs
View File

@ -2340,7 +2340,7 @@ define_print_and_forward_display! {
fn for_each_def(tcx: TyCtxt<'_>, mut collect_fn: impl for<'b> FnMut(&'b Ident, Namespace, DefId)) {
// Iterate all local crate items no matter where they are defined.
let hir = tcx.hir();
for item in hir.krate().items() {
for item in hir.items() {
if item.ident.name.as_str().is_empty() || matches!(item.kind, ItemKind::Use(_, _)) {
continue;
}

4
compiler/rustc_mir_transform/src/lib.rs
View File

@ -160,9 +160,7 @@ fn mir_keys(tcx: TyCtxt<'_>, (): ()) -> FxHashSet<LocalDefId> {
NestedVisitorMap::None
}
}
tcx.hir()
.krate()
.visit_all_item_likes(&mut GatherCtors { tcx, set: &mut set }.as_deep_visitor());
tcx.hir().visit_all_item_likes(&mut GatherCtors { tcx, set: &mut set }.as_deep_visitor());
set
}

2
compiler/rustc_monomorphize/src/collector.rs
View File

@ -330,7 +330,7 @@ fn collect_roots(tcx: TyCtxt<'_>, mode: MonoItemCollectionMode) -> Vec<MonoItem<
let mut visitor = RootCollector { tcx, mode, entry_fn, output: &mut roots };
tcx.hir().krate().visit_all_item_likes(&mut visitor);
tcx.hir().visit_all_item_likes(&mut visitor);
visitor.push_extra_entry_roots();
}

19
compiler/rustc_passes/src/dead.rs
View File

@ -510,15 +510,14 @@ fn has_allow_dead_code_or_lang_attr(tcx: TyCtxt<'_>, id: hir::HirId) -> bool {
// or
// 2) We are not sure to be live or not
// * Implementations of traits and trait methods
struct LifeSeeder<'k, 'tcx> {
struct LifeSeeder<'tcx> {
worklist: Vec<LocalDefId>,
krate: &'k hir::Crate<'k>,
tcx: TyCtxt<'tcx>,
// see `MarkSymbolVisitor::struct_constructors`
struct_constructors: FxHashMap<LocalDefId, LocalDefId>,
}
impl<'v, 'k, 'tcx> ItemLikeVisitor<'v> for LifeSeeder<'k, 'tcx> {
impl<'v, 'tcx> ItemLikeVisitor<'v> for LifeSeeder<'tcx> {
fn visit_item(&mut self, item: &hir::Item<'_>) {
let allow_dead_code = has_allow_dead_code_or_lang_attr(self.tcx, item.hir_id());
if allow_dead_code {
@ -545,7 +544,7 @@ impl<'v, 'k, 'tcx> ItemLikeVisitor<'v> for LifeSeeder<'k, 'tcx> {
self.worklist.push(item.def_id);
}
for impl_item_ref in items {
let impl_item = self.krate.impl_item(impl_item_ref.id);
let impl_item = self.tcx.hir().impl_item(impl_item_ref.id);
if of_trait.is_some()
|| has_allow_dead_code_or_lang_attr(self.tcx, impl_item.hir_id())
{
@ -589,7 +588,6 @@ impl<'v, 'k, 'tcx> ItemLikeVisitor<'v> for LifeSeeder<'k, 'tcx> {
fn create_and_seed_worklist<'tcx>(
tcx: TyCtxt<'tcx>,
access_levels: &privacy::AccessLevels,
krate: &hir::Crate<'_>,
) -> (Vec<LocalDefId>, FxHashMap<LocalDefId, LocalDefId>) {
let worklist = access_levels
.map
@ -604,9 +602,8 @@ fn create_and_seed_worklist<'tcx>(
.collect::<Vec<_>>();
// Seed implemented trait items
let mut life_seeder =
LifeSeeder { worklist, krate, tcx, struct_constructors: Default::default() };
krate.visit_all_item_likes(&mut life_seeder);
let mut life_seeder = LifeSeeder { worklist, tcx, struct_constructors: Default::default() };
tcx.hir().visit_all_item_likes(&mut life_seeder);
(life_seeder.worklist, life_seeder.struct_constructors)
}
@ -614,9 +611,8 @@ fn create_and_seed_worklist<'tcx>(
fn find_live<'tcx>(
tcx: TyCtxt<'tcx>,
access_levels: &privacy::AccessLevels,
krate: &hir::Crate<'_>,
) -> FxHashSet<LocalDefId> {
let (worklist, struct_constructors) = create_and_seed_worklist(tcx, access_levels, krate);
let (worklist, struct_constructors) = create_and_seed_worklist(tcx, access_levels);
let mut symbol_visitor = MarkSymbolVisitor {
worklist,
tcx,
@ -834,8 +830,7 @@ impl Visitor<'tcx> for DeadVisitor<'tcx> {
pub fn check_crate(tcx: TyCtxt<'_>) {
let access_levels = &tcx.privacy_access_levels(());
let krate = tcx.hir().krate();
let live_symbols = find_live(tcx, access_levels, krate);
let live_symbols = find_live(tcx, access_levels);
let mut visitor = DeadVisitor { tcx, live_symbols };
tcx.hir().walk_toplevel_module(&mut visitor);
}

2
compiler/rustc_passes/src/diagnostic_items.rs
View File

@ -105,7 +105,7 @@ fn diagnostic_items<'tcx>(tcx: TyCtxt<'tcx>, cnum: CrateNum) -> FxHashMap<Symbol
let mut collector = DiagnosticItemCollector::new(tcx);
// Collect diagnostic items in this crate.
tcx.hir().krate().visit_all_item_likes(&mut collector);
tcx.hir().visit_all_item_likes(&mut collector);
collector.items
}

6
compiler/rustc_passes/src/entry.rs
View File

@ -1,6 +1,6 @@
use rustc_ast::entry::EntryPointType;
use rustc_errors::struct_span_err;
use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
use rustc_hir::def_id::{DefId, CRATE_DEF_ID, CRATE_DEF_INDEX, LOCAL_CRATE};
use rustc_hir::itemlikevisit::ItemLikeVisitor;
use rustc_hir::{ForeignItem, HirId, ImplItem, Item, ItemKind, Node, TraitItem, CRATE_HIR_ID};
use rustc_middle::hir::map::Map;
@ -68,7 +68,7 @@ fn entry_fn(tcx: TyCtxt<'_>, (): ()) -> Option<(DefId, EntryFnType)> {
non_main_fns: Vec::new(),
};
tcx.hir().krate().visit_all_item_likes(&mut ctxt);
tcx.hir().visit_all_item_likes(&mut ctxt);
configure_main(tcx, &ctxt)
}
@ -183,7 +183,7 @@ fn configure_main(tcx: TyCtxt<'_>, visitor: &EntryContext<'_, '_>) -> Option<(De
}
fn no_main_err(tcx: TyCtxt<'_>, visitor: &EntryContext<'_, '_>) {
let sp = tcx.hir().krate().module().inner;
let sp = tcx.def_span(CRATE_DEF_ID);
if *tcx.sess.parse_sess.reached_eof.borrow() {
// There's an unclosed brace that made the parser reach `Eof`, we shouldn't complain about
// the missing `fn main()` then as it might have been hidden inside an unclosed block.

2
compiler/rustc_passes/src/lang_items.rs
View File

@ -262,7 +262,7 @@ fn get_lang_items(tcx: TyCtxt<'_>, (): ()) -> LanguageItems {
}
// Collect lang items in this crate.
tcx.hir().krate().visit_all_item_likes(&mut collector);
tcx.hir().visit_all_item_likes(&mut collector);
// Extract out the found lang items.
let LanguageItemCollector { mut items, .. } = collector;

2
compiler/rustc_passes/src/layout_test.rs
View File

@ -12,7 +12,7 @@ use rustc_target::abi::{HasDataLayout, TargetDataLayout};
pub fn test_layout(tcx: TyCtxt<'_>) {
if tcx.features().rustc_attrs {
// if the `rustc_attrs` feature is not enabled, don't bother testing layout
tcx.hir().krate().visit_all_item_likes(&mut LayoutTest { tcx });
tcx.hir().visit_all_item_likes(&mut LayoutTest { tcx });
}
}

2
compiler/rustc_passes/src/reachable.rs
View File

@ -427,7 +427,7 @@ fn reachable_set<'tcx>(tcx: TyCtxt<'tcx>, (): ()) -> FxHashSet<LocalDefId> {
access_levels,
worklist: &mut reachable_context.worklist,
};
tcx.hir().krate().visit_all_item_likes(&mut collect_private_impl_items);
tcx.hir().visit_all_item_likes(&mut collect_private_impl_items);
}
// Step 2: Mark all symbols that the symbols on the worklist touch.

3
compiler/rustc_passes/src/stability.rs
View File

@ -906,11 +906,10 @@ pub fn check_unused_or_stable_features(tcx: TyCtxt<'_>) {
let access_levels = &tcx.privacy_access_levels(());
if tcx.stability().staged_api[&LOCAL_CRATE] {
let krate = tcx.hir().krate();
let mut missing = MissingStabilityAnnotations { tcx, access_levels };
missing.check_missing_stability(CRATE_DEF_ID, tcx.hir().span(CRATE_HIR_ID));
tcx.hir().walk_toplevel_module(&mut missing);
krate.visit_all_item_likes(&mut missing.as_deep_visitor());
tcx.hir().visit_all_item_likes(&mut missing.as_deep_visitor());
}
let declared_lang_features = &tcx.features().declared_lang_features;

2
compiler/rustc_passes/src/weak_lang_items.rs
View File

@ -33,7 +33,7 @@ pub fn check_crate<'tcx>(tcx: TyCtxt<'tcx>, items: &mut lang_items::LanguageItem
{
let mut cx = Context { tcx, items };
tcx.hir().krate().visit_all_item_likes(&mut cx.as_deep_visitor());
tcx.hir().visit_all_item_likes(&mut cx.as_deep_visitor());
}
verify(tcx, items);
}

4
compiler/rustc_privacy/src/lib.rs
View File

@ -2189,8 +2189,6 @@ fn privacy_access_levels(tcx: TyCtxt<'_>, (): ()) -> &AccessLevels {
fn check_private_in_public(tcx: TyCtxt<'_>, (): ()) {
let access_levels = tcx.privacy_access_levels(());
let krate = tcx.hir().krate();
let mut visitor = ObsoleteVisiblePrivateTypesVisitor {
tcx,
access_levels: &access_levels,
@ -2230,5 +2228,5 @@ fn check_private_in_public(tcx: TyCtxt<'_>, (): ()) {
.filter_map(|hir_id| tcx.hir().opt_local_def_id(hir_id))
.collect(),
};
krate.visit_all_item_likes(&mut DeepVisitor::new(&mut visitor));
tcx.hir().visit_all_item_likes(&mut DeepVisitor::new(&mut visitor));
}

10
compiler/rustc_save_analysis/src/dump_visitor.rs
View File

@ -18,7 +18,7 @@ use rustc_ast::walk_list;
use rustc_data_structures::fx::FxHashSet;
use rustc_hir as hir;
use rustc_hir::def::{DefKind as HirDefKind, Res};
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_hir::def_id::{DefId, LocalDefId, CRATE_DEF_ID};
use rustc_hir::intravisit::{self, Visitor};
use rustc_hir_pretty::{bounds_to_string, fn_to_string, generic_params_to_string, ty_to_string};
use rustc_middle::hir::map::Map;
@ -128,7 +128,7 @@ impl<'tcx> DumpVisitor<'tcx> {
self.save_ctxt.lookup_def_id(ref_id)
}
pub fn dump_crate_info(&mut self, name: &str, krate: &hir::Crate<'_>) {
pub fn dump_crate_info(&mut self, name: &str) {
let source_file = self.tcx.sess.local_crate_source_file.as_ref();
let crate_root = source_file.map(|source_file| {
let source_file = Path::new(source_file);
@ -146,7 +146,7 @@ impl<'tcx> DumpVisitor<'tcx> {
},
crate_root: crate_root.unwrap_or_else(|| "<no source>".to_owned()),
external_crates: self.save_ctxt.get_external_crates(),
span: self.span_from_span(krate.module().inner),
span: self.span_from_span(self.tcx.def_span(CRATE_DEF_ID)),
};
self.dumper.crate_prelude(data);
@ -1090,13 +1090,13 @@ impl<'tcx> DumpVisitor<'tcx> {
}
}
pub(crate) fn process_crate(&mut self, krate: &'tcx hir::Crate<'tcx>) {
pub(crate) fn process_crate(&mut self) {
let id = hir::CRATE_HIR_ID;
let qualname =
format!("::{}", self.tcx.def_path_str(self.tcx.hir().local_def_id(id).to_def_id()));
let sm = self.tcx.sess.source_map();
let krate_mod = krate.module();
let krate_mod = self.tcx.hir().root_module();
let filename = sm.span_to_filename(krate_mod.inner);
let data_id = id_from_hir_id(id, &self.save_ctxt);
let children =

4
compiler/rustc_save_analysis/src/lib.rs
View File

@ -1003,9 +1003,9 @@ pub fn process_crate<'l, 'tcx, H: SaveHandler>(
let mut visitor = DumpVisitor::new(save_ctxt);
visitor.dump_crate_info(cratename, tcx.hir().krate());
visitor.dump_crate_info(cratename);
visitor.dump_compilation_options(input, cratename);
visitor.process_crate(tcx.hir().krate());
visitor.process_crate();
handler.save(&visitor.save_ctxt, &visitor.analysis())
})

2
compiler/rustc_symbol_mangling/src/test.rs
View File

@ -23,7 +23,7 @@ pub fn report_symbol_names(tcx: TyCtxt<'_>) {
tcx.dep_graph.with_ignore(|| {
let mut visitor = SymbolNamesTest { tcx };
tcx.hir().krate().visit_all_item_likes(&mut visitor);
tcx.hir().visit_all_item_likes(&mut visitor);
})
}

2
compiler/rustc_typeck/src/check/check.rs
View File

@ -31,7 +31,7 @@ use std::ops::ControlFlow;
pub fn check_wf_new(tcx: TyCtxt<'_>) {
let visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
tcx.hir().krate().par_visit_all_item_likes(&visit);
tcx.hir().par_visit_all_item_likes(&visit);
}
pub(super) fn check_abi(tcx: TyCtxt<'_>, hir_id: hir::HirId, span: Span, abi: Abi) {

2
compiler/rustc_typeck/src/check/method/suggest.rs
View File

@ -1646,7 +1646,7 @@ fn compute_all_traits(tcx: TyCtxt<'_>, (): ()) -> &[DefId] {
fn visit_foreign_item(&mut self, _foreign_item: &hir::ForeignItem<'_>) {}
}
tcx.hir().krate().visit_all_item_likes(&mut Visitor { traits: &mut traits });
tcx.hir().visit_all_item_likes(&mut Visitor { traits: &mut traits });
// Cross-crate:

4
compiler/rustc_typeck/src/check_unused.rs
View File

@ -16,7 +16,7 @@ pub fn check_crate(tcx: TyCtxt<'_>) {
}
let mut visitor = CheckVisitor { tcx, used_trait_imports };
tcx.hir().krate().visit_all_item_likes(&mut visitor);
tcx.hir().visit_all_item_likes(&mut visitor);
unused_crates_lint(tcx);
}
@ -111,7 +111,7 @@ fn unused_crates_lint(tcx: TyCtxt<'_>) {
// Collect all the extern crates (in a reliable order).
let mut crates_to_lint = vec![];
tcx.hir().krate().visit_all_item_likes(&mut CollectExternCrateVisitor {
tcx.hir().visit_all_item_likes(&mut CollectExternCrateVisitor {
crates_to_lint: &mut crates_to_lint,
});

3
compiler/rustc_typeck/src/coherence/inherent_impls.rs
View File

@ -17,9 +17,8 @@ use rustc_span::Span;
/// On-demand query: yields a map containing all types mapped to their inherent impls.
pub fn crate_inherent_impls(tcx: TyCtxt<'_>, (): ()) -> CrateInherentImpls {
let krate = tcx.hir().krate();
let mut collect = InherentCollect { tcx, impls_map: Default::default() };
krate.visit_all_item_likes(&mut collect);
tcx.hir().visit_all_item_likes(&mut collect);
collect.impls_map
}

3
compiler/rustc_typeck/src/coherence/inherent_impls_overlap.rs
View File

@ -10,8 +10,7 @@ use smallvec::SmallVec;
use std::collections::hash_map::Entry;
pub fn crate_inherent_impls_overlap_check(tcx: TyCtxt<'_>, (): ()) {
let krate = tcx.hir().krate();
krate.visit_all_item_likes(&mut InherentOverlapChecker { tcx });
tcx.hir().visit_all_item_likes(&mut InherentOverlapChecker { tcx });
}
struct InherentOverlapChecker<'tcx> {

2
compiler/rustc_typeck/src/coherence/orphan.rs
View File

@ -10,7 +10,7 @@ use rustc_trait_selection::traits;
pub fn check(tcx: TyCtxt<'_>) {
let mut orphan = OrphanChecker { tcx };
tcx.hir().krate().visit_all_item_likes(&mut orphan);
tcx.hir().visit_all_item_likes(&mut orphan);
}
struct OrphanChecker<'tcx> {

2
compiler/rustc_typeck/src/coherence/unsafety.rs
View File

@ -9,7 +9,7 @@ use rustc_middle::ty::TyCtxt;
pub fn check(tcx: TyCtxt<'_>) {
let mut unsafety = UnsafetyChecker { tcx };
tcx.hir().krate().visit_all_item_likes(&mut unsafety);
tcx.hir().visit_all_item_likes(&mut unsafety);
}
struct UnsafetyChecker<'tcx> {

2
compiler/rustc_typeck/src/outlives/implicit_infer.rs
View File

@ -37,7 +37,7 @@ pub fn infer_predicates<'tcx>(
};
// Visit all the crates and infer predicates
tcx.hir().krate().visit_all_item_likes(&mut visitor);
tcx.hir().visit_all_item_likes(&mut visitor);
}
global_inferred_outlives

2
compiler/rustc_typeck/src/outlives/test.rs
View File

@ -5,7 +5,7 @@ use rustc_middle::ty::TyCtxt;
use rustc_span::symbol::sym;
pub fn test_inferred_outlives(tcx: TyCtxt<'_>) {
tcx.hir().krate().visit_all_item_likes(&mut OutlivesTest { tcx });
tcx.hir().visit_all_item_likes(&mut OutlivesTest { tcx });
}
struct OutlivesTest<'tcx> {

2
compiler/rustc_typeck/src/variance/constraints.rs
View File

@ -62,7 +62,7 @@ pub fn add_constraints_from_crate<'a, 'tcx>(
constraints: Vec::new(),
};
tcx.hir().krate().visit_all_item_likes(&mut constraint_cx);
tcx.hir().visit_all_item_likes(&mut constraint_cx);
constraint_cx
}

2
compiler/rustc_typeck/src/variance/terms.rs
View File

@ -79,7 +79,7 @@ pub fn determine_parameters_to_be_inferred<'a, 'tcx>(
//
// - https://rustc-dev-guide.rust-lang.org/query.html
// - https://rustc-dev-guide.rust-lang.org/variance.html
tcx.hir().krate().visit_all_item_likes(&mut terms_cx);
tcx.hir().visit_all_item_likes(&mut terms_cx);
terms_cx
}

2
compiler/rustc_typeck/src/variance/test.rs
View File

@ -5,7 +5,7 @@ use rustc_middle::ty::TyCtxt;
use rustc_span::symbol::sym;
pub fn test_variance(tcx: TyCtxt<'_>) {
tcx.hir().krate().visit_all_item_likes(&mut VarianceTest { tcx });
tcx.hir().visit_all_item_likes(&mut VarianceTest { tcx });
}
struct VarianceTest<'tcx> {

6
src/librustdoc/clean/types.rs
View File

@ -230,8 +230,7 @@ impl ExternalCrate {
};
if root.is_local() {
tcx.hir()
.krate()
.module()
.root_module()
.item_ids
.iter()
.filter_map(|&id| {
@ -297,8 +296,7 @@ impl ExternalCrate {
if root.is_local() {
tcx.hir()
.krate()
.module()
.root_module()
.item_ids
.iter()
.filter_map(|&id| {

3
src/librustdoc/clean/utils.rs
View File

@ -26,8 +26,7 @@ mod tests;
crate fn krate(cx: &mut DocContext<'_>) -> Crate {
use crate::visit_lib::LibEmbargoVisitor;
let krate = cx.tcx.hir().krate();
let module = crate::visit_ast::RustdocVisitor::new(cx).visit(krate);
let module = crate::visit_ast::RustdocVisitor::new(cx).visit();
let mut externs = Vec::new();
for &cnum in cx.tcx.crates(()).iter() {

6
src/librustdoc/visit_ast.rs
View File

@ -71,12 +71,12 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
self.exact_paths.entry(did).or_insert_with(|| def_id_to_path(tcx, did));
}
crate fn visit(mut self, krate: &'tcx hir::Crate<'_>) -> Module<'tcx> {
let span = krate.module().inner;
crate fn visit(mut self) -> Module<'tcx> {
let span = self.cx.tcx.def_span(CRATE_DEF_ID);
let mut top_level_module = self.visit_mod_contents(
&Spanned { span, node: hir::VisibilityKind::Public },
hir::CRATE_HIR_ID,
&krate.module(),
self.cx.tcx.hir().root_module(),
self.cx.tcx.crate_name(LOCAL_CRATE),
);

8
src/tools/clippy/clippy_lints/src/missing_doc.rs
View File

@ -78,9 +78,7 @@ impl MissingDoc {
return;
}
let has_doc = attrs
.iter()
.any(|a| a.doc_str().is_some());
let has_doc = attrs.iter().any(|a| a.doc_str().is_some());
if !has_doc {
span_lint(
cx,
@ -104,9 +102,9 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
self.doc_hidden_stack.pop().expect("empty doc_hidden_stack");
}
fn check_crate(&mut self, cx: &LateContext<'tcx>, krate: &'tcx hir::Crate<'_>) {
fn check_crate(&mut self, cx: &LateContext<'tcx>, _: &'tcx hir::Crate<'_>) {
let attrs = cx.tcx.hir().attrs(hir::CRATE_HIR_ID);
self.check_missing_docs_attrs(cx, attrs, krate.module().inner, "the", "crate");
self.check_missing_docs_attrs(cx, attrs, cx.tcx.hir().root_module().inner, "the", "crate");
}
fn check_item(&mut self, cx: &LateContext<'tcx>, it: &'tcx hir::Item<'_>) {