hir: remove some obsolete NodeId methods

ljedrz · ljedrz · commit d7120e400de1 · 2019-03-07T15:46:41.000+01:00
diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs
@@ -618,11 +618,11 @@ impl<'hir> Map<'hir> {
         }
 
         for id in &module.trait_items {
-            visitor.visit_trait_item(self.expect_trait_item_by_hir_id(id.hir_id));
+            visitor.visit_trait_item(self.expect_trait_item(id.hir_id));
         }
 
         for id in &module.impl_items {
-            visitor.visit_impl_item(self.expect_impl_item_by_hir_id(id.hir_id));
+            visitor.visit_impl_item(self.expect_impl_item(id.hir_id));
         }
     }
 
@@ -929,66 +929,52 @@ impl<'hir> Map<'hir> {
 
     // FIXME(@ljedrz): replace the NodeId variant
     pub fn expect_item_by_hir_id(&self, id: HirId) -> &'hir Item {
-        let node_id = self.hir_to_node_id(id);
-        self.expect_item(node_id)
+        match self.find_by_hir_id(id) { // read recorded by `find`
+            Some(Node::Item(item)) => item,
+            _ => bug!("expected item, found {}", self.hir_to_string(id))
+        }
     }
 
-    pub fn expect_impl_item(&self, id: NodeId) -> &'hir ImplItem {
-        match self.find(id) {
+    pub fn expect_impl_item(&self, id: HirId) -> &'hir ImplItem {
+        match self.find_by_hir_id(id) {
             Some(Node::ImplItem(item)) => item,
-            _ => bug!("expected impl item, found {}", self.node_to_string(id))
+            _ => bug!("expected impl item, found {}", self.hir_to_string(id))
         }
     }
 
-    // FIXME(@ljedrz): replace the NodeId variant
-    pub fn expect_impl_item_by_hir_id(&self, id: HirId) -> &'hir ImplItem {
-        let node_id = self.hir_to_node_id(id);
-        self.expect_impl_item(node_id)
-    }
-
-    // FIXME(@ljedrz): replace the NodeId variant
-    pub fn expect_trait_item_by_hir_id(&self, id: HirId) -> &'hir TraitItem {
-        let node_id = self.hir_to_node_id(id);
-        self.expect_trait_item(node_id)
-    }
-
-    pub fn expect_trait_item(&self, id: NodeId) -> &'hir TraitItem {
-        match self.find(id) {
+    pub fn expect_trait_item(&self, id: HirId) -> &'hir TraitItem {
+        match self.find_by_hir_id(id) {
             Some(Node::TraitItem(item)) => item,
-            _ => bug!("expected trait item, found {}", self.node_to_string(id))
+            _ => bug!("expected trait item, found {}", self.hir_to_string(id))
         }
     }
 
     pub fn expect_variant_data(&self, id: HirId) -> &'hir VariantData {
-        let id = self.hir_to_node_id(id); // FIXME(@ljedrz): remove when possible
-
-        match self.find(id) {
+        match self.find_by_hir_id(id) {
             Some(Node::Item(i)) => {
                 match i.node {
                     ItemKind::Struct(ref struct_def, _) |
                     ItemKind::Union(ref struct_def, _) => struct_def,
-                    _ => bug!("struct ID bound to non-struct {}", self.node_to_string(id))
+                    _ => bug!("struct ID bound to non-struct {}", self.hir_to_string(id))
                 }
             }
             Some(Node::StructCtor(data)) => data,
             Some(Node::Variant(variant)) => &variant.node.data,
-            _ => bug!("expected struct or variant, found {}", self.node_to_string(id))
+            _ => bug!("expected struct or variant, found {}", self.hir_to_string(id))
         }
     }
 
     pub fn expect_variant(&self, id: HirId) -> &'hir Variant {
-        let id = self.hir_to_node_id(id); // FIXME(@ljedrz): remove when possible
-
-        match self.find(id) {
+        match self.find_by_hir_id(id) {
             Some(Node::Variant(variant)) => variant,
-            _ => bug!("expected variant, found {}", self.node_to_string(id)),
+            _ => bug!("expected variant, found {}", self.hir_to_string(id)),
         }
     }
 
-    pub fn expect_foreign_item(&self, id: NodeId) -> &'hir ForeignItem {
-        match self.find(id) {
+    pub fn expect_foreign_item(&self, id: HirId) -> &'hir ForeignItem {
+        match self.find_by_hir_id(id) {
             Some(Node::ForeignItem(item)) => item,
-            _ => bug!("expected foreign item, found {}", self.node_to_string(id))
+            _ => bug!("expected foreign item, found {}", self.hir_to_string(id))
         }
     }
 
diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs
@@ -780,7 +780,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> {
         let tcx = self.tcx;
 
         let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
-        let ast_item = tcx.hir().expect_trait_item_by_hir_id(hir_id);
+        let ast_item = tcx.hir().expect_trait_item(hir_id);
         let trait_item = tcx.associated_item(def_id);
 
         let container = match trait_item.defaultness {
@@ -890,7 +890,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> {
         let tcx = self.tcx;
 
         let hir_id = self.tcx.hir().as_local_hir_id(def_id).unwrap();
-        let ast_item = self.tcx.hir().expect_impl_item_by_hir_id(hir_id);
+        let ast_item = self.tcx.hir().expect_impl_item(hir_id);
         let impl_item = self.tcx.associated_item(def_id);
 
         let container = match impl_item.defaultness {
diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs
@@ -417,7 +417,7 @@ fn extract_spans_for_error_reporting<'a, 'gcx, 'tcx>(infcx: &infer::InferCtxt<'a
     let tcx = infcx.tcx;
     let impl_m_hir_id = tcx.hir().as_local_hir_id(impl_m.def_id).unwrap();
     let (impl_m_output, impl_m_iter) = match tcx.hir()
-                                                .expect_impl_item_by_hir_id(impl_m_hir_id)
+                                                .expect_impl_item(impl_m_hir_id)
                                                 .node {
         ImplItemKind::Method(ref impl_m_sig, _) => {
             (&impl_m_sig.decl.output, impl_m_sig.decl.inputs.iter())
@@ -429,7 +429,7 @@ fn extract_spans_for_error_reporting<'a, 'gcx, 'tcx>(infcx: &infer::InferCtxt<'a
         TypeError::Mutability => {
             if let Some(trait_m_hir_id) = tcx.hir().as_local_hir_id(trait_m.def_id) {
                 let trait_m_iter = match tcx.hir()
-                                            .expect_trait_item_by_hir_id(trait_m_hir_id)
+                                            .expect_trait_item(trait_m_hir_id)
                                             .node {
                     TraitItemKind::Method(ref trait_m_sig, _) => {
                         trait_m_sig.decl.inputs.iter()
@@ -456,7 +456,7 @@ fn extract_spans_for_error_reporting<'a, 'gcx, 'tcx>(infcx: &infer::InferCtxt<'a
         TypeError::Sorts(ExpectedFound { .. }) => {
             if let Some(trait_m_hir_id) = tcx.hir().as_local_hir_id(trait_m.def_id) {
                 let (trait_m_output, trait_m_iter) =
-                    match tcx.hir().expect_trait_item_by_hir_id(trait_m_hir_id).node {
+                    match tcx.hir().expect_trait_item(trait_m_hir_id).node {
                         TraitItemKind::Method(ref trait_m_sig, _) => {
                             (&trait_m_sig.decl.output, trait_m_sig.decl.inputs.iter())
                         }
@@ -599,8 +599,8 @@ fn compare_number_of_generics<'a, 'tcx>(
         if impl_count != trait_count {
             err_occurred = true;
 
-            let impl_node_id = tcx.hir().as_local_node_id(impl_.def_id).unwrap();
-            let impl_item = tcx.hir().expect_impl_item(impl_node_id);
+            let impl_hir_id = tcx.hir().as_local_hir_id(impl_.def_id).unwrap();
+            let impl_item = tcx.hir().expect_impl_item(impl_hir_id);
             let span = if impl_item.generics.params.is_empty()
                 || impl_item.generics.span.is_dummy() { // argument position impl Trait (#55374)
                 impl_span
@@ -666,7 +666,7 @@ fn compare_number_of_method_arguments<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     if trait_number_args != impl_number_args {
         let trait_m_hir_id = tcx.hir().as_local_hir_id(trait_m.def_id);
         let trait_span = if let Some(trait_id) = trait_m_hir_id {
-            match tcx.hir().expect_trait_item_by_hir_id(trait_id).node {
+            match tcx.hir().expect_trait_item(trait_id).node {
                 TraitItemKind::Method(ref trait_m_sig, _) => {
                     let pos = if trait_number_args > 0 {
                         trait_number_args - 1
@@ -691,7 +691,7 @@ fn compare_number_of_method_arguments<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             trait_item_span
         };
         let impl_m_hir_id = tcx.hir().as_local_hir_id(impl_m.def_id).unwrap();
-        let impl_span = match tcx.hir().expect_impl_item_by_hir_id(impl_m_hir_id).node {
+        let impl_span = match tcx.hir().expect_impl_item(impl_m_hir_id).node {
             ImplItemKind::Method(ref impl_m_sig, _) => {
                 let pos = if impl_number_args > 0 {
                     impl_number_args - 1
@@ -962,7 +962,7 @@ pub fn compare_const_impl<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                    trait_ty);
 
             // Locate the Span containing just the type of the offending impl
-            match tcx.hir().expect_impl_item_by_hir_id(impl_c_hir_id).node {
+            match tcx.hir().expect_impl_item(impl_c_hir_id).node {
                 ImplItemKind::Const(ref ty, _) => cause.span = ty.span,
                 _ => bug!("{:?} is not a impl const", impl_c),
             }
@@ -977,7 +977,7 @@ pub fn compare_const_impl<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             let trait_c_hir_id = tcx.hir().as_local_hir_id(trait_c.def_id);
             let trait_c_span = trait_c_hir_id.map(|trait_c_hir_id| {
                 // Add a label to the Span containing just the type of the const
-                match tcx.hir().expect_trait_item_by_hir_id(trait_c_hir_id).node {
+                match tcx.hir().expect_trait_item(trait_c_hir_id).node {
                     TraitItemKind::Const(ref ty, _) => ty.span,
                     _ => bug!("{:?} is not a trait const", trait_c),
                 }
diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs
@@ -152,7 +152,7 @@ pub fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: Def
 
 pub fn check_trait_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
     let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
-    let trait_item = tcx.hir().expect_trait_item_by_hir_id(hir_id);
+    let trait_item = tcx.hir().expect_trait_item(hir_id);
 
     let method_sig = match trait_item.node {
         hir::TraitItemKind::Method(ref sig, _) => Some(sig),
@@ -163,7 +163,7 @@ pub fn check_trait_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
 
 pub fn check_impl_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
     let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
-    let impl_item = tcx.hir().expect_impl_item_by_hir_id(hir_id);
+    let impl_item = tcx.hir().expect_impl_item(hir_id);
 
     let method_sig = match impl_item.node {
         hir::ImplItemKind::Method(ref sig, _) => Some(sig),
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
@@ -479,7 +479,7 @@ fn convert_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, item_id: hir::HirId) {
 }
 
 fn convert_trait_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, trait_item_id: hir::HirId) {
-    let trait_item = tcx.hir().expect_trait_item_by_hir_id(trait_item_id);
+    let trait_item = tcx.hir().expect_trait_item(trait_item_id);
     let def_id = tcx.hir().local_def_id_from_hir_id(trait_item.hir_id);
     tcx.generics_of(def_id);
 
@@ -504,7 +504,7 @@ fn convert_impl_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, impl_item_id: hir::H
     tcx.generics_of(def_id);
     tcx.type_of(def_id);
     tcx.predicates_of(def_id);
-    if let hir::ImplItemKind::Method(..) = tcx.hir().expect_impl_item_by_hir_id(impl_item_id).node {
+    if let hir::ImplItemKind::Method(..) = tcx.hir().expect_impl_item(impl_item_id).node {
         tcx.fn_sig(def_id);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -618,11 +618,11 @@ impl<'hir> Map<'hir> {`
`618`	`618`	`}`
`619`	`619`
`620`	`620`	`for id in &module.trait_items {`
`621`		`- visitor.visit_trait_item(self.expect_trait_item_by_hir_id(id.hir_id));`
	`621`	`+ visitor.visit_trait_item(self.expect_trait_item(id.hir_id));`
`622`	`622`	`}`
`623`	`623`
`624`	`624`	`for id in &module.impl_items {`
`625`		`- visitor.visit_impl_item(self.expect_impl_item_by_hir_id(id.hir_id));`
	`625`	`+ visitor.visit_impl_item(self.expect_impl_item(id.hir_id));`
`626`	`626`	`}`
`627`	`627`	`}`
`628`	`628`
`@@ -929,66 +929,52 @@ impl<'hir> Map<'hir> {`
`929`	`929`
`930`	`930`	`// FIXME(@ljedrz): replace the NodeId variant`
`931`	`931`	`pub fn expect_item_by_hir_id(&self, id: HirId) -> &'hir Item {`
`932`		`- let node_id = self.hir_to_node_id(id);`
`933`		`- self.expect_item(node_id)`
	`932`	+ match self.find_by_hir_id(id) { // read recorded by `find`
	`933`	`+ Some(Node::Item(item)) => item,`
	`934`	`+ _ => bug!("expected item, found {}", self.hir_to_string(id))`
	`935`	`+ }`
`934`	`936`	`}`
`935`	`937`
`936`		`- pub fn expect_impl_item(&self, id: NodeId) -> &'hir ImplItem {`
`937`		`- match self.find(id) {`
	`938`	`+ pub fn expect_impl_item(&self, id: HirId) -> &'hir ImplItem {`
	`939`	`+ match self.find_by_hir_id(id) {`
`938`	`940`	`Some(Node::ImplItem(item)) => item,`
`939`		`- _ => bug!("expected impl item, found {}", self.node_to_string(id))`
	`941`	`+ _ => bug!("expected impl item, found {}", self.hir_to_string(id))`
`940`	`942`	`}`
`941`	`943`	`}`
`942`	`944`
`943`		`- // FIXME(@ljedrz): replace the NodeId variant`
`944`		`- pub fn expect_impl_item_by_hir_id(&self, id: HirId) -> &'hir ImplItem {`
`945`		`- let node_id = self.hir_to_node_id(id);`
`946`		`- self.expect_impl_item(node_id)`
`947`		`- }`
`948`		`-`
`949`		`- // FIXME(@ljedrz): replace the NodeId variant`
`950`		`- pub fn expect_trait_item_by_hir_id(&self, id: HirId) -> &'hir TraitItem {`
`951`		`- let node_id = self.hir_to_node_id(id);`
`952`		`- self.expect_trait_item(node_id)`
`953`		`- }`
`954`		`-`
`955`		`- pub fn expect_trait_item(&self, id: NodeId) -> &'hir TraitItem {`
`956`		`- match self.find(id) {`
	`945`	`+ pub fn expect_trait_item(&self, id: HirId) -> &'hir TraitItem {`
	`946`	`+ match self.find_by_hir_id(id) {`
`957`	`947`	`Some(Node::TraitItem(item)) => item,`
`958`		`- _ => bug!("expected trait item, found {}", self.node_to_string(id))`
	`948`	`+ _ => bug!("expected trait item, found {}", self.hir_to_string(id))`
`959`	`949`	`}`
`960`	`950`	`}`
`961`	`951`
`962`	`952`	`pub fn expect_variant_data(&self, id: HirId) -> &'hir VariantData {`
`963`		`- let id = self.hir_to_node_id(id); // FIXME(@ljedrz): remove when possible`
`964`		`-`
`965`		`- match self.find(id) {`
	`953`	`+ match self.find_by_hir_id(id) {`
`966`	`954`	`Some(Node::Item(i)) => {`
`967`	`955`	`match i.node {`
`968`	`956`	`ItemKind::Struct(ref struct_def, _) \|`
`969`	`957`	`ItemKind::Union(ref struct_def, _) => struct_def,`
`970`		`- _ => bug!("struct ID bound to non-struct {}", self.node_to_string(id))`
	`958`	`+ _ => bug!("struct ID bound to non-struct {}", self.hir_to_string(id))`
`971`	`959`	`}`
`972`	`960`	`}`
`973`	`961`	`Some(Node::StructCtor(data)) => data,`
`974`	`962`	`Some(Node::Variant(variant)) => &variant.node.data,`
`975`		`- _ => bug!("expected struct or variant, found {}", self.node_to_string(id))`
	`963`	`+ _ => bug!("expected struct or variant, found {}", self.hir_to_string(id))`
`976`	`964`	`}`
`977`	`965`	`}`
`978`	`966`
`979`	`967`	`pub fn expect_variant(&self, id: HirId) -> &'hir Variant {`
`980`		`- let id = self.hir_to_node_id(id); // FIXME(@ljedrz): remove when possible`
`981`		`-`
`982`		`- match self.find(id) {`
	`968`	`+ match self.find_by_hir_id(id) {`
`983`	`969`	`Some(Node::Variant(variant)) => variant,`
`984`		`- _ => bug!("expected variant, found {}", self.node_to_string(id)),`
	`970`	`+ _ => bug!("expected variant, found {}", self.hir_to_string(id)),`
`985`	`971`	`}`
`986`	`972`	`}`
`987`	`973`
`988`		`- pub fn expect_foreign_item(&self, id: NodeId) -> &'hir ForeignItem {`
`989`		`- match self.find(id) {`
	`974`	`+ pub fn expect_foreign_item(&self, id: HirId) -> &'hir ForeignItem {`
	`975`	`+ match self.find_by_hir_id(id) {`
`990`	`976`	`Some(Node::ForeignItem(item)) => item,`
`991`		`- _ => bug!("expected foreign item, found {}", self.node_to_string(id))`
	`977`	`+ _ => bug!("expected foreign item, found {}", self.hir_to_string(id))`
`992`	`978`	`}`
`993`	`979`	`}`
`994`	`980`
Original file line number	Diff line number	Diff line change
`@@ -479,7 +479,7 @@ fn convert_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, item_id: hir::HirId) {`
`479`	`479`	`}`
`480`	`480`
`481`	`481`	`fn convert_trait_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, trait_item_id: hir::HirId) {`
`482`		`- let trait_item = tcx.hir().expect_trait_item_by_hir_id(trait_item_id);`
	`482`	`+ let trait_item = tcx.hir().expect_trait_item(trait_item_id);`
`483`	`483`	`let def_id = tcx.hir().local_def_id_from_hir_id(trait_item.hir_id);`
`484`	`484`	`tcx.generics_of(def_id);`
`485`	`485`
`@@ -504,7 +504,7 @@ fn convert_impl_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, impl_item_id: hir::H`
`504`	`504`	`tcx.generics_of(def_id);`
`505`	`505`	`tcx.type_of(def_id);`
`506`	`506`	`tcx.predicates_of(def_id);`
`507`		`- if let hir::ImplItemKind::Method(..) = tcx.hir().expect_impl_item_by_hir_id(impl_item_id).node {`
	`507`	`+ if let hir::ImplItemKind::Method(..) = tcx.hir().expect_impl_item(impl_item_id).node {`
`508`	`508`	`tcx.fn_sig(def_id);`
`509`	`509`	`}`
`510`	`510`	`}`