bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Rollup merge of #82269 - LeSeulArtichaut:cleanup-ppmode, r=spastorino

Browse source 
Cleanup `PpMode` and friends

This PR:
 - Separates `PpSourceMode` and `PpHirMode` to remove invalid states
 - Renames the variant to remove the redundant `Ppm` prefix
 - Adds basic documentation for the different pretty-print modes
 - Cleanups some code to make it more idiomatic

Not sure if this is actually useful, but it looks cleaner to me.
This commit is contained in:
Aaron Hill 2021-02-25 16:06:16 -05:00 • committed by GitHub
commit 8c0119da77
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3 changed files with 92 additions and 99 deletions
Download patch file Download diff file Expand all files Collapse all files

72
compiler/rustc_driver/src/pretty.rs
View file

@ -9,7 +9,7 @@ use rustc_hir_pretty as pprust_hir;
use rustc_middle::hir::map as hir_map; use rustc_middle::hir::map as hir_map;
use rustc_middle::ty::{self, TyCtxt}; use rustc_middle::ty::{self, TyCtxt};
use rustc_mir::util::{write_mir_graphviz, write_mir_pretty}; use rustc_mir::util::{write_mir_graphviz, write_mir_pretty};
use rustc_session::config::{Input, PpMode, PpSourceMode}; use rustc_session::config::{Input, PpHirMode, PpMode, PpSourceMode};
use rustc_session::Session; use rustc_session::Session;
use rustc_span::symbol::Ident; use rustc_span::symbol::Ident;
use rustc_span::FileName; use rustc_span::FileName;
@ -42,43 +42,41 @@ where
F: FnOnce(&dyn PrinterSupport) -> A, F: FnOnce(&dyn PrinterSupport) -> A,
{ {
match *ppmode { match *ppmode {
PpmNormal | PpmEveryBodyLoops | PpmExpanded => { Normal | EveryBodyLoops | Expanded => {
let annotation = NoAnn { sess, tcx }; let annotation = NoAnn { sess, tcx };
f(&annotation) f(&annotation)
} }
PpmIdentified | PpmExpandedIdentified => { Identified | ExpandedIdentified => {
let annotation = IdentifiedAnnotation { sess, tcx }; let annotation = IdentifiedAnnotation { sess, tcx };
f(&annotation) f(&annotation)
} }
PpmExpandedHygiene => { ExpandedHygiene => {
let annotation = HygieneAnnotation { sess }; let annotation = HygieneAnnotation { sess };
f(&annotation) 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 where
F: FnOnce(&dyn HirPrinterSupport<'_>, &hir::Crate<'_>) -> A, F: FnOnce(&dyn HirPrinterSupport<'_>, &hir::Crate<'_>) -> A,
{ {
match *ppmode { match *ppmode {
PpmNormal => { PpHirMode::Normal => {
let annotation = NoAnn { sess: tcx.sess, tcx: Some(tcx) }; let annotation = NoAnn { sess: tcx.sess, tcx: Some(tcx) };
f(&annotation, tcx.hir().krate()) f(&annotation, tcx.hir().krate())
} }
PpmIdentified => { PpHirMode::Identified => {
let annotation = IdentifiedAnnotation { sess: tcx.sess, tcx: Some(tcx) }; let annotation = IdentifiedAnnotation { sess: tcx.sess, tcx: Some(tcx) };
f(&annotation, tcx.hir().krate()) f(&annotation, tcx.hir().krate())
} }
PpmTyped => { PpHirMode::Typed => {
abort_on_err(tcx.analysis(LOCAL_CRATE), tcx.sess); abort_on_err(tcx.analysis(LOCAL_CRATE), tcx.sess);
let annotation = TypedAnnotation { tcx, maybe_typeck_results: Cell::new(None) }; 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().krate()))
} }
_ => panic!("Should use call_with_pp_support"),
} }
} }
@ -393,16 +391,13 @@ pub fn print_after_parsing(
) { ) {
let (src, src_name) = get_source(input, sess); let (src, src_name) = get_source(input, sess);
let mut out = String::new(); let out = if let Source(s) = ppm {
if let PpmSource(s) = ppm {
// Silently ignores an identified node. // Silently ignores an identified node.
let out = &mut out;
call_with_pp_support(&s, sess, None, move |annotation| { call_with_pp_support(&s, sess, None, move |annotation| {
debug!("pretty printing source code {:?}", s); debug!("pretty printing source code {:?}", s);
let sess = annotation.sess(); let sess = annotation.sess();
let parse = &sess.parse_sess; let parse = &sess.parse_sess;
*out = pprust::print_crate( pprust::print_crate(
sess.source_map(), sess.source_map(),
krate, krate,
src_name, src_name,
@ -413,7 +408,7 @@ pub fn print_after_parsing(
) )
}) })
} else { } else {
unreachable!(); unreachable!()
}; };
write_or_print(&out, ofile); write_or_print(&out, ofile);
@ -433,17 +428,14 @@ pub fn print_after_hir_lowering<'tcx>(
let (src, src_name) = get_source(input, tcx.sess); let (src, src_name) = get_source(input, tcx.sess);
let mut out = String::new(); let out = match ppm {
Source(s) => {
match ppm {
PpmSource(s) => {
// Silently ignores an identified node. // Silently ignores an identified node.
let out = &mut out;
call_with_pp_support(&s, tcx.sess, Some(tcx), move |annotation| { call_with_pp_support(&s, tcx.sess, Some(tcx), move |annotation| {
debug!("pretty printing source code {:?}", s); debug!("pretty printing source code {:?}", s);
let sess = annotation.sess(); let sess = annotation.sess();
let parse = &sess.parse_sess; let parse = &sess.parse_sess;
*out = pprust::print_crate( pprust::print_crate(
sess.source_map(), sess.source_map(),
krate, krate,
src_name, src_name,
@ -455,26 +447,20 @@ pub fn print_after_hir_lowering<'tcx>(
}) })
} }
PpmHir(s) => { Hir(s) => call_with_pp_support_hir(&s, tcx, move |annotation, krate| {
let out = &mut out; debug!("pretty printing HIR {:?}", s);
call_with_pp_support_hir(&s, tcx, move |annotation, krate| { let sess = annotation.sess();
debug!("pretty printing source code {:?}", s); let sm = sess.source_map();
let sess = annotation.sess(); pprust_hir::print_crate(sm, krate, src_name, src, annotation.pp_ann())
let sm = sess.source_map(); }),
*out = pprust_hir::print_crate(sm, krate, src_name, src, annotation.pp_ann())
})
}
PpmHirTree(s) => { HirTree => call_with_pp_support_hir(&PpHirMode::Normal, tcx, move |_annotation, krate| {
let out = &mut out; debug!("pretty printing HIR tree");
call_with_pp_support_hir(&s, tcx, move |_annotation, krate| { format!("{:#?}", krate)
debug!("pretty printing source code {:?}", s); }),
*out = format!("{:#?}", krate);
});
}
_ => unreachable!(), _ => unreachable!(),
} };
write_or_print(&out, ofile); write_or_print(&out, ofile);
} }
@ -493,14 +479,10 @@ fn print_with_analysis(
tcx.analysis(LOCAL_CRATE)?; tcx.analysis(LOCAL_CRATE)?;
match ppm { match ppm {
PpmMir | PpmMirCFG => match ppm { Mir => write_mir_pretty(tcx, None, &mut out).unwrap(),
PpmMir => write_mir_pretty(tcx, None, &mut out), MirCFG => write_mir_graphviz(tcx, None, &mut out).unwrap(),
PpmMirCFG => write_mir_graphviz(tcx, None, &mut out),
_ => unreachable!(),
},
_ => unreachable!(), _ => unreachable!(),
} }
.unwrap();
let out = std::str::from_utf8(&out).unwrap(); let out = std::str::from_utf8(&out).unwrap();
write_or_print(out, ofile); write_or_print(out, ofile);

2
compiler/rustc_interface/src/passes.rs
View file

@ -350,7 +350,7 @@ fn configure_and_expand_inner<'a>(
rustc_builtin_macros::test_harness::inject(&sess, &mut resolver, &mut krate) rustc_builtin_macros::test_harness::inject(&sess, &mut resolver, &mut krate)
}); });
if let Some(PpMode::PpmSource(PpSourceMode::PpmEveryBodyLoops)) = sess.opts.pretty { if let Some(PpMode::Source(PpSourceMode::EveryBodyLoops)) = sess.opts.pretty {
tracing::debug!("replacing bodies with loop {{}}"); tracing::debug!("replacing bodies with loop {{}}");
util::ReplaceBodyWithLoop::new(&mut resolver).visit_crate(&mut krate); util::ReplaceBodyWithLoop::new(&mut resolver).visit_crate(&mut krate);
} }

117
compiler/rustc_session/src/config.rs
View file

@ -2057,40 +2057,21 @@ fn parse_pretty(
debugging_opts: &DebuggingOptions, debugging_opts: &DebuggingOptions,
efmt: ErrorOutputType, efmt: ErrorOutputType,
) -> Option<PpMode> { ) -> Option<PpMode> {
let pretty = if debugging_opts.unstable_options {
matches.opt_default("pretty", "normal").map(|a| {
// stable pretty-print variants only
parse_pretty_inner(efmt, &a, false)
})
} else {
None
};
return if pretty.is_none() {
debugging_opts.unpretty.as_ref().map(|a| {
// extended with unstable pretty-print variants
parse_pretty_inner(efmt, &a, true)
})
} else {
pretty
};
fn parse_pretty_inner(efmt: ErrorOutputType, name: &str, extended: bool) -> PpMode { fn parse_pretty_inner(efmt: ErrorOutputType, name: &str, extended: bool) -> PpMode {
use PpMode::*; use PpMode::*;
use PpSourceMode::*;
let first = match (name, extended) { let first = match (name, extended) {
("normal", _) => PpmSource(PpmNormal), ("normal", _) => Source(PpSourceMode::Normal),
("identified", _) => PpmSource(PpmIdentified), ("identified", _) => Source(PpSourceMode::Identified),
("everybody_loops", true) => PpmSource(PpmEveryBodyLoops), ("everybody_loops", true) => Source(PpSourceMode::EveryBodyLoops),
("expanded", _) => PpmSource(PpmExpanded), ("expanded", _) => Source(PpSourceMode::Expanded),
("expanded,identified", _) => PpmSource(PpmExpandedIdentified), ("expanded,identified", _) => Source(PpSourceMode::ExpandedIdentified),
("expanded,hygiene", _) => PpmSource(PpmExpandedHygiene), ("expanded,hygiene", _) => Source(PpSourceMode::ExpandedHygiene),
("hir", true) => PpmHir(PpmNormal), ("hir", true) => Hir(PpHirMode::Normal),
("hir,identified", true) => PpmHir(PpmIdentified), ("hir,identified", true) => Hir(PpHirMode::Identified),
("hir,typed", true) => PpmHir(PpmTyped), ("hir,typed", true) => Hir(PpHirMode::Typed),
("hir-tree", true) => PpmHirTree(PpmNormal), ("hir-tree", true) => HirTree,
("mir", true) => PpmMir, ("mir", true) => Mir,
("mir-cfg", true) => PpmMirCFG, ("mir-cfg", true) => MirCFG,
_ => { _ => {
if extended { if extended {
early_error( early_error(
@ -2119,6 +2100,18 @@ fn parse_pretty(
tracing::debug!("got unpretty option: {:?}", first); tracing::debug!("got unpretty option: {:?}", first);
first first
} }
if debugging_opts.unstable_options {
if let Some(a) = matches.opt_default("pretty", "normal") {
// stable pretty-print variants only
return Some(parse_pretty_inner(efmt, &a, false));
}
}
debugging_opts.unpretty.as_ref().map(|a| {
// extended with unstable pretty-print variants
parse_pretty_inner(efmt, &a, true)
})
} }
pub fn make_crate_type_option() -> RustcOptGroup { pub fn make_crate_type_option() -> RustcOptGroup {
@ -2226,22 +2219,43 @@ impl fmt::Display for CrateType {
#[derive(Copy, Clone, PartialEq, Debug)] #[derive(Copy, Clone, PartialEq, Debug)]
pub enum PpSourceMode { pub enum PpSourceMode {
PpmNormal, /// `--pretty=normal`
PpmEveryBodyLoops, Normal,
PpmExpanded, /// `-Zunpretty=everybody_loops`
PpmIdentified, EveryBodyLoops,
PpmExpandedIdentified, /// `--pretty=expanded`
PpmExpandedHygiene, Expanded,
PpmTyped, /// `--pretty=identified`
Identified,
/// `--pretty=expanded,identified`
ExpandedIdentified,
/// `--pretty=expanded,hygiene`
ExpandedHygiene,
}
#[derive(Copy, Clone, PartialEq, Debug)]
pub enum PpHirMode {
/// `-Zunpretty=hir`
Normal,
/// `-Zunpretty=hir,identified`
Identified,
/// `-Zunpretty=hir,typed`
Typed,
} }
#[derive(Copy, Clone, PartialEq, Debug)] #[derive(Copy, Clone, PartialEq, Debug)]
pub enum PpMode { pub enum PpMode {
PpmSource(PpSourceMode), /// Options that print the source code, i.e.
PpmHir(PpSourceMode), /// `--pretty` and `-Zunpretty=everybody_loops`
PpmHirTree(PpSourceMode), Source(PpSourceMode),
PpmMir, /// Options that print the HIR, i.e. `-Zunpretty=hir`
PpmMirCFG, Hir(PpHirMode),
/// `-Zunpretty=hir-tree`
HirTree,
/// `-Zunpretty=mir`
Mir,
/// `-Zunpretty=mir-cfg`
MirCFG,
} }
impl PpMode { impl PpMode {
@ -2249,22 +2263,19 @@ impl PpMode {
use PpMode::*; use PpMode::*;
use PpSourceMode::*; use PpSourceMode::*;
match *self { match *self {
PpmSource(PpmNormal | PpmIdentified) => false, Source(Normal | Identified) => false,
PpmSource( Source(Expanded | EveryBodyLoops | ExpandedIdentified | ExpandedHygiene)
PpmExpanded | PpmEveryBodyLoops | PpmExpandedIdentified | PpmExpandedHygiene, | Hir(_)
) | HirTree
| PpmHir(_) | Mir
| PpmHirTree(_) | MirCFG => true,
| PpmMir
| PpmMirCFG => true,
PpmSource(PpmTyped) => panic!("invalid state"),
} }
} }
pub fn needs_analysis(&self) -> bool { pub fn needs_analysis(&self) -> bool {
use PpMode::*; use PpMode::*;
matches!(*self, PpmMir | PpmMirCFG) matches!(*self, Mir | MirCFG)
} }
} }