renamve hir_to_string to node_to_string

ljedrz · ljedrz · commit 1c8551b0ebb4 · 2019-06-17T18:59:27.000+02:00
diff --git a/src/librustc/cfg/graphviz.rs b/src/librustc/cfg/graphviz.rs
@@ -26,7 +26,7 @@ impl<'a, 'tcx> LabelledCFG<'a, 'tcx> {
             owner: self.tcx.hir().def_index_to_hir_id(self.cfg.owner_def_id.index).owner,
             local_id
         };
-        let s = self.tcx.hir().hir_to_string(hir_id);
+        let s = self.tcx.hir().node_to_string(hir_id);
 
         // Replacing newlines with \\l causes each line to be left-aligned,
         // improving presentation of (long) pretty-printed expressions.
diff --git a/src/librustc/hir/map/hir_id_validator.rs b/src/librustc/hir/map/hir_id_validator.rs
@@ -125,7 +125,7 @@ impl<'a, 'hir: 'a> HirIdValidator<'a, 'hir> {
                 let hir_id = self.hir_map.node_to_hir_id(node_id);
                 missing_items.push(format!("[local_id: {}, node:{}]",
                                            local_id,
-                                           self.hir_map.hir_to_string(hir_id)));
+                                           self.hir_map.node_to_string(hir_id)));
             }
             self.error(|| format!(
                 "ItemLocalIds not assigned densely in {}. \
@@ -139,7 +139,7 @@ impl<'a, 'hir: 'a> HirIdValidator<'a, 'hir> {
                         owner: owner_def_index,
                         local_id,
                     })
-                    .map(|h| format!("({:?} {})", h, self.hir_map.hir_to_string(h)))
+                    .map(|h| format!("({:?} {})", h, self.hir_map.node_to_string(h)))
                     .collect::<Vec<_>>()));
         }
     }
@@ -157,14 +157,14 @@ impl<'a, 'hir: 'a> intravisit::Visitor<'hir> for HirIdValidator<'a, 'hir> {
 
         if hir_id == hir::DUMMY_HIR_ID {
             self.error(|| format!("HirIdValidator: HirId {:?} is invalid",
-                                  self.hir_map.hir_to_string(hir_id)));
+                                  self.hir_map.node_to_string(hir_id)));
             return;
         }
 
         if owner != hir_id.owner {
             self.error(|| format!(
                 "HirIdValidator: The recorded owner of {} is {} instead of {}",
-                self.hir_map.hir_to_string(hir_id),
+                self.hir_map.node_to_string(hir_id),
                 self.hir_map.def_path(DefId::local(hir_id.owner)).to_string_no_crate(),
                 self.hir_map.def_path(DefId::local(owner)).to_string_no_crate()));
         }
diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs
@@ -453,7 +453,7 @@ impl<'hir> Map<'hir> {
     pub fn body_owned_by(&self, id: HirId) -> BodyId {
         self.maybe_body_owned_by(id).unwrap_or_else(|| {
             span_bug!(self.span(id), "body_owned_by: {} has no associated body",
-                      self.hir_to_string(id));
+                      self.node_to_string(id));
         })
     }
 
@@ -486,7 +486,7 @@ impl<'hir> Map<'hir> {
             Node::Item(&Item { node: ItemKind::Trait(..), .. }) |
             Node::Item(&Item { node: ItemKind::TraitAlias(..), .. }) => id,
             Node::GenericParam(_) => self.get_parent_node_by_hir_id(id),
-            _ => bug!("ty_param_owner: {} not a type parameter", self.hir_to_string(id))
+            _ => bug!("ty_param_owner: {} not a type parameter", self.node_to_string(id))
         }
     }
 
@@ -495,7 +495,7 @@ impl<'hir> Map<'hir> {
             Node::Item(&Item { node: ItemKind::Trait(..), .. }) |
             Node::Item(&Item { node: ItemKind::TraitAlias(..), .. }) => kw::SelfUpper,
             Node::GenericParam(param) => param.name.ident().name,
-            _ => bug!("ty_param_name: {} not a type parameter", self.hir_to_string(id)),
+            _ => bug!("ty_param_name: {} not a type parameter", self.node_to_string(id)),
         }
     }
 
@@ -874,27 +874,27 @@ impl<'hir> Map<'hir> {
                 return nm.abi;
             }
         }
-        bug!("expected foreign mod or inlined parent, found {}", self.hir_to_string(parent))
+        bug!("expected foreign mod or inlined parent, found {}", self.node_to_string(parent))
     }
 
     pub fn expect_item(&self, id: HirId) -> &'hir Item {
         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))
+            _ => bug!("expected item, found {}", self.node_to_string(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.hir_to_string(id))
+            _ => bug!("expected impl item, found {}", self.node_to_string(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.hir_to_string(id))
+            _ => bug!("expected trait item, found {}", self.node_to_string(id))
         }
     }
 
@@ -904,26 +904,26 @@ impl<'hir> Map<'hir> {
                 match i.node {
                     ItemKind::Struct(ref struct_def, _) |
                     ItemKind::Union(ref struct_def, _) => struct_def,
-                    _ => bug!("struct ID bound to non-struct {}", self.hir_to_string(id))
+                    _ => bug!("struct ID bound to non-struct {}", self.node_to_string(id))
                 }
             }
             Some(Node::Variant(variant)) => &variant.node.data,
             Some(Node::Ctor(data)) => data,
-            _ => bug!("expected struct or variant, found {}", self.hir_to_string(id))
+            _ => bug!("expected struct or variant, found {}", self.node_to_string(id))
         }
     }
 
     pub fn expect_variant(&self, id: HirId) -> &'hir Variant {
         match self.find_by_hir_id(id) {
             Some(Node::Variant(variant)) => variant,
-            _ => bug!("expected variant, found {}", self.hir_to_string(id)),
+            _ => bug!("expected variant, found {}", self.node_to_string(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.hir_to_string(id))
+            _ => bug!("expected foreign item, found {}", self.node_to_string(id))
         }
     }
 
@@ -936,7 +936,7 @@ impl<'hir> Map<'hir> {
     pub fn expect_expr_by_hir_id(&self, id: HirId) -> &'hir Expr {
         match self.find_by_hir_id(id) { // read recorded by find
             Some(Node::Expr(expr)) => expr,
-            _ => bug!("expected expr, found {}", self.hir_to_string(id))
+            _ => bug!("expected expr, found {}", self.node_to_string(id))
         }
     }
 
@@ -959,7 +959,7 @@ impl<'hir> Map<'hir> {
             Node::GenericParam(param) => param.name.ident().name,
             Node::Binding(&Pat { node: PatKind::Binding(_, _, l, _), .. }) => l.name,
             Node::Ctor(..) => self.name_by_hir_id(self.get_parent_item(id)),
-            _ => bug!("no name for {}", self.hir_to_string(id))
+            _ => bug!("no name for {}", self.node_to_string(id))
         }
     }
 
@@ -1071,7 +1071,7 @@ impl<'hir> Map<'hir> {
         self.as_local_hir_id(id).map(|id| self.span(id))
     }
 
-    pub fn hir_to_string(&self, id: HirId) -> String {
+    pub fn node_to_string(&self, id: HirId) -> String {
         hir_id_to_string(self, id, true)
     }
 
diff --git a/src/librustc/infer/opaque_types/mod.rs b/src/librustc/infer/opaque_types/mod.rs
@@ -819,7 +819,7 @@ impl<'a, 'tcx> Instantiator<'a, 'tcx> {
                             },
                             _ => bug!(
                                 "expected (impl) item, found {}",
-                                tcx.hir().hir_to_string(opaque_hir_id),
+                                tcx.hir().node_to_string(opaque_hir_id),
                             ),
                         };
                         if in_definition_scope {
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
@@ -501,7 +501,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
             None if self.is_tainted_by_errors() => Err(()),
             None => {
                 bug!("no type for node {}: {} in mem_categorization",
-                     id, self.tcx.hir().hir_to_string(id));
+                     id, self.tcx.hir().node_to_string(id));
             }
         }
     }
diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs
@@ -318,7 +318,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> {
             _ => {
                 bug!(
                     "found unexpected node kind in worklist: {} ({:?})",
-                    self.tcx.hir().hir_to_string(search_item),
+                    self.tcx.hir().node_to_string(search_item),
                     node,
                 );
             }
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
@@ -2696,7 +2696,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
 
         debug!(
             "insert_lifetime: {} resolved to {:?} span={:?}",
-            self.tcx.hir().hir_to_string(lifetime_ref.hir_id),
+            self.tcx.hir().node_to_string(lifetime_ref.hir_id),
             def,
             self.tcx.sess.source_map().span_to_string(lifetime_ref.span)
         );
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
@@ -252,7 +252,7 @@ fn validate_hir_id_for_typeck_tables(local_id_root: Option<DefId>,
                 ty::tls::with(|tcx| {
                     bug!("node {} with HirId::owner {:?} cannot be placed in \
                           TypeckTables with local_id_root {:?}",
-                         tcx.hir().hir_to_string(hir_id),
+                         tcx.hir().node_to_string(hir_id),
                          DefId::local(hir_id.owner),
                          local_id_root)
                 });
@@ -554,7 +554,7 @@ impl<'tcx> TypeckTables<'tcx> {
     pub fn node_type(&self, id: hir::HirId) -> Ty<'tcx> {
         self.node_type_opt(id).unwrap_or_else(||
             bug!("node_type: no type for node `{}`",
-                 tls::with(|tcx| tcx.hir().hir_to_string(id)))
+                 tls::with(|tcx| tcx.hir().node_to_string(id)))
         )
     }
 
diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs
@@ -1508,12 +1508,12 @@ impl<'tcx> fmt::Debug for LoanPath<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.kind {
             LpVar(id) => {
-                write!(f, "$({})", ty::tls::with(|tcx| tcx.hir().hir_to_string(id)))
+                write!(f, "$({})", ty::tls::with(|tcx| tcx.hir().node_to_string(id)))
             }
 
             LpUpvar(ty::UpvarId{ var_path: ty::UpvarPath {hir_id: var_id}, closure_expr_id }) => {
                 let s = ty::tls::with(|tcx| {
-                    tcx.hir().hir_to_string(var_id)
+                    tcx.hir().node_to_string(var_id)
                 });
                 write!(f, "$({} captured by id={:?})", s, closure_expr_id)
             }
@@ -1547,7 +1547,7 @@ impl<'tcx> fmt::Display for LoanPath<'tcx> {
 
             LpUpvar(ty::UpvarId{ var_path: ty::UpvarPath { hir_id }, closure_expr_id: _ }) => {
                 let s = ty::tls::with(|tcx| {
-                    tcx.hir().hir_to_string(hir_id)
+                    tcx.hir().node_to_string(hir_id)
                 });
                 write!(f, "$({} captured by closure)", s)
             }
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -2181,7 +2181,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
         self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
             span_bug!(span, "no type for local variable {}",
-                      self.tcx.hir().hir_to_string(nid))
+                      self.tcx.hir().node_to_string(nid))
         )
     }
 
@@ -2518,7 +2518,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             None if self.is_tainted_by_errors() => self.tcx.types.err,
             None => {
                 bug!("no type for node {}: {} in fcx {}",
-                     id, self.tcx.hir().hir_to_string(id),
+                     id, self.tcx.hir().node_to_string(id),
                      self.tag());
             }
         }
diff --git a/src/librustc_typeck/coherence/orphan.rs b/src/librustc_typeck/coherence/orphan.rs
@@ -26,7 +26,7 @@ impl ItemLikeVisitor<'v> for OrphanChecker<'tcx> {
         // "Trait" impl
         if let hir::ItemKind::Impl(.., Some(_), _, _) = item.node {
             debug!("coherence2::orphan check: trait impl {}",
-                   self.tcx.hir().hir_to_string(item.hir_id));
+                   self.tcx.hir().node_to_string(item.hir_id));
             let trait_ref = self.tcx.impl_trait_ref(def_id).unwrap();
             let trait_def_id = trait_ref.def_id;
             let cm = self.tcx.sess.source_map();
diff --git a/src/librustc_typeck/variance/terms.rs b/src/librustc_typeck/variance/terms.rs
@@ -129,7 +129,7 @@ impl<'a, 'tcx> TermsContext<'a, 'tcx> {
 impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for TermsContext<'a, 'tcx> {
     fn visit_item(&mut self, item: &hir::Item) {
         debug!("add_inferreds for item {}",
-               self.tcx.hir().hir_to_string(item.hir_id));
+               self.tcx.hir().node_to_string(item.hir_id));
 
         match item.node {
             hir::ItemKind::Struct(ref struct_def, _) |

Original file line number	Diff line number	Diff line change
`@@ -453,7 +453,7 @@ impl<'hir> Map<'hir> {`
`453`	`453`	`pub fn body_owned_by(&self, id: HirId) -> BodyId {`
`454`	`454`	`self.maybe_body_owned_by(id).unwrap_or_else(\|\| {`
`455`	`455`	`span_bug!(self.span(id), "body_owned_by: {} has no associated body",`
`456`		`- self.hir_to_string(id));`
	`456`	`+ self.node_to_string(id));`
`457`	`457`	`})`
`458`	`458`	`}`
`459`	`459`
`@@ -486,7 +486,7 @@ impl<'hir> Map<'hir> {`
`486`	`486`	`Node::Item(&Item { node: ItemKind::Trait(..), .. }) \|`
`487`	`487`	`Node::Item(&Item { node: ItemKind::TraitAlias(..), .. }) => id,`
`488`	`488`	`Node::GenericParam(_) => self.get_parent_node_by_hir_id(id),`
`489`		`- _ => bug!("ty_param_owner: {} not a type parameter", self.hir_to_string(id))`
	`489`	`+ _ => bug!("ty_param_owner: {} not a type parameter", self.node_to_string(id))`
`490`	`490`	`}`
`491`	`491`	`}`
`492`	`492`
`@@ -495,7 +495,7 @@ impl<'hir> Map<'hir> {`
`495`	`495`	`Node::Item(&Item { node: ItemKind::Trait(..), .. }) \|`
`496`	`496`	`Node::Item(&Item { node: ItemKind::TraitAlias(..), .. }) => kw::SelfUpper,`
`497`	`497`	`Node::GenericParam(param) => param.name.ident().name,`
`498`		`- _ => bug!("ty_param_name: {} not a type parameter", self.hir_to_string(id)),`
	`498`	`+ _ => bug!("ty_param_name: {} not a type parameter", self.node_to_string(id)),`
`499`	`499`	`}`
`500`	`500`	`}`
`501`	`501`
`@@ -874,27 +874,27 @@ impl<'hir> Map<'hir> {`
`874`	`874`	`return nm.abi;`
`875`	`875`	`}`
`876`	`876`	`}`
`877`		`- bug!("expected foreign mod or inlined parent, found {}", self.hir_to_string(parent))`
	`877`	`+ bug!("expected foreign mod or inlined parent, found {}", self.node_to_string(parent))`
`878`	`878`	`}`
`879`	`879`
`880`	`880`	`pub fn expect_item(&self, id: HirId) -> &'hir Item {`
`881`	`881`	match self.find_by_hir_id(id) { // read recorded by `find`
`882`	`882`	`Some(Node::Item(item)) => item,`
`883`		`- _ => bug!("expected item, found {}", self.hir_to_string(id))`
	`883`	`+ _ => bug!("expected item, found {}", self.node_to_string(id))`
`884`	`884`	`}`
`885`	`885`	`}`
`886`	`886`
`887`	`887`	`pub fn expect_impl_item(&self, id: HirId) -> &'hir ImplItem {`
`888`	`888`	`match self.find_by_hir_id(id) {`
`889`	`889`	`Some(Node::ImplItem(item)) => item,`
`890`		`- _ => bug!("expected impl item, found {}", self.hir_to_string(id))`
	`890`	`+ _ => bug!("expected impl item, found {}", self.node_to_string(id))`
`891`	`891`	`}`
`892`	`892`	`}`
`893`	`893`
`894`	`894`	`pub fn expect_trait_item(&self, id: HirId) -> &'hir TraitItem {`
`895`	`895`	`match self.find_by_hir_id(id) {`
`896`	`896`	`Some(Node::TraitItem(item)) => item,`
`897`		`- _ => bug!("expected trait item, found {}", self.hir_to_string(id))`
	`897`	`+ _ => bug!("expected trait item, found {}", self.node_to_string(id))`
`898`	`898`	`}`
`899`	`899`	`}`
`900`	`900`
`@@ -904,26 +904,26 @@ impl<'hir> Map<'hir> {`
`904`	`904`	`match i.node {`
`905`	`905`	`ItemKind::Struct(ref struct_def, _) \|`
`906`	`906`	`ItemKind::Union(ref struct_def, _) => struct_def,`
`907`		`- _ => bug!("struct ID bound to non-struct {}", self.hir_to_string(id))`
	`907`	`+ _ => bug!("struct ID bound to non-struct {}", self.node_to_string(id))`
`908`	`908`	`}`
`909`	`909`	`}`
`910`	`910`	`Some(Node::Variant(variant)) => &variant.node.data,`
`911`	`911`	`Some(Node::Ctor(data)) => data,`
`912`		`- _ => bug!("expected struct or variant, found {}", self.hir_to_string(id))`
	`912`	`+ _ => bug!("expected struct or variant, found {}", self.node_to_string(id))`
`913`	`913`	`}`
`914`	`914`	`}`
`915`	`915`
`916`	`916`	`pub fn expect_variant(&self, id: HirId) -> &'hir Variant {`
`917`	`917`	`match self.find_by_hir_id(id) {`
`918`	`918`	`Some(Node::Variant(variant)) => variant,`
`919`		`- _ => bug!("expected variant, found {}", self.hir_to_string(id)),`
	`919`	`+ _ => bug!("expected variant, found {}", self.node_to_string(id)),`
`920`	`920`	`}`
`921`	`921`	`}`
`922`	`922`
`923`	`923`	`pub fn expect_foreign_item(&self, id: HirId) -> &'hir ForeignItem {`
`924`	`924`	`match self.find_by_hir_id(id) {`
`925`	`925`	`Some(Node::ForeignItem(item)) => item,`
`926`		`- _ => bug!("expected foreign item, found {}", self.hir_to_string(id))`
	`926`	`+ _ => bug!("expected foreign item, found {}", self.node_to_string(id))`
`927`	`927`	`}`
`928`	`928`	`}`
`929`	`929`
`@@ -936,7 +936,7 @@ impl<'hir> Map<'hir> {`
`936`	`936`	`pub fn expect_expr_by_hir_id(&self, id: HirId) -> &'hir Expr {`
`937`	`937`	`match self.find_by_hir_id(id) { // read recorded by find`
`938`	`938`	`Some(Node::Expr(expr)) => expr,`
`939`		`- _ => bug!("expected expr, found {}", self.hir_to_string(id))`
	`939`	`+ _ => bug!("expected expr, found {}", self.node_to_string(id))`
`940`	`940`	`}`
`941`	`941`	`}`
`942`	`942`
`@@ -959,7 +959,7 @@ impl<'hir> Map<'hir> {`
`959`	`959`	`Node::GenericParam(param) => param.name.ident().name,`
`960`	`960`	`Node::Binding(&Pat { node: PatKind::Binding(_, _, l, _), .. }) => l.name,`
`961`	`961`	`Node::Ctor(..) => self.name_by_hir_id(self.get_parent_item(id)),`
`962`		`- _ => bug!("no name for {}", self.hir_to_string(id))`
	`962`	`+ _ => bug!("no name for {}", self.node_to_string(id))`
`963`	`963`	`}`
`964`	`964`	`}`
`965`	`965`
`@@ -1071,7 +1071,7 @@ impl<'hir> Map<'hir> {`
`1071`	`1071`	`self.as_local_hir_id(id).map(\|id\| self.span(id))`
`1072`	`1072`	`}`
`1073`	`1073`
`1074`		`- pub fn hir_to_string(&self, id: HirId) -> String {`
	`1074`	`+ pub fn node_to_string(&self, id: HirId) -> String {`
`1075`	`1075`	`hir_id_to_string(self, id, true)`
`1076`	`1076`	`}`
`1077`	`1077`
Original file line number	Diff line number	Diff line change
`@@ -501,7 +501,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {`
`501`	`501`	`None if self.is_tainted_by_errors() => Err(()),`
`502`	`502`	`None => {`
`503`	`503`	`bug!("no type for node {}: {} in mem_categorization",`
`504`		`- id, self.tcx.hir().hir_to_string(id));`
	`504`	`+ id, self.tcx.hir().node_to_string(id));`
`505`	`505`	`}`
`506`	`506`	`}`
`507`	`507`	`}`
Original file line number	Diff line number	Diff line change
`@@ -318,7 +318,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> {`
`318`	`318`	`_ => {`
`319`	`319`	`bug!(`
`320`	`320`	`"found unexpected node kind in worklist: {} ({:?})",`
`321`		`- self.tcx.hir().hir_to_string(search_item),`
	`321`	`+ self.tcx.hir().node_to_string(search_item),`
`322`	`322`	`node,`
`323`	`323`	`);`
`324`	`324`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2181,7 +2181,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`2181`	`2181`	`pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {`
`2182`	`2182`	`self.locals.borrow().get(&nid).cloned().unwrap_or_else(\|\|`
`2183`	`2183`	`span_bug!(span, "no type for local variable {}",`
`2184`		`- self.tcx.hir().hir_to_string(nid))`
	`2184`	`+ self.tcx.hir().node_to_string(nid))`
`2185`	`2185`	`)`
`2186`	`2186`	`}`
`2187`	`2187`
`@@ -2518,7 +2518,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`2518`	`2518`	`None if self.is_tainted_by_errors() => self.tcx.types.err,`
`2519`	`2519`	`None => {`
`2520`	`2520`	`bug!("no type for node {}: {} in fcx {}",`
`2521`		`- id, self.tcx.hir().hir_to_string(id),`
	`2521`	`+ id, self.tcx.hir().node_to_string(id),`
`2522`	`2522`	`self.tag());`
`2523`	`2523`	`}`
`2524`	`2524`	`}`