From db03a2deb090d5c24f15ef30cf4e5ccb13690b9d Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Tue, 29 Mar 2022 23:50:01 +0200 Subject: [PATCH 1/4] Avoid accessing HIR from MIR queries. --- compiler/rustc_borrowck/src/lib.rs | 21 ++++++++++--------- .../rustc_borrowck/src/universal_regions.rs | 8 +++---- .../src/transform/check_consts/check.rs | 8 ++----- .../src/transform/check_consts/mod.rs | 10 ++------- compiler/rustc_hir/src/def.rs | 8 +++++++ .../rustc_mir_transform/src/const_prop.rs | 5 +++-- .../src/const_prop_lint.rs | 2 +- compiler/rustc_mir_transform/src/lib.rs | 2 +- compiler/rustc_mir_transform/src/shim.rs | 5 ++--- compiler/rustc_ty_utils/src/ty.rs | 7 +------ 10 files changed, 35 insertions(+), 41 deletions(-) diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs index 0007d8026e66b..0a1eae39d75ce 100644 --- a/compiler/rustc_borrowck/src/lib.rs +++ b/compiler/rustc_borrowck/src/lib.rs @@ -23,7 +23,6 @@ use rustc_data_structures::graph::dominators::Dominators; use rustc_errors::{Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed}; use rustc_hir as hir; use rustc_hir::def_id::LocalDefId; -use rustc_hir::Node; use rustc_index::bit_set::ChunkedBitSet; use rustc_index::vec::IndexVec; use rustc_infer::infer::{InferCtxt, TyCtxtInferExt}; @@ -288,14 +287,16 @@ fn do_mir_borrowck<'a, 'tcx>( .pass_name("borrowck") .iterate_to_fixpoint(); - let def_hir_id = tcx.hir().local_def_id_to_hir_id(def.did); - let movable_generator = !matches!( - tcx.hir().get(def_hir_id), - Node::Expr(&hir::Expr { - kind: hir::ExprKind::Closure(.., Some(hir::Movability::Static)), - .. - }) - ); + let movable_generator = + // The first argument is the generator type passed by value + if let Some(local) = body.local_decls.raw.get(1) + // Get the interior types and substs which typeck computed + && let ty::Generator(_, _, hir::Movability::Static) = local.ty.kind() + { + false + } else { + true + }; for (idx, move_data_results) in promoted_errors { let promoted_body = &promoted[idx]; @@ -385,7 +386,7 @@ fn do_mir_borrowck<'a, 'tcx>( let scope = mbcx.body.source_info(location).scope; let lint_root = match &mbcx.body.source_scopes[scope].local_data { ClearCrossCrate::Set(data) => data.lint_root, - _ => def_hir_id, + _ => tcx.hir().local_def_id_to_hir_id(def.did), }; // Span and message don't matter; we overwrite them below anyway diff --git a/compiler/rustc_borrowck/src/universal_regions.rs b/compiler/rustc_borrowck/src/universal_regions.rs index 0bf2eb17d1b73..28a566ca40861 100644 --- a/compiler/rustc_borrowck/src/universal_regions.rs +++ b/compiler/rustc_borrowck/src/universal_regions.rs @@ -829,12 +829,12 @@ fn for_each_late_bound_region_defined_on<'tcx>( ) { if let Some((owner, late_bounds)) = tcx.is_late_bound_map(fn_def_id.expect_local()) { for &late_bound in late_bounds.iter() { - let hir_id = HirId { owner, local_id: late_bound }; - let name = tcx.hir().name(hir_id); - let region_def_id = tcx.hir().local_def_id(hir_id); + let region_def_id = + tcx.hir().local_def_id(HirId { owner, local_id: late_bound }).to_def_id(); + let name = tcx.item_name(region_def_id); let liberated_region = tcx.mk_region(ty::ReFree(ty::FreeRegion { scope: owner.to_def_id(), - bound_region: ty::BoundRegionKind::BrNamed(region_def_id.to_def_id(), name), + bound_region: ty::BoundRegionKind::BrNamed(region_def_id, name), })); f(liberated_region); } diff --git a/compiler/rustc_const_eval/src/transform/check_consts/check.rs b/compiler/rustc_const_eval/src/transform/check_consts/check.rs index e203c79030d20..625f57b872bf7 100644 --- a/compiler/rustc_const_eval/src/transform/check_consts/check.rs +++ b/compiler/rustc_const_eval/src/transform/check_consts/check.rs @@ -222,7 +222,7 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> { // `async` functions cannot be `const fn`. This is checked during AST lowering, so there's // no need to emit duplicate errors here. - if is_async_fn(self.ccx) || body.generator.is_some() { + if self.ccx.is_async() || body.generator.is_some() { tcx.sess.delay_span_bug(body.span, "`async` functions cannot be `const fn`"); return; } @@ -1056,12 +1056,8 @@ fn is_int_bool_or_char(ty: Ty<'_>) -> bool { ty.is_bool() || ty.is_integral() || ty.is_char() } -fn is_async_fn(ccx: &ConstCx<'_, '_>) -> bool { - ccx.fn_sig().map_or(false, |sig| sig.header.asyncness == hir::IsAsync::Async) -} - fn emit_unstable_in_stable_error(ccx: &ConstCx<'_, '_>, span: Span, gate: Symbol) { - let attr_span = ccx.fn_sig().map_or(ccx.body.span, |sig| sig.span.shrink_to_lo()); + let attr_span = ccx.tcx.def_span(ccx.def_id()).shrink_to_lo(); ccx.tcx .sess diff --git a/compiler/rustc_const_eval/src/transform/check_consts/mod.rs b/compiler/rustc_const_eval/src/transform/check_consts/mod.rs index b026bb2bad657..25ba97ee60567 100644 --- a/compiler/rustc_const_eval/src/transform/check_consts/mod.rs +++ b/compiler/rustc_const_eval/src/transform/check_consts/mod.rs @@ -61,14 +61,8 @@ impl<'mir, 'tcx> ConstCx<'mir, 'tcx> { && is_const_stable_const_fn(self.tcx, self.def_id().to_def_id()) } - /// Returns the function signature of the item being const-checked if it is a `fn` or `const fn`. - pub fn fn_sig(&self) -> Option<&'tcx hir::FnSig<'tcx>> { - // Get this from the HIR map instead of a query to avoid cycle errors. - // - // FIXME: Is this still an issue? - let hir_map = self.tcx.hir(); - let hir_id = hir_map.local_def_id_to_hir_id(self.def_id()); - hir_map.fn_sig_by_hir_id(hir_id) + fn is_async(&self) -> bool { + self.tcx.asyncness(self.def_id()) == hir::IsAsync::Async } } diff --git a/compiler/rustc_hir/src/def.rs b/compiler/rustc_hir/src/def.rs index 352f369f0d4bc..53d60d280c001 100644 --- a/compiler/rustc_hir/src/def.rs +++ b/compiler/rustc_hir/src/def.rs @@ -223,6 +223,14 @@ impl DefKind { | DefKind::Impl => None, } } + + #[inline] + pub fn is_fn_like(self) -> bool { + match self { + DefKind::Fn | DefKind::AssocFn | DefKind::Closure | DefKind::Generator => true, + _ => false, + } + } } /// The resolution of a path or export. diff --git a/compiler/rustc_mir_transform/src/const_prop.rs b/compiler/rustc_mir_transform/src/const_prop.rs index a342aeed905e9..aa47630a26ac0 100644 --- a/compiler/rustc_mir_transform/src/const_prop.rs +++ b/compiler/rustc_mir_transform/src/const_prop.rs @@ -71,8 +71,9 @@ impl<'tcx> MirPass<'tcx> for ConstProp { } let def_id = body.source.def_id().expect_local(); - let is_fn_like = tcx.hir().get_by_def_id(def_id).fn_kind().is_some(); - let is_assoc_const = tcx.def_kind(def_id) == DefKind::AssocConst; + let def_kind = tcx.def_kind(def_id); + let is_fn_like = def_kind.is_fn_like(); + let is_assoc_const = def_kind == DefKind::AssocConst; // Only run const prop on functions, methods, closures and associated constants if !is_fn_like && !is_assoc_const { diff --git a/compiler/rustc_mir_transform/src/const_prop_lint.rs b/compiler/rustc_mir_transform/src/const_prop_lint.rs index 159503ad2d3f7..50400cdeac978 100644 --- a/compiler/rustc_mir_transform/src/const_prop_lint.rs +++ b/compiler/rustc_mir_transform/src/const_prop_lint.rs @@ -67,7 +67,7 @@ impl<'tcx> MirLint<'tcx> for ConstProp { } let def_id = body.source.def_id().expect_local(); - let is_fn_like = tcx.hir().get_by_def_id(def_id).fn_kind().is_some(); + let is_fn_like = tcx.def_kind(def_id).is_fn_like(); let is_assoc_const = tcx.def_kind(def_id) == DefKind::AssocConst; // Only run const prop on functions, methods, closures and associated constants diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs index 059ee09dfd794..d395ccd381933 100644 --- a/compiler/rustc_mir_transform/src/lib.rs +++ b/compiler/rustc_mir_transform/src/lib.rs @@ -366,7 +366,7 @@ fn mir_drops_elaborated_and_const_checked<'tcx>( let mir_borrowck = tcx.mir_borrowck_opt_const_arg(def); - let is_fn_like = tcx.hir().get_by_def_id(def.did).fn_kind().is_some(); + let is_fn_like = tcx.def_kind(def.did).is_fn_like(); if is_fn_like { let did = def.did.to_def_id(); let def = ty::WithOptConstParam::unknown(did); diff --git a/compiler/rustc_mir_transform/src/shim.rs b/compiler/rustc_mir_transform/src/shim.rs index bf031b423c2e5..d10cac2ac7635 100644 --- a/compiler/rustc_mir_transform/src/shim.rs +++ b/compiler/rustc_mir_transform/src/shim.rs @@ -725,9 +725,6 @@ fn build_call_shim<'tcx>( pub fn build_adt_ctor(tcx: TyCtxt<'_>, ctor_id: DefId) -> Body<'_> { debug_assert!(tcx.is_constructor(ctor_id)); - let span = - tcx.hir().span_if_local(ctor_id).unwrap_or_else(|| bug!("no span for ctor {:?}", ctor_id)); - let param_env = tcx.param_env(ctor_id); // Normalize the sig. @@ -740,6 +737,8 @@ pub fn build_adt_ctor(tcx: TyCtxt<'_>, ctor_id: DefId) -> Body<'_> { debug!("build_ctor: ctor_id={:?} sig={:?}", ctor_id, sig); + let span = tcx.def_span(ctor_id); + let local_decls = local_decls_for_sig(&sig, span); let source_info = SourceInfo::outermost(span); diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs index 64145bbf189ff..6ad71bdb48169 100644 --- a/compiler/rustc_ty_utils/src/ty.rs +++ b/compiler/rustc_ty_utils/src/ty.rs @@ -414,12 +414,7 @@ fn issue33140_self_ty(tcx: TyCtxt<'_>, def_id: DefId) -> Option> { /// Check if a function is async. fn asyncness(tcx: TyCtxt<'_>, def_id: DefId) -> hir::IsAsync { let node = tcx.hir().get_by_def_id(def_id.expect_local()); - - let fn_kind = node.fn_kind().unwrap_or_else(|| { - bug!("asyncness: expected fn-like node but got `{:?}`", def_id); - }); - - fn_kind.asyncness() + if let Some(fn_kind) = node.fn_kind() { fn_kind.asyncness() } else { hir::IsAsync::NotAsync } } /// Don't call this directly: use ``tcx.conservative_is_privately_uninhabited`` instead. From 69d818333755d4b836a28a4498f2caad71c2d014 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Wed, 30 Mar 2022 00:17:41 +0200 Subject: [PATCH 2/4] Store LocalDefId in is_late_bound_map. This allows to avoid looking at HIR from borrowck. --- .../rustc_borrowck/src/universal_regions.rs | 8 ++--- .../src/middle/resolve_lifetime.rs | 2 +- compiler/rustc_middle/src/query/mod.rs | 3 +- compiler/rustc_middle/src/ty/context.rs | 5 --- compiler/rustc_resolve/src/late/lifetimes.rs | 17 +++++---- compiler/rustc_typeck/src/collect.rs | 35 ++++++++++++++----- 6 files changed, 42 insertions(+), 28 deletions(-) diff --git a/compiler/rustc_borrowck/src/universal_regions.rs b/compiler/rustc_borrowck/src/universal_regions.rs index 28a566ca40861..e26adba0d3002 100644 --- a/compiler/rustc_borrowck/src/universal_regions.rs +++ b/compiler/rustc_borrowck/src/universal_regions.rs @@ -828,13 +828,11 @@ fn for_each_late_bound_region_defined_on<'tcx>( mut f: impl FnMut(ty::Region<'tcx>), ) { if let Some((owner, late_bounds)) = tcx.is_late_bound_map(fn_def_id.expect_local()) { - for &late_bound in late_bounds.iter() { - let region_def_id = - tcx.hir().local_def_id(HirId { owner, local_id: late_bound }).to_def_id(); - let name = tcx.item_name(region_def_id); + for ®ion_def_id in late_bounds.iter() { + let name = tcx.item_name(region_def_id.to_def_id()); let liberated_region = tcx.mk_region(ty::ReFree(ty::FreeRegion { scope: owner.to_def_id(), - bound_region: ty::BoundRegionKind::BrNamed(region_def_id, name), + bound_region: ty::BoundRegionKind::BrNamed(region_def_id.to_def_id(), name), })); f(liberated_region); } diff --git a/compiler/rustc_middle/src/middle/resolve_lifetime.rs b/compiler/rustc_middle/src/middle/resolve_lifetime.rs index bc50730ab8b83..70586cefaeee1 100644 --- a/compiler/rustc_middle/src/middle/resolve_lifetime.rs +++ b/compiler/rustc_middle/src/middle/resolve_lifetime.rs @@ -64,7 +64,7 @@ pub struct ResolveLifetimes { /// Set of lifetime def ids that are late-bound; a region can /// be late-bound if (a) it does NOT appear in a where-clause and /// (b) it DOES appear in the arguments. - pub late_bound: FxHashMap>, + pub late_bound: FxHashMap>, pub late_bound_vars: FxHashMap>>, } diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs index bbe1d367b77ca..f38ade1076eac 100644 --- a/compiler/rustc_middle/src/query/mod.rs +++ b/compiler/rustc_middle/src/query/mod.rs @@ -1502,8 +1502,7 @@ rustc_queries! { Option<&'tcx FxHashMap> { desc { "looking up a named region" } } - query is_late_bound_map(_: LocalDefId) -> - Option<(LocalDefId, &'tcx FxHashSet)> { + query is_late_bound_map(_: LocalDefId) -> Option<(LocalDefId, &'tcx FxHashSet)> { desc { "testing if a region is late bound" } } /// For a given item (like a struct), gets the default lifetimes to be used diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs index a26de409b3c27..5244aaaec0a3c 100644 --- a/compiler/rustc_middle/src/ty/context.rs +++ b/compiler/rustc_middle/src/ty/context.rs @@ -2772,11 +2772,6 @@ impl<'tcx> TyCtxt<'tcx> { self.named_region_map(id.owner).and_then(|map| map.get(&id.local_id).cloned()) } - pub fn is_late_bound(self, id: HirId) -> bool { - self.is_late_bound_map(id.owner) - .map_or(false, |(owner, set)| owner == id.owner && set.contains(&id.local_id)) - } - pub fn late_bound_vars(self, id: HirId) -> &'tcx List { self.mk_bound_variable_kinds( self.late_bound_vars_map(id.owner) diff --git a/compiler/rustc_resolve/src/late/lifetimes.rs b/compiler/rustc_resolve/src/late/lifetimes.rs index 1460b5efbb058..2bf01146fae02 100644 --- a/compiler/rustc_resolve/src/late/lifetimes.rs +++ b/compiler/rustc_resolve/src/late/lifetimes.rs @@ -427,7 +427,7 @@ fn resolve_lifetimes_trait_definition( tcx: TyCtxt<'_>, local_def_id: LocalDefId, ) -> ResolveLifetimes { - convert_named_region_map(do_resolve(tcx, local_def_id, true, false)) + convert_named_region_map(tcx, do_resolve(tcx, local_def_id, true, false)) } /// Computes the `ResolveLifetimes` map that contains data for an entire `Item`. @@ -435,7 +435,7 @@ fn resolve_lifetimes_trait_definition( /// `named_region_map`, `is_late_bound_map`, etc. #[tracing::instrument(level = "debug", skip(tcx))] fn resolve_lifetimes(tcx: TyCtxt<'_>, local_def_id: LocalDefId) -> ResolveLifetimes { - convert_named_region_map(do_resolve(tcx, local_def_id, false, false)) + convert_named_region_map(tcx, do_resolve(tcx, local_def_id, false, false)) } fn do_resolve( @@ -468,7 +468,7 @@ fn do_resolve( named_region_map } -fn convert_named_region_map(named_region_map: NamedRegionMap) -> ResolveLifetimes { +fn convert_named_region_map(tcx: TyCtxt<'_>, named_region_map: NamedRegionMap) -> ResolveLifetimes { let mut rl = ResolveLifetimes::default(); for (hir_id, v) in named_region_map.defs { @@ -477,7 +477,8 @@ fn convert_named_region_map(named_region_map: NamedRegionMap) -> ResolveLifetime } for hir_id in named_region_map.late_bound { let map = rl.late_bound.entry(hir_id.owner).or_default(); - map.insert(hir_id.local_id); + let def_id = tcx.hir().local_def_id(hir_id); + map.insert(def_id); } for (hir_id, v) in named_region_map.late_bound_vars { let map = rl.late_bound_vars.entry(hir_id.owner).or_default(); @@ -537,7 +538,7 @@ fn item_for(tcx: TyCtxt<'_>, local_def_id: LocalDefId) -> LocalDefId { fn is_late_bound_map<'tcx>( tcx: TyCtxt<'tcx>, def_id: LocalDefId, -) -> Option<(LocalDefId, &'tcx FxHashSet)> { +) -> Option<(LocalDefId, &'tcx FxHashSet)> { match tcx.def_kind(def_id) { DefKind::AnonConst | DefKind::InlineConst => { let mut def_id = tcx @@ -774,8 +775,10 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { }); } for (&owner, late_bound) in resolved_lifetimes.late_bound.iter() { - late_bound.iter().for_each(|&local_id| { - self.map.late_bound.insert(hir::HirId { owner, local_id }); + late_bound.iter().for_each(|&id| { + let hir_id = self.tcx.local_def_id_to_hir_id(id); + debug_assert_eq!(owner, hir_id.owner); + self.map.late_bound.insert(hir_id); }); } for (&owner, late_bound_vars) in diff --git a/compiler/rustc_typeck/src/collect.rs b/compiler/rustc_typeck/src/collect.rs index 026151ce7df82..153ab8d95fd4b 100644 --- a/compiler/rustc_typeck/src/collect.rs +++ b/compiler/rustc_typeck/src/collect.rs @@ -1388,6 +1388,7 @@ fn has_late_bound_regions<'tcx>(tcx: TyCtxt<'tcx>, node: Node<'tcx>) -> Option( tcx: TyCtxt<'tcx>, + def_id: LocalDefId, generics: &'tcx hir::Generics<'tcx>, decl: &'tcx hir::FnDecl<'tcx>, ) -> Option { @@ -1396,9 +1397,14 @@ fn has_late_bound_regions<'tcx>(tcx: TyCtxt<'tcx>, node: Node<'tcx>) -> Option(tcx: TyCtxt<'tcx>, node: Node<'tcx>) -> Option match item.kind { hir::TraitItemKind::Fn(ref sig, _) => { - has_late_bound_regions(tcx, &item.generics, sig.decl) + has_late_bound_regions(tcx, item.def_id, &item.generics, sig.decl) } _ => None, }, Node::ImplItem(item) => match item.kind { hir::ImplItemKind::Fn(ref sig, _) => { - has_late_bound_regions(tcx, &item.generics, sig.decl) + has_late_bound_regions(tcx, item.def_id, &item.generics, sig.decl) } _ => None, }, Node::ForeignItem(item) => match item.kind { hir::ForeignItemKind::Fn(fn_decl, _, ref generics) => { - has_late_bound_regions(tcx, generics, fn_decl) + has_late_bound_regions(tcx, item.def_id, generics, fn_decl) } _ => None, }, Node::Item(item) => match item.kind { hir::ItemKind::Fn(ref sig, .., ref generics, _) => { - has_late_bound_regions(tcx, generics, sig.decl) + has_late_bound_regions(tcx, item.def_id, generics, sig.decl) } _ => None, }, @@ -1677,7 +1683,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics { params.push(opt_self); } - let early_lifetimes = early_bound_lifetimes_from_generics(tcx, ast_generics); + let early_lifetimes = early_bound_lifetimes_from_generics(tcx, hir_id.owner, ast_generics); params.extend(early_lifetimes.enumerate().map(|(i, param)| ty::GenericParamDef { name: param.name.ident().name, index: own_start + i as u32, @@ -2034,10 +2040,23 @@ fn impl_polarity(tcx: TyCtxt<'_>, def_id: DefId) -> ty::ImplPolarity { /// `resolve_lifetime::early_bound_lifetimes`. fn early_bound_lifetimes_from_generics<'a, 'tcx: 'a>( tcx: TyCtxt<'tcx>, + def_id: LocalDefId, generics: &'a hir::Generics<'a>, ) -> impl Iterator> + Captures<'tcx> { + let late_bound_map = if generics.params.is_empty() { + // This function may be called on `def_id == CRATE_DEF_ID`, + // which makes `is_late_bound_map` ICE. Don't even try if there + // is no generic parameter. + None + } else { + tcx.is_late_bound_map(def_id) + }; + let is_late_bound = move |hir_id| { + let id = tcx.hir().local_def_id(hir_id); + late_bound_map.map_or(false, |(_, set)| set.contains(&id)) + }; generics.params.iter().filter(move |param| match param.kind { - GenericParamKind::Lifetime { .. } => !tcx.is_late_bound(param.hir_id), + GenericParamKind::Lifetime { .. } => !is_late_bound(param.hir_id), _ => false, }) } @@ -2221,7 +2240,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP // well. In the case of parameters declared on a fn or method, we // have to be careful to only iterate over early-bound regions. let mut index = parent_count + has_own_self as u32; - for param in early_bound_lifetimes_from_generics(tcx, ast_generics) { + for param in early_bound_lifetimes_from_generics(tcx, hir_id.owner, ast_generics) { let region = tcx.mk_region(ty::ReEarlyBound(ty::EarlyBoundRegion { def_id: tcx.hir().local_def_id(param.hir_id).to_def_id(), index, From 0c6e2466f233349a9d2dc6c6e4f5a22f86d7882b Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Wed, 30 Mar 2022 12:13:31 +0200 Subject: [PATCH 3/4] Do not access HIR to compute symbol_name. --- compiler/rustc_symbol_mangling/src/lib.rs | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/compiler/rustc_symbol_mangling/src/lib.rs b/compiler/rustc_symbol_mangling/src/lib.rs index a5503b04ff629..0ff0267d0ce76 100644 --- a/compiler/rustc_symbol_mangling/src/lib.rs +++ b/compiler/rustc_symbol_mangling/src/lib.rs @@ -97,7 +97,6 @@ extern crate rustc_middle; use rustc_hir::def_id::{CrateNum, LOCAL_CRATE}; -use rustc_hir::Node; use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags; use rustc_middle::mir::mono::{InstantiationMode, MonoItem}; use rustc_middle::ty::query::Providers; @@ -168,17 +167,14 @@ fn compute_symbol_name<'tcx>( debug!("symbol_name(def_id={:?}, substs={:?})", def_id, substs); - // FIXME(eddyb) Precompute a custom symbol name based on attributes. - let is_foreign = if let Some(def_id) = def_id.as_local() { + if let Some(def_id) = def_id.as_local() { if tcx.proc_macro_decls_static(()) == Some(def_id) { let stable_crate_id = tcx.sess.local_stable_crate_id(); return tcx.sess.generate_proc_macro_decls_symbol(stable_crate_id); } - matches!(tcx.hir().get_by_def_id(def_id), Node::ForeignItem(_)) - } else { - tcx.is_foreign_item(def_id) - }; + } + // FIXME(eddyb) Precompute a custom symbol name based on attributes. let attrs = tcx.codegen_fn_attrs(def_id); // Foreign items by default use no mangling for their symbol name. There's a @@ -197,7 +193,7 @@ fn compute_symbol_name<'tcx>( // show up in the `wasm-import-name` custom attribute in LLVM IR. // // [1]: https://bugs.llvm.org/show_bug.cgi?id=44316 - if is_foreign + if tcx.is_foreign_item(def_id) && (!tcx.sess.target.is_like_wasm || !tcx.wasm_import_module_map(def_id.krate).contains_key(&def_id)) { From bbacfcb6c4b25ad4741ae9cf32db342f7e612b29 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Wed, 30 Mar 2022 12:25:23 +0200 Subject: [PATCH 4/4] Avoid checking HIR in variances_of. --- compiler/rustc_typeck/src/variance/mod.rs | 51 ++++++----------------- 1 file changed, 13 insertions(+), 38 deletions(-) diff --git a/compiler/rustc_typeck/src/variance/mod.rs b/compiler/rustc_typeck/src/variance/mod.rs index 66fb9eb86931b..e622192f2c94d 100644 --- a/compiler/rustc_typeck/src/variance/mod.rs +++ b/compiler/rustc_typeck/src/variance/mod.rs @@ -3,9 +3,8 @@ //! //! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/variance.html -use hir::Node; use rustc_arena::DroplessArena; -use rustc_hir as hir; +use rustc_hir::def::DefKind; use rustc_hir::def_id::DefId; use rustc_middle::ty::query::Providers; use rustc_middle::ty::{self, CrateVariancesMap, TyCtxt}; @@ -38,42 +37,18 @@ fn crate_variances(tcx: TyCtxt<'_>, (): ()) -> CrateVariancesMap<'_> { } fn variances_of(tcx: TyCtxt<'_>, item_def_id: DefId) -> &[ty::Variance] { - let id = tcx.hir().local_def_id_to_hir_id(item_def_id.expect_local()); - let unsupported = || { - // Variance not relevant. - span_bug!(tcx.hir().span(id), "asked to compute variance for wrong kind of item") - }; - match tcx.hir().get(id) { - Node::Item(item) => match item.kind { - hir::ItemKind::Enum(..) - | hir::ItemKind::Struct(..) - | hir::ItemKind::Union(..) - | hir::ItemKind::Fn(..) => {} - - _ => unsupported(), - }, - - Node::TraitItem(item) => match item.kind { - hir::TraitItemKind::Fn(..) => {} - - _ => unsupported(), - }, - - Node::ImplItem(item) => match item.kind { - hir::ImplItemKind::Fn(..) => {} - - _ => unsupported(), - }, - - Node::ForeignItem(item) => match item.kind { - hir::ForeignItemKind::Fn(..) => {} - - _ => unsupported(), - }, - - Node::Variant(_) | Node::Ctor(..) => {} - - _ => unsupported(), + match tcx.def_kind(item_def_id) { + DefKind::Fn + | DefKind::AssocFn + | DefKind::Enum + | DefKind::Struct + | DefKind::Union + | DefKind::Variant + | DefKind::Ctor(..) => {} + _ => { + // Variance not relevant. + span_bug!(tcx.def_span(item_def_id), "asked to compute variance for wrong kind of item") + } } // Everything else must be inferred.