decouple rustc_hir::print from crate

Centril · Centril · commit f07802c0de90 · 2020-03-24T06:22:27.000+01:00
diff --git a/src/librustc_hir/hir.rs b/src/librustc_hir/hir.rs
@@ -2,11 +2,6 @@ use crate::def::{DefKind, Namespace, Res};
 use crate::def_id::DefId;
 crate use crate::hir_id::HirId;
 use crate::itemlikevisit;
-use crate::print;
-
-crate use BlockCheckMode::*;
-crate use FnRetTy::*;
-crate use UnsafeSource::*;
 
 use rustc_ast::ast::{self, AsmDialect, CrateSugar, Ident, Name};
 use rustc_ast::ast::{AttrVec, Attribute, FloatTy, IntTy, Label, LitKind, StrStyle, UintTy};
@@ -169,12 +164,7 @@ impl fmt::Display for Lifetime {
 
 impl fmt::Debug for Lifetime {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "lifetime({}: {})",
-            self.hir_id,
-            print::to_string(print::NO_ANN, |s| s.print_lifetime(self))
-        )
+        write!(f, "lifetime({}: {})", self.hir_id, self.name.ident())
     }
 }
 
@@ -191,7 +181,7 @@ impl Lifetime {
 /// A `Path` is essentially Rust's notion of a name; for instance,
 /// `std::cmp::PartialEq`. It's represented as a sequence of identifiers,
 /// along with a bunch of supporting information.
-#[derive(RustcEncodable, RustcDecodable, HashStable_Generic)]
+#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)]
 pub struct Path<'hir> {
     pub span: Span,
     /// The resolution for the path.
@@ -206,18 +196,6 @@ impl Path<'_> {
     }
 }
 
-impl fmt::Debug for Path<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "path({})", self)
-    }
-}
-
-impl fmt::Display for Path<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", print::to_string(print::NO_ANN, |s| s.print_path(self, false)))
-    }
-}
-
 /// A segment of a path: an identifier, an optional lifetime, and a set of
 /// types.
 #[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)]
@@ -758,25 +736,14 @@ pub struct Block<'hir> {
     pub targeted_by_break: bool,
 }
 
-#[derive(RustcEncodable, RustcDecodable, HashStable_Generic)]
+#[derive(Debug, RustcEncodable, RustcDecodable, HashStable_Generic)]
 pub struct Pat<'hir> {
     #[stable_hasher(ignore)]
     pub hir_id: HirId,
     pub kind: PatKind<'hir>,
     pub span: Span,
 }
 
-impl fmt::Debug for Pat<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "pat({}: {})",
-            self.hir_id,
-            print::to_string(print::NO_ANN, |s| s.print_pat(self))
-        )
-    }
-}
-
 impl Pat<'_> {
     // FIXME(#19596) this is a workaround, but there should be a better way
     fn walk_short_(&self, it: &mut impl FnMut(&Pat<'_>) -> bool) -> bool {
@@ -1118,26 +1085,15 @@ impl UnOp {
 }
 
 /// A statement.
-#[derive(RustcEncodable, RustcDecodable, HashStable_Generic)]
+#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)]
 pub struct Stmt<'hir> {
     pub hir_id: HirId,
     pub kind: StmtKind<'hir>,
     pub span: Span,
 }
 
-impl fmt::Debug for Stmt<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "stmt({}: {})",
-            self.hir_id,
-            print::to_string(print::NO_ANN, |s| s.print_stmt(self))
-        )
-    }
-}
-
 /// The contents of a statement.
-#[derive(RustcEncodable, RustcDecodable, HashStable_Generic)]
+#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)]
 pub enum StmtKind<'hir> {
     /// A local (`let`) binding.
     Local(&'hir Local<'hir>),
@@ -1351,7 +1307,7 @@ pub struct AnonConst {
 }
 
 /// An expression.
-#[derive(RustcEncodable, RustcDecodable)]
+#[derive(Debug, RustcEncodable, RustcDecodable)]
 pub struct Expr<'hir> {
     pub hir_id: HirId,
     pub kind: ExprKind<'hir>,
@@ -1472,17 +1428,6 @@ impl Expr<'_> {
     }
 }
 
-impl fmt::Debug for Expr<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "expr({}: {})",
-            self.hir_id,
-            print::to_string(print::NO_ANN, |s| s.print_expr(self))
-        )
-    }
-}
-
 /// Checks if the specified expression is a built-in range literal.
 /// (See: `LoweringContext::lower_expr()`).
 ///
@@ -1965,19 +1910,13 @@ impl TypeBinding<'_> {
     }
 }
 
-#[derive(RustcEncodable, RustcDecodable)]
+#[derive(Debug, RustcEncodable, RustcDecodable)]
 pub struct Ty<'hir> {
     pub hir_id: HirId,
     pub kind: TyKind<'hir>,
     pub span: Span,
 }
 
-impl fmt::Debug for Ty<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "type({})", print::to_string(print::NO_ANN, |s| s.print_type(self)))
-    }
-}
-
 /// Not represented directly in the AST; referred to by name through a `ty_path`.
 #[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 #[derive(HashStable_Generic)]
@@ -2182,15 +2121,6 @@ pub enum FnRetTy<'hir> {
     Return(&'hir Ty<'hir>),
 }
 
-impl fmt::Display for FnRetTy<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Return(ref ty) => print::to_string(print::NO_ANN, |s| s.print_type(ty)).fmt(f),
-            Self::DefaultReturn(_) => "()".fmt(f),
-        }
-    }
-}
-
 impl FnRetTy<'_> {
     pub fn span(&self) -> Span {
         match *self {
diff --git a/src/librustc_hir/print.rs b/src/librustc_hir/print.rs
@@ -1006,10 +1006,10 @@ impl<'a> State<'a> {
         close_box: bool,
     ) {
         match blk.rules {
-            hir::UnsafeBlock(..) => self.word_space("unsafe"),
-            hir::PushUnsafeBlock(..) => self.word_space("push_unsafe"),
-            hir::PopUnsafeBlock(..) => self.word_space("pop_unsafe"),
-            hir::DefaultBlock => (),
+            hir::BlockCheckMode::UnsafeBlock(..) => self.word_space("unsafe"),
+            hir::BlockCheckMode::PushUnsafeBlock(..) => self.word_space("push_unsafe"),
+            hir::BlockCheckMode::PopUnsafeBlock(..) => self.word_space("pop_unsafe"),
+            hir::BlockCheckMode::DefaultBlock => (),
         }
         self.maybe_print_comment(blk.span.lo());
         self.ann.pre(self, AnnNode::Block(blk));
@@ -1848,7 +1848,8 @@ impl<'a> State<'a> {
                 self.print_block_unclosed(&blk);
 
                 // If it is a user-provided unsafe block, print a comma after it
-                if let hir::UnsafeBlock(hir::UserProvided) = blk.rules {
+                if let hir::BlockCheckMode::UnsafeBlock(hir::UnsafeSource::UserProvided) = blk.rules
+                {
                     self.s.word(",");
                 }
             }
@@ -1928,18 +1929,18 @@ impl<'a> State<'a> {
         });
         self.s.word("|");
 
-        if let hir::DefaultReturn(..) = decl.output {
+        if let hir::FnRetTy::DefaultReturn(..) = decl.output {
             return;
         }
 
         self.space_if_not_bol();
         self.word_space("->");
         match decl.output {
-            hir::Return(ref ty) => {
+            hir::FnRetTy::Return(ref ty) => {
                 self.print_type(&ty);
                 self.maybe_print_comment(ty.span.lo())
             }
-            hir::DefaultReturn(..) => unreachable!(),
+            hir::FnRetTy::DefaultReturn(..) => unreachable!(),
         }
     }
 
@@ -2112,21 +2113,21 @@ impl<'a> State<'a> {
     }
 
     pub fn print_fn_output(&mut self, decl: &hir::FnDecl<'_>) {
-        if let hir::DefaultReturn(..) = decl.output {
+        if let hir::FnRetTy::DefaultReturn(..) = decl.output {
             return;
         }
 
         self.space_if_not_bol();
         self.ibox(INDENT_UNIT);
         self.word_space("->");
         match decl.output {
-            hir::DefaultReturn(..) => unreachable!(),
-            hir::Return(ref ty) => self.print_type(&ty),
+            hir::FnRetTy::DefaultReturn(..) => unreachable!(),
+            hir::FnRetTy::Return(ref ty) => self.print_type(&ty),
         }
         self.end();
 
         match decl.output {
-            hir::Return(ref output) => self.maybe_print_comment(output.span.lo()),
+            hir::FnRetTy::Return(ref output) => self.maybe_print_comment(output.span.lo()),
             _ => {}
         }
     }
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
@@ -1313,14 +1313,18 @@ impl<'a, 'tcx> Visitor<'tcx> for TypePrivacyVisitor<'a, 'tcx> {
             let is_local_static =
                 if let DefKind::Static = kind { def_id.is_local() } else { false };
             if !self.item_is_accessible(def_id) && !is_local_static {
-                let name = match *qpath {
-                    hir::QPath::Resolved(_, ref path) => path.to_string(),
-                    hir::QPath::TypeRelative(_, ref segment) => segment.ident.to_string(),
+                let sess = self.tcx.sess;
+                let sm = sess.source_map();
+                let name = match qpath {
+                    hir::QPath::Resolved(_, path) => sm.span_to_snippet(path.span).ok(),
+                    hir::QPath::TypeRelative(_, segment) => Some(segment.ident.to_string()),
                 };
                 let kind = kind.descr(def_id);
-                self.tcx
-                    .sess
-                    .struct_span_err(span, &format!("{} `{}` is private", kind, name))
+                let msg = match name {
+                    Some(name) => format!("{} `{}` is private", kind, name),
+                    None => format!("{} is private", kind),
+                };
+                sess.struct_span_err(span, &msg)
                     .span_label(span, &format!("private {}", kind))
                     .emit();
                 return;
diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs
@@ -245,11 +245,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             {
                 // check that the `if` expr without `else` is the fn body's expr
                 if expr.span == span {
-                    return self.get_fn_decl(hir_id).map(|(fn_decl, _)| {
-                        (
-                            fn_decl.output.span(),
-                            format!("expected `{}` because of this return type", fn_decl.output),
-                        )
+                    return self.get_fn_decl(hir_id).and_then(|(fn_decl, _)| {
+                        let span = fn_decl.output.span();
+                        let snippet = self.tcx.sess.source_map().span_to_snippet(span).ok()?;
+                        Some((span, format!("expected `{}` because of this return type", snippet)))
                     });
                 }
             }
diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs
@@ -335,16 +335,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     err.span_label(call_expr.span, "call expression requires function");
 
                     if let Some(span) = self.tcx.hir().res_span(def) {
+                        let callee_ty = callee_ty.to_string();
                         let label = match (unit_variant, inner_callee_path) {
-                            (Some(path), _) => format!("`{}` defined here", path),
-                            (_, Some(hir::QPath::Resolved(_, path))) => format!(
-                                "`{}` defined here returns `{}`",
-                                path,
-                                callee_ty.to_string()
-                            ),
-                            _ => format!("`{}` defined here", callee_ty.to_string()),
+                            (Some(path), _) => Some(format!("`{}` defined here", path)),
+                            (_, Some(hir::QPath::Resolved(_, path))) => {
+                                self.tcx.sess.source_map().span_to_snippet(path.span).ok().map(
+                                    |p| format!("`{}` defined here returns `{}`", p, callee_ty),
+                                )
+                            }
+                            _ => Some(format!("`{}` defined here", callee_ty)),
                         };
-                        err.span_label(span, label);
+                        if let Some(label) = label {
+                            err.span_label(span, label);
+                        }
                     }
                     err.emit();
                 } else {
diff --git a/src/librustc_typeck/check/expr.rs b/src/librustc_typeck/check/expr.rs
@@ -696,10 +696,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     self,
                     &cause,
                     &mut |db| {
-                        db.span_label(
-                            fn_decl.output.span(),
-                            format!("expected `{}` because of this return type", fn_decl.output,),
-                        );
+                        let span = fn_decl.output.span();
+                        if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
+                            db.span_label(
+                                span,
+                                format!("expected `{}` because of this return type", snippet),
+                            );
+                        }
                     },
                     true,
                 );

Original file line number	Diff line number	Diff line change
`@@ -1006,10 +1006,10 @@ impl<'a> State<'a> {`
`1006`	`1006`	`close_box: bool,`
`1007`	`1007`	`) {`
`1008`	`1008`	`match blk.rules {`
`1009`		`- hir::UnsafeBlock(..) => self.word_space("unsafe"),`
`1010`		`- hir::PushUnsafeBlock(..) => self.word_space("push_unsafe"),`
`1011`		`- hir::PopUnsafeBlock(..) => self.word_space("pop_unsafe"),`
`1012`		`- hir::DefaultBlock => (),`
	`1009`	`+ hir::BlockCheckMode::UnsafeBlock(..) => self.word_space("unsafe"),`
	`1010`	`+ hir::BlockCheckMode::PushUnsafeBlock(..) => self.word_space("push_unsafe"),`
	`1011`	`+ hir::BlockCheckMode::PopUnsafeBlock(..) => self.word_space("pop_unsafe"),`
	`1012`	`+ hir::BlockCheckMode::DefaultBlock => (),`
`1013`	`1013`	`}`
`1014`	`1014`	`self.maybe_print_comment(blk.span.lo());`
`1015`	`1015`	`self.ann.pre(self, AnnNode::Block(blk));`
`@@ -1848,7 +1848,8 @@ impl<'a> State<'a> {`
`1848`	`1848`	`self.print_block_unclosed(&blk);`
`1849`	`1849`
`1850`	`1850`	`// If it is a user-provided unsafe block, print a comma after it`
`1851`		`- if let hir::UnsafeBlock(hir::UserProvided) = blk.rules {`
	`1851`	`+ if let hir::BlockCheckMode::UnsafeBlock(hir::UnsafeSource::UserProvided) = blk.rules`
	`1852`	`+ {`
`1852`	`1853`	`self.s.word(",");`
`1853`	`1854`	`}`
`1854`	`1855`	`}`
`@@ -1928,18 +1929,18 @@ impl<'a> State<'a> {`
`1928`	`1929`	`});`
`1929`	`1930`	`self.s.word("\|");`
`1930`	`1931`
`1931`		`- if let hir::DefaultReturn(..) = decl.output {`
	`1932`	`+ if let hir::FnRetTy::DefaultReturn(..) = decl.output {`
`1932`	`1933`	`return;`
`1933`	`1934`	`}`
`1934`	`1935`
`1935`	`1936`	`self.space_if_not_bol();`
`1936`	`1937`	`self.word_space("->");`
`1937`	`1938`	`match decl.output {`
`1938`		`- hir::Return(ref ty) => {`
	`1939`	`+ hir::FnRetTy::Return(ref ty) => {`
`1939`	`1940`	`self.print_type(&ty);`
`1940`	`1941`	`self.maybe_print_comment(ty.span.lo())`
`1941`	`1942`	`}`
`1942`		`- hir::DefaultReturn(..) => unreachable!(),`
	`1943`	`+ hir::FnRetTy::DefaultReturn(..) => unreachable!(),`
`1943`	`1944`	`}`
`1944`	`1945`	`}`
`1945`	`1946`
`@@ -2112,21 +2113,21 @@ impl<'a> State<'a> {`
`2112`	`2113`	`}`
`2113`	`2114`
`2114`	`2115`	`pub fn print_fn_output(&mut self, decl: &hir::FnDecl<'_>) {`
`2115`		`- if let hir::DefaultReturn(..) = decl.output {`
	`2116`	`+ if let hir::FnRetTy::DefaultReturn(..) = decl.output {`
`2116`	`2117`	`return;`
`2117`	`2118`	`}`
`2118`	`2119`
`2119`	`2120`	`self.space_if_not_bol();`
`2120`	`2121`	`self.ibox(INDENT_UNIT);`
`2121`	`2122`	`self.word_space("->");`
`2122`	`2123`	`match decl.output {`
`2123`		`- hir::DefaultReturn(..) => unreachable!(),`
`2124`		`- hir::Return(ref ty) => self.print_type(&ty),`
	`2124`	`+ hir::FnRetTy::DefaultReturn(..) => unreachable!(),`
	`2125`	`+ hir::FnRetTy::Return(ref ty) => self.print_type(&ty),`
`2125`	`2126`	`}`
`2126`	`2127`	`self.end();`
`2127`	`2128`
`2128`	`2129`	`match decl.output {`
`2129`		`- hir::Return(ref output) => self.maybe_print_comment(output.span.lo()),`
	`2130`	`+ hir::FnRetTy::Return(ref output) => self.maybe_print_comment(output.span.lo()),`
`2130`	`2131`	`_ => {}`
`2131`	`2132`	`}`
`2132`	`2133`	`}`
Original file line number	Diff line number	Diff line change
`@@ -245,11 +245,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`245`	`245`	`{`
`246`	`246`	// check that the `if` expr without `else` is the fn body's expr
`247`	`247`	`if expr.span == span {`
`248`		`- return self.get_fn_decl(hir_id).map(\|(fn_decl, _)\| {`
`249`		`- (`
`250`		`- fn_decl.output.span(),`
`251`		- format!("expected `{}` because of this return type", fn_decl.output),
`252`		`- )`
	`248`	`+ return self.get_fn_decl(hir_id).and_then(\|(fn_decl, _)\| {`
	`249`	`+ let span = fn_decl.output.span();`
	`250`	`+ let snippet = self.tcx.sess.source_map().span_to_snippet(span).ok()?;`
	`251`	+ Some((span, format!("expected `{}` because of this return type", snippet)))
`253`	`252`	`});`
`254`	`253`	`}`
`255`	`254`	`}`