1 //! The various pretty-printing routines.
2
3 use crate::session_diagnostics::UnprettyDumpFail;
4 use rustc_ast as ast;
5 use rustc_ast_pretty::pprust;
6 use rustc_errors::ErrorGuaranteed;
7 use rustc_hir as hir;
8 use rustc_hir_pretty as pprust_hir;
9 use rustc_middle::hir::map as hir_map;
10 use rustc_middle::mir::{write_mir_graphviz, write_mir_pretty};
11 use rustc_middle::ty::{self, TyCtxt};
12 use rustc_session::config::{OutFileName, PpAstTreeMode, PpHirMode, PpMode, PpSourceMode};
13 use rustc_session::Session;
14 use rustc_span::symbol::Ident;
15 use rustc_span::FileName;
16
17 use std::cell::Cell;
18 use std::fmt::Write;
19
20 pub use self::PpMode::*;
21 pub use self::PpSourceMode::*;
22 use crate::abort_on_err;
23
24 // This slightly awkward construction is to allow for each PpMode to
25 // choose whether it needs to do analyses (which can consume the
26 // Session) and then pass through the session (now attached to the
27 // analysis results) on to the chosen pretty-printer, along with the
28 // `&PpAnn` object.
29 //
30 // Note that since the `&PrinterSupport` is freshly constructed on each
31 // call, it would not make sense to try to attach the lifetime of `self`
32 // to the lifetime of the `&PrinterObject`.
33
34 /// Constructs a `PrinterSupport` object and passes it to `f`.
call_with_pp_support<'tcx, A, F>( ppmode: &PpSourceMode, sess: &'tcx Session, tcx: Option<TyCtxt<'tcx>>, f: F, ) -> A where F: FnOnce(&dyn PrinterSupport) -> A,35 fn call_with_pp_support<'tcx, A, F>(
36 ppmode: &PpSourceMode,
37 sess: &'tcx Session,
38 tcx: Option<TyCtxt<'tcx>>,
39 f: F,
40 ) -> A
41 where
42 F: FnOnce(&dyn PrinterSupport) -> A,
43 {
44 match *ppmode {
45 Normal | Expanded => {
46 let annotation = NoAnn { sess, tcx };
47 f(&annotation)
48 }
49
50 Identified | ExpandedIdentified => {
51 let annotation = IdentifiedAnnotation { sess, tcx };
52 f(&annotation)
53 }
54 ExpandedHygiene => {
55 let annotation = HygieneAnnotation { sess };
56 f(&annotation)
57 }
58 }
59 }
call_with_pp_support_hir<A, F>(ppmode: &PpHirMode, tcx: TyCtxt<'_>, f: F) -> A where F: FnOnce(&dyn HirPrinterSupport<'_>, hir_map::Map<'_>) -> A,60 fn call_with_pp_support_hir<A, F>(ppmode: &PpHirMode, tcx: TyCtxt<'_>, f: F) -> A
61 where
62 F: FnOnce(&dyn HirPrinterSupport<'_>, hir_map::Map<'_>) -> A,
63 {
64 match *ppmode {
65 PpHirMode::Normal => {
66 let annotation = NoAnn { sess: tcx.sess, tcx: Some(tcx) };
67 f(&annotation, tcx.hir())
68 }
69
70 PpHirMode::Identified => {
71 let annotation = IdentifiedAnnotation { sess: tcx.sess, tcx: Some(tcx) };
72 f(&annotation, tcx.hir())
73 }
74 PpHirMode::Typed => {
75 abort_on_err(tcx.analysis(()), tcx.sess);
76
77 let annotation = TypedAnnotation { tcx, maybe_typeck_results: Cell::new(None) };
78 tcx.dep_graph.with_ignore(|| f(&annotation, tcx.hir()))
79 }
80 }
81 }
82
83 trait PrinterSupport: pprust::PpAnn {
84 /// Provides a uniform interface for re-extracting a reference to a
85 /// `Session` from a value that now owns it.
sess(&self) -> &Session86 fn sess(&self) -> &Session;
87
88 /// Produces the pretty-print annotation object.
89 ///
90 /// (Rust does not yet support upcasting from a trait object to
91 /// an object for one of its supertraits.)
pp_ann(&self) -> &dyn pprust::PpAnn92 fn pp_ann(&self) -> &dyn pprust::PpAnn;
93 }
94
95 trait HirPrinterSupport<'hir>: pprust_hir::PpAnn {
96 /// Provides a uniform interface for re-extracting a reference to a
97 /// `Session` from a value that now owns it.
sess(&self) -> &Session98 fn sess(&self) -> &Session;
99
100 /// Provides a uniform interface for re-extracting a reference to an
101 /// `hir_map::Map` from a value that now owns it.
hir_map(&self) -> Option<hir_map::Map<'hir>>102 fn hir_map(&self) -> Option<hir_map::Map<'hir>>;
103
104 /// Produces the pretty-print annotation object.
105 ///
106 /// (Rust does not yet support upcasting from a trait object to
107 /// an object for one of its supertraits.)
pp_ann(&self) -> &dyn pprust_hir::PpAnn108 fn pp_ann(&self) -> &dyn pprust_hir::PpAnn;
109 }
110
111 struct NoAnn<'hir> {
112 sess: &'hir Session,
113 tcx: Option<TyCtxt<'hir>>,
114 }
115
116 impl<'hir> PrinterSupport for NoAnn<'hir> {
sess(&self) -> &Session117 fn sess(&self) -> &Session {
118 self.sess
119 }
120
pp_ann(&self) -> &dyn pprust::PpAnn121 fn pp_ann(&self) -> &dyn pprust::PpAnn {
122 self
123 }
124 }
125
126 impl<'hir> HirPrinterSupport<'hir> for NoAnn<'hir> {
sess(&self) -> &Session127 fn sess(&self) -> &Session {
128 self.sess
129 }
130
hir_map(&self) -> Option<hir_map::Map<'hir>>131 fn hir_map(&self) -> Option<hir_map::Map<'hir>> {
132 self.tcx.map(|tcx| tcx.hir())
133 }
134
pp_ann(&self) -> &dyn pprust_hir::PpAnn135 fn pp_ann(&self) -> &dyn pprust_hir::PpAnn {
136 self
137 }
138 }
139
140 impl<'hir> pprust::PpAnn for NoAnn<'hir> {}
141 impl<'hir> pprust_hir::PpAnn for NoAnn<'hir> {
nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested)142 fn nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested) {
143 if let Some(tcx) = self.tcx {
144 pprust_hir::PpAnn::nested(&(&tcx.hir() as &dyn hir::intravisit::Map<'_>), state, nested)
145 }
146 }
147 }
148
149 struct IdentifiedAnnotation<'hir> {
150 sess: &'hir Session,
151 tcx: Option<TyCtxt<'hir>>,
152 }
153
154 impl<'hir> PrinterSupport for IdentifiedAnnotation<'hir> {
sess(&self) -> &Session155 fn sess(&self) -> &Session {
156 self.sess
157 }
158
pp_ann(&self) -> &dyn pprust::PpAnn159 fn pp_ann(&self) -> &dyn pprust::PpAnn {
160 self
161 }
162 }
163
164 impl<'hir> pprust::PpAnn for IdentifiedAnnotation<'hir> {
pre(&self, s: &mut pprust::State<'_>, node: pprust::AnnNode<'_>)165 fn pre(&self, s: &mut pprust::State<'_>, node: pprust::AnnNode<'_>) {
166 if let pprust::AnnNode::Expr(_) = node {
167 s.popen();
168 }
169 }
post(&self, s: &mut pprust::State<'_>, node: pprust::AnnNode<'_>)170 fn post(&self, s: &mut pprust::State<'_>, node: pprust::AnnNode<'_>) {
171 match node {
172 pprust::AnnNode::Crate(_) | pprust::AnnNode::Ident(_) | pprust::AnnNode::Name(_) => {}
173
174 pprust::AnnNode::Item(item) => {
175 s.s.space();
176 s.synth_comment(item.id.to_string())
177 }
178 pprust::AnnNode::SubItem(id) => {
179 s.s.space();
180 s.synth_comment(id.to_string())
181 }
182 pprust::AnnNode::Block(blk) => {
183 s.s.space();
184 s.synth_comment(format!("block {}", blk.id))
185 }
186 pprust::AnnNode::Expr(expr) => {
187 s.s.space();
188 s.synth_comment(expr.id.to_string());
189 s.pclose()
190 }
191 pprust::AnnNode::Pat(pat) => {
192 s.s.space();
193 s.synth_comment(format!("pat {}", pat.id));
194 }
195 }
196 }
197 }
198
199 impl<'hir> HirPrinterSupport<'hir> for IdentifiedAnnotation<'hir> {
sess(&self) -> &Session200 fn sess(&self) -> &Session {
201 self.sess
202 }
203
hir_map(&self) -> Option<hir_map::Map<'hir>>204 fn hir_map(&self) -> Option<hir_map::Map<'hir>> {
205 self.tcx.map(|tcx| tcx.hir())
206 }
207
pp_ann(&self) -> &dyn pprust_hir::PpAnn208 fn pp_ann(&self) -> &dyn pprust_hir::PpAnn {
209 self
210 }
211 }
212
213 impl<'hir> pprust_hir::PpAnn for IdentifiedAnnotation<'hir> {
nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested)214 fn nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested) {
215 if let Some(ref tcx) = self.tcx {
216 pprust_hir::PpAnn::nested(&(&tcx.hir() as &dyn hir::intravisit::Map<'_>), state, nested)
217 }
218 }
pre(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>)219 fn pre(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>) {
220 if let pprust_hir::AnnNode::Expr(_) = node {
221 s.popen();
222 }
223 }
post(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>)224 fn post(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>) {
225 match node {
226 pprust_hir::AnnNode::Name(_) => {}
227 pprust_hir::AnnNode::Item(item) => {
228 s.s.space();
229 s.synth_comment(format!("hir_id: {}", item.hir_id()));
230 }
231 pprust_hir::AnnNode::SubItem(id) => {
232 s.s.space();
233 s.synth_comment(id.to_string());
234 }
235 pprust_hir::AnnNode::Block(blk) => {
236 s.s.space();
237 s.synth_comment(format!("block hir_id: {}", blk.hir_id));
238 }
239 pprust_hir::AnnNode::Expr(expr) => {
240 s.s.space();
241 s.synth_comment(format!("expr hir_id: {}", expr.hir_id));
242 s.pclose();
243 }
244 pprust_hir::AnnNode::Pat(pat) => {
245 s.s.space();
246 s.synth_comment(format!("pat hir_id: {}", pat.hir_id));
247 }
248 pprust_hir::AnnNode::Arm(arm) => {
249 s.s.space();
250 s.synth_comment(format!("arm hir_id: {}", arm.hir_id));
251 }
252 }
253 }
254 }
255
256 struct HygieneAnnotation<'a> {
257 sess: &'a Session,
258 }
259
260 impl<'a> PrinterSupport for HygieneAnnotation<'a> {
sess(&self) -> &Session261 fn sess(&self) -> &Session {
262 self.sess
263 }
264
pp_ann(&self) -> &dyn pprust::PpAnn265 fn pp_ann(&self) -> &dyn pprust::PpAnn {
266 self
267 }
268 }
269
270 impl<'a> pprust::PpAnn for HygieneAnnotation<'a> {
post(&self, s: &mut pprust::State<'_>, node: pprust::AnnNode<'_>)271 fn post(&self, s: &mut pprust::State<'_>, node: pprust::AnnNode<'_>) {
272 match node {
273 pprust::AnnNode::Ident(&Ident { name, span }) => {
274 s.s.space();
275 s.synth_comment(format!("{}{:?}", name.as_u32(), span.ctxt()))
276 }
277 pprust::AnnNode::Name(&name) => {
278 s.s.space();
279 s.synth_comment(name.as_u32().to_string())
280 }
281 pprust::AnnNode::Crate(_) => {
282 s.s.hardbreak();
283 let verbose = self.sess.verbose();
284 s.synth_comment(rustc_span::hygiene::debug_hygiene_data(verbose));
285 s.s.hardbreak_if_not_bol();
286 }
287 _ => {}
288 }
289 }
290 }
291
292 struct TypedAnnotation<'tcx> {
293 tcx: TyCtxt<'tcx>,
294 maybe_typeck_results: Cell<Option<&'tcx ty::TypeckResults<'tcx>>>,
295 }
296
297 impl<'tcx> HirPrinterSupport<'tcx> for TypedAnnotation<'tcx> {
sess(&self) -> &Session298 fn sess(&self) -> &Session {
299 self.tcx.sess
300 }
301
hir_map(&self) -> Option<hir_map::Map<'tcx>>302 fn hir_map(&self) -> Option<hir_map::Map<'tcx>> {
303 Some(self.tcx.hir())
304 }
305
pp_ann(&self) -> &dyn pprust_hir::PpAnn306 fn pp_ann(&self) -> &dyn pprust_hir::PpAnn {
307 self
308 }
309 }
310
311 impl<'tcx> pprust_hir::PpAnn for TypedAnnotation<'tcx> {
nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested)312 fn nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested) {
313 let old_maybe_typeck_results = self.maybe_typeck_results.get();
314 if let pprust_hir::Nested::Body(id) = nested {
315 self.maybe_typeck_results.set(Some(self.tcx.typeck_body(id)));
316 }
317 let pp_ann = &(&self.tcx.hir() as &dyn hir::intravisit::Map<'_>);
318 pprust_hir::PpAnn::nested(pp_ann, state, nested);
319 self.maybe_typeck_results.set(old_maybe_typeck_results);
320 }
pre(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>)321 fn pre(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>) {
322 if let pprust_hir::AnnNode::Expr(_) = node {
323 s.popen();
324 }
325 }
post(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>)326 fn post(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>) {
327 if let pprust_hir::AnnNode::Expr(expr) = node {
328 let typeck_results = self.maybe_typeck_results.get().or_else(|| {
329 self.tcx
330 .hir()
331 .maybe_body_owned_by(expr.hir_id.owner.def_id)
332 .map(|body_id| self.tcx.typeck_body(body_id))
333 });
334
335 if let Some(typeck_results) = typeck_results {
336 s.s.space();
337 s.s.word("as");
338 s.s.space();
339 s.s.word(typeck_results.expr_ty(expr).to_string());
340 }
341
342 s.pclose();
343 }
344 }
345 }
346
get_source(sess: &Session) -> (String, FileName)347 fn get_source(sess: &Session) -> (String, FileName) {
348 let src_name = sess.io.input.source_name();
349 let src = String::clone(
350 sess.source_map()
351 .get_source_file(&src_name)
352 .expect("get_source_file")
353 .src
354 .as_ref()
355 .expect("src"),
356 );
357 (src, src_name)
358 }
359
write_or_print(out: &str, sess: &Session)360 fn write_or_print(out: &str, sess: &Session) {
361 match &sess.io.output_file {
362 None | Some(OutFileName::Stdout) => print!("{out}"),
363 Some(OutFileName::Real(p)) => {
364 if let Err(e) = std::fs::write(p, out) {
365 sess.emit_fatal(UnprettyDumpFail {
366 path: p.display().to_string(),
367 err: e.to_string(),
368 });
369 }
370 }
371 }
372 }
373
print_after_parsing(sess: &Session, krate: &ast::Crate, ppm: PpMode)374 pub fn print_after_parsing(sess: &Session, krate: &ast::Crate, ppm: PpMode) {
375 let (src, src_name) = get_source(sess);
376
377 let out = match ppm {
378 Source(s) => {
379 // Silently ignores an identified node.
380 call_with_pp_support(&s, sess, None, move |annotation| {
381 debug!("pretty printing source code {:?}", s);
382 let sess = annotation.sess();
383 let parse = &sess.parse_sess;
384 pprust::print_crate(
385 sess.source_map(),
386 krate,
387 src_name,
388 src,
389 annotation.pp_ann(),
390 false,
391 parse.edition,
392 &sess.parse_sess.attr_id_generator,
393 )
394 })
395 }
396 AstTree(PpAstTreeMode::Normal) => {
397 debug!("pretty printing AST tree");
398 format!("{krate:#?}")
399 }
400 _ => unreachable!(),
401 };
402
403 write_or_print(&out, sess);
404 }
405
print_after_hir_lowering<'tcx>(tcx: TyCtxt<'tcx>, ppm: PpMode)406 pub fn print_after_hir_lowering<'tcx>(tcx: TyCtxt<'tcx>, ppm: PpMode) {
407 if ppm.needs_analysis() {
408 abort_on_err(print_with_analysis(tcx, ppm), tcx.sess);
409 return;
410 }
411
412 let (src, src_name) = get_source(tcx.sess);
413
414 let out = match ppm {
415 Source(s) => {
416 // Silently ignores an identified node.
417 call_with_pp_support(&s, tcx.sess, Some(tcx), move |annotation| {
418 debug!("pretty printing source code {:?}", s);
419 let sess = annotation.sess();
420 let parse = &sess.parse_sess;
421 pprust::print_crate(
422 sess.source_map(),
423 &tcx.resolver_for_lowering(()).borrow().1,
424 src_name,
425 src,
426 annotation.pp_ann(),
427 true,
428 parse.edition,
429 &sess.parse_sess.attr_id_generator,
430 )
431 })
432 }
433
434 AstTree(PpAstTreeMode::Expanded) => {
435 debug!("pretty-printing expanded AST");
436 format!("{:#?}", tcx.resolver_for_lowering(()).borrow().1)
437 }
438
439 Hir(s) => call_with_pp_support_hir(&s, tcx, move |annotation, hir_map| {
440 debug!("pretty printing HIR {:?}", s);
441 let sess = annotation.sess();
442 let sm = sess.source_map();
443 let attrs = |id| hir_map.attrs(id);
444 pprust_hir::print_crate(
445 sm,
446 hir_map.root_module(),
447 src_name,
448 src,
449 &attrs,
450 annotation.pp_ann(),
451 )
452 }),
453
454 HirTree => {
455 call_with_pp_support_hir(&PpHirMode::Normal, tcx, move |_annotation, hir_map| {
456 debug!("pretty printing HIR tree");
457 format!("{:#?}", hir_map.krate())
458 })
459 }
460
461 _ => unreachable!(),
462 };
463
464 write_or_print(&out, tcx.sess);
465 }
466
467 // In an ideal world, this would be a public function called by the driver after
468 // analysis is performed. However, we want to call `phase_3_run_analysis_passes`
469 // with a different callback than the standard driver, so that isn't easy.
470 // Instead, we call that function ourselves.
print_with_analysis(tcx: TyCtxt<'_>, ppm: PpMode) -> Result<(), ErrorGuaranteed>471 fn print_with_analysis(tcx: TyCtxt<'_>, ppm: PpMode) -> Result<(), ErrorGuaranteed> {
472 tcx.analysis(())?;
473 let out = match ppm {
474 Mir => {
475 let mut out = Vec::new();
476 write_mir_pretty(tcx, None, &mut out).unwrap();
477 String::from_utf8(out).unwrap()
478 }
479
480 MirCFG => {
481 let mut out = Vec::new();
482 write_mir_graphviz(tcx, None, &mut out).unwrap();
483 String::from_utf8(out).unwrap()
484 }
485
486 ThirTree => {
487 let mut out = String::new();
488 abort_on_err(rustc_hir_analysis::check_crate(tcx), tcx.sess);
489 debug!("pretty printing THIR tree");
490 for did in tcx.hir().body_owners() {
491 let _ = writeln!(out, "{:?}:\n{}\n", did, tcx.thir_tree(did));
492 }
493 out
494 }
495
496 ThirFlat => {
497 let mut out = String::new();
498 abort_on_err(rustc_hir_analysis::check_crate(tcx), tcx.sess);
499 debug!("pretty printing THIR flat");
500 for did in tcx.hir().body_owners() {
501 let _ = writeln!(out, "{:?}:\n{}\n", did, tcx.thir_flat(did));
502 }
503 out
504 }
505
506 _ => unreachable!(),
507 };
508
509 write_or_print(&out, tcx.sess);
510
511 Ok(())
512 }
513