//! The various pretty-printing routines.
+use crate::session_diagnostics::UnprettyDumpFail;
use rustc_ast as ast;
use rustc_ast_pretty::pprust;
-use rustc_errors::ErrorReported;
+use rustc_errors::ErrorGuaranteed;
use rustc_hir as hir;
-use rustc_hir::def_id::LOCAL_CRATE;
use rustc_hir_pretty as pprust_hir;
use rustc_middle::hir::map as hir_map;
+use rustc_middle::mir::{write_mir_graphviz, write_mir_pretty};
use rustc_middle::ty::{self, TyCtxt};
-use rustc_mir::util::{write_mir_graphviz, write_mir_pretty};
-use rustc_session::config::{Input, PpMode, PpSourceMode};
+use rustc_session::config::{Input, PpAstTreeMode, PpHirMode, PpMode, PpSourceMode};
use rustc_session::Session;
use rustc_span::symbol::Ident;
use rustc_span::FileName;
use std::cell::Cell;
-use std::fs::File;
-use std::io::Write;
+use std::fmt::Write;
use std::path::Path;
pub use self::PpMode::*;
F: FnOnce(&dyn PrinterSupport) -> A,
{
match *ppmode {
- PpmNormal | PpmEveryBodyLoops | PpmExpanded => {
+ Normal | Expanded => {
let annotation = NoAnn { sess, tcx };
f(&annotation)
}
- PpmIdentified | PpmExpandedIdentified => {
+ Identified | ExpandedIdentified => {
let annotation = IdentifiedAnnotation { sess, tcx };
f(&annotation)
}
- PpmExpandedHygiene => {
+ ExpandedHygiene => {
let annotation = HygieneAnnotation { sess };
f(&annotation)
}
- _ => panic!("Should use call_with_pp_support_hir"),
}
}
-fn call_with_pp_support_hir<A, F>(ppmode: &PpSourceMode, tcx: TyCtxt<'_>, f: F) -> A
+fn call_with_pp_support_hir<A, F>(ppmode: &PpHirMode, tcx: TyCtxt<'_>, f: F) -> A
where
- F: FnOnce(&dyn HirPrinterSupport<'_>, &hir::Crate<'_>) -> A,
+ F: FnOnce(&dyn HirPrinterSupport<'_>, hir_map::Map<'_>) -> A,
{
match *ppmode {
- PpmNormal => {
+ PpHirMode::Normal => {
let annotation = NoAnn { sess: tcx.sess, tcx: Some(tcx) };
- f(&annotation, tcx.hir().krate())
+ f(&annotation, tcx.hir())
}
- PpmIdentified => {
+ PpHirMode::Identified => {
let annotation = IdentifiedAnnotation { sess: tcx.sess, tcx: Some(tcx) };
- f(&annotation, tcx.hir().krate())
+ f(&annotation, tcx.hir())
}
- PpmTyped => {
- abort_on_err(tcx.analysis(LOCAL_CRATE), tcx.sess);
+ PpHirMode::Typed => {
+ abort_on_err(tcx.analysis(()), tcx.sess);
let annotation = TypedAnnotation { tcx, maybe_typeck_results: Cell::new(None) };
- tcx.dep_graph.with_ignore(|| f(&annotation, tcx.hir().krate()))
+ tcx.dep_graph.with_ignore(|| f(&annotation, tcx.hir()))
}
- _ => panic!("Should use call_with_pp_support"),
}
}
/// Produces the pretty-print annotation object.
///
/// (Rust does not yet support upcasting from a trait object to
- /// an object for one of its super-traits.)
+ /// an object for one of its supertraits.)
fn pp_ann(&self) -> &dyn pprust::PpAnn;
}
/// Produces the pretty-print annotation object.
///
/// (Rust does not yet support upcasting from a trait object to
- /// an object for one of its super-traits.)
+ /// an object for one of its supertraits.)
fn pp_ann(&self) -> &dyn pprust_hir::PpAnn;
-
- /// Computes an user-readable representation of a path, if possible.
- fn node_path(&self, id: hir::HirId) -> Option<String> {
- self.hir_map().and_then(|map| map.def_path_from_hir_id(id)).map(|path| {
- path.data.into_iter().map(|elem| elem.data.to_string()).collect::<Vec<_>>().join("::")
- })
- }
}
struct NoAnn<'hir> {
pprust_hir::AnnNode::Name(_) => {}
pprust_hir::AnnNode::Item(item) => {
s.s.space();
- s.synth_comment(format!("hir_id: {}", item.hir_id));
+ s.synth_comment(format!("hir_id: {}", item.hir_id()));
}
pprust_hir::AnnNode::SubItem(id) => {
s.s.space();
maybe_typeck_results: Cell<Option<&'tcx ty::TypeckResults<'tcx>>>,
}
-impl<'tcx> TypedAnnotation<'tcx> {
- /// Gets the type-checking results for the current body.
- /// As this will ICE if called outside bodies, only call when working with
- /// `Expr` or `Pat` nodes (they are guaranteed to be found only in bodies).
- #[track_caller]
- fn typeck_results(&self) -> &'tcx ty::TypeckResults<'tcx> {
- self.maybe_typeck_results
- .get()
- .expect("`TypedAnnotation::typeck_results` called outside of body")
- }
-}
-
impl<'tcx> HirPrinterSupport<'tcx> for TypedAnnotation<'tcx> {
fn sess(&self) -> &Session {
- &self.tcx.sess
+ self.tcx.sess
}
fn hir_map(&self) -> Option<hir_map::Map<'tcx>> {
fn pp_ann(&self) -> &dyn pprust_hir::PpAnn {
self
}
-
- fn node_path(&self, id: hir::HirId) -> Option<String> {
- Some(self.tcx.def_path_str(self.tcx.hir().local_def_id(id).to_def_id()))
- }
}
impl<'tcx> pprust_hir::PpAnn for TypedAnnotation<'tcx> {
}
fn post(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>) {
if let pprust_hir::AnnNode::Expr(expr) = node {
- s.s.space();
- s.s.word("as");
- s.s.space();
- s.s.word(self.typeck_results().expr_ty(expr).to_string());
+ let typeck_results = self.maybe_typeck_results.get().or_else(|| {
+ self.tcx
+ .hir()
+ .maybe_body_owned_by(expr.hir_id.owner.def_id)
+ .map(|body_id| self.tcx.typeck_body(body_id))
+ });
+
+ if let Some(typeck_results) = typeck_results {
+ s.s.space();
+ s.s.word("as");
+ s.s.space();
+ s.s.word(typeck_results.expr_ty(expr).to_string());
+ }
+
s.pclose();
}
}
fn get_source(input: &Input, sess: &Session) -> (String, FileName) {
let src_name = input.source_name();
- let src =
- String::clone(&sess.source_map().get_source_file(&src_name).unwrap().src.as_ref().unwrap());
+ let src = String::clone(
+ sess.source_map()
+ .get_source_file(&src_name)
+ .expect("get_source_file")
+ .src
+ .as_ref()
+ .expect("src"),
+ );
(src, src_name)
}
-fn write_output(out: Vec<u8>, ofile: Option<&Path>) {
+fn write_or_print(out: &str, ofile: Option<&Path>, sess: &Session) {
match ofile {
- None => print!("{}", String::from_utf8(out).unwrap()),
- Some(p) => match File::create(p) {
- Ok(mut w) => w.write_all(&out).unwrap(),
- Err(e) => panic!("print-print failed to open {} due to {}", p.display(), e),
- },
+ None => print!("{}", out),
+ Some(p) => {
+ if let Err(e) = std::fs::write(p, out) {
+ sess.emit_fatal(UnprettyDumpFail {
+ path: p.display().to_string(),
+ err: e.to_string(),
+ });
+ }
+ }
}
}
) {
let (src, src_name) = get_source(input, sess);
- let mut out = String::new();
-
- if let PpmSource(s) = ppm {
- // Silently ignores an identified node.
- let out = &mut out;
- call_with_pp_support(&s, sess, None, move |annotation| {
- debug!("pretty printing source code {:?}", s);
- let sess = annotation.sess();
- let parse = &sess.parse_sess;
- *out = pprust::print_crate(
- sess.source_map(),
- krate,
- src_name,
- src,
- annotation.pp_ann(),
- false,
- parse.edition,
- )
- })
- } else {
- unreachable!();
+ let out = match ppm {
+ Source(s) => {
+ // Silently ignores an identified node.
+ call_with_pp_support(&s, sess, None, move |annotation| {
+ debug!("pretty printing source code {:?}", s);
+ let sess = annotation.sess();
+ let parse = &sess.parse_sess;
+ pprust::print_crate(
+ sess.source_map(),
+ krate,
+ src_name,
+ src,
+ annotation.pp_ann(),
+ false,
+ parse.edition,
+ &sess.parse_sess.attr_id_generator,
+ )
+ })
+ }
+ AstTree(PpAstTreeMode::Normal) => {
+ debug!("pretty printing AST tree");
+ format!("{:#?}", krate)
+ }
+ _ => unreachable!(),
};
- write_output(out.into_bytes(), ofile);
+ write_or_print(&out, ofile, sess);
}
pub fn print_after_hir_lowering<'tcx>(
let (src, src_name) = get_source(input, tcx.sess);
- let mut out = String::new();
-
- match ppm {
- PpmSource(s) => {
+ let out = match ppm {
+ Source(s) => {
// Silently ignores an identified node.
- let out = &mut out;
call_with_pp_support(&s, tcx.sess, Some(tcx), move |annotation| {
debug!("pretty printing source code {:?}", s);
let sess = annotation.sess();
let parse = &sess.parse_sess;
- *out = pprust::print_crate(
+ pprust::print_crate(
sess.source_map(),
krate,
src_name,
annotation.pp_ann(),
true,
parse.edition,
+ &sess.parse_sess.attr_id_generator,
)
})
}
- PpmHir(s) => {
- let out = &mut out;
- call_with_pp_support_hir(&s, tcx, move |annotation, krate| {
- debug!("pretty printing source code {:?}", s);
- let sess = annotation.sess();
- let sm = sess.source_map();
- *out = pprust_hir::print_crate(sm, krate, src_name, src, annotation.pp_ann())
- })
+ AstTree(PpAstTreeMode::Expanded) => {
+ debug!("pretty-printing expanded AST");
+ format!("{:#?}", krate)
}
- PpmHirTree(s) => {
- let out = &mut out;
- call_with_pp_support_hir(&s, tcx, move |_annotation, krate| {
- debug!("pretty printing source code {:?}", s);
- *out = format!("{:#?}", krate);
- });
+ Hir(s) => call_with_pp_support_hir(&s, tcx, move |annotation, hir_map| {
+ debug!("pretty printing HIR {:?}", s);
+ let sess = annotation.sess();
+ let sm = sess.source_map();
+ let attrs = |id| hir_map.attrs(id);
+ pprust_hir::print_crate(
+ sm,
+ hir_map.root_module(),
+ src_name,
+ src,
+ &attrs,
+ annotation.pp_ann(),
+ )
+ }),
+
+ HirTree => {
+ call_with_pp_support_hir(&PpHirMode::Normal, tcx, move |_annotation, hir_map| {
+ debug!("pretty printing HIR tree");
+ format!("{:#?}", hir_map.krate())
+ })
}
_ => unreachable!(),
- }
+ };
- write_output(out.into_bytes(), ofile);
+ write_or_print(&out, ofile, tcx.sess);
}
// In an ideal world, this would be a public function called by the driver after
tcx: TyCtxt<'_>,
ppm: PpMode,
ofile: Option<&Path>,
-) -> Result<(), ErrorReported> {
- let mut out = Vec::new();
+) -> Result<(), ErrorGuaranteed> {
+ tcx.analysis(())?;
+ let out = match ppm {
+ Mir => {
+ let mut out = Vec::new();
+ write_mir_pretty(tcx, None, &mut out).unwrap();
+ String::from_utf8(out).unwrap()
+ }
- tcx.analysis(LOCAL_CRATE)?;
+ MirCFG => {
+ let mut out = Vec::new();
+ write_mir_graphviz(tcx, None, &mut out).unwrap();
+ String::from_utf8(out).unwrap()
+ }
+
+ ThirTree => {
+ let mut out = String::new();
+ abort_on_err(rustc_hir_analysis::check_crate(tcx), tcx.sess);
+ debug!("pretty printing THIR tree");
+ for did in tcx.hir().body_owners() {
+ let _ = writeln!(
+ out,
+ "{:?}:\n{}\n",
+ did,
+ tcx.thir_tree(ty::WithOptConstParam::unknown(did))
+ );
+ }
+ out
+ }
- match ppm {
- PpmMir | PpmMirCFG => match ppm {
- PpmMir => write_mir_pretty(tcx, None, &mut out),
- PpmMirCFG => write_mir_graphviz(tcx, None, &mut out),
- _ => unreachable!(),
- },
_ => unreachable!(),
- }
- .unwrap();
+ };
- write_output(out, ofile);
+ write_or_print(&out, ofile, tcx.sess);
Ok(())
}
projects / rustc.git / blobdiff