5 use crate::pp::Breaks::{Consistent, Inconsistent};
6 use crate::pp::{self, Breaks};
9 use rustc_ast::token::{self, BinOpToken, CommentKind, Delimiter, Nonterminal, Token, TokenKind};
10 use rustc_ast::tokenstream::{TokenStream, TokenTree};
11 use rustc_ast::util::classify;
12 use rustc_ast::util::comments::{gather_comments, Comment, CommentStyle};
13 use rustc_ast::util::parser;
14 use rustc_ast::{self as ast, BlockCheckMode, PatKind, RangeEnd, RangeSyntax};
15 use rustc_ast::{attr, Term};
16 use rustc_ast::{GenericArg, MacArgs, MacArgsEq};
17 use rustc_ast::{GenericBound, SelfKind, TraitBoundModifier};
18 use rustc_ast::{InlineAsmOperand, InlineAsmRegOrRegClass};
19 use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece};
20 use rustc_span::edition::Edition;
21 use rustc_span::source_map::{SourceMap, Spanned};
22 use rustc_span::symbol::{kw, sym, Ident, IdentPrinter, Symbol};
23 use rustc_span::{BytePos, FileName, Span};
27 pub use self::delimited::IterDelimited;
29 pub enum MacHeader<'a> {
31 Keyword(&'static str),
34 pub enum AnnNode<'a> {
37 Block(&'a ast::Block),
42 Crate(&'a ast::Crate),
46 fn pre(&self, _state: &mut State<'_>, _node: AnnNode<'_>) {}
47 fn post(&self, _state: &mut State<'_>, _node: AnnNode<'_>) {}
50 #[derive(Copy, Clone)]
53 impl PpAnn for NoAnn {}
55 pub struct Comments<'a> {
57 comments: Vec<Comment>,
61 impl<'a> Comments<'a> {
62 pub fn new(sm: &'a SourceMap, filename: FileName, input: String) -> Comments<'a> {
63 let comments = gather_comments(sm, filename, input);
64 Comments { sm, comments, current: 0 }
67 pub fn next(&self) -> Option<Comment> {
68 self.comments.get(self.current).cloned()
71 pub fn trailing_comment(
73 span: rustc_span::Span,
74 next_pos: Option<BytePos>,
75 ) -> Option<Comment> {
76 if let Some(cmnt) = self.next() {
77 if cmnt.style != CommentStyle::Trailing {
80 let span_line = self.sm.lookup_char_pos(span.hi());
81 let comment_line = self.sm.lookup_char_pos(cmnt.pos);
82 let next = next_pos.unwrap_or_else(|| cmnt.pos + BytePos(1));
83 if span.hi() < cmnt.pos && cmnt.pos < next && span_line.line == comment_line.line {
92 pub struct State<'a> {
94 comments: Option<Comments<'a>>,
95 ann: &'a (dyn PpAnn + 'a),
98 pub(crate) const INDENT_UNIT: isize = 4;
100 /// Requires you to pass an input filename and reader so that
101 /// it can scan the input text for comments to copy forward.
102 pub fn print_crate<'a>(
112 State { s: pp::Printer::new(), comments: Some(Comments::new(sm, filename, input)), ann };
114 if is_expanded && !krate.attrs.iter().any(|attr| attr.has_name(sym::no_core)) {
115 // We need to print `#![no_std]` (and its feature gate) so that
116 // compiling pretty-printed source won't inject libstd again.
117 // However, we don't want these attributes in the AST because
118 // of the feature gate, so we fake them up here.
120 // `#![feature(prelude_import)]`
121 let pi_nested = attr::mk_nested_word_item(Ident::with_dummy_span(sym::prelude_import));
122 let list = attr::mk_list_item(Ident::with_dummy_span(sym::feature), vec![pi_nested]);
123 let fake_attr = attr::mk_attr_inner(list);
124 s.print_attribute(&fake_attr);
126 // Currently, in Rust 2018 we don't have `extern crate std;` at the crate
127 // root, so this is not needed, and actually breaks things.
128 if edition == Edition::Edition2015 {
130 let no_std_meta = attr::mk_word_item(Ident::with_dummy_span(sym::no_std));
131 let fake_attr = attr::mk_attr_inner(no_std_meta);
132 s.print_attribute(&fake_attr);
136 s.print_inner_attributes(&krate.attrs);
137 for item in &krate.items {
140 s.print_remaining_comments();
141 s.ann.post(&mut s, AnnNode::Crate(krate));
145 /// This makes printed token streams look slightly nicer,
146 /// and also addresses some specific regressions described in #63896 and #73345.
147 fn tt_prepend_space(tt: &TokenTree, prev: &TokenTree) -> bool {
148 if let TokenTree::Token(token) = prev {
149 if matches!(token.kind, token::Dot | token::Dollar) {
152 if let token::DocComment(comment_kind, ..) = token.kind {
153 return comment_kind != CommentKind::Line;
157 TokenTree::Token(token) => !matches!(token.kind, token::Comma | token::Not | token::Dot),
158 TokenTree::Delimited(_, Delimiter::Parenthesis, _) => {
159 !matches!(prev, TokenTree::Token(Token { kind: token::Ident(..), .. }))
161 TokenTree::Delimited(_, Delimiter::Bracket, _) => {
162 !matches!(prev, TokenTree::Token(Token { kind: token::Pound, .. }))
164 TokenTree::Delimited(..) => true,
168 fn binop_to_string(op: BinOpToken) -> &'static str {
174 token::Percent => "%",
183 fn doc_comment_to_string(
184 comment_kind: CommentKind,
185 attr_style: ast::AttrStyle,
188 match (comment_kind, attr_style) {
189 (CommentKind::Line, ast::AttrStyle::Outer) => format!("///{}", data),
190 (CommentKind::Line, ast::AttrStyle::Inner) => format!("//!{}", data),
191 (CommentKind::Block, ast::AttrStyle::Outer) => format!("/**{}*/", data),
192 (CommentKind::Block, ast::AttrStyle::Inner) => format!("/*!{}*/", data),
196 pub fn literal_to_string(lit: token::Lit) -> String {
197 let token::Lit { kind, symbol, suffix } = lit;
198 let mut out = match kind {
199 token::Byte => format!("b'{}'", symbol),
200 token::Char => format!("'{}'", symbol),
201 token::Str => format!("\"{}\"", symbol),
202 token::StrRaw(n) => {
203 format!("r{delim}\"{string}\"{delim}", delim = "#".repeat(n as usize), string = symbol)
205 token::ByteStr => format!("b\"{}\"", symbol),
206 token::ByteStrRaw(n) => {
207 format!("br{delim}\"{string}\"{delim}", delim = "#".repeat(n as usize), string = symbol)
209 token::Integer | token::Float | token::Bool | token::Err => symbol.to_string(),
212 if let Some(suffix) = suffix {
213 out.push_str(suffix.as_str())
219 impl std::ops::Deref for State<'_> {
220 type Target = pp::Printer;
221 fn deref(&self) -> &Self::Target {
226 impl std::ops::DerefMut for State<'_> {
227 fn deref_mut(&mut self) -> &mut Self::Target {
232 pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::DerefMut {
233 fn comments(&mut self) -> &mut Option<Comments<'a>>;
234 fn print_ident(&mut self, ident: Ident);
235 fn print_generic_args(&mut self, args: &ast::GenericArgs, colons_before_params: bool);
245 F: FnMut(&mut Self, &T),
248 if let Some((first, rest)) = elts.split_first() {
254 self.word_space(sep);
261 fn commasep<T, F>(&mut self, b: Breaks, elts: &[T], op: F)
263 F: FnMut(&mut Self, &T),
265 self.strsep(",", false, b, elts, op)
268 fn maybe_print_comment(&mut self, pos: BytePos) -> bool {
269 let mut has_comment = false;
270 while let Some(ref cmnt) = self.next_comment() {
273 self.print_comment(cmnt);
281 fn print_comment(&mut self, cmnt: &Comment) {
283 CommentStyle::Mixed => {
284 if !self.is_beginning_of_line() {
287 if let Some((last, lines)) = cmnt.lines.split_last() {
291 self.word(line.clone());
295 self.word(last.clone());
302 CommentStyle::Isolated => {
303 self.hardbreak_if_not_bol();
304 for line in &cmnt.lines {
305 // Don't print empty lines because they will end up as trailing
307 if !line.is_empty() {
308 self.word(line.clone());
313 CommentStyle::Trailing => {
314 if !self.is_beginning_of_line() {
317 if cmnt.lines.len() == 1 {
318 self.word(cmnt.lines[0].clone());
322 for line in &cmnt.lines {
323 if !line.is_empty() {
324 self.word(line.clone());
331 CommentStyle::BlankLine => {
332 // We need to do at least one, possibly two hardbreaks.
333 let twice = match self.last_token() {
334 Some(pp::Token::String(s)) => ";" == s,
335 Some(pp::Token::Begin(_)) => true,
336 Some(pp::Token::End) => true,
345 if let Some(cmnts) = self.comments() {
350 fn next_comment(&mut self) -> Option<Comment> {
351 self.comments().as_mut().and_then(|c| c.next())
354 fn maybe_print_trailing_comment(&mut self, span: rustc_span::Span, next_pos: Option<BytePos>) {
355 if let Some(cmnts) = self.comments() {
356 if let Some(cmnt) = cmnts.trailing_comment(span, next_pos) {
357 self.print_comment(&cmnt);
362 fn print_remaining_comments(&mut self) {
363 // If there aren't any remaining comments, then we need to manually
364 // make sure there is a line break at the end.
365 if self.next_comment().is_none() {
368 while let Some(ref cmnt) = self.next_comment() {
369 self.print_comment(cmnt)
373 fn print_literal(&mut self, lit: &ast::Lit) {
374 self.maybe_print_comment(lit.span.lo());
375 self.word(lit.token.to_string())
378 fn print_string(&mut self, st: &str, style: ast::StrStyle) {
379 let st = match style {
380 ast::StrStyle::Cooked => (format!("\"{}\"", st.escape_debug())),
381 ast::StrStyle::Raw(n) => {
382 format!("r{delim}\"{string}\"{delim}", delim = "#".repeat(n as usize), string = st)
388 fn print_symbol(&mut self, sym: Symbol, style: ast::StrStyle) {
389 self.print_string(sym.as_str(), style);
392 fn print_inner_attributes(&mut self, attrs: &[ast::Attribute]) -> bool {
393 self.print_either_attributes(attrs, ast::AttrStyle::Inner, false, true)
396 fn print_inner_attributes_no_trailing_hardbreak(&mut self, attrs: &[ast::Attribute]) -> bool {
397 self.print_either_attributes(attrs, ast::AttrStyle::Inner, false, false)
400 fn print_outer_attributes(&mut self, attrs: &[ast::Attribute]) -> bool {
401 self.print_either_attributes(attrs, ast::AttrStyle::Outer, false, true)
404 fn print_inner_attributes_inline(&mut self, attrs: &[ast::Attribute]) -> bool {
405 self.print_either_attributes(attrs, ast::AttrStyle::Inner, true, true)
408 fn print_outer_attributes_inline(&mut self, attrs: &[ast::Attribute]) -> bool {
409 self.print_either_attributes(attrs, ast::AttrStyle::Outer, true, true)
412 fn print_either_attributes(
414 attrs: &[ast::Attribute],
415 kind: ast::AttrStyle,
417 trailing_hardbreak: bool,
419 let mut printed = false;
421 if attr.style == kind {
422 self.print_attribute_inline(attr, is_inline);
429 if printed && trailing_hardbreak && !is_inline {
430 self.hardbreak_if_not_bol();
435 fn print_attribute(&mut self, attr: &ast::Attribute) {
436 self.print_attribute_inline(attr, false)
439 fn print_attribute_inline(&mut self, attr: &ast::Attribute, is_inline: bool) {
441 self.hardbreak_if_not_bol();
443 self.maybe_print_comment(attr.span.lo());
445 ast::AttrKind::Normal(ref item, _) => {
447 ast::AttrStyle::Inner => self.word("#!["),
448 ast::AttrStyle::Outer => self.word("#["),
450 self.print_attr_item(&item, attr.span);
453 ast::AttrKind::DocComment(comment_kind, data) => {
454 self.word(doc_comment_to_string(comment_kind, attr.style, data));
460 fn print_attr_item(&mut self, item: &ast::AttrItem, span: Span) {
463 MacArgs::Delimited(_, delim, tokens) => self.print_mac_common(
464 Some(MacHeader::Path(&item.path)),
467 Some(delim.to_token()),
473 self.print_path(&item.path, false, 0);
475 MacArgs::Eq(_, MacArgsEq::Ast(expr)) => {
476 self.print_path(&item.path, false, 0);
478 self.word_space("=");
479 let token_str = self.expr_to_string(expr);
480 self.word(token_str);
482 MacArgs::Eq(_, MacArgsEq::Hir(lit)) => {
483 self.print_path(&item.path, false, 0);
485 self.word_space("=");
486 let token_str = self.literal_to_string(lit);
487 self.word(token_str);
493 fn print_meta_list_item(&mut self, item: &ast::NestedMetaItem) {
495 ast::NestedMetaItem::MetaItem(ref mi) => self.print_meta_item(mi),
496 ast::NestedMetaItem::Literal(ref lit) => self.print_literal(lit),
500 fn print_meta_item(&mut self, item: &ast::MetaItem) {
501 self.ibox(INDENT_UNIT);
503 ast::MetaItemKind::Word => self.print_path(&item.path, false, 0),
504 ast::MetaItemKind::NameValue(ref value) => {
505 self.print_path(&item.path, false, 0);
507 self.word_space("=");
508 self.print_literal(value);
510 ast::MetaItemKind::List(ref items) => {
511 self.print_path(&item.path, false, 0);
513 self.commasep(Consistent, &items, |s, i| s.print_meta_list_item(i));
520 /// This doesn't deserve to be called "pretty" printing, but it should be
521 /// meaning-preserving. A quick hack that might help would be to look at the
522 /// spans embedded in the TTs to decide where to put spaces and newlines.
523 /// But it'd be better to parse these according to the grammar of the
524 /// appropriate macro, transcribe back into the grammar we just parsed from,
525 /// and then pretty-print the resulting AST nodes (so, e.g., we print
526 /// expression arguments as expressions). It can be done! I think.
527 fn print_tt(&mut self, tt: &TokenTree, convert_dollar_crate: bool) {
529 TokenTree::Token(token) => {
530 let token_str = self.token_to_string_ext(&token, convert_dollar_crate);
531 self.word(token_str);
532 if let token::DocComment(..) = token.kind {
536 TokenTree::Delimited(dspan, delim, tts) => {
537 self.print_mac_common(
543 convert_dollar_crate,
550 fn print_tts(&mut self, tts: &TokenStream, convert_dollar_crate: bool) {
551 let mut iter = tts.trees().peekable();
552 while let Some(tt) = iter.next() {
553 self.print_tt(tt, convert_dollar_crate);
554 if let Some(next) = iter.peek() {
555 if tt_prepend_space(next, tt) {
564 header: Option<MacHeader<'_>>,
566 ident: Option<Ident>,
567 delim: Option<Delimiter>,
569 convert_dollar_crate: bool,
572 if delim == Some(Delimiter::Brace) {
573 self.cbox(INDENT_UNIT);
576 Some(MacHeader::Path(path)) => self.print_path(path, false, 0),
577 Some(MacHeader::Keyword(kw)) => self.word(kw),
583 if let Some(ident) = ident {
585 self.print_ident(ident);
588 Some(Delimiter::Brace) => {
589 if header.is_some() || has_bang || ident.is_some() {
597 self.print_tts(tts, convert_dollar_crate);
599 let empty = tts.is_empty();
600 self.bclose(span, empty);
603 let token_str = self.token_kind_to_string(&token::OpenDelim(delim));
604 self.word(token_str);
606 self.print_tts(tts, convert_dollar_crate);
608 let token_str = self.token_kind_to_string(&token::CloseDelim(delim));
609 self.word(token_str);
613 self.print_tts(tts, convert_dollar_crate);
621 macro_def: &ast::MacroDef,
624 print_visibility: impl FnOnce(&mut Self),
626 let (kw, has_bang) = if macro_def.macro_rules {
627 ("macro_rules", true)
629 print_visibility(self);
632 self.print_mac_common(
633 Some(MacHeader::Keyword(kw)),
636 macro_def.body.delim(),
637 ¯o_def.body.inner_tokens(),
641 if macro_def.body.need_semicolon() {
646 fn print_path(&mut self, path: &ast::Path, colons_before_params: bool, depth: usize) {
647 self.maybe_print_comment(path.span.lo());
649 for (i, segment) in path.segments[..path.segments.len() - depth].iter().enumerate() {
653 self.print_path_segment(segment, colons_before_params);
657 fn print_path_segment(&mut self, segment: &ast::PathSegment, colons_before_params: bool) {
658 if segment.ident.name != kw::PathRoot {
659 self.print_ident(segment.ident);
660 if let Some(ref args) = segment.args {
661 self.print_generic_args(args, colons_before_params);
666 fn head<S: Into<Cow<'static, str>>>(&mut self, w: S) {
668 // Outer-box is consistent.
669 self.cbox(INDENT_UNIT);
670 // Head-box is inconsistent.
672 // Keyword that starts the head.
678 fn bopen(&mut self) {
680 self.end(); // Close the head-box.
683 fn bclose_maybe_open(&mut self, span: rustc_span::Span, empty: bool, close_box: bool) {
684 let has_comment = self.maybe_print_comment(span.hi());
685 if !empty || has_comment {
686 self.break_offset_if_not_bol(1, -(INDENT_UNIT as isize));
690 self.end(); // Close the outer-box.
694 fn bclose(&mut self, span: rustc_span::Span, empty: bool) {
695 let close_box = true;
696 self.bclose_maybe_open(span, empty, close_box)
699 fn break_offset_if_not_bol(&mut self, n: usize, off: isize) {
700 if !self.is_beginning_of_line() {
701 self.break_offset(n, off)
703 if let Some(last_token) = self.last_token_still_buffered() {
704 if last_token.is_hardbreak_tok() {
705 // We do something pretty sketchy here: tuck the nonzero
706 // offset-adjustment we were going to deposit along with the
707 // break into the previous hardbreak.
708 self.replace_last_token_still_buffered(pp::Printer::hardbreak_tok_offset(off));
714 fn nonterminal_to_string(&self, nt: &Nonterminal) -> String {
716 token::NtExpr(ref e) => self.expr_to_string(e),
717 token::NtMeta(ref e) => self.attr_item_to_string(e),
718 token::NtTy(ref e) => self.ty_to_string(e),
719 token::NtPath(ref e) => self.path_to_string(e),
720 token::NtItem(ref e) => self.item_to_string(e),
721 token::NtBlock(ref e) => self.block_to_string(e),
722 token::NtStmt(ref e) => self.stmt_to_string(e),
723 token::NtPat(ref e) => self.pat_to_string(e),
724 token::NtIdent(e, is_raw) => IdentPrinter::for_ast_ident(e, is_raw).to_string(),
725 token::NtLifetime(e) => e.to_string(),
726 token::NtLiteral(ref e) => self.expr_to_string(e),
727 token::NtVis(ref e) => self.vis_to_string(e),
731 /// Print the token kind precisely, without converting `$crate` into its respective crate name.
732 fn token_kind_to_string(&self, tok: &TokenKind) -> Cow<'static, str> {
733 self.token_kind_to_string_ext(tok, None)
736 fn token_kind_to_string_ext(
739 convert_dollar_crate: Option<Span>,
740 ) -> Cow<'static, str> {
742 token::Eq => "=".into(),
743 token::Lt => "<".into(),
744 token::Le => "<=".into(),
745 token::EqEq => "==".into(),
746 token::Ne => "!=".into(),
747 token::Ge => ">=".into(),
748 token::Gt => ">".into(),
749 token::Not => "!".into(),
750 token::Tilde => "~".into(),
751 token::OrOr => "||".into(),
752 token::AndAnd => "&&".into(),
753 token::BinOp(op) => binop_to_string(op).into(),
754 token::BinOpEq(op) => format!("{}=", binop_to_string(op)).into(),
756 /* Structural symbols */
757 token::At => "@".into(),
758 token::Dot => ".".into(),
759 token::DotDot => "..".into(),
760 token::DotDotDot => "...".into(),
761 token::DotDotEq => "..=".into(),
762 token::Comma => ",".into(),
763 token::Semi => ";".into(),
764 token::Colon => ":".into(),
765 token::ModSep => "::".into(),
766 token::RArrow => "->".into(),
767 token::LArrow => "<-".into(),
768 token::FatArrow => "=>".into(),
769 token::OpenDelim(Delimiter::Parenthesis) => "(".into(),
770 token::CloseDelim(Delimiter::Parenthesis) => ")".into(),
771 token::OpenDelim(Delimiter::Bracket) => "[".into(),
772 token::CloseDelim(Delimiter::Bracket) => "]".into(),
773 token::OpenDelim(Delimiter::Brace) => "{".into(),
774 token::CloseDelim(Delimiter::Brace) => "}".into(),
775 token::OpenDelim(Delimiter::Invisible) | token::CloseDelim(Delimiter::Invisible) => {
778 token::Pound => "#".into(),
779 token::Dollar => "$".into(),
780 token::Question => "?".into(),
781 token::SingleQuote => "'".into(),
784 token::Literal(lit) => literal_to_string(lit).into(),
786 /* Name components */
787 token::Ident(s, is_raw) => {
788 IdentPrinter::new(s, is_raw, convert_dollar_crate).to_string().into()
790 token::Lifetime(s) => s.to_string().into(),
793 token::DocComment(comment_kind, attr_style, data) => {
794 doc_comment_to_string(comment_kind, attr_style, data).into()
796 token::Eof => "<eof>".into(),
798 token::Interpolated(ref nt) => self.nonterminal_to_string(nt).into(),
802 /// Print the token precisely, without converting `$crate` into its respective crate name.
803 fn token_to_string(&self, token: &Token) -> Cow<'static, str> {
804 self.token_to_string_ext(token, false)
807 fn token_to_string_ext(&self, token: &Token, convert_dollar_crate: bool) -> Cow<'static, str> {
808 let convert_dollar_crate = convert_dollar_crate.then_some(token.span);
809 self.token_kind_to_string_ext(&token.kind, convert_dollar_crate)
812 fn ty_to_string(&self, ty: &ast::Ty) -> String {
813 Self::to_string(|s| s.print_type(ty))
816 fn bounds_to_string(&self, bounds: &[ast::GenericBound]) -> String {
817 Self::to_string(|s| s.print_type_bounds(bounds))
820 fn pat_to_string(&self, pat: &ast::Pat) -> String {
821 Self::to_string(|s| s.print_pat(pat))
824 fn expr_to_string(&self, e: &ast::Expr) -> String {
825 Self::to_string(|s| s.print_expr(e))
828 fn literal_to_string(&self, lit: &ast::Lit) -> String {
829 Self::to_string(|s| s.print_literal(lit))
832 fn tt_to_string(&self, tt: &TokenTree) -> String {
833 Self::to_string(|s| s.print_tt(tt, false))
836 fn tts_to_string(&self, tokens: &TokenStream) -> String {
837 Self::to_string(|s| s.print_tts(tokens, false))
840 fn stmt_to_string(&self, stmt: &ast::Stmt) -> String {
841 Self::to_string(|s| s.print_stmt(stmt))
844 fn item_to_string(&self, i: &ast::Item) -> String {
845 Self::to_string(|s| s.print_item(i))
848 fn assoc_item_to_string(&self, i: &ast::AssocItem) -> String {
849 Self::to_string(|s| s.print_assoc_item(i))
852 fn foreign_item_to_string(&self, i: &ast::ForeignItem) -> String {
853 Self::to_string(|s| s.print_foreign_item(i))
856 fn generic_params_to_string(&self, generic_params: &[ast::GenericParam]) -> String {
857 Self::to_string(|s| s.print_generic_params(generic_params))
860 fn path_to_string(&self, p: &ast::Path) -> String {
861 Self::to_string(|s| s.print_path(p, false, 0))
864 fn path_segment_to_string(&self, p: &ast::PathSegment) -> String {
865 Self::to_string(|s| s.print_path_segment(p, false))
868 fn vis_to_string(&self, v: &ast::Visibility) -> String {
869 Self::to_string(|s| s.print_visibility(v))
872 fn block_to_string(&self, blk: &ast::Block) -> String {
873 Self::to_string(|s| {
874 // Containing cbox, will be closed by `print_block` at `}`.
876 // Head-ibox, will be closed by `print_block` after `{`.
882 fn meta_list_item_to_string(&self, li: &ast::NestedMetaItem) -> String {
883 Self::to_string(|s| s.print_meta_list_item(li))
886 fn attr_item_to_string(&self, ai: &ast::AttrItem) -> String {
887 Self::to_string(|s| s.print_attr_item(ai, ai.path.span))
890 fn attribute_to_string(&self, attr: &ast::Attribute) -> String {
891 Self::to_string(|s| s.print_attribute(attr))
894 fn param_to_string(&self, arg: &ast::Param) -> String {
895 Self::to_string(|s| s.print_param(arg, false))
898 fn to_string(f: impl FnOnce(&mut State<'_>)) -> String {
899 let mut printer = State::new();
905 impl<'a> PrintState<'a> for State<'a> {
906 fn comments(&mut self) -> &mut Option<Comments<'a>> {
910 fn print_ident(&mut self, ident: Ident) {
911 self.word(IdentPrinter::for_ast_ident(ident, ident.is_raw_guess()).to_string());
912 self.ann.post(self, AnnNode::Ident(&ident))
915 fn print_generic_args(&mut self, args: &ast::GenericArgs, colons_before_params: bool) {
916 if colons_before_params {
921 ast::GenericArgs::AngleBracketed(ref data) => {
923 self.commasep(Inconsistent, &data.args, |s, arg| match arg {
924 ast::AngleBracketedArg::Arg(a) => s.print_generic_arg(a),
925 ast::AngleBracketedArg::Constraint(c) => s.print_assoc_constraint(c),
930 ast::GenericArgs::Parenthesized(ref data) => {
932 self.commasep(Inconsistent, &data.inputs, |s, ty| s.print_type(ty));
934 self.print_fn_ret_ty(&data.output);
941 pub fn new() -> State<'a> {
942 State { s: pp::Printer::new(), comments: None, ann: &NoAnn }
945 pub(crate) fn commasep_cmnt<T, F, G>(
952 F: FnMut(&mut State<'_>, &T),
953 G: FnMut(&T) -> rustc_span::Span,
956 let len = elts.len();
959 self.maybe_print_comment(get_span(elt).hi());
964 self.maybe_print_trailing_comment(get_span(elt), Some(get_span(&elts[i]).hi()));
965 self.space_if_not_bol();
971 pub(crate) fn commasep_exprs(&mut self, b: Breaks, exprs: &[P<ast::Expr>]) {
972 self.commasep_cmnt(b, exprs, |s, e| s.print_expr(e), |e| e.span)
975 pub fn print_opt_lifetime(&mut self, lifetime: &Option<ast::Lifetime>) {
976 if let Some(lt) = *lifetime {
977 self.print_lifetime(lt);
982 pub fn print_assoc_constraint(&mut self, constraint: &ast::AssocConstraint) {
983 self.print_ident(constraint.ident);
984 constraint.gen_args.as_ref().map(|args| self.print_generic_args(args, false));
986 match &constraint.kind {
987 ast::AssocConstraintKind::Equality { term } => {
988 self.word_space("=");
990 Term::Ty(ty) => self.print_type(ty),
991 Term::Const(c) => self.print_expr_anon_const(c, &[]),
994 ast::AssocConstraintKind::Bound { bounds } => {
995 if !bounds.is_empty() {
997 self.print_type_bounds(&bounds);
1003 pub fn print_generic_arg(&mut self, generic_arg: &GenericArg) {
1005 GenericArg::Lifetime(lt) => self.print_lifetime(*lt),
1006 GenericArg::Type(ty) => self.print_type(ty),
1007 GenericArg::Const(ct) => self.print_expr(&ct.value),
1011 pub fn print_type(&mut self, ty: &ast::Ty) {
1012 self.maybe_print_comment(ty.span.lo());
1015 ast::TyKind::Slice(ref ty) => {
1017 self.print_type(ty);
1020 ast::TyKind::Ptr(ref mt) => {
1022 self.print_mt(mt, true);
1024 ast::TyKind::Rptr(ref lifetime, ref mt) => {
1026 self.print_opt_lifetime(lifetime);
1027 self.print_mt(mt, false);
1029 ast::TyKind::Never => {
1032 ast::TyKind::Tup(ref elts) => {
1034 self.commasep(Inconsistent, &elts, |s, ty| s.print_type(ty));
1035 if elts.len() == 1 {
1040 ast::TyKind::Paren(ref typ) => {
1042 self.print_type(typ);
1045 ast::TyKind::BareFn(ref f) => {
1046 self.print_ty_fn(f.ext, f.unsafety, &f.decl, None, &f.generic_params);
1048 ast::TyKind::Path(None, ref path) => {
1049 self.print_path(path, false, 0);
1051 ast::TyKind::Path(Some(ref qself), ref path) => self.print_qpath(path, qself, false),
1052 ast::TyKind::TraitObject(ref bounds, syntax) => {
1053 if syntax == ast::TraitObjectSyntax::Dyn {
1054 self.word_nbsp("dyn");
1056 self.print_type_bounds(bounds);
1058 ast::TyKind::ImplTrait(_, ref bounds) => {
1059 self.word_nbsp("impl");
1060 self.print_type_bounds(bounds);
1062 ast::TyKind::Array(ref ty, ref length) => {
1064 self.print_type(ty);
1066 self.print_expr(&length.value);
1069 ast::TyKind::Typeof(ref e) => {
1070 self.word("typeof(");
1071 self.print_expr(&e.value);
1074 ast::TyKind::Infer => {
1077 ast::TyKind::Err => {
1079 self.word("/*ERROR*/");
1082 ast::TyKind::ImplicitSelf => {
1085 ast::TyKind::MacCall(ref m) => {
1088 ast::TyKind::CVarArgs => {
1095 fn print_trait_ref(&mut self, t: &ast::TraitRef) {
1096 self.print_path(&t.path, false, 0)
1099 fn print_formal_generic_params(&mut self, generic_params: &[ast::GenericParam]) {
1100 if !generic_params.is_empty() {
1102 self.print_generic_params(generic_params);
1107 fn print_poly_trait_ref(&mut self, t: &ast::PolyTraitRef) {
1108 self.print_formal_generic_params(&t.bound_generic_params);
1109 self.print_trait_ref(&t.trait_ref)
1112 pub(crate) fn print_stmt(&mut self, st: &ast::Stmt) {
1113 self.maybe_print_comment(st.span.lo());
1115 ast::StmtKind::Local(ref loc) => {
1116 self.print_outer_attributes(&loc.attrs);
1117 self.space_if_not_bol();
1118 self.ibox(INDENT_UNIT);
1119 self.word_nbsp("let");
1121 self.ibox(INDENT_UNIT);
1122 self.print_local_decl(loc);
1124 if let Some((init, els)) = loc.kind.init_else_opt() {
1126 self.word_space("=");
1127 self.print_expr(init);
1128 if let Some(els) = els {
1129 self.cbox(INDENT_UNIT);
1130 self.ibox(INDENT_UNIT);
1131 self.word(" else ");
1132 self.print_block(els);
1136 self.end(); // `let` ibox
1138 ast::StmtKind::Item(ref item) => self.print_item(item),
1139 ast::StmtKind::Expr(ref expr) => {
1140 self.space_if_not_bol();
1141 self.print_expr_outer_attr_style(expr, false);
1142 if classify::expr_requires_semi_to_be_stmt(expr) {
1146 ast::StmtKind::Semi(ref expr) => {
1147 self.space_if_not_bol();
1148 self.print_expr_outer_attr_style(expr, false);
1151 ast::StmtKind::Empty => {
1152 self.space_if_not_bol();
1155 ast::StmtKind::MacCall(ref mac) => {
1156 self.space_if_not_bol();
1157 self.print_outer_attributes(&mac.attrs);
1158 self.print_mac(&mac.mac);
1159 if mac.style == ast::MacStmtStyle::Semicolon {
1164 self.maybe_print_trailing_comment(st.span, None)
1167 pub(crate) fn print_block(&mut self, blk: &ast::Block) {
1168 self.print_block_with_attrs(blk, &[])
1171 pub(crate) fn print_block_unclosed_indent(&mut self, blk: &ast::Block) {
1172 self.print_block_maybe_unclosed(blk, &[], false)
1175 pub(crate) fn print_block_with_attrs(&mut self, blk: &ast::Block, attrs: &[ast::Attribute]) {
1176 self.print_block_maybe_unclosed(blk, attrs, true)
1179 pub(crate) fn print_block_maybe_unclosed(
1182 attrs: &[ast::Attribute],
1186 BlockCheckMode::Unsafe(..) => self.word_space("unsafe"),
1187 BlockCheckMode::Default => (),
1189 self.maybe_print_comment(blk.span.lo());
1190 self.ann.pre(self, AnnNode::Block(blk));
1193 let has_attrs = self.print_inner_attributes(attrs);
1195 for (i, st) in blk.stmts.iter().enumerate() {
1197 ast::StmtKind::Expr(ref expr) if i == blk.stmts.len() - 1 => {
1198 self.maybe_print_comment(st.span.lo());
1199 self.space_if_not_bol();
1200 self.print_expr_outer_attr_style(expr, false);
1201 self.maybe_print_trailing_comment(expr.span, Some(blk.span.hi()));
1203 _ => self.print_stmt(st),
1207 let empty = !has_attrs && blk.stmts.is_empty();
1208 self.bclose_maybe_open(blk.span, empty, close_box);
1209 self.ann.post(self, AnnNode::Block(blk))
1212 /// Print a `let pat = expr` expression.
1213 pub(crate) fn print_let(&mut self, pat: &ast::Pat, expr: &ast::Expr) {
1215 self.print_pat(pat);
1217 self.word_space("=");
1218 let npals = || parser::needs_par_as_let_scrutinee(expr.precedence().order());
1219 self.print_expr_cond_paren(expr, Self::cond_needs_par(expr) || npals())
1222 pub(crate) fn print_mac(&mut self, m: &ast::MacCall) {
1223 self.print_mac_common(
1224 Some(MacHeader::Path(&m.path)),
1228 &m.args.inner_tokens(),
1234 fn print_inline_asm(&mut self, asm: &ast::InlineAsm) {
1237 Operand(&'a InlineAsmOperand),
1239 Options(InlineAsmOptions),
1242 let mut args = vec![AsmArg::Template(InlineAsmTemplatePiece::to_string(&asm.template))];
1243 args.extend(asm.operands.iter().map(|(o, _)| AsmArg::Operand(o)));
1244 for (abi, _) in &asm.clobber_abis {
1245 args.push(AsmArg::ClobberAbi(*abi));
1247 if !asm.options.is_empty() {
1248 args.push(AsmArg::Options(asm.options));
1252 self.commasep(Consistent, &args, |s, arg| match arg {
1253 AsmArg::Template(template) => s.print_string(&template, ast::StrStyle::Cooked),
1254 AsmArg::Operand(op) => {
1255 let print_reg_or_class = |s: &mut Self, r: &InlineAsmRegOrRegClass| match r {
1256 InlineAsmRegOrRegClass::Reg(r) => s.print_symbol(*r, ast::StrStyle::Cooked),
1257 InlineAsmRegOrRegClass::RegClass(r) => s.word(r.to_string()),
1260 InlineAsmOperand::In { reg, expr } => {
1263 print_reg_or_class(s, reg);
1268 InlineAsmOperand::Out { reg, late, expr } => {
1269 s.word(if *late { "lateout" } else { "out" });
1271 print_reg_or_class(s, reg);
1275 Some(expr) => s.print_expr(expr),
1276 None => s.word("_"),
1279 InlineAsmOperand::InOut { reg, late, expr } => {
1280 s.word(if *late { "inlateout" } else { "inout" });
1282 print_reg_or_class(s, reg);
1287 InlineAsmOperand::SplitInOut { reg, late, in_expr, out_expr } => {
1288 s.word(if *late { "inlateout" } else { "inout" });
1290 print_reg_or_class(s, reg);
1293 s.print_expr(in_expr);
1297 Some(out_expr) => s.print_expr(out_expr),
1298 None => s.word("_"),
1301 InlineAsmOperand::Const { anon_const } => {
1304 s.print_expr(&anon_const.value);
1306 InlineAsmOperand::Sym { sym } => {
1309 if let Some(qself) = &sym.qself {
1310 s.print_qpath(&sym.path, qself, true);
1312 s.print_path(&sym.path, true, 0);
1317 AsmArg::ClobberAbi(abi) => {
1318 s.word("clobber_abi");
1320 s.print_symbol(*abi, ast::StrStyle::Cooked);
1323 AsmArg::Options(opts) => {
1326 let mut options = vec![];
1327 if opts.contains(InlineAsmOptions::PURE) {
1328 options.push("pure");
1330 if opts.contains(InlineAsmOptions::NOMEM) {
1331 options.push("nomem");
1333 if opts.contains(InlineAsmOptions::READONLY) {
1334 options.push("readonly");
1336 if opts.contains(InlineAsmOptions::PRESERVES_FLAGS) {
1337 options.push("preserves_flags");
1339 if opts.contains(InlineAsmOptions::NORETURN) {
1340 options.push("noreturn");
1342 if opts.contains(InlineAsmOptions::NOSTACK) {
1343 options.push("nostack");
1345 if opts.contains(InlineAsmOptions::ATT_SYNTAX) {
1346 options.push("att_syntax");
1348 if opts.contains(InlineAsmOptions::RAW) {
1349 options.push("raw");
1351 if opts.contains(InlineAsmOptions::MAY_UNWIND) {
1352 options.push("may_unwind");
1354 s.commasep(Inconsistent, &options, |s, &opt| {
1363 pub(crate) fn print_local_decl(&mut self, loc: &ast::Local) {
1364 self.print_pat(&loc.pat);
1365 if let Some(ref ty) = loc.ty {
1366 self.word_space(":");
1367 self.print_type(ty);
1371 pub(crate) fn print_name(&mut self, name: Symbol) {
1372 self.word(name.to_string());
1373 self.ann.post(self, AnnNode::Name(&name))
1376 fn print_qpath(&mut self, path: &ast::Path, qself: &ast::QSelf, colons_before_params: bool) {
1378 self.print_type(&qself.ty);
1379 if qself.position > 0 {
1381 self.word_space("as");
1382 let depth = path.segments.len() - qself.position;
1383 self.print_path(path, false, depth);
1386 for item_segment in &path.segments[qself.position..] {
1388 self.print_ident(item_segment.ident);
1389 if let Some(ref args) = item_segment.args {
1390 self.print_generic_args(args, colons_before_params)
1395 pub(crate) fn print_pat(&mut self, pat: &ast::Pat) {
1396 self.maybe_print_comment(pat.span.lo());
1397 self.ann.pre(self, AnnNode::Pat(pat));
1398 /* Pat isn't normalized, but the beauty of it
1399 is that it doesn't matter */
1401 PatKind::Wild => self.word("_"),
1402 PatKind::Ident(binding_mode, ident, ref sub) => {
1403 match binding_mode {
1404 ast::BindingMode::ByRef(mutbl) => {
1405 self.word_nbsp("ref");
1406 self.print_mutability(mutbl, false);
1408 ast::BindingMode::ByValue(ast::Mutability::Not) => {}
1409 ast::BindingMode::ByValue(ast::Mutability::Mut) => {
1410 self.word_nbsp("mut");
1413 self.print_ident(ident);
1414 if let Some(ref p) = *sub {
1416 self.word_space("@");
1420 PatKind::TupleStruct(ref qself, ref path, ref elts) => {
1421 if let Some(qself) = qself {
1422 self.print_qpath(path, qself, true);
1424 self.print_path(path, true, 0);
1427 self.commasep(Inconsistent, &elts, |s, p| s.print_pat(p));
1430 PatKind::Or(ref pats) => {
1431 self.strsep("|", true, Inconsistent, &pats, |s, p| s.print_pat(p));
1433 PatKind::Path(None, ref path) => {
1434 self.print_path(path, true, 0);
1436 PatKind::Path(Some(ref qself), ref path) => {
1437 self.print_qpath(path, qself, false);
1439 PatKind::Struct(ref qself, ref path, ref fields, etc) => {
1440 if let Some(qself) = qself {
1441 self.print_qpath(path, qself, true);
1443 self.print_path(path, true, 0);
1447 let empty = fields.is_empty() && !etc;
1455 s.cbox(INDENT_UNIT);
1456 if !f.is_shorthand {
1457 s.print_ident(f.ident);
1460 s.print_pat(&f.pat);
1466 if !fields.is_empty() {
1467 self.word_space(",");
1476 PatKind::Tuple(ref elts) => {
1478 self.commasep(Inconsistent, &elts, |s, p| s.print_pat(p));
1479 if elts.len() == 1 {
1484 PatKind::Box(ref inner) => {
1486 self.print_pat(inner);
1488 PatKind::Ref(ref inner, mutbl) => {
1490 if mutbl == ast::Mutability::Mut {
1493 if let PatKind::Ident(ast::BindingMode::ByValue(ast::Mutability::Mut), ..) =
1497 self.print_pat(inner);
1500 self.print_pat(inner);
1503 PatKind::Lit(ref e) => self.print_expr(&**e),
1504 PatKind::Range(ref begin, ref end, Spanned { node: ref end_kind, .. }) => {
1505 if let Some(e) = begin {
1509 RangeEnd::Included(RangeSyntax::DotDotDot) => self.word("..."),
1510 RangeEnd::Included(RangeSyntax::DotDotEq) => self.word("..="),
1511 RangeEnd::Excluded => self.word(".."),
1513 if let Some(e) = end {
1517 PatKind::Slice(ref elts) => {
1519 self.commasep(Inconsistent, &elts, |s, p| s.print_pat(p));
1522 PatKind::Rest => self.word(".."),
1523 PatKind::Paren(ref inner) => {
1525 self.print_pat(inner);
1528 PatKind::MacCall(ref m) => self.print_mac(m),
1530 self.ann.post(self, AnnNode::Pat(pat))
1533 fn print_explicit_self(&mut self, explicit_self: &ast::ExplicitSelf) {
1534 match explicit_self.node {
1535 SelfKind::Value(m) => {
1536 self.print_mutability(m, false);
1539 SelfKind::Region(ref lt, m) => {
1541 self.print_opt_lifetime(lt);
1542 self.print_mutability(m, false);
1545 SelfKind::Explicit(ref typ, m) => {
1546 self.print_mutability(m, false);
1548 self.word_space(":");
1549 self.print_type(typ)
1554 pub(crate) fn print_asyncness(&mut self, asyncness: ast::Async) {
1555 if asyncness.is_async() {
1556 self.word_nbsp("async");
1560 pub fn print_type_bounds(&mut self, bounds: &[ast::GenericBound]) {
1561 let mut first = true;
1562 for bound in bounds {
1567 self.word_space("+");
1571 GenericBound::Trait(tref, modifier) => {
1572 if modifier == &TraitBoundModifier::Maybe {
1575 self.print_poly_trait_ref(tref);
1577 GenericBound::Outlives(lt) => self.print_lifetime(*lt),
1582 pub(crate) fn print_lifetime(&mut self, lifetime: ast::Lifetime) {
1583 self.print_name(lifetime.ident.name)
1586 pub(crate) fn print_lifetime_bounds(&mut self, bounds: &ast::GenericBounds) {
1587 for (i, bound) in bounds.iter().enumerate() {
1592 ast::GenericBound::Outlives(lt) => self.print_lifetime(*lt),
1598 pub(crate) fn print_generic_params(&mut self, generic_params: &[ast::GenericParam]) {
1599 if generic_params.is_empty() {
1605 self.commasep(Inconsistent, &generic_params, |s, param| {
1606 s.print_outer_attributes_inline(¶m.attrs);
1609 ast::GenericParamKind::Lifetime => {
1610 let lt = ast::Lifetime { id: param.id, ident: param.ident };
1611 s.print_lifetime(lt);
1612 if !param.bounds.is_empty() {
1614 s.print_lifetime_bounds(¶m.bounds)
1617 ast::GenericParamKind::Type { ref default } => {
1618 s.print_ident(param.ident);
1619 if !param.bounds.is_empty() {
1621 s.print_type_bounds(¶m.bounds);
1623 if let Some(ref default) = default {
1626 s.print_type(default)
1629 ast::GenericParamKind::Const { ref ty, kw_span: _, ref default } => {
1630 s.word_space("const");
1631 s.print_ident(param.ident);
1635 if !param.bounds.is_empty() {
1637 s.print_type_bounds(¶m.bounds);
1639 if let Some(ref default) = default {
1642 s.print_expr(&default.value);
1651 pub fn print_mutability(&mut self, mutbl: ast::Mutability, print_const: bool) {
1653 ast::Mutability::Mut => self.word_nbsp("mut"),
1654 ast::Mutability::Not => {
1656 self.word_nbsp("const");
1662 pub(crate) fn print_mt(&mut self, mt: &ast::MutTy, print_const: bool) {
1663 self.print_mutability(mt.mutbl, print_const);
1664 self.print_type(&mt.ty)
1667 pub(crate) fn print_param(&mut self, input: &ast::Param, is_closure: bool) {
1668 self.ibox(INDENT_UNIT);
1670 self.print_outer_attributes_inline(&input.attrs);
1672 match input.ty.kind {
1673 ast::TyKind::Infer if is_closure => self.print_pat(&input.pat),
1675 if let Some(eself) = input.to_self() {
1676 self.print_explicit_self(&eself);
1678 let invalid = if let PatKind::Ident(_, ident, _) = input.pat.kind {
1679 ident.name == kw::Empty
1684 self.print_pat(&input.pat);
1688 self.print_type(&input.ty);
1695 pub(crate) fn print_fn_ret_ty(&mut self, fn_ret_ty: &ast::FnRetTy) {
1696 if let ast::FnRetTy::Ty(ty) = fn_ret_ty {
1697 self.space_if_not_bol();
1698 self.ibox(INDENT_UNIT);
1699 self.word_space("->");
1700 self.print_type(ty);
1702 self.maybe_print_comment(ty.span.lo());
1706 pub(crate) fn print_ty_fn(
1709 unsafety: ast::Unsafe,
1711 name: Option<Ident>,
1712 generic_params: &[ast::GenericParam],
1714 self.ibox(INDENT_UNIT);
1715 self.print_formal_generic_params(generic_params);
1716 let generics = ast::Generics {
1718 where_clause: ast::WhereClause {
1719 has_where_token: false,
1720 predicates: Vec::new(),
1721 span: rustc_span::DUMMY_SP,
1723 span: rustc_span::DUMMY_SP,
1725 let header = ast::FnHeader { unsafety, ext, ..ast::FnHeader::default() };
1726 self.print_fn(decl, header, name, &generics);
1730 pub(crate) fn print_fn_header_info(&mut self, header: ast::FnHeader) {
1731 self.print_constness(header.constness);
1732 self.print_asyncness(header.asyncness);
1733 self.print_unsafety(header.unsafety);
1736 ast::Extern::None => {}
1737 ast::Extern::Implicit => {
1738 self.word_nbsp("extern");
1740 ast::Extern::Explicit(abi) => {
1741 self.word_nbsp("extern");
1742 self.print_literal(&abi.as_lit());
1750 pub(crate) fn print_unsafety(&mut self, s: ast::Unsafe) {
1752 ast::Unsafe::No => {}
1753 ast::Unsafe::Yes(_) => self.word_nbsp("unsafe"),
1757 pub(crate) fn print_constness(&mut self, s: ast::Const) {
1759 ast::Const::No => {}
1760 ast::Const::Yes(_) => self.word_nbsp("const"),
1764 pub(crate) fn print_is_auto(&mut self, s: ast::IsAuto) {
1766 ast::IsAuto::Yes => self.word_nbsp("auto"),
1767 ast::IsAuto::No => {}