diff options
62 files changed, 545 insertions, 492 deletions
diff --git a/src/librustc_codegen_ssa/back/symbol_export.rs b/src/librustc_codegen_ssa/back/symbol_export.rs index d5489ff9505..38a5f8d6d71 100644 --- a/src/librustc_codegen_ssa/back/symbol_export.rs +++ b/src/librustc_codegen_ssa/back/symbol_export.rs @@ -96,7 +96,7 @@ fn reachable_non_generics_provider( if !generics.requires_monomorphization(tcx) && // Functions marked with #[inline] are only ever codegened // with "internal" linkage and are never exported. - !Instance::mono(tcx, def_id).def.generates_cgu_internal_copy(tcx) + !Instance::mono(tcx, def_id.to_def_id()).def.generates_cgu_internal_copy(tcx) { Some(def_id) } else { @@ -109,7 +109,7 @@ fn reachable_non_generics_provider( }) .map(|def_id| { let export_level = if special_runtime_crate { - let name = tcx.symbol_name(Instance::mono(tcx, def_id)).name.as_str(); + let name = tcx.symbol_name(Instance::mono(tcx, def_id.to_def_id())).name.as_str(); // We can probably do better here by just ensuring that // it has hidden visibility rather than public // visibility, as this is primarily here to ensure it's @@ -126,14 +126,14 @@ fn reachable_non_generics_provider( SymbolExportLevel::Rust } } else { - symbol_export_level(tcx, def_id) + symbol_export_level(tcx, def_id.to_def_id()) }; debug!( "EXPORTED SYMBOL (local): {} ({:?})", - tcx.symbol_name(Instance::mono(tcx, def_id)), + tcx.symbol_name(Instance::mono(tcx, def_id.to_def_id())), export_level ); - (def_id, export_level) + (def_id.to_def_id(), export_level) }) .collect(); diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs index 78a271810b2..610e9b90510 100644 --- a/src/librustc_driver/pretty.rs +++ b/src/librustc_driver/pretty.rs @@ -322,7 +322,7 @@ impl<'b, 'tcx> HirPrinterSupport<'tcx> for TypedAnnotation<'b, 'tcx> { } fn node_path(&self, id: hir::HirId) -> Option<String> { - Some(self.tcx.def_path_str(self.tcx.hir().local_def_id(id))) + Some(self.tcx.def_path_str(self.tcx.hir().local_def_id(id).to_def_id())) } } diff --git a/src/librustc_incremental/assert_dep_graph.rs b/src/librustc_incremental/assert_dep_graph.rs index 5135820ac50..673d6e92b7e 100644 --- a/src/librustc_incremental/assert_dep_graph.rs +++ b/src/librustc_incremental/assert_dep_graph.rs @@ -115,7 +115,7 @@ impl IfThisChanged<'tcx> { fn process_attrs(&mut self, hir_id: hir::HirId, attrs: &[ast::Attribute]) { let def_id = self.tcx.hir().local_def_id(hir_id); - let def_path_hash = self.tcx.def_path_hash(def_id); + let def_path_hash = self.tcx.def_path_hash(def_id.to_def_id()); for attr in attrs { if attr.check_name(sym::rustc_if_this_changed) { let dep_node_interned = self.argument(attr); @@ -131,7 +131,7 @@ impl IfThisChanged<'tcx> { } }, }; - self.if_this_changed.push((attr.span, def_id, dep_node)); + self.if_this_changed.push((attr.span, def_id.to_def_id(), dep_node)); } else if attr.check_name(sym::rustc_then_this_would_need) { let dep_node_interned = self.argument(attr); let dep_node = match dep_node_interned { diff --git a/src/librustc_incremental/persist/dirty_clean.rs b/src/librustc_incremental/persist/dirty_clean.rs index 804d1744d68..27aebf7b1b9 100644 --- a/src/librustc_incremental/persist/dirty_clean.rs +++ b/src/librustc_incremental/persist/dirty_clean.rs @@ -434,16 +434,16 @@ impl DirtyCleanVisitor<'tcx> { fn check_item(&mut self, item_id: hir::HirId, item_span: Span) { let def_id = self.tcx.hir().local_def_id(item_id); - for attr in self.tcx.get_attrs(def_id).iter() { + for attr in self.tcx.get_attrs(def_id.to_def_id()).iter() { let assertion = match self.assertion_maybe(item_id, attr) { Some(a) => a, None => continue, }; self.checked_attrs.insert(attr.id); - for dep_node in self.dep_nodes(&assertion.clean, def_id) { + for dep_node in self.dep_nodes(&assertion.clean, def_id.to_def_id()) { self.assert_clean(item_span, dep_node); } - for dep_node in self.dep_nodes(&assertion.dirty, def_id) { + for dep_node in self.dep_nodes(&assertion.dirty, def_id.to_def_id()) { self.assert_dirty(item_span, dep_node); } } diff --git a/src/librustc_interface/proc_macro_decls.rs b/src/librustc_interface/proc_macro_decls.rs index 47b53aeba72..c74cba81ca9 100644 --- a/src/librustc_interface/proc_macro_decls.rs +++ b/src/librustc_interface/proc_macro_decls.rs @@ -16,7 +16,7 @@ fn proc_macro_decls_static(tcx: TyCtxt<'_>, cnum: CrateNum) -> Option<DefId> { let mut finder = Finder { decls: None }; tcx.hir().krate().visit_all_item_likes(&mut finder); - finder.decls.map(|id| tcx.hir().local_def_id(id)) + finder.decls.map(|id| tcx.hir().local_def_id(id).to_def_id()) } struct Finder { diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index 627a438c2c3..0fba510e101 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -461,7 +461,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { }; let def_id = cx.tcx.hir().local_def_id(it.hir_id); - let (article, desc) = cx.tcx.article_and_description(def_id); + let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id()); self.check_missing_docs_attrs(cx, Some(it.hir_id), &it.attrs, it.span, article, desc); } @@ -472,7 +472,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { } let def_id = cx.tcx.hir().local_def_id(trait_item.hir_id); - let (article, desc) = cx.tcx.article_and_description(def_id); + let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id()); self.check_missing_docs_attrs( cx, @@ -491,7 +491,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { } let def_id = cx.tcx.hir().local_def_id(impl_item.hir_id); - let (article, desc) = cx.tcx.article_and_description(def_id); + let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id()); self.check_missing_docs_attrs( cx, Some(impl_item.hir_id), @@ -1531,7 +1531,8 @@ impl ExplicitOutlivesRequirements { inferred_outlives: &'tcx [(ty::Predicate<'tcx>, Span)], ty_generics: &'tcx ty::Generics, ) -> Vec<ty::Region<'tcx>> { - let index = ty_generics.param_def_id_to_index[&tcx.hir().local_def_id(param.hir_id)]; + let index = + ty_generics.param_def_id_to_index[&tcx.hir().local_def_id(param.hir_id).to_def_id()]; match param.kind { hir::GenericParamKind::Lifetime { .. } => { diff --git a/src/librustc_metadata/foreign_modules.rs b/src/librustc_metadata/foreign_modules.rs index b312aa37d46..8675197656a 100644 --- a/src/librustc_metadata/foreign_modules.rs +++ b/src/librustc_metadata/foreign_modules.rs @@ -22,9 +22,11 @@ impl ItemLikeVisitor<'tcx> for Collector<'tcx> { }; let foreign_items = - fm.items.iter().map(|it| self.tcx.hir().local_def_id(it.hir_id)).collect(); - self.modules - .push(ForeignModule { foreign_items, def_id: self.tcx.hir().local_def_id(it.hir_id) }); + fm.items.iter().map(|it| self.tcx.hir().local_def_id(it.hir_id).to_def_id()).collect(); + self.modules.push(ForeignModule { + foreign_items, + def_id: self.tcx.hir().local_def_id(it.hir_id).to_def_id(), + }); } fn visit_trait_item(&mut self, _it: &'tcx hir::TraitItem<'tcx>) {} diff --git a/src/librustc_metadata/native_libs.rs b/src/librustc_metadata/native_libs.rs index 4b92a2205c2..51c9950a5df 100644 --- a/src/librustc_metadata/native_libs.rs +++ b/src/librustc_metadata/native_libs.rs @@ -51,7 +51,7 @@ impl ItemLikeVisitor<'tcx> for Collector<'tcx> { name: None, kind: cstore::NativeUnknown, cfg: None, - foreign_module: Some(self.tcx.hir().local_def_id(it.hir_id)), + foreign_module: Some(self.tcx.hir().local_def_id(it.hir_id).to_def_id()), wasm_import_module: None, }; let mut kind_specified = false; diff --git a/src/librustc_metadata/rmeta/encoder.rs b/src/librustc_metadata/rmeta/encoder.rs index b56198724db..ab5a6a798a5 100644 --- a/src/librustc_metadata/rmeta/encoder.rs +++ b/src/librustc_metadata/rmeta/encoder.rs @@ -605,9 +605,8 @@ impl EncodeContext<'tcx> { record!(self.tables.ty[def_id] <- self.tcx.type_of(def_id)); } - fn encode_enum_variant_info(&mut self, enum_did: DefId, index: VariantIdx) { + fn encode_enum_variant_info(&mut self, def: &ty::AdtDef, index: VariantIdx) { let tcx = self.tcx; - let def = tcx.adt_def(enum_did); let variant = &def.variants[index]; let def_id = variant.def_id; debug!("EncodeContext::encode_enum_variant_info({:?})", def_id); @@ -618,7 +617,7 @@ impl EncodeContext<'tcx> { ctor: variant.ctor_def_id.map(|did| did.index), }; - let enum_id = tcx.hir().as_local_hir_id(enum_did).unwrap(); + let enum_id = tcx.hir().as_local_hir_id(def.did).unwrap(); let enum_vis = &tcx.hir().expect_item(enum_id).vis; record!(self.tables.kind[def_id] <- EntryKind::Variant(self.lazy(data))); @@ -649,9 +648,8 @@ impl EncodeContext<'tcx> { self.encode_promoted_mir(def_id); } - fn encode_enum_variant_ctor(&mut self, enum_did: DefId, index: VariantIdx) { + fn encode_enum_variant_ctor(&mut self, def: &ty::AdtDef, index: VariantIdx) { let tcx = self.tcx; - let def = tcx.adt_def(enum_did); let variant = &def.variants[index]; let def_id = variant.ctor_def_id.unwrap(); debug!("EncodeContext::encode_enum_variant_ctor({:?})", def_id); @@ -665,7 +663,7 @@ impl EncodeContext<'tcx> { // Variant constructors have the same visibility as the parent enums, unless marked as // non-exhaustive, in which case they are lowered to `pub(crate)`. - let enum_id = tcx.hir().as_local_hir_id(enum_did).unwrap(); + let enum_id = tcx.hir().as_local_hir_id(def.did).unwrap(); let enum_vis = &tcx.hir().expect_item(enum_id).vis; let mut ctor_vis = ty::Visibility::from_hir(enum_vis, enum_id, tcx); if variant.is_field_list_non_exhaustive() && ctor_vis == ty::Visibility::Public { @@ -697,7 +695,7 @@ impl EncodeContext<'tcx> { vis: &hir::Visibility<'_>, ) { let tcx = self.tcx; - let def_id = tcx.hir().local_def_id(id); + let def_id = tcx.hir().local_def_id(id).to_def_id(); debug!("EncodeContext::encode_info_for_mod({:?})", def_id); let data = ModData { @@ -712,15 +710,20 @@ impl EncodeContext<'tcx> { record!(self.tables.span[def_id] <- self.tcx.def_span(def_id)); record!(self.tables.attributes[def_id] <- attrs); record!(self.tables.children[def_id] <- md.item_ids.iter().map(|item_id| { - tcx.hir().local_def_id(item_id.id).index + tcx.hir().local_def_id(item_id.id).local_def_index })); self.encode_stability(def_id); self.encode_deprecation(def_id); } - fn encode_field(&mut self, adt_def_id: DefId, variant_index: VariantIdx, field_index: usize) { + fn encode_field( + &mut self, + adt_def: &ty::AdtDef, + variant_index: VariantIdx, + field_index: usize, + ) { let tcx = self.tcx; - let variant = &tcx.adt_def(adt_def_id).variants[variant_index]; + let variant = &adt_def.variants[variant_index]; let field = &variant.fields[field_index]; let def_id = field.did; @@ -742,10 +745,9 @@ impl EncodeContext<'tcx> { self.encode_inferred_outlives(def_id); } - fn encode_struct_ctor(&mut self, adt_def_id: DefId, def_id: DefId) { + fn encode_struct_ctor(&mut self, adt_def: &ty::AdtDef, def_id: DefId) { debug!("EncodeContext::encode_struct_ctor({:?})", def_id); let tcx = self.tcx; - let adt_def = tcx.adt_def(adt_def_id); let variant = adt_def.non_enum_variant(); let data = VariantData { @@ -754,7 +756,7 @@ impl EncodeContext<'tcx> { ctor: Some(def_id.index), }; - let struct_id = tcx.hir().as_local_hir_id(adt_def_id).unwrap(); + let struct_id = tcx.hir().as_local_hir_id(adt_def.did).unwrap(); let struct_vis = &tcx.hir().expect_item(struct_id).vis; let mut ctor_vis = ty::Visibility::from_hir(struct_vis, struct_id, tcx); for field in &variant.fields { @@ -1101,7 +1103,7 @@ impl EncodeContext<'tcx> { // for methods, write all the stuff get_trait_method // needs to know let ctor = struct_def.ctor_hir_id().map(|ctor_hir_id| { - self.tcx.hir().local_def_id(ctor_hir_id).index + self.tcx.hir().local_def_id(ctor_hir_id).local_def_index }); EntryKind::Struct(self.lazy(VariantData { @@ -1182,7 +1184,7 @@ impl EncodeContext<'tcx> { fm.items .iter() .map(|foreign_item| tcx.hir().local_def_id( - foreign_item.hir_id).index) + foreign_item.hir_id).local_def_index) ), hir::ItemKind::Enum(..) => record!(self.tables.children[def_id] <- self.tcx.adt_def(def_id).variants.iter().map(|v| { @@ -1287,7 +1289,7 @@ impl EncodeContext<'tcx> { /// Serialize the text of exported macros fn encode_info_for_macro_def(&mut self, macro_def: &hir::MacroDef<'_>) { - let def_id = self.tcx.hir().local_def_id(macro_def.hir_id); + let def_id = self.tcx.hir().local_def_id(macro_def.hir_id).to_def_id(); record!(self.tables.kind[def_id] <- EntryKind::MacroDef(self.lazy(macro_def.ast.clone()))); record!(self.tables.visibility[def_id] <- ty::Visibility::Public); record!(self.tables.span[def_id] <- macro_def.span); @@ -1306,7 +1308,8 @@ impl EncodeContext<'tcx> { } } - fn encode_info_for_closure(&mut self, def_id: DefId) { + fn encode_info_for_closure(&mut self, def_id: LocalDefId) { + let def_id = def_id.to_def_id(); debug!("EncodeContext::encode_info_for_closure({:?})", def_id); // NOTE(eddyb) `tcx.type_of(def_id)` isn't used because it's fully generic, @@ -1336,7 +1339,8 @@ impl EncodeContext<'tcx> { self.encode_promoted_mir(def_id); } - fn encode_info_for_anon_const(&mut self, def_id: DefId) { + fn encode_info_for_anon_const(&mut self, def_id: LocalDefId) { + let def_id = def_id.to_def_id(); debug!("EncodeContext::encode_info_for_anon_const({:?})", def_id); let id = self.tcx.hir().as_local_hir_id(def_id).unwrap(); let body_id = self.tcx.hir().body_owned_by(id); @@ -1573,14 +1577,14 @@ impl Visitor<'tcx> for EncodeContext<'tcx> { let def_id = self.tcx.hir().local_def_id(item.hir_id); match item.kind { hir::ItemKind::ExternCrate(_) | hir::ItemKind::Use(..) => {} // ignore these - _ => self.encode_info_for_item(def_id, item), + _ => self.encode_info_for_item(def_id.to_def_id(), item), } self.encode_addl_info_for_item(item); } fn visit_foreign_item(&mut self, ni: &'tcx hir::ForeignItem<'tcx>) { intravisit::walk_foreign_item(self, ni); let def_id = self.tcx.hir().local_def_id(ni.hir_id); - self.encode_info_for_foreign_item(def_id, ni); + self.encode_info_for_foreign_item(def_id.to_def_id(), ni); } fn visit_generics(&mut self, generics: &'tcx hir::Generics<'tcx>) { intravisit::walk_generics(self, generics); @@ -1592,13 +1596,10 @@ impl Visitor<'tcx> for EncodeContext<'tcx> { } impl EncodeContext<'tcx> { - fn encode_fields(&mut self, adt_def_id: DefId) { - let def = self.tcx.adt_def(adt_def_id); - for (variant_index, variant) in def.variants.iter_enumerated() { + fn encode_fields(&mut self, adt_def: &ty::AdtDef) { + for (variant_index, variant) in adt_def.variants.iter_enumerated() { for (field_index, _field) in variant.fields.iter().enumerate() { - // FIXME(eddyb) `adt_def_id` is leftover from incremental isolation, - // pass `def`, `variant` or `field` instead. - self.encode_field(adt_def_id, variant_index, field_index); + self.encode_field(adt_def, variant_index, field_index); } } } @@ -1610,13 +1611,17 @@ impl EncodeContext<'tcx> { GenericParamKind::Lifetime { .. } => continue, GenericParamKind::Type { ref default, .. } => { self.encode_info_for_generic_param( - def_id, + def_id.to_def_id(), EntryKind::TypeParam, default.is_some(), ); } GenericParamKind::Const { .. } => { - self.encode_info_for_generic_param(def_id, EntryKind::ConstParam, true); + self.encode_info_for_generic_param( + def_id.to_def_id(), + EntryKind::ConstParam, + true, + ); } } } @@ -1654,40 +1659,40 @@ impl EncodeContext<'tcx> { // no sub-item recording needed in these cases } hir::ItemKind::Enum(..) => { - self.encode_fields(def_id); + let def = self.tcx.adt_def(def_id.to_def_id()); + self.encode_fields(def); - let def = self.tcx.adt_def(def_id); for (i, variant) in def.variants.iter_enumerated() { - // FIXME(eddyb) `def_id` is leftover from incremental isolation, - // pass `def` or `variant` instead. - self.encode_enum_variant_info(def_id, i); + self.encode_enum_variant_info(def, i); - // FIXME(eddyb) `def_id` is leftover from incremental isolation, - // pass `def`, `variant` or `ctor_def_id` instead. if let Some(_ctor_def_id) = variant.ctor_def_id { - self.encode_enum_variant_ctor(def_id, i); + self.encode_enum_variant_ctor(def, i); } } } hir::ItemKind::Struct(ref struct_def, _) => { - self.encode_fields(def_id); + let def = self.tcx.adt_def(def_id.to_def_id()); + self.encode_fields(def); // If the struct has a constructor, encode it. if let Some(ctor_hir_id) = struct_def.ctor_hir_id() { let ctor_def_id = self.tcx.hir().local_def_id(ctor_hir_id); - self.encode_struct_ctor(def_id, ctor_def_id); + self.encode_struct_ctor(def, ctor_def_id.to_def_id()); } } hir::ItemKind::Union(..) => { - self.encode_fields(def_id); + let def = self.tcx.adt_def(def_id.to_def_id()); + self.encode_fields(def); } hir::ItemKind::Impl { .. } => { - for &trait_item_def_id in self.tcx.associated_item_def_ids(def_id).iter() { + for &trait_item_def_id in + self.tcx.associated_item_def_ids(def_id.to_def_id()).iter() + { self.encode_info_for_impl_item(trait_item_def_id); } } hir::ItemKind::Trait(..) => { - for &item_def_id in self.tcx.associated_item_def_ids(def_id).iter() { + for &item_def_id in self.tcx.associated_item_def_ids(def_id.to_def_id()).iter() { self.encode_info_for_trait_item(item_def_id); } } @@ -1704,8 +1709,8 @@ impl<'tcx, 'v> ItemLikeVisitor<'v> for ImplVisitor<'tcx> { fn visit_item(&mut self, item: &hir::Item<'_>) { if let hir::ItemKind::Impl { .. } = item.kind { let impl_id = self.tcx.hir().local_def_id(item.hir_id); - if let Some(trait_ref) = self.tcx.impl_trait_ref(impl_id) { - self.impls.entry(trait_ref.def_id).or_default().push(impl_id.index); + if let Some(trait_ref) = self.tcx.impl_trait_ref(impl_id.to_def_id()) { + self.impls.entry(trait_ref.def_id).or_default().push(impl_id.local_def_index); } } } @@ -1725,7 +1730,8 @@ struct PrefetchVisitor<'tcx> { } impl<'tcx> PrefetchVisitor<'tcx> { - fn prefetch_mir(&self, def_id: DefId) { + fn prefetch_mir(&self, def_id: LocalDefId) { + let def_id = def_id.to_def_id(); if self.mir_keys.contains(&def_id) { self.tcx.optimized_mir(def_id); self.tcx.promoted_mir(def_id); @@ -1743,9 +1749,9 @@ impl<'tcx, 'v> ParItemLikeVisitor<'v> for PrefetchVisitor<'tcx> { } hir::ItemKind::Fn(ref sig, ..) => { let def_id = tcx.hir().local_def_id(item.hir_id); - let generics = tcx.generics_of(def_id); + let generics = tcx.generics_of(def_id.to_def_id()); let needs_inline = generics.requires_monomorphization(tcx) - || tcx.codegen_fn_attrs(def_id).requests_inline(); + || tcx.codegen_fn_attrs(def_id.to_def_id()).requests_inline(); if needs_inline || sig.header.constness == hir::Constness::Const { self.prefetch_mir(def_id) } @@ -1768,9 +1774,9 @@ impl<'tcx, 'v> ParItemLikeVisitor<'v> for PrefetchVisitor<'tcx> { } hir::ImplItemKind::Fn(ref sig, _) => { let def_id = tcx.hir().local_def_id(impl_item.hir_id); - let generics = tcx.generics_of(def_id); + let generics = tcx.generics_of(def_id.to_def_id()); let needs_inline = generics.requires_monomorphization(tcx) - || tcx.codegen_fn_attrs(def_id).requests_inline(); + || tcx.codegen_fn_attrs(def_id.to_def_id()).requests_inline(); let is_const_fn = sig.header.constness == hir::Constness::Const; if needs_inline || is_const_fn { self.prefetch_mir(def_id) diff --git a/src/librustc_middle/hir/map/mod.rs b/src/librustc_middle/hir/map/mod.rs index a734cbc6fe9..f18410cedf3 100644 --- a/src/librustc_middle/hir/map/mod.rs +++ b/src/librustc_middle/hir/map/mod.rs @@ -171,16 +171,14 @@ impl<'hir> Map<'hir> { // FIXME(eddyb) this function can and should return `LocalDefId`. #[inline] - pub fn local_def_id(&self, hir_id: HirId) -> DefId { - self.opt_local_def_id(hir_id) - .unwrap_or_else(|| { - bug!( - "local_def_id: no entry for `{:?}`, which has a map of `{:?}`", - hir_id, - self.find_entry(hir_id) - ) - }) - .to_def_id() + pub fn local_def_id(&self, hir_id: HirId) -> LocalDefId { + self.opt_local_def_id(hir_id).unwrap_or_else(|| { + bug!( + "local_def_id: no entry for `{:?}`, which has a map of `{:?}`", + hir_id, + self.find_entry(hir_id) + ) + }) } #[inline] @@ -378,7 +376,7 @@ impl<'hir> Map<'hir> { } pub fn body_owner_def_id(&self, id: BodyId) -> LocalDefId { - self.local_def_id(self.body_owner(id)).expect_local() + self.local_def_id(self.body_owner(id)) } /// Given a `HirId`, returns the `BodyId` associated with it, @@ -729,7 +727,7 @@ impl<'hir> Map<'hir> { } pub fn get_parent_did(&self, id: HirId) -> LocalDefId { - self.local_def_id(self.get_parent_item(id)).expect_local() + self.local_def_id(self.get_parent_item(id)) } pub fn get_foreign_abi(&self, hir_id: HirId) -> Abi { @@ -995,7 +993,7 @@ fn hir_id_to_string(map: &Map<'_>, id: HirId) -> String { crate::ty::tls::with_opt(|tcx| { if let Some(tcx) = tcx { let def_id = map.local_def_id(id); - tcx.def_path_str(def_id) + tcx.def_path_str(def_id.to_def_id()) } else if let Some(path) = map.def_path_from_hir_id(id) { path.data .into_iter() diff --git a/src/librustc_middle/hir/mod.rs b/src/librustc_middle/hir/mod.rs index ce8e1f48daa..3d3d9dcf41d 100644 --- a/src/librustc_middle/hir/mod.rs +++ b/src/librustc_middle/hir/mod.rs @@ -69,7 +69,6 @@ pub fn provide(providers: &mut Providers<'_>) { providers.parent_module_from_def_id = |tcx, id| { let hir = tcx.hir(); hir.local_def_id(hir.get_module_parent_node(hir.as_local_hir_id(id.to_def_id()).unwrap())) - .expect_local() }; providers.hir_crate = |tcx, _| tcx.untracked_crate; providers.index_hir = map::index_hir; diff --git a/src/librustc_middle/middle/stability.rs b/src/librustc_middle/middle/stability.rs index 1dd14b7c4ff..9d95a700313 100644 --- a/src/librustc_middle/middle/stability.rs +++ b/src/librustc_middle/middle/stability.rs @@ -286,7 +286,7 @@ impl<'tcx> TyCtxt<'tcx> { if let Some(depr_entry) = self.lookup_deprecation_entry(def_id) { let parent_def_id = self.hir().local_def_id(self.hir().get_parent_item(id)); let skip = self - .lookup_deprecation_entry(parent_def_id) + .lookup_deprecation_entry(parent_def_id.to_def_id()) .map_or(false, |parent_depr| parent_depr.same_origin(&depr_entry)); if !skip { diff --git a/src/librustc_middle/ty/inhabitedness/def_id_forest.rs b/src/librustc_middle/ty/inhabitedness/def_id_forest.rs index 14ead77653c..ee6b06a1cc8 100644 --- a/src/librustc_middle/ty/inhabitedness/def_id_forest.rs +++ b/src/librustc_middle/ty/inhabitedness/def_id_forest.rs @@ -32,7 +32,7 @@ impl<'tcx> DefIdForest { #[inline] pub fn full(tcx: TyCtxt<'tcx>) -> DefIdForest { let crate_id = tcx.hir().local_def_id(CRATE_HIR_ID); - DefIdForest::from_id(crate_id) + DefIdForest::from_id(crate_id.to_def_id()) } /// Creates a forest containing a `DefId` and all its descendants. diff --git a/src/librustc_middle/ty/sty.rs b/src/librustc_middle/ty/sty.rs index 43f28ff2ac3..0134ea1a4e9 100644 --- a/src/librustc_middle/ty/sty.rs +++ b/src/librustc_middle/ty/sty.rs @@ -2269,8 +2269,9 @@ impl<'tcx> Const<'tcx> { let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); let item_id = tcx.hir().get_parent_node(hir_id); let item_def_id = tcx.hir().local_def_id(item_id); - let generics = tcx.generics_of(item_def_id); - let index = generics.param_def_id_to_index[&tcx.hir().local_def_id(hir_id)]; + let generics = tcx.generics_of(item_def_id.to_def_id()); + let index = + generics.param_def_id_to_index[&tcx.hir().local_def_id(hir_id).to_def_id()]; let name = tcx.hir().name(hir_id); ty::ConstKind::Param(ty::ParamConst::new(index, name)) } diff --git a/src/librustc_middle/ty/trait_def.rs b/src/librustc_middle/ty/trait_def.rs index 912f8be1d33..2686759ab97 100644 --- a/src/librustc_middle/ty/trait_def.rs +++ b/src/librustc_middle/ty/trait_def.rs @@ -217,7 +217,7 @@ pub(super) fn trait_impls_of_provider(tcx: TyCtxt<'_>, trait_id: DefId) -> &Trai } for &hir_id in tcx.hir().trait_impls(trait_id) { - add_impl(tcx.hir().local_def_id(hir_id)); + add_impl(tcx.hir().local_def_id(hir_id).to_def_id()); } } diff --git a/src/librustc_mir/borrow_check/universal_regions.rs b/src/librustc_mir/borrow_check/universal_regions.rs index 4d67d7204ca..2dbfcb69017 100644 --- a/src/librustc_mir/borrow_check/universal_regions.rs +++ b/src/librustc_mir/borrow_check/universal_regions.rs @@ -777,7 +777,7 @@ fn for_each_late_bound_region_defined_on<'tcx>( let region_def_id = tcx.hir().local_def_id(hir_id); let liberated_region = tcx.mk_region(ty::ReFree(ty::FreeRegion { scope: fn_def_id, - bound_region: ty::BoundRegion::BrNamed(region_def_id, name), + bound_region: ty::BoundRegion::BrNamed(region_def_id.to_def_id(), name), })); f(liberated_region); } diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs index 129dfe98e5e..b8f7596070f 100644 --- a/src/librustc_mir/monomorphize/collector.rs +++ b/src/librustc_mir/monomorphize/collector.rs @@ -180,7 +180,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_data_structures::sync::{par_iter, MTLock, MTRef, ParallelIterator}; use rustc_errors::ErrorReported; use rustc_hir as hir; -use rustc_hir::def_id::{DefId, DefIdMap, LOCAL_CRATE}; +use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId, LOCAL_CRATE}; use rustc_hir::itemlikevisit::ItemLikeVisitor; use rustc_hir::lang_items::{ExchangeMallocFnLangItem, StartFnLangItem}; use rustc_index::bit_set::GrowableBitSet; @@ -952,8 +952,8 @@ impl ItemLikeVisitor<'v> for RootCollector<'_, 'v> { def_id_to_string(self.tcx, def_id) ); - let ty = - Instance::new(def_id, InternalSubsts::empty()).monomorphic_ty(self.tcx); + let ty = Instance::new(def_id.to_def_id(), InternalSubsts::empty()) + .monomorphic_ty(self.tcx); visit_drop_use(self.tcx, ty, true, self.output); } } @@ -968,7 +968,7 @@ impl ItemLikeVisitor<'v> for RootCollector<'_, 'v> { hir::ItemKind::Static(..) => { let def_id = self.tcx.hir().local_def_id(item.hir_id); debug!("RootCollector: ItemKind::Static({})", def_id_to_string(self.tcx, def_id)); - self.output.push(MonoItem::Static(def_id)); + self.output.push(MonoItem::Static(def_id.to_def_id())); } hir::ItemKind::Const(..) => { // const items only generate mono items if they are @@ -977,7 +977,7 @@ impl ItemLikeVisitor<'v> for RootCollector<'_, 'v> { // but even just declaring them must collect the items they refer to let def_id = self.tcx.hir().local_def_id(item.hir_id); - if let Ok(val) = self.tcx.const_eval_poly(def_id) { + if let Ok(val) = self.tcx.const_eval_poly(def_id.to_def_id()) { collect_const_value(self.tcx, val, &mut self.output); } } @@ -1002,12 +1002,12 @@ impl ItemLikeVisitor<'v> for RootCollector<'_, 'v> { } impl RootCollector<'_, 'v> { - fn is_root(&self, def_id: DefId) -> bool { + fn is_root(&self, def_id: LocalDefId) -> bool { !item_requires_monomorphization(self.tcx, def_id) && match self.mode { MonoItemCollectionMode::Eager => true, MonoItemCollectionMode::Lazy => { - self.entry_fn.map(|(id, _)| id) == Some(def_id) + self.entry_fn.map(|(id, _)| id) == Some(def_id.to_def_id()) || self.tcx.is_reachable_non_generic(def_id) || self .tcx @@ -1020,11 +1020,11 @@ impl RootCollector<'_, 'v> { /// If `def_id` represents a root, pushes it onto the list of /// outputs. (Note that all roots must be monomorphic.) - fn push_if_root(&mut self, def_id: DefId) { + fn push_if_root(&mut self, def_id: LocalDefId) { if self.is_root(def_id) { debug!("RootCollector::push_if_root: found root def_id={:?}", def_id); - let instance = Instance::mono(self.tcx, def_id); + let instance = Instance::mono(self.tcx, def_id.to_def_id()); self.output.push(create_fn_mono_item(instance)); } } @@ -1066,7 +1066,7 @@ impl RootCollector<'_, 'v> { } } -fn item_requires_monomorphization(tcx: TyCtxt<'_>, def_id: DefId) -> bool { +fn item_requires_monomorphization(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool { let generics = tcx.generics_of(def_id); generics.requires_monomorphization(tcx) } @@ -1170,10 +1170,10 @@ fn collect_neighbours<'tcx>( MirNeighborCollector { tcx, body: &body, output, instance }.visit_body(&body); } -fn def_id_to_string(tcx: TyCtxt<'_>, def_id: DefId) -> String { +fn def_id_to_string(tcx: TyCtxt<'_>, def_id: LocalDefId) -> String { let mut output = String::new(); let printer = DefPathBasedNames::new(tcx, false, false); - printer.push_def_path(def_id, &mut output); + printer.push_def_path(def_id.to_def_id(), &mut output); output } diff --git a/src/librustc_mir/monomorphize/partitioning.rs b/src/librustc_mir/monomorphize/partitioning.rs index 5f75633ae59..cad5b114ae4 100644 --- a/src/librustc_mir/monomorphize/partitioning.rs +++ b/src/librustc_mir/monomorphize/partitioning.rs @@ -306,7 +306,7 @@ fn mono_item_visibility( let def_id = tcx.hir().local_def_id(*hir_id); return if tcx.is_reachable_non_generic(def_id) { *can_be_internalized = false; - default_visibility(tcx, def_id, false) + default_visibility(tcx, def_id.to_def_id(), false) } else { Visibility::Hidden }; @@ -755,7 +755,7 @@ fn characteristic_def_id_of_mono_item<'tcx>( Some(def_id) } MonoItem::Static(def_id) => Some(def_id), - MonoItem::GlobalAsm(hir_id) => Some(tcx.hir().local_def_id(hir_id)), + MonoItem::GlobalAsm(hir_id) => Some(tcx.hir().local_def_id(hir_id).to_def_id()), } } diff --git a/src/librustc_mir/transform/mod.rs b/src/librustc_mir/transform/mod.rs index a87955274a7..40f26d5c52c 100644 --- a/src/librustc_mir/transform/mod.rs +++ b/src/librustc_mir/transform/mod.rs @@ -80,7 +80,7 @@ fn mir_keys(tcx: TyCtxt<'_>, krate: CrateNum) -> &DefIdSet { _: Span, ) { if let hir::VariantData::Tuple(_, hir_id) = *v { - self.set.insert(self.tcx.hir().local_def_id(hir_id)); + self.set.insert(self.tcx.hir().local_def_id(hir_id).to_def_id()); } intravisit::walk_struct_def(self, v) } diff --git a/src/librustc_mir_build/build/mod.rs b/src/librustc_mir_build/build/mod.rs index 2a3e9188437..2d76e274510 100644 --- a/src/librustc_mir_build/build/mod.rs +++ b/src/librustc_mir_build/build/mod.rs @@ -5,7 +5,7 @@ use crate::hair::{BindingMode, LintLevel, PatKind}; use rustc_attr::{self as attr, UnwindAttr}; use rustc_errors::ErrorReported; use rustc_hir as hir; -use rustc_hir::def_id::DefId; +use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::lang_items; use rustc_hir::{GeneratorKind, HirIdMap, Node}; use rustc_index::vec::{Idx, IndexVec}; @@ -523,9 +523,9 @@ macro_rules! unpack { }}; } -fn should_abort_on_panic(tcx: TyCtxt<'_>, fn_def_id: DefId, _abi: Abi) -> bool { +fn should_abort_on_panic(tcx: TyCtxt<'_>, fn_def_id: LocalDefId, _abi: Abi) -> bool { // Validate `#[unwind]` syntax regardless of platform-specific panic strategy. - let attrs = &tcx.get_attrs(fn_def_id); + let attrs = &tcx.get_attrs(fn_def_id.to_def_id()); let unwind_attr = attr::find_unwind_attr(Some(tcx.sess.diagnostic()), attrs); // We never unwind, so it's not relevant to stop an unwind. @@ -613,7 +613,7 @@ where builder.in_scope(arg_scope_s, LintLevel::Inherited, |builder| { builder.args_and_body( block, - fn_def_id, + fn_def_id.to_def_id(), &arguments, arg_scope, &body.value, @@ -643,7 +643,7 @@ where } else { None }; - debug!("fn_id {:?} has attrs {:?}", fn_def_id, tcx.get_attrs(fn_def_id)); + debug!("fn_id {:?} has attrs {:?}", fn_def_id, tcx.get_attrs(fn_def_id.to_def_id())); let mut body = builder.finish(); body.spread_arg = spread_arg; diff --git a/src/librustc_mir_build/hair/cx/expr.rs b/src/librustc_mir_build/hair/cx/expr.rs index 21d632b9f6b..e5cd05da805 100644 --- a/src/librustc_mir_build/hair/cx/expr.rs +++ b/src/librustc_mir_build/hair/cx/expr.rs @@ -408,7 +408,7 @@ fn make_mirror_unadjusted<'a, 'tcx>( // Now comes the rote stuff: hir::ExprKind::Repeat(ref v, ref count) => { - let count_def_id = cx.tcx.hir().local_def_id(count.hir_id).expect_local(); + let count_def_id = cx.tcx.hir().local_def_id(count.hir_id); let count = ty::Const::from_anon_const(cx.tcx, count_def_id); ExprKind::Repeat { value: v.to_ref(), count } @@ -695,7 +695,7 @@ fn convert_path_expr<'a, 'tcx>( let item_def_id = cx.tcx.hir().local_def_id(item_id); let generics = cx.tcx.generics_of(item_def_id); let local_def_id = cx.tcx.hir().local_def_id(hir_id); - let index = generics.param_def_id_to_index[&local_def_id]; + let index = generics.param_def_id_to_index[&local_def_id.to_def_id()]; let name = cx.tcx.hir().name(hir_id); let val = ty::ConstKind::Param(ty::ParamConst::new(index, name)); ExprKind::Literal { @@ -962,7 +962,7 @@ fn capture_upvar<'tcx>( ) -> ExprRef<'tcx> { let upvar_id = ty::UpvarId { var_path: ty::UpvarPath { hir_id: var_hir_id }, - closure_expr_id: cx.tcx.hir().local_def_id(closure_expr.hir_id).expect_local(), + closure_expr_id: cx.tcx.hir().local_def_id(closure_expr.hir_id), }; let upvar_capture = cx.tables().upvar_capture(upvar_id); let temp_lifetime = cx.region_scope_tree.temporary_scope(closure_expr.hir_id.local_id); diff --git a/src/librustc_mir_build/hair/cx/mod.rs b/src/librustc_mir_build/hair/cx/mod.rs index 18a981dfea1..46607fd07cd 100644 --- a/src/librustc_mir_build/hair/cx/mod.rs +++ b/src/librustc_mir_build/hair/cx/mod.rs @@ -82,11 +82,11 @@ impl<'a, 'tcx> Cx<'a, 'tcx> { infcx, root_lint_level: src_id, param_env: tcx.param_env(src_def_id), - identity_substs: InternalSubsts::identity_for_item(tcx, src_def_id), + identity_substs: InternalSubsts::identity_for_item(tcx, src_def_id.to_def_id()), region_scope_tree: tcx.region_scope_tree(src_def_id), tables, constness, - body_owner: src_def_id, + body_owner: src_def_id.to_def_id(), body_owner_kind, check_overflow, control_flow_destroyed: Vec::new(), diff --git a/src/librustc_passes/diagnostic_items.rs b/src/librustc_passes/diagnostic_items.rs index c7210432b1d..bed2221fe60 100644 --- a/src/librustc_passes/diagnostic_items.rs +++ b/src/librustc_passes/diagnostic_items.rs @@ -47,7 +47,7 @@ impl<'tcx> DiagnosticItemCollector<'tcx> { if let Some(name) = extract(attrs) { let def_id = self.tcx.hir().local_def_id(hir_id); // insert into our table - collect_item(self.tcx, &mut self.items, name, def_id); + collect_item(self.tcx, &mut self.items, name, def_id.to_def_id()); } } } diff --git a/src/librustc_passes/entry.rs b/src/librustc_passes/entry.rs index 678859219ea..35805db8d59 100644 --- a/src/librustc_passes/entry.rs +++ b/src/librustc_passes/entry.rs @@ -34,7 +34,7 @@ struct EntryContext<'a, 'tcx> { impl<'a, 'tcx> ItemLikeVisitor<'tcx> for EntryContext<'a, 'tcx> { fn visit_item(&mut self, item: &'tcx Item<'tcx>) { let def_id = self.map.local_def_id(item.hir_id); - let def_key = self.map.def_key(def_id.expect_local()); + let def_key = self.map.def_key(def_id); let at_root = def_key.parent == Some(CRATE_DEF_INDEX); find_item(item, self, at_root); } @@ -145,11 +145,11 @@ fn find_item(item: &Item<'_>, ctxt: &mut EntryContext<'_, '_>, at_root: bool) { fn configure_main(tcx: TyCtxt<'_>, visitor: &EntryContext<'_, '_>) -> Option<(DefId, EntryFnType)> { if let Some((hir_id, _)) = visitor.start_fn { - Some((tcx.hir().local_def_id(hir_id), EntryFnType::Start)) + Some((tcx.hir().local_def_id(hir_id).to_def_id(), EntryFnType::Start)) } else if let Some((hir_id, _)) = visitor.attr_main_fn { - Some((tcx.hir().local_def_id(hir_id), EntryFnType::Main)) + Some((tcx.hir().local_def_id(hir_id).to_def_id(), EntryFnType::Main)) } else if let Some((hir_id, _)) = visitor.main_fn { - Some((tcx.hir().local_def_id(hir_id), EntryFnType::Main)) + Some((tcx.hir().local_def_id(hir_id).to_def_id(), EntryFnType::Main)) } else { no_main_err(tcx, visitor); None diff --git a/src/librustc_passes/hir_id_validator.rs b/src/librustc_passes/hir_id_validator.rs index 1e31b7c74b6..80dfcd9c241 100644 --- a/src/librustc_passes/hir_id_validator.rs +++ b/src/librustc_passes/hir_id_validator.rs @@ -17,7 +17,7 @@ pub fn check_crate(tcx: TyCtxt<'_>) { par_iter(&hir_map.krate().modules).for_each(|(module_id, _)| { let local_def_id = hir_map.local_def_id(*module_id); hir_map.visit_item_likes_in_module( - local_def_id, + local_def_id.to_def_id(), &mut OuterVisitor { hir_map, errors: &errors }, ); }); @@ -79,7 +79,7 @@ impl<'a, 'hir> HirIdValidator<'a, 'hir> { fn check<F: FnOnce(&mut HirIdValidator<'a, 'hir>)>(&mut self, hir_id: HirId, walk: F) { assert!(self.owner.is_none()); - let owner = self.hir_map.local_def_id(hir_id).expect_local(); + let owner = self.hir_map.local_def_id(hir_id); self.owner = Some(owner); walk(self); diff --git a/src/librustc_passes/lang_items.rs b/src/librustc_passes/lang_items.rs index f1aa76cd223..c48e6f9133b 100644 --- a/src/librustc_passes/lang_items.rs +++ b/src/librustc_passes/lang_items.rs @@ -34,7 +34,7 @@ impl ItemLikeVisitor<'v> for LanguageItemCollector<'tcx> { // Known lang item with attribute on correct target. Some((item_index, expected_target)) if actual_target == expected_target => { let def_id = self.tcx.hir().local_def_id(item.hir_id); - self.collect_item(item_index, def_id); + self.collect_item(item_index, def_id.to_def_id()); } // Known lang item with attribute on incorrect target. Some((_, expected_target)) => { diff --git a/src/librustc_passes/layout_test.rs b/src/librustc_passes/layout_test.rs index dbc39169f2b..c0826f8cc60 100644 --- a/src/librustc_passes/layout_test.rs +++ b/src/librustc_passes/layout_test.rs @@ -1,6 +1,6 @@ use rustc_ast::ast::Attribute; use rustc_hir as hir; -use rustc_hir::def_id::DefId; +use rustc_hir::def_id::LocalDefId; use rustc_hir::itemlikevisit::ItemLikeVisitor; use rustc_hir::ItemKind; use rustc_middle::ty::layout::{HasParamEnv, HasTyCtxt, TyAndLayout}; @@ -29,7 +29,7 @@ impl ItemLikeVisitor<'tcx> for LayoutTest<'tcx> { | ItemKind::Struct(..) | ItemKind::Union(..) | ItemKind::OpaqueTy(..) => { - for attr in self.tcx.get_attrs(item_def_id).iter() { + for attr in self.tcx.get_attrs(item_def_id.to_def_id()).iter() { if attr.check_name(sym::rustc_layout) { self.dump_layout_of(item_def_id, item, attr); } @@ -44,7 +44,7 @@ impl ItemLikeVisitor<'tcx> for LayoutTest<'tcx> { } impl LayoutTest<'tcx> { - fn dump_layout_of(&self, item_def_id: DefId, item: &hir::Item<'tcx>, attr: &Attribute) { + fn dump_layout_of(&self, item_def_id: LocalDefId, item: &hir::Item<'tcx>, attr: &Attribute) { let tcx = self.tcx; let param_env = self.tcx.param_env(item_def_id); let ty = self.tcx.type_of(item_def_id); diff --git a/src/librustc_passes/liveness.rs b/src/librustc_passes/liveness.rs index 24f6d1a9c58..25d53485bc5 100644 --- a/src/librustc_passes/liveness.rs +++ b/src/librustc_passes/liveness.rs @@ -361,7 +361,7 @@ fn visit_fn<'tcx>( // swap in a new set of IR maps for this function body: let def_id = ir.tcx.hir().local_def_id(id); - let mut fn_maps = IrMaps::new(ir.tcx, def_id); + let mut fn_maps = IrMaps::new(ir.tcx, def_id.to_def_id()); // Don't run unused pass for #[derive()] if let FnKind::Method(..) = fk { @@ -398,7 +398,7 @@ fn visit_fn<'tcx>( intravisit::walk_fn(&mut fn_maps, fk, decl, body_id, sp, id); // compute liveness - let mut lsets = Liveness::new(&mut fn_maps, def_id); + let mut lsets = Liveness::new(&mut fn_maps, def_id.to_def_id()); let entry_ln = lsets.compute(&body.value); // check for various error conditions @@ -496,7 +496,7 @@ fn visit_expr<'tcx>(ir: &mut IrMaps<'tcx>, expr: &'tcx Expr<'tcx>) { } ir.set_captures(expr.hir_id, call_caps); let old_body_owner = ir.body_owner; - ir.body_owner = closure_def_id; + ir.body_owner = closure_def_id.to_def_id(); intravisit::walk_expr(ir, expr); ir.body_owner = old_body_owner; } diff --git a/src/librustc_plugin_impl/build.rs b/src/librustc_plugin_impl/build.rs index c7841595fe5..34522cfe97f 100644 --- a/src/librustc_plugin_impl/build.rs +++ b/src/librustc_plugin_impl/build.rs @@ -42,7 +42,7 @@ fn plugin_registrar_fn(tcx: TyCtxt<'_>, cnum: CrateNum) -> Option<DefId> { 0 => None, 1 => { let (hir_id, _) = finder.registrars.pop().unwrap(); - Some(tcx.hir().local_def_id(hir_id)) + Some(tcx.hir().local_def_id(hir_id).to_def_id()) } _ => { let diagnostic = tcx.sess.diagnostic(); diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 51e1588c71c..e8d016aa07a 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -268,11 +268,11 @@ fn def_id_visibility<'tcx>( Node::Variant(..) => { let parent_did = tcx.hir().local_def_id(parent_hir_id); let (mut ctor_vis, mut span, mut descr) = - def_id_visibility(tcx, parent_did); + def_id_visibility(tcx, parent_did.to_def_id()); let adt_def = tcx.adt_def(tcx.hir().get_parent_did(hir_id).to_def_id()); let ctor_did = tcx.hir().local_def_id(vdata.ctor_hir_id().unwrap()); - let variant = adt_def.variant_with_ctor_id(ctor_did); + let variant = adt_def.variant_with_ctor_id(ctor_did.to_def_id()); if variant.is_field_list_non_exhaustive() && ctor_vis == ty::Visibility::Public @@ -514,7 +514,7 @@ impl EmbargoVisitor<'tcx> { ) -> ReachEverythingInTheInterfaceVisitor<'_, 'tcx> { ReachEverythingInTheInterfaceVisitor { access_level: cmp::min(access_level, Some(AccessLevel::Reachable)), - item_def_id: self.tcx.hir().local_def_id(item_id), + item_def_id: self.tcx.hir().local_def_id(item_id).to_def_id(), ev: self, } } @@ -532,7 +532,7 @@ impl EmbargoVisitor<'tcx> { fn update_macro_reachable_mod(&mut self, reachable_mod: hir::HirId, defining_mod: DefId) { let module_def_id = self.tcx.hir().local_def_id(reachable_mod); - let module = self.tcx.hir().get_module(module_def_id).0; + let module = self.tcx.hir().get_module(module_def_id.to_def_id()).0; for item_id in module.item_ids { let hir_id = item_id.id; let item_def_id = self.tcx.hir().local_def_id(hir_id); @@ -661,7 +661,7 @@ impl EmbargoVisitor<'tcx> { for item_id in m.item_ids { let item = self.tcx.hir().expect_item(item_id.id); let def_id = self.tcx.hir().local_def_id(item_id.id); - if !self.tcx.hygienic_eq(segment.ident, item.ident, def_id) { + if !self.tcx.hygienic_eq(segment.ident, item.ident, def_id.to_def_id()) { continue; } if let hir::ItemKind::Use(..) = item.kind { @@ -927,7 +927,8 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { } let macro_module_def_id = - ty::DefIdTree::parent(self.tcx, self.tcx.hir().local_def_id(md.hir_id)).unwrap(); + ty::DefIdTree::parent(self.tcx, self.tcx.hir().local_def_id(md.hir_id).to_def_id()) + .unwrap(); // FIXME(#71104) Should really be using just `as_local_hir_id` but // some `DefId` do not seem to have a corresponding HirId. let hir_id = macro_module_def_id @@ -1370,8 +1371,10 @@ impl<'a, 'tcx> Visitor<'tcx> for TypePrivacyVisitor<'a, 'tcx> { // Check types in item interfaces. fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { - let orig_current_item = - mem::replace(&mut self.current_item, self.tcx.hir().local_def_id(item.hir_id)); + let orig_current_item = mem::replace( + &mut self.current_item, + self.tcx.hir().local_def_id(item.hir_id).to_def_id(), + ); let orig_in_body = mem::replace(&mut self.in_body, false); let orig_tables = mem::replace(&mut self.tables, item_tables(self.tcx, item.hir_id, self.empty_tables)); @@ -1913,7 +1916,7 @@ impl<'a, 'tcx> PrivateItemsInPublicInterfacesVisitor<'a, 'tcx> { SearchInterfaceForPrivateItemsVisitor { tcx: self.tcx, item_id, - item_def_id: self.tcx.hir().local_def_id(item_id), + item_def_id: self.tcx.hir().local_def_id(item_id).to_def_id(), span: self.tcx.hir().span(item_id), required_visibility, has_pub_restricted: self.has_pub_restricted, diff --git a/src/librustc_resolve/late/lifetimes.rs b/src/librustc_resolve/late/lifetimes.rs index 0d12bf08747..5839b914906 100644 --- a/src/librustc_resolve/late/lifetimes.rs +++ b/src/librustc_resolve/late/lifetimes.rs @@ -62,7 +62,7 @@ impl RegionExt for Region { let def_id = hir_map.local_def_id(param.hir_id); let origin = LifetimeDefOrigin::from_param(param); debug!("Region::early: index={} def_id={:?}", i, def_id); - (param.name.normalize_to_macros_2_0(), Region::EarlyBound(i, def_id, origin)) + (param.name.normalize_to_macros_2_0(), Region::EarlyBound(i, def_id.to_def_id(), origin)) } fn late(hir_map: &Map<'_>, param: &GenericParam<'_>) -> (ParamName, Region) { @@ -73,7 +73,7 @@ impl RegionExt for Region { "Region::late: param={:?} depth={:?} def_id={:?} origin={:?}", param, depth, def_id, origin, ); - (param.name.normalize_to_macros_2_0(), Region::LateBound(depth, def_id, origin)) + (param.name.normalize_to_macros_2_0(), Region::LateBound(depth, def_id.to_def_id(), origin)) } fn late_anon(index: &Cell<u32>) -> Region { @@ -1278,7 +1278,7 @@ fn object_lifetime_defaults_for_item( _ => continue, }; - if res == Res::Def(DefKind::TyParam, param_def_id) { + if res == Res::Def(DefKind::TyParam, param_def_id.to_def_id()) { add_bounds(&mut set, &data.bounds); } } @@ -1304,7 +1304,11 @@ fn object_lifetime_defaults_for_item( .find(|&(_, (_, lt_name, _))| lt_name == name) .map_or(Set1::Many, |(i, (id, _, origin))| { let def_id = tcx.hir().local_def_id(id); - Set1::One(Region::EarlyBound(i as u32, def_id, origin)) + Set1::One(Region::EarlyBound( + i as u32, + def_id.to_def_id(), + origin, + )) }) } } @@ -1812,7 +1816,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { }) | Node::ImplItem(&hir::ImplItem { kind: hir::ImplItemKind::Fn(..), .. }) => { let scope = self.tcx.hir().local_def_id(fn_id); - def = Region::Free(scope, def.id().unwrap()); + def = Region::Free(scope.to_def_id(), def.id().unwrap()); } _ => {} } diff --git a/src/librustc_symbol_mangling/test.rs b/src/librustc_symbol_mangling/test.rs index a20915dd6fc..5175b692e17 100644 --- a/src/librustc_symbol_mangling/test.rs +++ b/src/librustc_symbol_mangling/test.rs @@ -33,10 +33,10 @@ impl SymbolNamesTest<'tcx> { fn process_attrs(&mut self, hir_id: hir::HirId) { let tcx = self.tcx; let def_id = tcx.hir().local_def_id(hir_id); - for attr in tcx.get_attrs(def_id).iter() { + for attr in tcx.get_attrs(def_id.to_def_id()).iter() { if attr.check_name(SYMBOL_NAME) { // for now, can only use on monomorphic names - let instance = Instance::mono(tcx, def_id); + let instance = Instance::mono(tcx, def_id.to_def_id()); let mangled = self.tcx.symbol_name(instance); tcx.sess.span_err(attr.span, &format!("symbol-name({})", mangled)); if let Ok(demangling) = rustc_demangle::try_demangle(&mangled.name.as_str()) { @@ -44,7 +44,7 @@ impl SymbolNamesTest<'tcx> { tcx.sess.span_err(attr.span, &format!("demangling-alt({:#})", demangling)); } } else if attr.check_name(DEF_PATH) { - let path = tcx.def_path_str(def_id); + let path = tcx.def_path_str(def_id.to_def_id()); tcx.sess.span_err(attr.span, &format!("def-path({})", path)); } diff --git a/src/librustc_trait_selection/opaque_types.rs b/src/librustc_trait_selection/opaque_types.rs index f67b8b87ced..fffb41f8cb7 100644 --- a/src/librustc_trait_selection/opaque_types.rs +++ b/src/librustc_trait_selection/opaque_types.rs @@ -1040,7 +1040,8 @@ impl<'a, 'tcx> Instantiator<'a, 'tcx> { let parent_def_id = self.parent_def_id; let def_scope_default = || { let opaque_parent_hir_id = tcx.hir().get_parent_item(opaque_hir_id); - parent_def_id == tcx.hir().local_def_id(opaque_parent_hir_id) + parent_def_id + == tcx.hir().local_def_id(opaque_parent_hir_id).to_def_id() }; let (in_definition_scope, origin) = match tcx.hir().find(opaque_hir_id) { Some(Node::Item(item)) => match item.kind { diff --git a/src/librustc_ty/ty.rs b/src/librustc_ty/ty.rs index 43ff39f92f7..a3bf297db80 100644 --- a/src/librustc_ty/ty.rs +++ b/src/librustc_ty/ty.rs @@ -1,6 +1,6 @@ use rustc_data_structures::svh::Svh; use rustc_hir as hir; -use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; +use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE}; use rustc_middle::hir::map as hir_map; use rustc_middle::ty::subst::Subst; use rustc_middle::ty::{self, ToPredicate, Ty, TyCtxt, WithConstness}; @@ -78,7 +78,7 @@ fn sized_constraint_for_ty<'tcx>( fn associated_item_from_trait_item_ref( tcx: TyCtxt<'_>, - parent_def_id: DefId, + parent_def_id: LocalDefId, parent_vis: &hir::Visibility<'_>, trait_item_ref: &hir::TraitItemRef, ) -> ty::AssocItem { @@ -96,15 +96,15 @@ fn associated_item_from_trait_item_ref( // Visibility of trait items is inherited from their traits. vis: ty::Visibility::from_hir(parent_vis, trait_item_ref.id.hir_id, tcx), defaultness: trait_item_ref.defaultness, - def_id, - container: ty::TraitContainer(parent_def_id), + def_id: def_id.to_def_id(), + container: ty::TraitContainer(parent_def_id.to_def_id()), fn_has_self_parameter: has_self, } } fn associated_item_from_impl_item_ref( tcx: TyCtxt<'_>, - parent_def_id: DefId, + parent_def_id: LocalDefId, impl_item_ref: &hir::ImplItemRef<'_>, ) -> ty::AssocItem { let def_id = tcx.hir().local_def_id(impl_item_ref.id.hir_id); @@ -121,8 +121,8 @@ fn associated_item_from_impl_item_ref( // Visibility of trait impl items doesn't matter. vis: ty::Visibility::from_hir(&impl_item_ref.vis, impl_item_ref.id.hir_id, tcx), defaultness: impl_item_ref.defaultness, - def_id, - container: ty::ImplContainer(parent_def_id), + def_id: def_id.to_def_id(), + container: ty::ImplContainer(parent_def_id.to_def_id()), fn_has_self_parameter: has_self, } } @@ -207,13 +207,13 @@ fn associated_item_def_ids(tcx: TyCtxt<'_>, def_id: DefId) -> &[DefId] { trait_item_refs .iter() .map(|trait_item_ref| trait_item_ref.id) - .map(|id| tcx.hir().local_def_id(id.hir_id)), + .map(|id| tcx.hir().local_def_id(id.hir_id).to_def_id()), ), hir::ItemKind::Impl { ref items, .. } => tcx.arena.alloc_from_iter( items .iter() .map(|impl_item_ref| impl_item_ref.id) - .map(|id| tcx.hir().local_def_id(id.hir_id)), + .map(|id| tcx.hir().local_def_id(id.hir_id).to_def_id()), ), hir::ItemKind::TraitAlias(..) => &[], _ => span_bug!(item.span, "associated_item_def_ids: not impl or trait"), diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 19c8f540c57..cd2f3af200e 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -784,7 +784,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { } } (GenericParamDefKind::Const, GenericArg::Const(ct)) => { - let ct_def_id = tcx.hir().local_def_id(ct.value.hir_id).expect_local(); + let ct_def_id = tcx.hir().local_def_id(ct.value.hir_id); ty::Const::from_anon_const(tcx, ct_def_id).into() } _ => unreachable!(), @@ -2759,7 +2759,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { } hir::TyKind::Def(item_id, ref lifetimes) => { let did = tcx.hir().local_def_id(item_id.id); - self.impl_trait_ty_to_ty(did, lifetimes) + self.impl_trait_ty_to_ty(did.to_def_id(), lifetimes) } hir::TyKind::Path(hir::QPath::TypeRelative(ref qself, ref segment)) => { debug!("ast_ty_to_ty: qself={:?} segment={:?}", qself, segment); @@ -2775,7 +2775,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { .unwrap_or(tcx.types.err) } hir::TyKind::Array(ref ty, ref length) => { - let length_def_id = tcx.hir().local_def_id(length.hir_id).expect_local(); + let length_def_id = tcx.hir().local_def_id(length.hir_id); let length = ty::Const::from_anon_const(tcx, length_def_id); let array_ty = tcx.mk_ty(ty::Array(self.ast_ty_to_ty(&ty), length)); self.normalize_ty(ast_ty.span, array_ty) diff --git a/src/librustc_typeck/check/closure.rs b/src/librustc_typeck/check/closure.rs index 2ccf7890c30..fc4ca1e04b9 100644 --- a/src/librustc_typeck/check/closure.rs +++ b/src/librustc_typeck/check/closure.rs @@ -71,49 +71,52 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let expr_def_id = self.tcx.hir().local_def_id(expr.hir_id); let ClosureSignatures { bound_sig, liberated_sig } = - self.sig_of_closure(expr_def_id, decl, body, expected_sig); + self.sig_of_closure(expr_def_id.to_def_id(), decl, body, expected_sig); debug!("check_closure: ty_of_closure returns {:?}", liberated_sig); let generator_types = check_fn(self, self.param_env, liberated_sig, decl, expr.hir_id, body, gen).1; - let base_substs = - InternalSubsts::identity_for_item(self.tcx, self.tcx.closure_base_def_id(expr_def_id)); + let base_substs = InternalSubsts::identity_for_item( + self.tcx, + self.tcx.closure_base_def_id(expr_def_id.to_def_id()), + ); // HACK(eddyb) this hardcodes indices into substs but it should rely on // `ClosureSubsts` and `GeneratorSubsts` providing constructors, instead. // That would also remove the need for most of the inference variables, // as they immediately unified with the actual type below, including // the `InferCtxt::closure_sig` and `ClosureSubsts::sig_ty` methods. let tupled_upvars_idx = base_substs.len() + if generator_types.is_some() { 4 } else { 2 }; - let substs = base_substs.extend_to(self.tcx, expr_def_id, |param, _| match param.kind { - GenericParamDefKind::Lifetime => span_bug!(expr.span, "closure has lifetime param"), - GenericParamDefKind::Type { .. } => if param.index as usize == tupled_upvars_idx { - self.tcx.mk_tup(self.tcx.upvars(expr_def_id).iter().flat_map(|upvars| { - upvars.iter().map(|(&var_hir_id, _)| { - // Create type variables (for now) to represent the transformed - // types of upvars. These will be unified during the upvar - // inference phase (`upvar.rs`). - self.infcx.next_ty_var(TypeVariableOrigin { - // FIXME(eddyb) distinguish upvar inference variables from the rest. - kind: TypeVariableOriginKind::ClosureSynthetic, - span: self.tcx.hir().span(var_hir_id), + let substs = + base_substs.extend_to(self.tcx, expr_def_id.to_def_id(), |param, _| match param.kind { + GenericParamDefKind::Lifetime => span_bug!(expr.span, "closure has lifetime param"), + GenericParamDefKind::Type { .. } => if param.index as usize == tupled_upvars_idx { + self.tcx.mk_tup(self.tcx.upvars(expr_def_id).iter().flat_map(|upvars| { + upvars.iter().map(|(&var_hir_id, _)| { + // Create type variables (for now) to represent the transformed + // types of upvars. These will be unified during the upvar + // inference phase (`upvar.rs`). + self.infcx.next_ty_var(TypeVariableOrigin { + // FIXME(eddyb) distinguish upvar inference variables from the rest. + kind: TypeVariableOriginKind::ClosureSynthetic, + span: self.tcx.hir().span(var_hir_id), + }) }) + })) + } else { + // Create type variables (for now) to represent the various + // pieces of information kept in `{Closure,Generic}Substs`. + // They will either be unified below, or later during the upvar + // inference phase (`upvar.rs`) + self.infcx.next_ty_var(TypeVariableOrigin { + kind: TypeVariableOriginKind::ClosureSynthetic, + span: expr.span, }) - })) - } else { - // Create type variables (for now) to represent the various - // pieces of information kept in `{Closure,Generic}Substs`. - // They will either be unified below, or later during the upvar - // inference phase (`upvar.rs`) - self.infcx.next_ty_var(TypeVariableOrigin { - kind: TypeVariableOriginKind::ClosureSynthetic, - span: expr.span, - }) - } - .into(), - GenericParamDefKind::Const => span_bug!(expr.span, "closure has const param"), - }); + } + .into(), + GenericParamDefKind::Const => span_bug!(expr.span, "closure has const param"), + }); if let Some(GeneratorTypes { resume_ty, yield_ty, interior, movability }) = generator_types { let generator_substs = substs.as_generator(); @@ -126,7 +129,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // it should rely on `GeneratorSubsts` providing a constructor, instead. let substs = self.resolve_vars_if_possible(&substs); - return self.tcx.mk_generator(expr_def_id, substs, movability); + return self.tcx.mk_generator(expr_def_id.to_def_id(), substs, movability); } // Tuple up the arguments and insert the resulting function type into @@ -157,7 +160,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // it should rely on `ClosureSubsts` providing a constructor, instead. let substs = self.resolve_vars_if_possible(&substs); - let closure_type = self.tcx.mk_closure(expr_def_id, substs); + let closure_type = self.tcx.mk_closure(expr_def_id.to_def_id(), substs); debug!("check_closure: expr.hir_id={:?} closure_type={:?}", expr.hir_id, closure_type); diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index c4f53332cb6..90a9f8a4d6f 100644 --- a/src/librustc_typeck/check/method/mod.rs +++ b/src/librustc_typeck/check/method/mod.rs @@ -198,7 +198,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { debug!("used_trait_import: {:?}", import_def_id); Lrc::get_mut(&mut self.tables.borrow_mut().used_trait_imports) .unwrap() - .insert(import_def_id); + .insert(import_def_id.to_def_id()); } self.tcx.check_stability(pick.item.def_id, Some(call_expr.hir_id), span); @@ -463,7 +463,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { for import_id in pick.import_ids { let import_def_id = tcx.hir().local_def_id(import_id); debug!("resolve_ufcs: used_trait_import: {:?}", import_def_id); - used_trait_imports.insert(import_def_id); + used_trait_imports.insert(import_def_id.to_def_id()); } } diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index 362910f54cd..45b384e2656 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -1258,7 +1258,7 @@ fn compute_all_traits(tcx: TyCtxt<'_>) -> Vec<DefId> { match i.kind { hir::ItemKind::Trait(..) | hir::ItemKind::TraitAlias(..) => { let def_id = self.map.local_def_id(i.hir_id); - self.traits.push(def_id); + self.traits.push(def_id.to_def_id()); } _ => (), } diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 65bcb19b20a..1a5862cd5c8 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1332,7 +1332,7 @@ fn check_fn<'a, 'tcx>( fcx.resume_yield_tys = Some((resume_ty, yield_ty)); } - let outer_def_id = tcx.closure_base_def_id(hir.local_def_id(fn_id)); + let outer_def_id = tcx.closure_base_def_id(hir.local_def_id(fn_id).to_def_id()); let outer_hir_id = hir.as_local_hir_id(outer_def_id).unwrap(); GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id }.visit_body(body); @@ -1470,7 +1470,7 @@ fn check_fn<'a, 'tcx>( // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !` if let Some(panic_impl_did) = tcx.lang_items().panic_impl() { - if panic_impl_did == hir.local_def_id(fn_id) { + if panic_impl_did == hir.local_def_id(fn_id).to_def_id() { if let Some(panic_info_did) = tcx.lang_items().panic_info() { if declared_ret_ty.kind != ty::Never { sess.span_err(decl.output.span(), "return type should be `!`"); @@ -1514,7 +1514,7 @@ fn check_fn<'a, 'tcx>( // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !` if let Some(alloc_error_handler_did) = tcx.lang_items().oom() { - if alloc_error_handler_did == hir.local_def_id(fn_id) { + if alloc_error_handler_did == hir.local_def_id(fn_id).to_def_id() { if let Some(alloc_layout_did) = tcx.lang_items().alloc_layout() { if declared_ret_ty.kind != ty::Never { sess.span_err(decl.output.span(), "return type should be `!`"); @@ -1566,8 +1566,8 @@ fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) { check_simd(tcx, span, def_id); } - check_transparent(tcx, span, def_id); - check_packed(tcx, span, def_id); + check_transparent(tcx, span, def); + check_packed(tcx, span, def); } fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) { @@ -1575,14 +1575,14 @@ fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) { let def = tcx.adt_def(def_id); def.destructor(tcx); // force the destructor to be evaluated check_representable(tcx, span, def_id); - check_transparent(tcx, span, def_id); + check_transparent(tcx, span, def); check_union_fields(tcx, span, def_id); - check_packed(tcx, span, def_id); + check_packed(tcx, span, def); } /// When the `#![feature(untagged_unions)]` gate is active, /// check that the fields of the `union` does not contain fields that need dropping. -fn check_union_fields(tcx: TyCtxt<'_>, span: Span, item_def_id: DefId) -> bool { +fn check_union_fields(tcx: TyCtxt<'_>, span: Span, item_def_id: LocalDefId) -> bool { let item_type = tcx.type_of(item_def_id); if let ty::Adt(def, substs) = item_type.kind { assert!(def.is_union()); @@ -1614,7 +1614,7 @@ fn check_union_fields(tcx: TyCtxt<'_>, span: Span, item_def_id: DefId) -> bool { /// projections that would result in "inheriting lifetimes". fn check_opaque<'tcx>( tcx: TyCtxt<'tcx>, - def_id: DefId, + def_id: LocalDefId, substs: SubstsRef<'tcx>, span: Span, origin: &hir::OpaqueTyOrigin, @@ -1625,9 +1625,10 @@ fn check_opaque<'tcx>( /// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result /// in "inheriting lifetimes". -fn check_opaque_for_inheriting_lifetimes(tcx: TyCtxt<'tcx>, def_id: DefId, span: Span) { - let item = - tcx.hir().expect_item(tcx.hir().as_local_hir_id(def_id).expect("opaque type is not local")); +fn check_opaque_for_inheriting_lifetimes(tcx: TyCtxt<'tcx>, def_id: LocalDefId, span: Span) { + let item = tcx.hir().expect_item( + tcx.hir().as_local_hir_id(def_id.to_def_id()).expect("opaque type is not local"), + ); debug!( "check_opaque_for_inheriting_lifetimes: def_id={:?} span={:?} item={:?}", def_id, span, item @@ -1661,8 +1662,10 @@ fn check_opaque_for_inheriting_lifetimes(tcx: TyCtxt<'tcx>, def_id: DefId, span: .. }) => { let mut visitor = ProhibitOpaqueVisitor { - opaque_identity_ty: tcx - .mk_opaque(def_id, InternalSubsts::identity_for_item(tcx, def_id)), + opaque_identity_ty: tcx.mk_opaque( + def_id.to_def_id(), + InternalSubsts::identity_for_item(tcx, def_id.to_def_id()), + ), generics: tcx.generics_of(def_id), }; debug!("check_opaque_for_inheriting_lifetimes: visitor={:?}", visitor); @@ -1699,12 +1702,13 @@ fn check_opaque_for_inheriting_lifetimes(tcx: TyCtxt<'tcx>, def_id: DefId, span: /// Checks that an opaque type does not contain cycles. fn check_opaque_for_cycles<'tcx>( tcx: TyCtxt<'tcx>, - def_id: DefId, + def_id: LocalDefId, substs: SubstsRef<'tcx>, span: Span, origin: &hir::OpaqueTyOrigin, ) { - if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) { + if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id.to_def_id(), substs) + { if let hir::OpaqueTyOrigin::AsyncFn = origin { struct_span_err!(tcx.sess, span, E0733, "recursion in an `async fn` requires boxing",) .span_label(span, "recursive `async fn`") @@ -1736,7 +1740,7 @@ pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) { debug!( "check_item_type(it.hir_id={}, it.name={})", it.hir_id, - tcx.def_path_str(tcx.hir().local_def_id(it.hir_id)) + tcx.def_path_str(tcx.hir().local_def_id(it.hir_id).to_def_id()) ); let _indenter = indenter(); match it.kind { @@ -1764,7 +1768,7 @@ pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) { } hir::ItemKind::Trait(_, _, _, _, ref items) => { let def_id = tcx.hir().local_def_id(it.hir_id); - check_on_unimplemented(tcx, def_id, it); + check_on_unimplemented(tcx, def_id.to_def_id(), it); for item in items.iter() { let item = tcx.hir().trait_item(item.id); @@ -1783,7 +1787,7 @@ pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) { hir::ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => { let def_id = tcx.hir().local_def_id(it.hir_id); - let substs = InternalSubsts::identity_for_item(tcx, def_id); + let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id()); check_opaque(tcx, def_id, substs, it.span, &origin); } hir::ItemKind::TyAlias(..) => { @@ -1846,7 +1850,7 @@ pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) { } } -fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) { +fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: LocalDefId, span: Span) { // Only restricted on wasm32 target for now if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") { return; @@ -1866,7 +1870,7 @@ fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is // the consumer's responsibility to ensure all bytes that have been read // have defined values. - match tcx.const_eval_poly(id) { + match tcx.const_eval_poly(id.to_def_id()) { Ok(ConstValue::ByRef { alloc, .. }) => { if alloc.relocations().len() != 0 { let msg = "statics with a custom `#[link_section]` must be a \ @@ -1883,7 +1887,7 @@ fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item<'_>) { let item_def_id = tcx.hir().local_def_id(item.hir_id); // an error would be reported if this fails. - let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id); + let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id.to_def_id()); } fn report_forbidden_specialization( @@ -1987,7 +1991,7 @@ fn check_specialization_validity<'tcx>( fn check_impl_items_against_trait<'tcx>( tcx: TyCtxt<'tcx>, full_impl_span: Span, - impl_id: DefId, + impl_id: LocalDefId, impl_trait_ref: ty::TraitRef<'tcx>, impl_item_refs: &[hir::ImplItemRef<'_>], ) { @@ -2128,13 +2132,19 @@ fn check_impl_items_against_trait<'tcx>( } } - check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item); + check_specialization_validity( + tcx, + trait_def, + &ty_trait_item, + impl_id.to_def_id(), + impl_item, + ); } } // Check for missing items from trait let mut missing_items = Vec::new(); - if let Ok(ancestors) = trait_def.ancestors(tcx, impl_id) { + if let Ok(ancestors) = trait_def.ancestors(tcx, impl_id.to_def_id()) { for trait_item in tcx.associated_items(impl_trait_ref.def_id).in_definition_order() { let is_implemented = ancestors .leaf_def(tcx, trait_item.ident, trait_item.kind) @@ -2358,7 +2368,7 @@ fn suggestion_signature(assoc: &ty::AssocItem, tcx: TyCtxt<'_>) -> String { /// Checks whether a type can be represented in memory. In particular, it /// identifies types that contain themselves without indirection through a /// pointer, which would mean their size is unbounded. -fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool { +fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: LocalDefId) -> bool { let rty = tcx.type_of(item_def_id); // Check that it is possible to represent this type. This call identifies @@ -2368,7 +2378,7 @@ fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool { // caught by case 1. match rty.is_representable(tcx, sp) { Representability::SelfRecursive(spans) => { - let mut err = recursive_type_with_infinite_size_error(tcx, item_def_id); + let mut err = recursive_type_with_infinite_size_error(tcx, item_def_id.to_def_id()); for span in spans { err.span_label(span, "recursive without indirection"); } @@ -2380,7 +2390,7 @@ fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool { true } -pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) { +pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) { let t = tcx.type_of(def_id); if let ty::Adt(def, substs) = t.kind { if def.is_struct() { @@ -2414,10 +2424,10 @@ pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) { } } -fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) { - let repr = tcx.adt_def(def_id).repr; +fn check_packed(tcx: TyCtxt<'_>, sp: Span, def: &ty::AdtDef) { + let repr = def.repr; if repr.packed() { - for attr in tcx.get_attrs(def_id).iter() { + for attr in tcx.get_attrs(def.did).iter() { for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) { if let attr::ReprPacked(pack) = r { if let Some(repr_pack) = repr.pack { @@ -2443,7 +2453,7 @@ fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) { ) .emit(); } else { - if let Some(def_spans) = check_packed_inner(tcx, def_id, &mut vec![]) { + if let Some(def_spans) = check_packed_inner(tcx, def.did, &mut vec![]) { let mut err = struct_span_err!( tcx.sess, sp, @@ -2471,7 +2481,7 @@ fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) { &if first { format!( "`{}` contains a field of type `{}`", - tcx.type_of(def_id), + tcx.type_of(def.did), ident ) } else { @@ -2564,8 +2574,7 @@ fn bad_non_zero_sized_fields<'tcx>( err.emit(); } -fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) { - let adt = tcx.adt_def(def_id); +fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, adt: &'tcx ty::AdtDef) { if !adt.repr.transparent() { return; } @@ -2582,7 +2591,7 @@ fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) { } if adt.variants.len() != 1 { - bad_variant_count(tcx, adt, sp, def_id); + bad_variant_count(tcx, adt, sp, adt.did); if adt.variants.is_empty() { // Don't bother checking the fields. No variants (and thus no fields) exist. return; @@ -2634,7 +2643,7 @@ pub fn check_enum<'tcx>( def.destructor(tcx); // force the destructor to be evaluated if vs.is_empty() { - let attributes = tcx.get_attrs(def_id); + let attributes = tcx.get_attrs(def_id.to_def_id()); if let Some(attr) = attr::find_by_name(&attributes, sym::repr) { struct_span_err!( tcx.sess, @@ -2714,7 +2723,7 @@ pub fn check_enum<'tcx>( } check_representable(tcx, sp, def_id); - check_transparent(tcx, sp, def_id); + check_transparent(tcx, sp, def); } fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span) { @@ -3243,7 +3252,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let (value, opaque_type_map) = self.register_infer_ok_obligations(self.instantiate_opaque_types( - parent_def_id, + parent_def_id.to_def_id(), self.body_id, self.param_env, value, @@ -3348,7 +3357,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } pub fn to_const(&self, ast_c: &hir::AnonConst) -> &'tcx ty::Const<'tcx> { - let const_def_id = self.tcx.hir().local_def_id(ast_c.hir_id).expect_local(); + let const_def_id = self.tcx.hir().local_def_id(ast_c.hir_id); let c = ty::Const::from_anon_const(self.tcx, const_def_id); // HACK(eddyb) emulate what a `WellFormedConst` obligation would do. diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index afbda967c32..58c8d56b558 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -135,7 +135,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { self, RepeatingScope(item_id), item_id, - Subject(subject), + Subject(subject.to_def_id()), self.param_env, ); rcx.outlives_environment.add_implied_bounds(self, wf_tys, item_id, span); diff --git a/src/librustc_typeck/check/upvar.rs b/src/librustc_typeck/check/upvar.rs index c8f2a5798cd..3ff79a6b5de 100644 --- a/src/librustc_typeck/check/upvar.rs +++ b/src/librustc_typeck/check/upvar.rs @@ -226,7 +226,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let upvar_ty = self.node_ty(var_hir_id); let upvar_id = ty::UpvarId { var_path: ty::UpvarPath { hir_id: var_hir_id }, - closure_expr_id: closure_def_id.expect_local(), + closure_expr_id: closure_def_id, }; let capture = self.tables.borrow().upvar_capture(upvar_id); diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index 32004744ff9..574e5a4f8f1 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -5,7 +5,7 @@ use rustc_ast::ast; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder}; use rustc_hir as hir; -use rustc_hir::def_id::DefId; +use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::itemlikevisit::ParItemLikeVisitor; use rustc_hir::lang_items; use rustc_hir::ItemKind; @@ -195,10 +195,10 @@ pub fn check_trait_item(tcx: TyCtxt<'_>, def_id: DefId) { check_associated_item(tcx, trait_item.hir_id, trait_item.span, method_sig); } -fn could_be_self(trait_def_id: DefId, ty: &hir::Ty<'_>) -> bool { +fn could_be_self(trait_def_id: LocalDefId, ty: &hir::Ty<'_>) -> bool { match ty.kind { hir::TyKind::TraitObject([trait_ref], ..) => match trait_ref.trait_ref.path.segments { - [s] => s.res.and_then(|r| r.opt_def_id()) == Some(trait_def_id), + [s] => s.res.and_then(|r| r.opt_def_id()) == Some(trait_def_id.to_def_id()), _ => false, }, _ => false, @@ -330,7 +330,7 @@ fn for_item<'tcx>(tcx: TyCtxt<'tcx>, item: &hir::Item<'_>) -> CheckWfFcxBuilder< } fn for_id(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) -> CheckWfFcxBuilder<'_> { - let def_id = tcx.hir().local_def_id(id).expect_local(); + let def_id = tcx.hir().local_def_id(id); CheckWfFcxBuilder { inherited: Inherited::build(tcx, def_id), id, @@ -413,7 +413,7 @@ fn check_type_defn<'tcx, F>( } } - check_where_clauses(tcx, fcx, item.span, def_id, None); + check_where_clauses(tcx, fcx, item.span, def_id.to_def_id(), None); // No implied bounds in a struct definition. vec![] @@ -441,8 +441,8 @@ fn check_trait(tcx: TyCtxt<'_>, item: &hir::Item<'_>) { } for_item(tcx, item).with_fcx(|fcx, _| { - check_where_clauses(tcx, fcx, item.span, trait_def_id, None); - check_associated_type_defaults(fcx, trait_def_id); + check_where_clauses(tcx, fcx, item.span, trait_def_id.to_def_id(), None); + check_associated_type_defaults(fcx, trait_def_id.to_def_id()); vec![] }); @@ -555,7 +555,15 @@ fn check_item_fn(tcx: TyCtxt<'_>, item: &hir::Item<'_>) { ItemKind::Fn(sig, ..) => sig, _ => bug!("expected `ItemKind::Fn`, found `{:?}`", item.kind), }; - check_fn_or_method(tcx, fcx, item.ident.span, sig, hir_sig, def_id, &mut implied_bounds); + check_fn_or_method( + tcx, + fcx, + item.ident.span, + sig, + hir_sig, + def_id.to_def_id(), + &mut implied_bounds, + ); implied_bounds }) } @@ -631,9 +639,9 @@ fn check_impl<'tcx>( } } - check_where_clauses(tcx, fcx, item.span, item_def_id, None); + check_where_clauses(tcx, fcx, item.span, item_def_id.to_def_id(), None); - fcx.impl_implied_bounds(item_def_id, item.span) + fcx.impl_implied_bounds(item_def_id.to_def_id(), item.span) }); } diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs index ce5967e7a9a..83f5ba18ad7 100644 --- a/src/librustc_typeck/check/writeback.rs +++ b/src/librustc_typeck/check/writeback.rs @@ -42,7 +42,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // This attribute causes us to dump some writeback information // in the form of errors, which is uSymbol for unit tests. - let rustc_dump_user_substs = self.tcx.has_attr(item_def_id, sym::rustc_dump_user_substs); + let rustc_dump_user_substs = + self.tcx.has_attr(item_def_id.to_def_id(), sym::rustc_dump_user_substs); let mut wbcx = WritebackCx::new(self, body, rustc_dump_user_substs); for param in body.params { diff --git a/src/librustc_typeck/check_unused.rs b/src/librustc_typeck/check_unused.rs index cc99ae20199..bb2e077ceb0 100644 --- a/src/librustc_typeck/check_unused.rs +++ b/src/librustc_typeck/check_unused.rs @@ -50,7 +50,7 @@ impl CheckVisitor<'tcx> { return; } - if self.used_trait_imports.contains(&def_id) { + if self.used_trait_imports.contains(&def_id.to_def_id()) { return; } @@ -216,7 +216,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for CollectExternCrateVisitor<'a, 'tcx> { if let hir::ItemKind::ExternCrate(orig_name) = item.kind { let extern_crate_def_id = self.tcx.hir().local_def_id(item.hir_id); self.crates_to_lint.push(ExternCrateToLint { - def_id: extern_crate_def_id, + def_id: extern_crate_def_id.to_def_id(), span: item.span, orig_name, warn_if_unused: !item.ident.as_str().starts_with('_'), diff --git a/src/librustc_typeck/coherence/builtin.rs b/src/librustc_typeck/coherence/builtin.rs index 384a22d010e..7cfb7fa712c 100644 --- a/src/librustc_typeck/coherence/builtin.rs +++ b/src/librustc_typeck/coherence/builtin.rs @@ -3,7 +3,7 @@ use rustc_errors::struct_span_err; use rustc_hir as hir; -use rustc_hir::def_id::DefId; +use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::lang_items::UnsizeTraitLangItem; use rustc_hir::ItemKind; use rustc_infer::infer; @@ -35,7 +35,7 @@ struct Checker<'tcx> { impl<'tcx> Checker<'tcx> { fn check<F>(&self, trait_def_id: Option<DefId>, mut f: F) -> &Self where - F: FnMut(TyCtxt<'tcx>, DefId), + F: FnMut(TyCtxt<'tcx>, LocalDefId), { if Some(self.trait_def_id) == trait_def_id { for &impl_id in self.tcx.hir().trait_impls(self.trait_def_id) { @@ -47,13 +47,14 @@ impl<'tcx> Checker<'tcx> { } } -fn visit_implementation_of_drop(tcx: TyCtxt<'_>, impl_did: DefId) { +fn visit_implementation_of_drop(tcx: TyCtxt<'_>, impl_did: LocalDefId) { // Destructors only work on nominal types. if let ty::Adt(..) | ty::Error = tcx.type_of(impl_did).kind { return; } - let impl_hir_id = tcx.hir().as_local_hir_id(impl_did).expect("foreign Drop impl on non-ADT"); + let impl_hir_id = + tcx.hir().as_local_hir_id(impl_did.to_def_id()).expect("foreign Drop impl on non-ADT"); let sp = match tcx.hir().expect_item(impl_hir_id).kind { ItemKind::Impl { self_ty, .. } => self_ty.span, _ => bug!("expected Drop impl item"), @@ -69,10 +70,10 @@ fn visit_implementation_of_drop(tcx: TyCtxt<'_>, impl_did: DefId) { .emit(); } -fn visit_implementation_of_copy(tcx: TyCtxt<'_>, impl_did: DefId) { +fn visit_implementation_of_copy(tcx: TyCtxt<'_>, impl_did: LocalDefId) { debug!("visit_implementation_of_copy: impl_did={:?}", impl_did); - let impl_hir_id = if let Some(n) = tcx.hir().as_local_hir_id(impl_did) { + let impl_hir_id = if let Some(n) = tcx.hir().as_local_hir_id(impl_did.to_def_id()) { n } else { debug!("visit_implementation_of_copy(): impl not in this crate"); @@ -137,187 +138,184 @@ fn visit_implementation_of_copy(tcx: TyCtxt<'_>, impl_did: DefId) { } } -fn visit_implementation_of_coerce_unsized(tcx: TyCtxt<'tcx>, impl_did: DefId) { +fn visit_implementation_of_coerce_unsized(tcx: TyCtxt<'tcx>, impl_did: LocalDefId) { debug!("visit_implementation_of_coerce_unsized: impl_did={:?}", impl_did); // Just compute this for the side-effects, in particular reporting // errors; other parts of the code may demand it for the info of // course. - if impl_did.is_local() { - let span = tcx.def_span(impl_did); - tcx.at(span).coerce_unsized_info(impl_did); - } + let span = tcx.def_span(impl_did); + tcx.at(span).coerce_unsized_info(impl_did); } -fn visit_implementation_of_dispatch_from_dyn(tcx: TyCtxt<'_>, impl_did: DefId) { +fn visit_implementation_of_dispatch_from_dyn(tcx: TyCtxt<'_>, impl_did: LocalDefId) { debug!("visit_implementation_of_dispatch_from_dyn: impl_did={:?}", impl_did); - if impl_did.is_local() { - let dispatch_from_dyn_trait = tcx.lang_items().dispatch_from_dyn_trait().unwrap(); - let impl_hir_id = tcx.hir().as_local_hir_id(impl_did).unwrap(); - let span = tcx.hir().span(impl_hir_id); + let dispatch_from_dyn_trait = tcx.lang_items().dispatch_from_dyn_trait().unwrap(); - let source = tcx.type_of(impl_did); - assert!(!source.has_escaping_bound_vars()); - let target = { - let trait_ref = tcx.impl_trait_ref(impl_did).unwrap(); - assert_eq!(trait_ref.def_id, dispatch_from_dyn_trait); + let impl_hir_id = tcx.hir().as_local_hir_id(impl_did.to_def_id()).unwrap(); + let span = tcx.hir().span(impl_hir_id); - trait_ref.substs.type_at(1) - }; + let source = tcx.type_of(impl_did); + assert!(!source.has_escaping_bound_vars()); + let target = { + let trait_ref = tcx.impl_trait_ref(impl_did).unwrap(); + assert_eq!(trait_ref.def_id, dispatch_from_dyn_trait); - debug!("visit_implementation_of_dispatch_from_dyn: {:?} -> {:?}", source, target); + trait_ref.substs.type_at(1) + }; + + debug!("visit_implementation_of_dispatch_from_dyn: {:?} -> {:?}", source, target); - let param_env = tcx.param_env(impl_did); + let param_env = tcx.param_env(impl_did); - let create_err = |msg: &str| struct_span_err!(tcx.sess, span, E0378, "{}", msg); + let create_err = |msg: &str| struct_span_err!(tcx.sess, span, E0378, "{}", msg); - tcx.infer_ctxt().enter(|infcx| { - let cause = ObligationCause::misc(span, impl_hir_id); + tcx.infer_ctxt().enter(|infcx| { + let cause = ObligationCause::misc(span, impl_hir_id); - use ty::TyKind::*; - match (&source.kind, &target.kind) { - (&Ref(r_a, _, mutbl_a), Ref(r_b, _, mutbl_b)) - if infcx.at(&cause, param_env).eq(r_a, r_b).is_ok() && mutbl_a == *mutbl_b => {} - (&RawPtr(tm_a), &RawPtr(tm_b)) if tm_a.mutbl == tm_b.mutbl => (), - (&Adt(def_a, substs_a), &Adt(def_b, substs_b)) - if def_a.is_struct() && def_b.is_struct() => - { - if def_a != def_b { - let source_path = tcx.def_path_str(def_a.did); - let target_path = tcx.def_path_str(def_b.did); + use ty::TyKind::*; + match (&source.kind, &target.kind) { + (&Ref(r_a, _, mutbl_a), Ref(r_b, _, mutbl_b)) + if infcx.at(&cause, param_env).eq(r_a, r_b).is_ok() && mutbl_a == *mutbl_b => {} + (&RawPtr(tm_a), &RawPtr(tm_b)) if tm_a.mutbl == tm_b.mutbl => (), + (&Adt(def_a, substs_a), &Adt(def_b, substs_b)) + if def_a.is_struct() && def_b.is_struct() => + { + if def_a != def_b { + let source_path = tcx.def_path_str(def_a.did); + let target_path = tcx.def_path_str(def_b.did); - create_err(&format!( - "the trait `DispatchFromDyn` may only be implemented \ + create_err(&format!( + "the trait `DispatchFromDyn` may only be implemented \ for a coercion between structures with the same \ definition; expected `{}`, found `{}`", - source_path, target_path, - )) - .emit(); + source_path, target_path, + )) + .emit(); - return; - } + return; + } - if def_a.repr.c() || def_a.repr.packed() { - create_err( - "structs implementing `DispatchFromDyn` may not have \ + if def_a.repr.c() || def_a.repr.packed() { + create_err( + "structs implementing `DispatchFromDyn` may not have \ `#[repr(packed)]` or `#[repr(C)]`", - ) - .emit(); - } + ) + .emit(); + } - let fields = &def_a.non_enum_variant().fields; + let fields = &def_a.non_enum_variant().fields; - let coerced_fields = fields - .iter() - .filter_map(|field| { - let ty_a = field.ty(tcx, substs_a); - let ty_b = field.ty(tcx, substs_b); + let coerced_fields = fields + .iter() + .filter_map(|field| { + let ty_a = field.ty(tcx, substs_a); + let ty_b = field.ty(tcx, substs_b); - if let Ok(layout) = tcx.layout_of(param_env.and(ty_a)) { - if layout.is_zst() && layout.align.abi.bytes() == 1 { - // ignore ZST fields with alignment of 1 byte - return None; - } + if let Ok(layout) = tcx.layout_of(param_env.and(ty_a)) { + if layout.is_zst() && layout.align.abi.bytes() == 1 { + // ignore ZST fields with alignment of 1 byte + return None; } + } - if let Ok(ok) = infcx.at(&cause, param_env).eq(ty_a, ty_b) { - if ok.obligations.is_empty() { - create_err( - "the trait `DispatchFromDyn` may only be implemented \ + if let Ok(ok) = infcx.at(&cause, param_env).eq(ty_a, ty_b) { + if ok.obligations.is_empty() { + create_err( + "the trait `DispatchFromDyn` may only be implemented \ for structs containing the field being coerced, \ ZST fields with 1 byte alignment, and nothing else", - ) - .note(&format!( - "extra field `{}` of type `{}` is not allowed", - field.ident, ty_a, - )) - .emit(); - - return None; - } + ) + .note(&format!( + "extra field `{}` of type `{}` is not allowed", + field.ident, ty_a, + )) + .emit(); + + return None; } + } - Some(field) - }) - .collect::<Vec<_>>(); + Some(field) + }) + .collect::<Vec<_>>(); - if coerced_fields.is_empty() { - create_err( - "the trait `DispatchFromDyn` may only be implemented \ + if coerced_fields.is_empty() { + create_err( + "the trait `DispatchFromDyn` may only be implemented \ for a coercion between structures with a single field \ being coerced, none found", - ) - .emit(); - } else if coerced_fields.len() > 1 { - create_err( - "implementing the `DispatchFromDyn` trait requires multiple coercions", - ) - .note( - "the trait `DispatchFromDyn` may only be implemented \ + ) + .emit(); + } else if coerced_fields.len() > 1 { + create_err( + "implementing the `DispatchFromDyn` trait requires multiple coercions", + ) + .note( + "the trait `DispatchFromDyn` may only be implemented \ for a coercion between structures with a single field \ being coerced", - ) - .note(&format!( - "currently, {} fields need coercions: {}", - coerced_fields.len(), - coerced_fields - .iter() - .map(|field| { - format!( - "`{}` (`{}` to `{}`)", - field.ident, - field.ty(tcx, substs_a), - field.ty(tcx, substs_b), - ) - }) - .collect::<Vec<_>>() - .join(", ") - )) - .emit(); - } else { - let mut fulfill_cx = TraitEngine::new(infcx.tcx); - - for field in coerced_fields { - let predicate = predicate_for_trait_def( - tcx, - param_env, - cause.clone(), - dispatch_from_dyn_trait, - 0, - field.ty(tcx, substs_a), - &[field.ty(tcx, substs_b).into()], - ); - - fulfill_cx.register_predicate_obligation(&infcx, predicate); - } + ) + .note(&format!( + "currently, {} fields need coercions: {}", + coerced_fields.len(), + coerced_fields + .iter() + .map(|field| { + format!( + "`{}` (`{}` to `{}`)", + field.ident, + field.ty(tcx, substs_a), + field.ty(tcx, substs_b), + ) + }) + .collect::<Vec<_>>() + .join(", ") + )) + .emit(); + } else { + let mut fulfill_cx = TraitEngine::new(infcx.tcx); + + for field in coerced_fields { + let predicate = predicate_for_trait_def( + tcx, + param_env, + cause.clone(), + dispatch_from_dyn_trait, + 0, + field.ty(tcx, substs_a), + &[field.ty(tcx, substs_b).into()], + ); - // Check that all transitive obligations are satisfied. - if let Err(errors) = fulfill_cx.select_all_or_error(&infcx) { - infcx.report_fulfillment_errors(&errors, None, false); - } + fulfill_cx.register_predicate_obligation(&infcx, predicate); + } - // Finally, resolve all regions. - let region_scope_tree = region::ScopeTree::default(); - let outlives_env = OutlivesEnvironment::new(param_env); - infcx.resolve_regions_and_report_errors( - impl_did, - ®ion_scope_tree, - &outlives_env, - RegionckMode::default(), - ); + // Check that all transitive obligations are satisfied. + if let Err(errors) = fulfill_cx.select_all_or_error(&infcx) { + infcx.report_fulfillment_errors(&errors, None, false); } + + // Finally, resolve all regions. + let region_scope_tree = region::ScopeTree::default(); + let outlives_env = OutlivesEnvironment::new(param_env); + infcx.resolve_regions_and_report_errors( + impl_did.to_def_id(), + ®ion_scope_tree, + &outlives_env, + RegionckMode::default(), + ); } - _ => { - create_err( - "the trait `DispatchFromDyn` may only be implemented \ + } + _ => { + create_err( + "the trait `DispatchFromDyn` may only be implemented \ for a coercion between structures", - ) - .emit(); - } + ) + .emit(); } - }) - } + } + }) } pub fn coerce_unsized_info(tcx: TyCtxt<'tcx>, impl_did: DefId) -> CoerceUnsizedInfo { diff --git a/src/librustc_typeck/coherence/inherent_impls.rs b/src/librustc_typeck/coherence/inherent_impls.rs index 2e841734770..6817312e303 100644 --- a/src/librustc_typeck/coherence/inherent_impls.rs +++ b/src/librustc_typeck/coherence/inherent_impls.rs @@ -9,7 +9,7 @@ use rustc_errors::struct_span_err; use rustc_hir as hir; -use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; +use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE}; use rustc_hir::itemlikevisit::ItemLikeVisitor; use rustc_middle::ty::{self, CrateInherentImpls, TyCtxt}; @@ -327,7 +327,7 @@ impl InherentCollect<'tcx> { // the implementation does not have any associated traits. let impl_def_id = self.tcx.hir().local_def_id(item.hir_id); let vec = self.impls_map.inherent_impls.entry(def_id).or_default(); - vec.push(impl_def_id); + vec.push(impl_def_id.to_def_id()); } else { struct_span_err!( self.tcx.sess, @@ -344,7 +344,7 @@ impl InherentCollect<'tcx> { fn check_primitive_impl( &self, - impl_def_id: DefId, + impl_def_id: LocalDefId, lang_def_id: Option<DefId>, lang_def_id2: Option<DefId>, lang: &str, @@ -352,10 +352,10 @@ impl InherentCollect<'tcx> { span: Span, ) { match (lang_def_id, lang_def_id2) { - (Some(lang_def_id), _) if lang_def_id == impl_def_id => { + (Some(lang_def_id), _) if lang_def_id == impl_def_id.to_def_id() => { // OK } - (_, Some(lang_def_id)) if lang_def_id == impl_def_id => { + (_, Some(lang_def_id)) if lang_def_id == impl_def_id.to_def_id() => { // OK } _ => { diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 0df08b7bc8b..d8ffb9f6b4c 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -6,7 +6,7 @@ // mappings. That mapping code resides here. use rustc_errors::struct_span_err; -use rustc_hir::def_id::{DefId, LOCAL_CRATE}; +use rustc_hir::def_id::{DefId, LocalDefId, LOCAL_CRATE}; use rustc_middle::ty::query::Providers; use rustc_middle::ty::{self, TyCtxt, TypeFoldable}; use rustc_span::Span; @@ -19,15 +19,15 @@ mod orphan; mod unsafety; /// Obtains the span of just the impl header of `impl_def_id`. -fn impl_header_span(tcx: TyCtxt<'_>, impl_def_id: DefId) -> Span { - tcx.sess.source_map().guess_head_span(tcx.span_of_impl(impl_def_id).unwrap()) +fn impl_header_span(tcx: TyCtxt<'_>, impl_def_id: LocalDefId) -> Span { + tcx.sess.source_map().guess_head_span(tcx.span_of_impl(impl_def_id.to_def_id()).unwrap()) } -fn check_impl(tcx: TyCtxt<'_>, impl_def_id: DefId, trait_ref: ty::TraitRef<'_>) { +fn check_impl(tcx: TyCtxt<'_>, impl_def_id: LocalDefId, trait_ref: ty::TraitRef<'_>) { debug!( "(checking implementation) adding impl for trait '{:?}', item '{}'", trait_ref, - tcx.def_path_str(impl_def_id) + tcx.def_path_str(impl_def_id.to_def_id()) ); // Skip impls where one of the self type is an error type. @@ -40,7 +40,11 @@ fn check_impl(tcx: TyCtxt<'_>, impl_def_id: DefId, trait_ref: ty::TraitRef<'_>) enforce_empty_impls_for_marker_traits(tcx, impl_def_id, trait_ref.def_id); } -fn enforce_trait_manually_implementable(tcx: TyCtxt<'_>, impl_def_id: DefId, trait_def_id: DefId) { +fn enforce_trait_manually_implementable( + tcx: TyCtxt<'_>, + impl_def_id: LocalDefId, + trait_def_id: DefId, +) { let did = Some(trait_def_id); let li = tcx.lang_items(); @@ -117,7 +121,11 @@ fn enforce_trait_manually_implementable(tcx: TyCtxt<'_>, impl_def_id: DefId, tra /// We allow impls of marker traits to overlap, so they can't override impls /// as that could make it ambiguous which associated item to use. -fn enforce_empty_impls_for_marker_traits(tcx: TyCtxt<'_>, impl_def_id: DefId, trait_def_id: DefId) { +fn enforce_empty_impls_for_marker_traits( + tcx: TyCtxt<'_>, + impl_def_id: LocalDefId, + trait_def_id: DefId, +) { if !tcx.trait_def(trait_def_id).is_marker { return; } @@ -177,7 +185,7 @@ pub fn check_coherence(tcx: TyCtxt<'_>) { /// Checks whether an impl overlaps with the automatic `impl Trait for dyn Trait`. fn check_object_overlap<'tcx>( tcx: TyCtxt<'tcx>, - impl_def_id: DefId, + impl_def_id: LocalDefId, trait_ref: ty::TraitRef<'tcx>, ) { let trait_def_id = trait_ref.def_id; diff --git a/src/librustc_typeck/coherence/orphan.rs b/src/librustc_typeck/coherence/orphan.rs index d77f2bd0d8b..71469770f2a 100644 --- a/src/librustc_typeck/coherence/orphan.rs +++ b/src/librustc_typeck/coherence/orphan.rs @@ -35,7 +35,7 @@ impl ItemLikeVisitor<'v> for OrphanChecker<'tcx> { let trait_def_id = trait_ref.def_id; let sm = self.tcx.sess.source_map(); let sp = sm.guess_head_span(item.span); - match traits::orphan_check(self.tcx, def_id) { + match traits::orphan_check(self.tcx, def_id.to_def_id()) { Ok(()) => {} Err(traits::OrphanCheckErr::NonLocalInputType(tys)) => { let mut err = struct_span_err!( diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index b06fe212c1a..936ef0299cc 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -26,7 +26,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_errors::{struct_span_err, Applicability}; use rustc_hir as hir; use rustc_hir::def::{CtorKind, DefKind, Res}; -use rustc_hir::def_id::{DefId, LOCAL_CRATE}; +use rustc_hir::def_id::{DefId, LocalDefId, LOCAL_CRATE}; use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor}; use rustc_hir::weak_lang_items; use rustc_hir::{GenericParamKind, Node, Unsafety}; @@ -497,8 +497,11 @@ fn type_param_predicates( let ty = tcx.mk_ty_param(index, tcx.hir().ty_param_name(param_id)); // Don't look for bounds where the type parameter isn't in scope. - let parent = - if item_def_id == param_owner_def_id { None } else { tcx.generics_of(item_def_id).parent }; + let parent = if item_def_id == param_owner_def_id.to_def_id() { + None + } else { + tcx.generics_of(item_def_id).parent + }; let mut result = parent .map(|parent| { @@ -613,7 +616,7 @@ fn is_param(tcx: TyCtxt<'_>, ast_ty: &hir::Ty<'_>, param_id: hir::HirId) -> bool if let hir::TyKind::Path(hir::QPath::Resolved(None, ref path)) = ast_ty.kind { match path.res { Res::SelfTy(Some(def_id), None) | Res::Def(DefKind::TyParam, def_id) => { - def_id == tcx.hir().local_def_id(param_id) + def_id == tcx.hir().local_def_id(param_id).to_def_id() } _ => false, } @@ -647,7 +650,7 @@ fn convert_item(tcx: TyCtxt<'_>, item_id: hir::HirId) { tcx.generics_of(def_id); tcx.type_of(def_id); tcx.predicates_of(def_id); - convert_enum_variant_types(tcx, def_id, &enum_definition.variants); + convert_enum_variant_types(tcx, def_id.to_def_id(), &enum_definition.variants); } hir::ItemKind::Impl { .. } => { tcx.generics_of(def_id); @@ -769,7 +772,7 @@ fn convert_enum_variant_types(tcx: TyCtxt<'_>, def_id: DefId, variants: &[hir::V prev_discr = Some( if let Some(ref e) = variant.disr_expr { let expr_did = tcx.hir().local_def_id(e.hir_id); - def.eval_explicit_discr(tcx, expr_did) + def.eval_explicit_discr(tcx, expr_did.to_def_id()) } else if let Some(discr) = repr_type.disr_incr(tcx, prev_discr) { Some(discr) } else { @@ -805,8 +808,8 @@ fn convert_enum_variant_types(tcx: TyCtxt<'_>, def_id: DefId, variants: &[hir::V fn convert_variant( tcx: TyCtxt<'_>, - variant_did: Option<DefId>, - ctor_did: Option<DefId>, + variant_did: Option<LocalDefId>, + ctor_did: Option<LocalDefId>, ident: Ident, discr: ty::VariantDiscr, def: &hir::VariantData<'_>, @@ -814,7 +817,10 @@ fn convert_variant( parent_did: DefId, ) -> ty::VariantDef { let mut seen_fields: FxHashMap<ast::Ident, Span> = Default::default(); - let hir_id = tcx.hir().as_local_hir_id(variant_did.unwrap_or(parent_did)).unwrap(); + let hir_id = tcx + .hir() + .as_local_hir_id(variant_did.map(LocalDefId::to_def_id).unwrap_or(parent_did)) + .unwrap(); let fields = def .fields() .iter() @@ -837,7 +843,7 @@ fn convert_variant( } ty::FieldDef { - did: fid, + did: fid.to_def_id(), ident: f.ident, vis: ty::Visibility::from_hir(&f.vis, hir_id, tcx), } @@ -850,8 +856,8 @@ fn convert_variant( ty::VariantDef::new( tcx, ident, - variant_did, - ctor_did, + variant_did.map(LocalDefId::to_def_id), + ctor_did.map(LocalDefId::to_def_id), discr, fields, CtorKind::from_hir(def), @@ -884,7 +890,7 @@ fn adt_def(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::AdtDef { let discr = if let Some(ref e) = v.disr_expr { distance_from_explicit = 0; - ty::VariantDiscr::Explicit(tcx.hir().local_def_id(e.hir_id)) + ty::VariantDiscr::Explicit(tcx.hir().local_def_id(e.hir_id).to_def_id()) } else { ty::VariantDiscr::Relative(distance_from_explicit) }; @@ -906,7 +912,7 @@ fn adt_def(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::AdtDef { (AdtKind::Enum, variants) } ItemKind::Struct(ref def, _) => { - let variant_did = None; + let variant_did = None::<LocalDefId>; let ctor_did = def.ctor_hir_id().map(|hir_id| tcx.hir().local_def_id(hir_id)); let variants = std::iter::once(convert_variant( @@ -1170,7 +1176,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::Generics { | Node::Ctor(..) | Node::Field(_) => { let parent_id = tcx.hir().get_parent_item(hir_id); - Some(tcx.hir().local_def_id(parent_id)) + Some(tcx.hir().local_def_id(parent_id).to_def_id()) } // FIXME(#43408) enable this always when we get lazy normalization. Node::AnonConst(_) => { @@ -1181,7 +1187,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::Generics { // `feature(const_generics)` is enabled, so that const expressions // used with const generics, e.g. `Foo<{N+1}>`, can work at all. if tcx.features().const_generics { - Some(parent_def_id) + Some(parent_def_id.to_def_id()) } else { let parent_node = tcx.hir().get(tcx.hir().get_parent_node(hir_id)); match parent_node { @@ -1191,7 +1197,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::Generics { Node::Expr(&Expr { kind: ExprKind::Repeat(_, ref constant), .. }) if constant.hir_id == hir_id => { - Some(parent_def_id) + Some(parent_def_id.to_def_id()) } _ => None, @@ -1214,7 +1220,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::Generics { if let Node::Item(hir::Item { kind: ItemKind::OpaqueTy(..), .. }) = tcx.hir().get(parent_id) { - Some(tcx.hir().local_def_id(parent_id)) + Some(tcx.hir().local_def_id(parent_id).to_def_id()) } else { None } @@ -1261,7 +1267,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::Generics { opt_self = Some(ty::GenericParamDef { index: 0, name: kw::SelfUpper, - def_id: tcx.hir().local_def_id(param_id), + def_id: tcx.hir().local_def_id(param_id).to_def_id(), pure_wrt_drop: false, kind: ty::GenericParamDefKind::Type { has_default: false, @@ -1304,7 +1310,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::Generics { params.extend(early_lifetimes.enumerate().map(|(i, param)| ty::GenericParamDef { name: param.name.ident().name, index: own_start + i as u32, - def_id: tcx.hir().local_def_id(param.hir_id), + def_id: tcx.hir().local_def_id(param.hir_id).to_def_id(), pure_wrt_drop: param.pure_wrt_drop, kind: ty::GenericParamDefKind::Lifetime, })); @@ -1350,7 +1356,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::Generics { let param_def = ty::GenericParamDef { index: type_start + i as u32, name: param.name.ident().name, - def_id: tcx.hir().local_def_id(param.hir_id), + def_id: tcx.hir().local_def_id(param.hir_id).to_def_id(), pure_wrt_drop: param.pure_wrt_drop, kind, }; @@ -1366,7 +1372,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::Generics { let param_def = ty::GenericParamDef { index: type_start + i as u32, name: param.name.ident().name, - def_id: tcx.hir().local_def_id(param.hir_id), + def_id: tcx.hir().local_def_id(param.hir_id).to_def_id(), pure_wrt_drop: param.pure_wrt_drop, kind: ty::GenericParamDefKind::Const, }; @@ -1845,7 +1851,7 @@ fn explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicat let mut index = parent_count + has_own_self as u32; for param in early_bound_lifetimes_from_generics(tcx, ast_generics) { let region = tcx.mk_region(ty::ReEarlyBound(ty::EarlyBoundRegion { - def_id: tcx.hir().local_def_id(param.hir_id), + def_id: tcx.hir().local_def_id(param.hir_id).to_def_id(), index, name: param.name.ident().name, })); @@ -2064,12 +2070,13 @@ fn associated_item_predicates( // the `Binder` around the the predicate. // // FIXME(generic_associated_types): Currently only lifetimes are handled. - self_trait_ref.substs.extend_to(tcx, item_def_id, mk_bound_param) + self_trait_ref.substs.extend_to(tcx, item_def_id.to_def_id(), mk_bound_param) } else { self_trait_ref.substs }; - let assoc_ty = tcx.mk_projection(tcx.hir().local_def_id(trait_item.hir_id), bound_substs); + let assoc_ty = + tcx.mk_projection(tcx.hir().local_def_id(trait_item.hir_id).to_def_id(), bound_substs); let bounds = AstConv::compute_bounds( &ItemCtxt::new(tcx, def_id), diff --git a/src/librustc_typeck/collect/type_of.rs b/src/librustc_typeck/collect/type_of.rs index 18987d6b5a4..5d05cfe74a1 100644 --- a/src/librustc_typeck/collect/type_of.rs +++ b/src/librustc_typeck/collect/type_of.rs @@ -484,13 +484,13 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) { if let hir::ExprKind::Closure(..) = ex.kind { let def_id = self.tcx.hir().local_def_id(ex.hir_id); - self.check(def_id); + self.check(def_id.to_def_id()); } intravisit::walk_expr(self, ex); } fn visit_item(&mut self, it: &'tcx Item<'tcx>) { debug!("find_existential_constraints: visiting {:?}", it); - let def_id = self.tcx.hir().local_def_id(it.hir_id); + let def_id = self.tcx.hir().local_def_id(it.hir_id).to_def_id(); // The opaque type itself or its children are not within its reveal scope. if def_id != self.def_id { self.check(def_id); @@ -499,7 +499,7 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { } fn visit_impl_item(&mut self, it: &'tcx ImplItem<'tcx>) { debug!("find_existential_constraints: visiting {:?}", it); - let def_id = self.tcx.hir().local_def_id(it.hir_id); + let def_id = self.tcx.hir().local_def_id(it.hir_id).to_def_id(); // The opaque type itself or its children are not within its reveal scope. if def_id != self.def_id { self.check(def_id); @@ -509,7 +509,7 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { fn visit_trait_item(&mut self, it: &'tcx TraitItem<'tcx>) { debug!("find_existential_constraints: visiting {:?}", it); let def_id = self.tcx.hir().local_def_id(it.hir_id); - self.check(def_id); + self.check(def_id.to_def_id()); intravisit::walk_trait_item(self, it); } } diff --git a/src/librustc_typeck/expr_use_visitor.rs b/src/librustc_typeck/expr_use_visitor.rs index b6d7309f86a..2244a89f129 100644 --- a/src/librustc_typeck/expr_use_visitor.rs +++ b/src/librustc_typeck/expr_use_visitor.rs @@ -519,7 +519,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> { for &var_id in upvars.keys() { let upvar_id = ty::UpvarId { var_path: ty::UpvarPath { hir_id: var_id }, - closure_expr_id: closure_def_id.expect_local(), + closure_expr_id: closure_def_id, }; let upvar_capture = self.mc.tables.upvar_capture(upvar_id); let captured_place = return_if_err!(self.cat_captured_var( diff --git a/src/librustc_typeck/impl_wf_check.rs b/src/librustc_typeck/impl_wf_check.rs index 319f3238513..e13d9ea2b26 100644 --- a/src/librustc_typeck/impl_wf_check.rs +++ b/src/librustc_typeck/impl_wf_check.rs @@ -14,7 +14,7 @@ use min_specialization::check_min_specialization; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_errors::struct_span_err; use rustc_hir as hir; -use rustc_hir::def_id::DefId; +use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::itemlikevisit::ItemLikeVisitor; use rustc_middle::ty::query::Providers; use rustc_middle::ty::{self, TyCtxt, TypeFoldable}; @@ -59,7 +59,7 @@ pub fn impl_wf_check(tcx: TyCtxt<'_>) { // but it's one that we must perform earlier than the rest of // WfCheck. for &module in tcx.hir().krate().modules.keys() { - tcx.ensure().check_mod_impl_wf(tcx.hir().local_def_id(module)); + tcx.ensure().check_mod_impl_wf(tcx.hir().local_def_id(module).to_def_id()); } } @@ -85,7 +85,7 @@ impl ItemLikeVisitor<'tcx> for ImplWfCheck<'tcx> { enforce_impl_params_are_constrained(self.tcx, impl_def_id, items); enforce_impl_items_are_distinct(self.tcx, items); if self.min_specialization { - check_min_specialization(self.tcx, impl_def_id, item.span); + check_min_specialization(self.tcx, impl_def_id.to_def_id(), item.span); } } } @@ -97,7 +97,7 @@ impl ItemLikeVisitor<'tcx> for ImplWfCheck<'tcx> { fn enforce_impl_params_are_constrained( tcx: TyCtxt<'_>, - impl_def_id: DefId, + impl_def_id: LocalDefId, impl_item_refs: &[hir::ImplItemRef<'_>], ) { // Every lifetime used in an associated type must be constrained. diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index cd76184c9bf..04e037c83ad 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -378,7 +378,7 @@ pub fn hir_ty_to_ty<'tcx>(tcx: TyCtxt<'tcx>, hir_ty: &hir::Ty<'_>) -> Ty<'tcx> { // scope. This is derived from the enclosing item-like thing. let env_node_id = tcx.hir().get_parent_item(hir_ty.hir_id); let env_def_id = tcx.hir().local_def_id(env_node_id); - let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id); + let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id.to_def_id()); astconv::AstConv::ast_ty_to_ty(&item_cx, hir_ty) } @@ -393,7 +393,7 @@ pub fn hir_trait_to_predicates<'tcx>( // scope. This is derived from the enclosing item-like thing. let env_hir_id = tcx.hir().get_parent_item(hir_trait.hir_ref_id); let env_def_id = tcx.hir().local_def_id(env_hir_id); - let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id); + let item_cx = self::collect::ItemCtxt::new(tcx, env_def_id.to_def_id()); let mut bounds = Bounds::default(); let _ = AstConv::instantiate_poly_trait_ref_inner( &item_cx, diff --git a/src/librustc_typeck/outlives/implicit_infer.rs b/src/librustc_typeck/outlives/implicit_infer.rs index 2abca302469..6a9cbc544f8 100644 --- a/src/librustc_typeck/outlives/implicit_infer.rs +++ b/src/librustc_typeck/outlives/implicit_infer.rs @@ -53,7 +53,7 @@ pub struct InferVisitor<'cx, 'tcx> { impl<'cx, 'tcx> ItemLikeVisitor<'tcx> for InferVisitor<'cx, 'tcx> { fn visit_item(&mut self, item: &hir::Item<'_>) { - let item_did = self.tcx.hir().local_def_id(item.hir_id); + let item_did = self.tcx.hir().local_def_id(item.hir_id).to_def_id(); debug!("InferVisitor::visit_item(item={:?})", item_did); diff --git a/src/librustc_typeck/outlives/test.rs b/src/librustc_typeck/outlives/test.rs index 655f938493a..abe9319d71c 100644 --- a/src/librustc_typeck/outlives/test.rs +++ b/src/librustc_typeck/outlives/test.rs @@ -18,7 +18,7 @@ impl ItemLikeVisitor<'tcx> for OutlivesTest<'tcx> { // For unit testing: check for a special "rustc_outlives" // attribute and report an error with various results if found. - if self.tcx.has_attr(item_def_id, sym::rustc_outlives) { + if self.tcx.has_attr(item_def_id.to_def_id(), sym::rustc_outlives) { let inferred_outlives_of = self.tcx.inferred_outlives_of(item_def_id); struct_span_err!(self.tcx.sess, item.span, E0640, "{:?}", inferred_outlives_of).emit(); } diff --git a/src/librustc_typeck/variance/constraints.rs b/src/librustc_typeck/variance/constraints.rs index afa6e49a05c..83be3e2c878 100644 --- a/src/librustc_typeck/variance/constraints.rs +++ b/src/librustc_typeck/variance/constraints.rs @@ -121,7 +121,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { fn visit_node_helper(&mut self, id: hir::HirId) { let tcx = self.terms_cx.tcx; let def_id = tcx.hir().local_def_id(id); - self.build_constraints_for_item(def_id); + self.build_constraints_for_item(def_id.to_def_id()); } fn tcx(&self) -> TyCtxt<'tcx> { diff --git a/src/librustc_typeck/variance/solve.rs b/src/librustc_typeck/variance/solve.rs index 4fc46ce93ee..7402117a7eb 100644 --- a/src/librustc_typeck/variance/solve.rs +++ b/src/librustc_typeck/variance/solve.rs @@ -115,7 +115,7 @@ impl<'a, 'tcx> SolveContext<'a, 'tcx> { } } - (def_id, &*variances) + (def_id.to_def_id(), &*variances) }) .collect() } diff --git a/src/librustc_typeck/variance/test.rs b/src/librustc_typeck/variance/test.rs index a25252ccd3d..1aab89310c6 100644 --- a/src/librustc_typeck/variance/test.rs +++ b/src/librustc_typeck/variance/test.rs @@ -18,7 +18,7 @@ impl ItemLikeVisitor<'tcx> for VarianceTest<'tcx> { // For unit testing: check for a special "rustc_variance" // attribute and report an error with various results if found. - if self.tcx.has_attr(item_def_id, sym::rustc_variance) { + if self.tcx.has_attr(item_def_id.to_def_id(), sym::rustc_variance) { let variances_of = self.tcx.variances_of(item_def_id); struct_span_err!(self.tcx.sess, item.span, E0208, "{:?}", variances_of).emit(); } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index ad9d54c345c..f7e61a723da 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -137,15 +137,16 @@ impl Clean<ExternalCrate> for CrateNum { .filter_map(|&id| { let item = cx.tcx.hir().expect_item(id.id); match item.kind { - hir::ItemKind::Mod(_) => { - as_primitive(Res::Def(DefKind::Mod, cx.tcx.hir().local_def_id(id.id))) - } + hir::ItemKind::Mod(_) => as_primitive(Res::Def( + DefKind::Mod, + cx.tcx.hir().local_def_id(id.id).to_def_id(), + )), hir::ItemKind::Use(ref path, hir::UseKind::Single) if item.vis.node.is_pub() => { as_primitive(path.res).map(|(_, prim, attrs)| { // Pretend the primitive is local. - (cx.tcx.hir().local_def_id(id.id), prim, attrs) + (cx.tcx.hir().local_def_id(id.id).to_def_id(), prim, attrs) }) } _ => None, @@ -191,14 +192,15 @@ impl Clean<ExternalCrate> for CrateNum { .filter_map(|&id| { let item = cx.tcx.hir().expect_item(id.id); match item.kind { - hir::ItemKind::Mod(_) => { - as_keyword(Res::Def(DefKind::Mod, cx.tcx.hir().local_def_id(id.id))) - } + hir::ItemKind::Mod(_) => as_keyword(Res::Def( + DefKind::Mod, + cx.tcx.hir().local_def_id(id.id).to_def_id(), + )), hir::ItemKind::Use(ref path, hir::UseKind::Single) if item.vis.node.is_pub() => { as_keyword(path.res).map(|(_, prim, attrs)| { - (cx.tcx.hir().local_def_id(id.id), prim, attrs) + (cx.tcx.hir().local_def_id(id.id).to_def_id(), prim, attrs) }) } _ => None, @@ -273,7 +275,7 @@ impl Clean<Item> for doctree::Module<'_> { visibility: self.vis.clean(cx), stability: cx.stability(self.id).clean(cx), deprecation: cx.deprecation(self.id).clean(cx), - def_id: cx.tcx.hir().local_def_id(self.id), + def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(), inner: ModuleItem(Module { is_crate: self.is_crate, items }), } } @@ -624,7 +626,7 @@ impl Clean<GenericParamDef> for hir::GenericParam<'_> { hir::GenericParamKind::Type { ref default, synthetic } => ( self.name.ident().name.clean(cx), GenericParamDefKind::Type { - did: cx.tcx.hir().local_def_id(self.hir_id), + did: cx.tcx.hir().local_def_id(self.hir_id).to_def_id(), bounds: self.bounds.clean(cx), default: default.clean(cx), synthetic, @@ -633,7 +635,7 @@ impl Clean<GenericParamDef> for hir::GenericParam<'_> { hir::GenericParamKind::Const { ref ty } => ( self.name.ident().name.clean(cx), GenericParamDefKind::Const { - did: cx.tcx.hir().local_def_id(self.hir_id), + did: cx.tcx.hir().local_def_id(self.hir_id).to_def_id(), ty: ty.clean(cx), }, ), @@ -894,7 +896,7 @@ impl Clean<Item> for doctree::Function<'_> { enter_impl_trait(cx, || (self.generics.clean(cx), (self.decl, self.body).clean(cx))); let did = cx.tcx.hir().local_def_id(self.id); - let constness = if is_min_const_fn(cx.tcx, did) { + let constness = if is_min_const_fn(cx.tcx, did.to_def_id()) { hir::Constness::Const } else { hir::Constness::NotConst @@ -907,7 +909,7 @@ impl Clean<Item> for doctree::Function<'_> { visibility: self.vis.clean(cx), stability: cx.stability(self.id).clean(cx), deprecation: cx.deprecation(self.id).clean(cx), - def_id: did, + def_id: did.to_def_id(), inner: FunctionItem(Function { decl, generics, @@ -1016,7 +1018,7 @@ impl Clean<Item> for doctree::Trait<'_> { name: Some(self.name.clean(cx)), attrs, source: self.whence.clean(cx), - def_id: cx.tcx.hir().local_def_id(self.id), + def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(), visibility: self.vis.clean(cx), stability: cx.stability(self.id).clean(cx), deprecation: cx.deprecation(self.id).clean(cx), @@ -1039,7 +1041,7 @@ impl Clean<Item> for doctree::TraitAlias<'_> { name: Some(self.name.clean(cx)), attrs, source: self.whence.clean(cx), - def_id: cx.tcx.hir().local_def_id(self.id), + def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(), visibility: self.vis.clean(cx), stability: cx.stability(self.id).clean(cx), deprecation: cx.deprecation(self.id).clean(cx), @@ -1120,10 +1122,10 @@ impl Clean<Item> for hir::TraitItem<'_> { name: Some(self.ident.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.span.clean(cx), - def_id: local_did, + def_id: local_did.to_def_id(), visibility: Visibility::Inherited, - stability: get_stability(cx, local_did), - deprecation: get_deprecation(cx, local_did), + stability: get_stability(cx, local_did.to_def_id()), + deprecation: get_deprecation(cx, local_did.to_def_id()), inner, } } @@ -1153,10 +1155,10 @@ impl Clean<Item> for hir::ImplItem<'_> { name: Some(self.ident.name.clean(cx)), source: self.span.clean(cx), attrs: self.attrs.clean(cx), - def_id: local_did, + def_id: local_did.to_def_id(), visibility: self.vis.clean(cx), - stability: get_stability(cx, local_did), - deprecation: get_deprecation(cx, local_did), + stability: get_stability(cx, local_did.to_def_id()), + deprecation: get_deprecation(cx, local_did.to_def_id()), inner, } } @@ -1348,7 +1350,7 @@ impl Clean<Type> for hir::Ty<'_> { TyKind::Slice(ref ty) => Slice(box ty.clean(cx)), TyKind::Array(ref ty, ref length) => { let def_id = cx.tcx.hir().local_def_id(length.hir_id); - let length = match cx.tcx.const_eval_poly(def_id) { + let length = match cx.tcx.const_eval_poly(def_id.to_def_id()) { Ok(length) => { print_const(cx, ty::Const::from_value(cx.tcx, length, cx.tcx.types.usize)) } @@ -1415,7 +1417,7 @@ impl Clean<Type> for hir::Ty<'_> { if let Some(lt) = lifetime.cloned() { if !lt.is_elided() { let lt_def_id = cx.tcx.hir().local_def_id(param.hir_id); - lt_substs.insert(lt_def_id, lt.clean(cx)); + lt_substs.insert(lt_def_id.to_def_id(), lt.clean(cx)); } } indices.lifetimes += 1; @@ -1435,9 +1437,10 @@ impl Clean<Type> for hir::Ty<'_> { _ => None, }); if let Some(ty) = type_ { - ty_substs.insert(ty_param_def_id, ty.clean(cx)); + ty_substs.insert(ty_param_def_id.to_def_id(), ty.clean(cx)); } else if let Some(default) = *default { - ty_substs.insert(ty_param_def_id, default.clean(cx)); + ty_substs + .insert(ty_param_def_id.to_def_id(), default.clean(cx)); } indices.types += 1; } @@ -1457,7 +1460,8 @@ impl Clean<Type> for hir::Ty<'_> { _ => None, }); if let Some(ct) = const_ { - ct_substs.insert(const_param_def_id, ct.clean(cx)); + ct_substs + .insert(const_param_def_id.to_def_id(), ct.clean(cx)); } // FIXME(const_generics:defaults) indices.consts += 1; @@ -1749,9 +1753,9 @@ impl Clean<Item> for hir::StructField<'_> { attrs: self.attrs.clean(cx), source: self.span.clean(cx), visibility: self.vis.clean(cx), - stability: get_stability(cx, local_did), - deprecation: get_deprecation(cx, local_did), - def_id: local_did, + stability: get_stability(cx, local_did.to_def_id()), + deprecation: get_deprecation(cx, local_did.to_def_id()), + def_id: local_did.to_def_id(), inner: StructFieldItem(self.ty.clean(cx)), } } @@ -1799,7 +1803,7 @@ impl Clean<Item> for doctree::Struct<'_> { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: cx.tcx.hir().local_def_id(self.id), + def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(), visibility: self.vis.clean(cx), stability: cx.stability(self.id).clean(cx), deprecation: cx.deprecation(self.id).clean(cx), @@ -1819,7 +1823,7 @@ impl Clean<Item> for doctree::Union<'_> { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: cx.tcx.hir().local_def_id(self.id), + def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(), visibility: self.vis.clean(cx), stability: cx.stability(self.id).clean(cx), deprecation: cx.deprecation(self.id).clean(cx), @@ -1849,7 +1853,7 @@ impl Clean<Item> for doctree::Enum<'_> { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: cx.tcx.hir().local_def_id(self.id), + def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(), visibility: self.vis.clean(cx), stability: cx.stability(self.id).clean(cx), deprecation: cx.deprecation(self.id).clean(cx), @@ -1871,7 +1875,7 @@ impl Clean<Item> for doctree::Variant<'_> { visibility: Inherited, stability: cx.stability(self.id).clean(cx), deprecation: cx.deprecation(self.id).clean(cx), - def_id: cx.tcx.hir().local_def_id(self.id), + def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(), inner: VariantItem(Variant { kind: self.def.clean(cx) }), } } @@ -2020,7 +2024,7 @@ impl Clean<Item> for doctree::Typedef<'_> { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: cx.tcx.hir().local_def_id(self.id), + def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(), visibility: self.vis.clean(cx), stability: cx.stability(self.id).clean(cx), deprecation: cx.deprecation(self.id).clean(cx), @@ -2035,7 +2039,7 @@ impl Clean<Item> for doctree::OpaqueTy<'_> { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: cx.tcx.hir().local_def_id(self.id), + def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(), visibility: self.vis.clean(cx), stability: cx.stability(self.id).clean(cx), deprecation: cx.deprecation(self.id).clean(cx), @@ -2066,7 +2070,7 @@ impl Clean<Item> for doctree::Static<'_> { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: cx.tcx.hir().local_def_id(self.id), + def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(), visibility: self.vis.clean(cx), stability: cx.stability(self.id).clean(cx), deprecation: cx.deprecation(self.id).clean(cx), @@ -2087,14 +2091,14 @@ impl Clean<Item> for doctree::Constant<'_> { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id, + def_id: def_id.to_def_id(), visibility: self.vis.clean(cx), stability: cx.stability(self.id).clean(cx), deprecation: cx.deprecation(self.id).clean(cx), inner: ConstantItem(Constant { type_: self.type_.clean(cx), expr: print_const_expr(cx, self.expr), - value: print_evaluated_const(cx, def_id), + value: print_evaluated_const(cx, def_id.to_def_id()), is_literal: is_literal_expr(cx, self.expr.hir_id), }), } @@ -2141,7 +2145,7 @@ impl Clean<Vec<Item>> for doctree::Impl<'_> { name: None, attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id, + def_id: def_id.to_def_id(), visibility: self.vis.clean(cx), stability: cx.stability(self.id).clean(cx), deprecation: cx.deprecation(self.id).clean(cx), @@ -2299,7 +2303,7 @@ impl Clean<Item> for doctree::ForeignItem<'_> { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: cx.tcx.hir().local_def_id(self.id), + def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(), visibility: self.vis.clean(cx), stability: cx.stability(self.id).clean(cx), deprecation: cx.deprecation(self.id).clean(cx), @@ -2343,7 +2347,7 @@ impl Clean<Item> for doctree::ProcMacro<'_> { visibility: Public, stability: cx.stability(self.id).clean(cx), deprecation: cx.deprecation(self.id).clean(cx), - def_id: cx.tcx.hir().local_def_id(self.id), + def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(), inner: ProcMacroItem(ProcMacro { kind: self.kind, helpers: self.helpers.clean(cx) }), } } diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index f83bb9b1162..f26f6d3eff9 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -389,7 +389,7 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt map: access_levels .map .iter() - .map(|(&k, &v)| (tcx.hir().local_def_id(k), v)) + .map(|(&k, &v)| (tcx.hir().local_def_id(k).to_def_id(), v)) .collect(), }; diff --git a/src/librustdoc/passes/collect_trait_impls.rs b/src/librustdoc/passes/collect_trait_impls.rs index c80967a4b33..6ef01c3dec7 100644 --- a/src/librustdoc/passes/collect_trait_impls.rs +++ b/src/librustdoc/passes/collect_trait_impls.rs @@ -120,7 +120,7 @@ pub fn collect_trait_impls(krate: Crate, cx: &DocContext<'_>) -> Crate { for &trait_did in cx.tcx.all_traits(LOCAL_CRATE).iter() { for &impl_node in cx.tcx.hir().trait_impls(trait_did) { let impl_did = cx.tcx.hir().local_def_id(impl_node); - inline::build_impl(cx, impl_did, None, &mut new_items); + inline::build_impl(cx, impl_did.to_def_id(), None, &mut new_items); } } diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index b7a3b13cf04..fa2a08479aa 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -391,7 +391,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { if item.vis.node.is_pub() { let def_id = self.cx.tcx.hir().local_def_id(item.hir_id); - self.store_path(def_id); + self.store_path(def_id.to_def_id()); } match item.kind { @@ -629,7 +629,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { Macro { hid: def.hir_id, - def_id: self.cx.tcx.hir().local_def_id(def.hir_id), + def_id: self.cx.tcx.hir().local_def_id(def.hir_id).to_def_id(), attrs: &def.attrs, name: renamed.unwrap_or(def.ident.name), whence: def.span, |