bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Rollup merge of #70119 - eddyb:typeck-tables-local-def-id, r=petrochenkov

Browse source 
rustc: use LocalDefId instead of DefId in TypeckTables.

The logic in `TypeckTables`' implementation of `HashStable`, which created `DefId`s by combining a `CrateNum` from a `DefId` and a `DefIndex` from a `LocalDefId`, bothered me a bit.

I don't know how much this matters, but it works so might as well submit it.
This commit is contained in:
Dylan DPC 2020-03-21 13:06:42 +01:00 • committed by GitHub
commit f1ab750083
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
9 changed files with 94 additions and 125 deletions
Download patch file Download diff file Expand all files Collapse all files

127
src/librustc/ty/context.rs
View file

@ -188,37 +188,37 @@ pub struct CommonConsts<'tcx> {
} }
pub struct LocalTableInContext<'a, V> { pub struct LocalTableInContext<'a, V> {
local_id_root: Option<DefId>, hir_owner: Option<LocalDefId>,
data: &'a ItemLocalMap<V>, data: &'a ItemLocalMap<V>,
} }
/// Validate that the given HirId (respectively its `local_id` part) can be /// Validate that the given HirId (respectively its `local_id` part) can be
/// safely used as a key in the tables of a TypeckTable. For that to be /// safely used as a key in the tables of a TypeckTable. For that to be
/// the case, the HirId must have the same `owner` as all the other IDs in /// the case, the HirId must have the same `owner` as all the other IDs in
/// this table (signified by `local_id_root`). Otherwise the HirId /// this table (signified by `hir_owner`). Otherwise the HirId
/// would be in a different frame of reference and using its `local_id` /// would be in a different frame of reference and using its `local_id`
/// would result in lookup errors, or worse, in silently wrong data being /// would result in lookup errors, or worse, in silently wrong data being
/// stored/returned. /// stored/returned.
fn validate_hir_id_for_typeck_tables( fn validate_hir_id_for_typeck_tables(
local_id_root: Option<DefId>, hir_owner: Option<LocalDefId>,
hir_id: hir::HirId, hir_id: hir::HirId,
mut_access: bool, mut_access: bool,
) { ) {
if let Some(local_id_root) = local_id_root { if let Some(hir_owner) = hir_owner {
if hir_id.owner.to_def_id() != local_id_root { if hir_id.owner != hir_owner {
ty::tls::with(|tcx| { ty::tls::with(|tcx| {
bug!( bug!(
"node {} with HirId::owner {:?} cannot be placed in \ "node {} with HirId::owner {:?} cannot be placed in \
TypeckTables with local_id_root {:?}", TypeckTables with hir_owner {:?}",
tcx.hir().node_to_string(hir_id), tcx.hir().node_to_string(hir_id),
hir_id.owner, hir_id.owner,
local_id_root hir_owner
) )
}); });
} }
} else { } else {
// We use "Null Object" TypeckTables in some of the analysis passes. // We use "Null Object" TypeckTables in some of the analysis passes.
// These are just expected to be empty and their `local_id_root` is // These are just expected to be empty and their `hir_owner` is
// `None`. Therefore we cannot verify whether a given `HirId` would // `None`. Therefore we cannot verify whether a given `HirId` would
// be a valid key for the given table. Instead we make sure that // be a valid key for the given table. Instead we make sure that
// nobody tries to write to such a Null Object table. // nobody tries to write to such a Null Object table.
@ -230,12 +230,12 @@ fn validate_hir_id_for_typeck_tables(
impl<'a, V> LocalTableInContext<'a, V> { impl<'a, V> LocalTableInContext<'a, V> {
pub fn contains_key(&self, id: hir::HirId) -> bool { pub fn contains_key(&self, id: hir::HirId) -> bool {
validate_hir_id_for_typeck_tables(self.local_id_root, id, false); validate_hir_id_for_typeck_tables(self.hir_owner, id, false);
self.data.contains_key(&id.local_id) self.data.contains_key(&id.local_id)
} }
pub fn get(&self, id: hir::HirId) -> Option<&V> { pub fn get(&self, id: hir::HirId) -> Option<&V> {
validate_hir_id_for_typeck_tables(self.local_id_root, id, false); validate_hir_id_for_typeck_tables(self.hir_owner, id, false);
self.data.get(&id.local_id) self.data.get(&id.local_id)
} }
@ -253,28 +253,28 @@ impl<'a, V> ::std::ops::Index<hir::HirId> for LocalTableInContext<'a, V> {
} }
pub struct LocalTableInContextMut<'a, V> { pub struct LocalTableInContextMut<'a, V> {
local_id_root: Option<DefId>, hir_owner: Option<LocalDefId>,
data: &'a mut ItemLocalMap<V>, data: &'a mut ItemLocalMap<V>,
} }
impl<'a, V> LocalTableInContextMut<'a, V> { impl<'a, V> LocalTableInContextMut<'a, V> {
pub fn get_mut(&mut self, id: hir::HirId) -> Option<&mut V> { pub fn get_mut(&mut self, id: hir::HirId) -> Option<&mut V> {
validate_hir_id_for_typeck_tables(self.local_id_root, id, true); validate_hir_id_for_typeck_tables(self.hir_owner, id, true);
self.data.get_mut(&id.local_id) self.data.get_mut(&id.local_id)
} }
pub fn entry(&mut self, id: hir::HirId) -> Entry<'_, hir::ItemLocalId, V> { pub fn entry(&mut self, id: hir::HirId) -> Entry<'_, hir::ItemLocalId, V> {
validate_hir_id_for_typeck_tables(self.local_id_root, id, true); validate_hir_id_for_typeck_tables(self.hir_owner, id, true);
self.data.entry(id.local_id) self.data.entry(id.local_id)
} }
pub fn insert(&mut self, id: hir::HirId, val: V) -> Option<V> { pub fn insert(&mut self, id: hir::HirId, val: V) -> Option<V> {
validate_hir_id_for_typeck_tables(self.local_id_root, id, true); validate_hir_id_for_typeck_tables(self.hir_owner, id, true);
self.data.insert(id.local_id, val) self.data.insert(id.local_id, val)
} }
pub fn remove(&mut self, id: hir::HirId) -> Option<V> { pub fn remove(&mut self, id: hir::HirId) -> Option<V> {
validate_hir_id_for_typeck_tables(self.local_id_root, id, true); validate_hir_id_for_typeck_tables(self.hir_owner, id, true);
self.data.remove(&id.local_id) self.data.remove(&id.local_id)
} }
} }
@ -322,8 +322,8 @@ pub struct GeneratorInteriorTypeCause<'tcx> {
#[derive(RustcEncodable, RustcDecodable, Debug)] #[derive(RustcEncodable, RustcDecodable, Debug)]
pub struct TypeckTables<'tcx> { pub struct TypeckTables<'tcx> {
/// The HirId::owner all ItemLocalIds in this table are relative to. /// The `HirId::owner` all `ItemLocalId`s in this table are relative to.
pub local_id_root: Option<DefId>, pub hir_owner: Option<LocalDefId>,
/// Resolved definitions for `<T>::X` associated paths and /// Resolved definitions for `<T>::X` associated paths and
/// method calls, including those of overloaded operators. /// method calls, including those of overloaded operators.
@ -431,9 +431,9 @@ pub struct TypeckTables<'tcx> {
} }
impl<'tcx> TypeckTables<'tcx> { impl<'tcx> TypeckTables<'tcx> {
pub fn empty(local_id_root: Option<DefId>) -> TypeckTables<'tcx> { pub fn empty(hir_owner: Option<LocalDefId>) -> TypeckTables<'tcx> {
TypeckTables { TypeckTables {
local_id_root, hir_owner,
type_dependent_defs: Default::default(), type_dependent_defs: Default::default(),
field_indices: Default::default(), field_indices: Default::default(),
user_provided_types: Default::default(), user_provided_types: Default::default(),
@ -469,11 +469,11 @@ impl<'tcx> TypeckTables<'tcx> {
pub fn type_dependent_defs( pub fn type_dependent_defs(
&self, &self,
) -> LocalTableInContext<'_, Result<(DefKind, DefId), ErrorReported>> { ) -> LocalTableInContext<'_, Result<(DefKind, DefId), ErrorReported>> {
LocalTableInContext { local_id_root: self.local_id_root, data: &self.type_dependent_defs } LocalTableInContext { hir_owner: self.hir_owner, data: &self.type_dependent_defs }
} }
pub fn type_dependent_def(&self, id: HirId) -> Option<(DefKind, DefId)> { pub fn type_dependent_def(&self, id: HirId) -> Option<(DefKind, DefId)> {
validate_hir_id_for_typeck_tables(self.local_id_root, id, false); validate_hir_id_for_typeck_tables(self.hir_owner, id, false);
self.type_dependent_defs.get(&id.local_id).cloned().and_then(|r| r.ok()) self.type_dependent_defs.get(&id.local_id).cloned().and_then(|r| r.ok())
} }
@ -484,39 +484,33 @@ impl<'tcx> TypeckTables<'tcx> {
pub fn type_dependent_defs_mut( pub fn type_dependent_defs_mut(
&mut self, &mut self,
) -> LocalTableInContextMut<'_, Result<(DefKind, DefId), ErrorReported>> { ) -> LocalTableInContextMut<'_, Result<(DefKind, DefId), ErrorReported>> {
LocalTableInContextMut { LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.type_dependent_defs }
local_id_root: self.local_id_root,
data: &mut self.type_dependent_defs,
}
} }
pub fn field_indices(&self) -> LocalTableInContext<'_, usize> { pub fn field_indices(&self) -> LocalTableInContext<'_, usize> {
LocalTableInContext { local_id_root: self.local_id_root, data: &self.field_indices } LocalTableInContext { hir_owner: self.hir_owner, data: &self.field_indices }
} }
pub fn field_indices_mut(&mut self) -> LocalTableInContextMut<'_, usize> { pub fn field_indices_mut(&mut self) -> LocalTableInContextMut<'_, usize> {
LocalTableInContextMut { local_id_root: self.local_id_root, data: &mut self.field_indices } LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.field_indices }
} }
pub fn user_provided_types(&self) -> LocalTableInContext<'_, CanonicalUserType<'tcx>> { pub fn user_provided_types(&self) -> LocalTableInContext<'_, CanonicalUserType<'tcx>> {
LocalTableInContext { local_id_root: self.local_id_root, data: &self.user_provided_types } LocalTableInContext { hir_owner: self.hir_owner, data: &self.user_provided_types }
} }
pub fn user_provided_types_mut( pub fn user_provided_types_mut(
&mut self, &mut self,
) -> LocalTableInContextMut<'_, CanonicalUserType<'tcx>> { ) -> LocalTableInContextMut<'_, CanonicalUserType<'tcx>> {
LocalTableInContextMut { LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.user_provided_types }
local_id_root: self.local_id_root,
data: &mut self.user_provided_types,
}
} }
pub fn node_types(&self) -> LocalTableInContext<'_, Ty<'tcx>> { pub fn node_types(&self) -> LocalTableInContext<'_, Ty<'tcx>> {
LocalTableInContext { local_id_root: self.local_id_root, data: &self.node_types } LocalTableInContext { hir_owner: self.hir_owner, data: &self.node_types }
} }
pub fn node_types_mut(&mut self) -> LocalTableInContextMut<'_, Ty<'tcx>> { pub fn node_types_mut(&mut self) -> LocalTableInContextMut<'_, Ty<'tcx>> {
LocalTableInContextMut { local_id_root: self.local_id_root, data: &mut self.node_types } LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.node_types }
} }
pub fn node_type(&self, id: hir::HirId) -> Ty<'tcx> { pub fn node_type(&self, id: hir::HirId) -> Ty<'tcx> {
@ -526,21 +520,21 @@ impl<'tcx> TypeckTables<'tcx> {
} }
pub fn node_type_opt(&self, id: hir::HirId) -> Option<Ty<'tcx>> { pub fn node_type_opt(&self, id: hir::HirId) -> Option<Ty<'tcx>> {
validate_hir_id_for_typeck_tables(self.local_id_root, id, false); validate_hir_id_for_typeck_tables(self.hir_owner, id, false);
self.node_types.get(&id.local_id).cloned() self.node_types.get(&id.local_id).cloned()
} }
pub fn node_substs_mut(&mut self) -> LocalTableInContextMut<'_, SubstsRef<'tcx>> { pub fn node_substs_mut(&mut self) -> LocalTableInContextMut<'_, SubstsRef<'tcx>> {
LocalTableInContextMut { local_id_root: self.local_id_root, data: &mut self.node_substs } LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.node_substs }
} }
pub fn node_substs(&self, id: hir::HirId) -> SubstsRef<'tcx> { pub fn node_substs(&self, id: hir::HirId) -> SubstsRef<'tcx> {
validate_hir_id_for_typeck_tables(self.local_id_root, id, false); validate_hir_id_for_typeck_tables(self.hir_owner, id, false);
self.node_substs.get(&id.local_id).cloned().unwrap_or_else(|| InternalSubsts::empty()) self.node_substs.get(&id.local_id).cloned().unwrap_or_else(|| InternalSubsts::empty())
} }
pub fn node_substs_opt(&self, id: hir::HirId) -> Option<SubstsRef<'tcx>> { pub fn node_substs_opt(&self, id: hir::HirId) -> Option<SubstsRef<'tcx>> {
validate_hir_id_for_typeck_tables(self.local_id_root, id, false); validate_hir_id_for_typeck_tables(self.hir_owner, id, false);
self.node_substs.get(&id.local_id).cloned() self.node_substs.get(&id.local_id).cloned()
} }
@ -573,17 +567,17 @@ impl<'tcx> TypeckTables<'tcx> {
} }
pub fn adjustments(&self) -> LocalTableInContext<'_, Vec<ty::adjustment::Adjustment<'tcx>>> { pub fn adjustments(&self) -> LocalTableInContext<'_, Vec<ty::adjustment::Adjustment<'tcx>>> {
LocalTableInContext { local_id_root: self.local_id_root, data: &self.adjustments } LocalTableInContext { hir_owner: self.hir_owner, data: &self.adjustments }
} }
pub fn adjustments_mut( pub fn adjustments_mut(
&mut self, &mut self,
) -> LocalTableInContextMut<'_, Vec<ty::adjustment::Adjustment<'tcx>>> { ) -> LocalTableInContextMut<'_, Vec<ty::adjustment::Adjustment<'tcx>>> {
LocalTableInContextMut { local_id_root: self.local_id_root, data: &mut self.adjustments } LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.adjustments }
} }
pub fn expr_adjustments(&self, expr: &hir::Expr<'_>) -> &[ty::adjustment::Adjustment<'tcx>] { pub fn expr_adjustments(&self, expr: &hir::Expr<'_>) -> &[ty::adjustment::Adjustment<'tcx>] {
validate_hir_id_for_typeck_tables(self.local_id_root, expr.hir_id, false); validate_hir_id_for_typeck_tables(self.hir_owner, expr.hir_id, false);
self.adjustments.get(&expr.hir_id.local_id).map_or(&[], |a| &a[..]) self.adjustments.get(&expr.hir_id.local_id).map_or(&[], |a| &a[..])
} }
@ -618,25 +612,19 @@ impl<'tcx> TypeckTables<'tcx> {
} }
pub fn pat_binding_modes(&self) -> LocalTableInContext<'_, BindingMode> { pub fn pat_binding_modes(&self) -> LocalTableInContext<'_, BindingMode> {
LocalTableInContext { local_id_root: self.local_id_root, data: &self.pat_binding_modes } LocalTableInContext { hir_owner: self.hir_owner, data: &self.pat_binding_modes }
} }
pub fn pat_binding_modes_mut(&mut self) -> LocalTableInContextMut<'_, BindingMode> { pub fn pat_binding_modes_mut(&mut self) -> LocalTableInContextMut<'_, BindingMode> {
LocalTableInContextMut { LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.pat_binding_modes }
local_id_root: self.local_id_root,
data: &mut self.pat_binding_modes,
}
} }
pub fn pat_adjustments(&self) -> LocalTableInContext<'_, Vec<Ty<'tcx>>> { pub fn pat_adjustments(&self) -> LocalTableInContext<'_, Vec<Ty<'tcx>>> {
LocalTableInContext { local_id_root: self.local_id_root, data: &self.pat_adjustments } LocalTableInContext { hir_owner: self.hir_owner, data: &self.pat_adjustments }
} }
pub fn pat_adjustments_mut(&mut self) -> LocalTableInContextMut<'_, Vec<Ty<'tcx>>> { pub fn pat_adjustments_mut(&mut self) -> LocalTableInContextMut<'_, Vec<Ty<'tcx>>> {
LocalTableInContextMut { LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.pat_adjustments }
local_id_root: self.local_id_root,
data: &mut self.pat_adjustments,
}
} }
pub fn upvar_capture(&self, upvar_id: ty::UpvarId) -> ty::UpvarCapture<'tcx> { pub fn upvar_capture(&self, upvar_id: ty::UpvarId) -> ty::UpvarCapture<'tcx> {
@ -644,40 +632,31 @@ impl<'tcx> TypeckTables<'tcx> {
} }
pub fn closure_kind_origins(&self) -> LocalTableInContext<'_, (Span, ast::Name)> { pub fn closure_kind_origins(&self) -> LocalTableInContext<'_, (Span, ast::Name)> {
LocalTableInContext { local_id_root: self.local_id_root, data: &self.closure_kind_origins } LocalTableInContext { hir_owner: self.hir_owner, data: &self.closure_kind_origins }
} }
pub fn closure_kind_origins_mut(&mut self) -> LocalTableInContextMut<'_, (Span, ast::Name)> { pub fn closure_kind_origins_mut(&mut self) -> LocalTableInContextMut<'_, (Span, ast::Name)> {
LocalTableInContextMut { LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.closure_kind_origins }
local_id_root: self.local_id_root,
data: &mut self.closure_kind_origins,
}
} }
pub fn liberated_fn_sigs(&self) -> LocalTableInContext<'_, ty::FnSig<'tcx>> { pub fn liberated_fn_sigs(&self) -> LocalTableInContext<'_, ty::FnSig<'tcx>> {
LocalTableInContext { local_id_root: self.local_id_root, data: &self.liberated_fn_sigs } LocalTableInContext { hir_owner: self.hir_owner, data: &self.liberated_fn_sigs }
} }
pub fn liberated_fn_sigs_mut(&mut self) -> LocalTableInContextMut<'_, ty::FnSig<'tcx>> { pub fn liberated_fn_sigs_mut(&mut self) -> LocalTableInContextMut<'_, ty::FnSig<'tcx>> {
LocalTableInContextMut { LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.liberated_fn_sigs }
local_id_root: self.local_id_root,
data: &mut self.liberated_fn_sigs,
}
} }
pub fn fru_field_types(&self) -> LocalTableInContext<'_, Vec<Ty<'tcx>>> { pub fn fru_field_types(&self) -> LocalTableInContext<'_, Vec<Ty<'tcx>>> {
LocalTableInContext { local_id_root: self.local_id_root, data: &self.fru_field_types } LocalTableInContext { hir_owner: self.hir_owner, data: &self.fru_field_types }
} }
pub fn fru_field_types_mut(&mut self) -> LocalTableInContextMut<'_, Vec<Ty<'tcx>>> { pub fn fru_field_types_mut(&mut self) -> LocalTableInContextMut<'_, Vec<Ty<'tcx>>> {
LocalTableInContextMut { LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.fru_field_types }
local_id_root: self.local_id_root,
data: &mut self.fru_field_types,
}
} }
pub fn is_coercion_cast(&self, hir_id: hir::HirId) -> bool { pub fn is_coercion_cast(&self, hir_id: hir::HirId) -> bool {
validate_hir_id_for_typeck_tables(self.local_id_root, hir_id, true); validate_hir_id_for_typeck_tables(self.hir_owner, hir_id, true);
self.coercion_casts.contains(&hir_id.local_id) self.coercion_casts.contains(&hir_id.local_id)
} }
@ -693,7 +672,7 @@ impl<'tcx> TypeckTables<'tcx> {
impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for TypeckTables<'tcx> { impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for TypeckTables<'tcx> {
fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
let ty::TypeckTables { let ty::TypeckTables {
local_id_root, hir_owner,
ref type_dependent_defs, ref type_dependent_defs,
ref field_indices, ref field_indices,
ref user_provided_types, ref user_provided_types,
@ -730,18 +709,12 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for TypeckTables<'tcx> {
hash_stable_hashmap(hcx, hasher, upvar_capture_map, |up_var_id, hcx| { hash_stable_hashmap(hcx, hasher, upvar_capture_map, |up_var_id, hcx| {
let ty::UpvarId { var_path, closure_expr_id } = *up_var_id; let ty::UpvarId { var_path, closure_expr_id } = *up_var_id;
let local_id_root = local_id_root.expect("trying to hash invalid TypeckTables"); assert_eq!(Some(var_path.hir_id.owner), hir_owner);
let var_owner_def_id = DefId {
krate: local_id_root.krate,
index: var_path.hir_id.owner.local_def_index,
};
let closure_def_id =
DefId { krate: local_id_root.krate, index: closure_expr_id.local_def_index };
( (
hcx.def_path_hash(var_owner_def_id), hcx.local_def_path_hash(var_path.hir_id.owner),
var_path.hir_id.local_id, var_path.hir_id.local_id,
hcx.def_path_hash(closure_def_id), hcx.local_def_path_hash(closure_expr_id),
) )
}); });

10
src/librustc_infer/infer/error_reporting/mod.rs
View file

@ -1784,11 +1784,11 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
// suggest adding an explicit lifetime bound to it. // suggest adding an explicit lifetime bound to it.
let type_param_span = match (self.in_progress_tables, bound_kind) { let type_param_span = match (self.in_progress_tables, bound_kind) {
(Some(ref table), GenericKind::Param(ref param)) => { (Some(ref table), GenericKind::Param(ref param)) => {
let table = table.borrow(); let table_owner = table.borrow().hir_owner;
table.local_id_root.and_then(|did| { table_owner.and_then(|table_owner| {
let generics = self.tcx.generics_of(did); let generics = self.tcx.generics_of(table_owner.to_def_id());
// Account for the case where `did` corresponds to `Self`, which doesn't have // Account for the case where `param` corresponds to `Self`,
// the expected type argument. // which doesn't have the expected type argument.
if !(generics.has_self && param.index == 0) { if !(generics.has_self && param.index == 0) {
let type_param = generics.type_param(param, self.tcx); let type_param = generics.type_param(param, self.tcx);
let hir = &self.tcx.hir(); let hir = &self.tcx.hir();

4
src/librustc_infer/infer/mod.rs
View file

@ -29,7 +29,7 @@ use rustc_data_structures::sync::Lrc;
use rustc_data_structures::unify as ut; use rustc_data_structures::unify as ut;
use rustc_errors::DiagnosticBuilder; use rustc_errors::DiagnosticBuilder;
use rustc_hir as hir; use rustc_hir as hir;
use rustc_hir::def_id::DefId; use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_session::config::BorrowckMode; use rustc_session::config::BorrowckMode;
use rustc_span::symbol::Symbol; use rustc_span::symbol::Symbol;
use rustc_span::Span; use rustc_span::Span;
@ -559,7 +559,7 @@ impl TyCtxtInferExt<'tcx> for TyCtxt<'tcx> {
impl<'tcx> InferCtxtBuilder<'tcx> { impl<'tcx> InferCtxtBuilder<'tcx> {
/// Used only by `rustc_typeck` during body type-checking/inference, /// Used only by `rustc_typeck` during body type-checking/inference,
/// will initialize `in_progress_tables` with fresh `TypeckTables`. /// will initialize `in_progress_tables` with fresh `TypeckTables`.
pub fn with_fresh_in_progress_tables(mut self, table_owner: DefId) -> Self { pub fn with_fresh_in_progress_tables(mut self, table_owner: LocalDefId) -> Self {
self.fresh_tables = Some(RefCell::new(ty::TypeckTables::empty(Some(table_owner)))); self.fresh_tables = Some(RefCell::new(ty::TypeckTables::empty(Some(table_owner))));
self self
} }

6
src/librustc_trait_selection/traits/error_reporting/suggestions.rs
View file

@ -1105,15 +1105,15 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
let generator_did_root = self.tcx.closure_base_def_id(generator_did); let generator_did_root = self.tcx.closure_base_def_id(generator_did);
debug!( debug!(
"maybe_note_obligation_cause_for_async_await: generator_did={:?} \ "maybe_note_obligation_cause_for_async_await: generator_did={:?} \
generator_did_root={:?} in_progress_tables.local_id_root={:?} span={:?}", generator_did_root={:?} in_progress_tables.hir_owner={:?} span={:?}",
generator_did, generator_did,
generator_did_root, generator_did_root,
in_progress_tables.as_ref().map(|t| t.local_id_root), in_progress_tables.as_ref().map(|t| t.hir_owner),
span span
); );
let query_tables; let query_tables;
let tables: &TypeckTables<'tcx> = match &in_progress_tables { let tables: &TypeckTables<'tcx> = match &in_progress_tables {
Some(t) if t.local_id_root == Some(generator_did_root) => t, Some(t) if t.hir_owner.map(|owner| owner.to_def_id()) == Some(generator_did_root) => t,
_ => { _ => {
query_tables = self.tcx.typeck_tables_of(generator_did); query_tables = self.tcx.typeck_tables_of(generator_did);
&query_tables &query_tables

6
src/librustc_typeck/check/compare_method.rs
View file

@ -213,7 +213,7 @@ fn compare_predicate_entailment<'tcx>(
); );
tcx.infer_ctxt().enter(|infcx| { tcx.infer_ctxt().enter(|infcx| {
let inh = Inherited::new(infcx, impl_m.def_id); let inh = Inherited::new(infcx, impl_m.def_id.expect_local());
let infcx = &inh.infcx; let infcx = &inh.infcx;
debug!("compare_impl_method: caller_bounds={:?}", param_env.caller_bounds); debug!("compare_impl_method: caller_bounds={:?}", param_env.caller_bounds);
@ -950,7 +950,7 @@ crate fn compare_const_impl<'tcx>(
tcx.infer_ctxt().enter(|infcx| { tcx.infer_ctxt().enter(|infcx| {
let param_env = tcx.param_env(impl_c.def_id); let param_env = tcx.param_env(impl_c.def_id);
let inh = Inherited::new(infcx, impl_c.def_id); let inh = Inherited::new(infcx, impl_c.def_id.expect_local());
let infcx = &inh.infcx; let infcx = &inh.infcx;
// The below is for the most part highly similar to the procedure // The below is for the most part highly similar to the procedure
@ -1130,7 +1130,7 @@ fn compare_type_predicate_entailment(
normalize_cause.clone(), normalize_cause.clone(),
); );
tcx.infer_ctxt().enter(|infcx| { tcx.infer_ctxt().enter(|infcx| {
let inh = Inherited::new(infcx, impl_ty.def_id); let inh = Inherited::new(infcx, impl_ty.def_id.expect_local());
let infcx = &inh.infcx; let infcx = &inh.infcx;
debug!("compare_type_predicate_entailment: caller_bounds={:?}", param_env.caller_bounds); debug!("compare_type_predicate_entailment: caller_bounds={:?}", param_env.caller_bounds);

6
src/librustc_typeck/check/method/suggest.rs
View file

@ -1018,9 +1018,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Obtain the span for `param` and use it for a structured suggestion. // Obtain the span for `param` and use it for a structured suggestion.
let mut suggested = false; let mut suggested = false;
if let (Some(ref param), Some(ref table)) = (param_type, self.in_progress_tables) { if let (Some(ref param), Some(ref table)) = (param_type, self.in_progress_tables) {
let table = table.borrow(); let table_owner = table.borrow().hir_owner;
if let Some(did) = table.local_id_root { if let Some(table_owner) = table_owner {
let generics = self.tcx.generics_of(did); let generics = self.tcx.generics_of(table_owner.to_def_id());
let type_param = generics.type_param(param, self.tcx); let type_param = generics.type_param(param, self.tcx);
let hir = &self.tcx.hir(); let hir = &self.tcx.hir();
if let Some(id) = hir.as_local_hir_id(type_param.def_id) { if let Some(id) = hir.as_local_hir_id(type_param.def_id) {

24
src/librustc_typeck/check/mod.rs
View file

@ -112,7 +112,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticBuilder, DiagnosticId}; use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticBuilder, DiagnosticId};
use rustc_hir as hir; use rustc_hir as hir;
use rustc_hir::def::{CtorOf, DefKind, Res}; use rustc_hir::def::{CtorOf, DefKind, Res};
use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet, LOCAL_CRATE}; use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet, LocalDefId, LOCAL_CRATE};
use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor}; use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
use rustc_hir::itemlikevisit::ItemLikeVisitor; use rustc_hir::itemlikevisit::ItemLikeVisitor;
use rustc_hir::{ExprKind, GenericArg, HirIdMap, Item, ItemKind, Node, PatKind, QPath}; use rustc_hir::{ExprKind, GenericArg, HirIdMap, Item, ItemKind, Node, PatKind, QPath};
@ -633,19 +633,15 @@ impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
/// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`. /// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
pub struct InheritedBuilder<'tcx> { pub struct InheritedBuilder<'tcx> {
infcx: infer::InferCtxtBuilder<'tcx>, infcx: infer::InferCtxtBuilder<'tcx>,
def_id: DefId, def_id: LocalDefId,
} }
impl Inherited<'_, 'tcx> { impl Inherited<'_, 'tcx> {
pub fn build(tcx: TyCtxt<'tcx>, def_id: DefId) -> InheritedBuilder<'tcx> { pub fn build(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> InheritedBuilder<'tcx> {
let hir_id_root = if let Some(def_id) = def_id.as_local() { let hir_owner = tcx.hir().local_def_id_to_hir_id(def_id).owner;
tcx.hir().local_def_id_to_hir_id(def_id).owner.to_def_id()
} else {
def_id
};
InheritedBuilder { InheritedBuilder {
infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root), infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_owner),
def_id, def_id,
} }
} }
@ -662,10 +658,10 @@ impl<'tcx> InheritedBuilder<'tcx> {
} }
impl Inherited<'a, 'tcx> { impl Inherited<'a, 'tcx> {
fn new(infcx: InferCtxt<'a, 'tcx>, def_id: DefId) -> Self { fn new(infcx: InferCtxt<'a, 'tcx>, def_id: LocalDefId) -> Self {
let tcx = infcx.tcx; let tcx = infcx.tcx;
let item_id = tcx.hir().as_local_hir_id(def_id); let item_id = tcx.hir().local_def_id_to_hir_id(def_id);
let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id)); let body_id = tcx.hir().maybe_body_owned_by(item_id);
let implicit_region_bound = body_id.map(|body_id| { let implicit_region_bound = body_id.map(|body_id| {
let body = tcx.hir().body(body_id); let body = tcx.hir().body(body_id);
tcx.mk_region(ty::ReScope(region::Scope { tcx.mk_region(ty::ReScope(region::Scope {
@ -1002,7 +998,7 @@ fn typeck_tables_of_with_fallback<'tcx>(
}); });
let body = tcx.hir().body(body_id); let body = tcx.hir().body(body_id);
let tables = Inherited::build(tcx, def_id).enter(|inh| { let tables = Inherited::build(tcx, def_id.expect_local()).enter(|inh| {
let param_env = tcx.param_env(def_id); let param_env = tcx.param_env(def_id);
let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) { let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) {
let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() { let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() {
@ -1127,7 +1123,7 @@ fn typeck_tables_of_with_fallback<'tcx>(
// Consistency check our TypeckTables instance can hold all ItemLocalIds // Consistency check our TypeckTables instance can hold all ItemLocalIds
// it will need to hold. // it will need to hold.
assert_eq!(tables.local_id_root, Some(id.owner.to_def_id())); assert_eq!(tables.hir_owner, Some(id.owner));
tables tables
} }

4
src/librustc_typeck/check/wfcheck.rs
View file

@ -316,12 +316,12 @@ fn for_item<'tcx>(tcx: TyCtxt<'tcx>, item: &hir::Item<'_>) -> CheckWfFcxBuilder<
} }
fn for_id(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) -> CheckWfFcxBuilder<'_> { fn for_id(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) -> CheckWfFcxBuilder<'_> {
let def_id = tcx.hir().local_def_id(id); let def_id = tcx.hir().local_def_id(id).expect_local();
CheckWfFcxBuilder { CheckWfFcxBuilder {
inherited: Inherited::build(tcx, def_id), inherited: Inherited::build(tcx, def_id),
id, id,
span, span,
param_env: tcx.param_env(def_id), param_env: tcx.param_env(def_id.to_def_id()),
} }
} }

32
src/librustc_typeck/check/writeback.rs
View file

@ -111,7 +111,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
WritebackCx { WritebackCx {
fcx, fcx,
tables: ty::TypeckTables::empty(Some(owner.to_def_id())), tables: ty::TypeckTables::empty(Some(owner)),
body, body,
rustc_dump_user_substs, rustc_dump_user_substs,
} }
@ -338,11 +338,11 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
fn visit_closures(&mut self) { fn visit_closures(&mut self) {
let fcx_tables = self.fcx.tables.borrow(); let fcx_tables = self.fcx.tables.borrow();
debug_assert_eq!(fcx_tables.local_id_root, self.tables.local_id_root); assert_eq!(fcx_tables.hir_owner, self.tables.hir_owner);
let common_local_id_root = fcx_tables.local_id_root.unwrap(); let common_hir_owner = fcx_tables.hir_owner.unwrap();
for (&id, &origin) in fcx_tables.closure_kind_origins().iter() { for (&id, &origin) in fcx_tables.closure_kind_origins().iter() {
let hir_id = hir::HirId { owner: common_local_id_root.expect_local(), local_id: id }; let hir_id = hir::HirId { owner: common_hir_owner, local_id: id };
self.tables.closure_kind_origins_mut().insert(hir_id, origin); self.tables.closure_kind_origins_mut().insert(hir_id, origin);
} }
} }
@ -350,7 +350,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
fn visit_coercion_casts(&mut self) { fn visit_coercion_casts(&mut self) {
let fcx_tables = self.fcx.tables.borrow(); let fcx_tables = self.fcx.tables.borrow();
let fcx_coercion_casts = fcx_tables.coercion_casts(); let fcx_coercion_casts = fcx_tables.coercion_casts();
debug_assert_eq!(fcx_tables.local_id_root, self.tables.local_id_root); assert_eq!(fcx_tables.hir_owner, self.tables.hir_owner);
for local_id in fcx_coercion_casts { for local_id in fcx_coercion_casts {
self.tables.set_coercion_cast(*local_id); self.tables.set_coercion_cast(*local_id);
@ -359,12 +359,12 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
fn visit_user_provided_tys(&mut self) { fn visit_user_provided_tys(&mut self) {
let fcx_tables = self.fcx.tables.borrow(); let fcx_tables = self.fcx.tables.borrow();
debug_assert_eq!(fcx_tables.local_id_root, self.tables.local_id_root); assert_eq!(fcx_tables.hir_owner, self.tables.hir_owner);
let common_local_id_root = fcx_tables.local_id_root.unwrap(); let common_hir_owner = fcx_tables.hir_owner.unwrap();
let mut errors_buffer = Vec::new(); let mut errors_buffer = Vec::new();
for (&local_id, c_ty) in fcx_tables.user_provided_types().iter() { for (&local_id, c_ty) in fcx_tables.user_provided_types().iter() {
let hir_id = hir::HirId { owner: common_local_id_root.expect_local(), local_id }; let hir_id = hir::HirId { owner: common_hir_owner, local_id };
if cfg!(debug_assertions) && c_ty.has_local_value() { if cfg!(debug_assertions) && c_ty.has_local_value() {
span_bug!(hir_id.to_span(self.fcx.tcx), "writeback: `{:?}` is a local value", c_ty); span_bug!(hir_id.to_span(self.fcx.tcx), "writeback: `{:?}` is a local value", c_ty);
@ -397,7 +397,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
fn visit_user_provided_sigs(&mut self) { fn visit_user_provided_sigs(&mut self) {
let fcx_tables = self.fcx.tables.borrow(); let fcx_tables = self.fcx.tables.borrow();
debug_assert_eq!(fcx_tables.local_id_root, self.tables.local_id_root); assert_eq!(fcx_tables.hir_owner, self.tables.hir_owner);
for (&def_id, c_sig) in fcx_tables.user_provided_sigs.iter() { for (&def_id, c_sig) in fcx_tables.user_provided_sigs.iter() {
if cfg!(debug_assertions) && c_sig.has_local_value() { if cfg!(debug_assertions) && c_sig.has_local_value() {
@ -414,7 +414,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
fn visit_generator_interior_types(&mut self) { fn visit_generator_interior_types(&mut self) {
let fcx_tables = self.fcx.tables.borrow(); let fcx_tables = self.fcx.tables.borrow();
debug_assert_eq!(fcx_tables.local_id_root, self.tables.local_id_root); assert_eq!(fcx_tables.hir_owner, self.tables.hir_owner);
self.tables.generator_interior_types = fcx_tables.generator_interior_types.clone(); self.tables.generator_interior_types = fcx_tables.generator_interior_types.clone();
} }
@ -553,11 +553,11 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
fn visit_liberated_fn_sigs(&mut self) { fn visit_liberated_fn_sigs(&mut self) {
let fcx_tables = self.fcx.tables.borrow(); let fcx_tables = self.fcx.tables.borrow();
debug_assert_eq!(fcx_tables.local_id_root, self.tables.local_id_root); assert_eq!(fcx_tables.hir_owner, self.tables.hir_owner);
let common_local_id_root = fcx_tables.local_id_root.unwrap(); let common_hir_owner = fcx_tables.hir_owner.unwrap();
for (&local_id, fn_sig) in fcx_tables.liberated_fn_sigs().iter() { for (&local_id, fn_sig) in fcx_tables.liberated_fn_sigs().iter() {
let hir_id = hir::HirId { owner: common_local_id_root.expect_local(), local_id }; let hir_id = hir::HirId { owner: common_hir_owner, local_id };
let fn_sig = self.resolve(fn_sig, &hir_id); let fn_sig = self.resolve(fn_sig, &hir_id);
self.tables.liberated_fn_sigs_mut().insert(hir_id, fn_sig.clone()); self.tables.liberated_fn_sigs_mut().insert(hir_id, fn_sig.clone());
} }
@ -565,11 +565,11 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
fn visit_fru_field_types(&mut self) { fn visit_fru_field_types(&mut self) {
let fcx_tables = self.fcx.tables.borrow(); let fcx_tables = self.fcx.tables.borrow();
debug_assert_eq!(fcx_tables.local_id_root, self.tables.local_id_root); assert_eq!(fcx_tables.hir_owner, self.tables.hir_owner);
let common_local_id_root = fcx_tables.local_id_root.unwrap(); let common_hir_owner = fcx_tables.hir_owner.unwrap();
for (&local_id, ftys) in fcx_tables.fru_field_types().iter() { for (&local_id, ftys) in fcx_tables.fru_field_types().iter() {
let hir_id = hir::HirId { owner: common_local_id_root.expect_local(), local_id }; let hir_id = hir::HirId { owner: common_hir_owner, local_id };
let ftys = self.resolve(ftys, &hir_id); let ftys = self.resolve(ftys, &hir_id);
self.tables.fru_field_types_mut().insert(hir_id, ftys); self.tables.fru_field_types_mut().insert(hir_id, ftys);
} }