Struct syntax::print::pprust::State [−] [src]

pub struct State<'a> {
    pub s: Printer<'a>,
    // some fields omitted
}
Unstable

Fields

s
Unstable

Methods

impl<'a> State<'a>

fn new_from_input(cm: &'a CodeMap, span_diagnostic: &SpanHandler, filename: String, input: &mut Read, out: Box<Write + 'a>, ann: &'a PpAnn, is_expanded: bool) -> State<'a>

Unstable

fn new(cm: &'a CodeMap, out: Box<Write + 'a>, ann: &'a PpAnn, comments: Option<Vec<Comment>>, literals: Option<Vec<Literal>>) -> State<'a>

Unstable

impl<'a> State<'a>

fn ibox(&mut self, u: usize) -> Result<()>

Unstable

fn end(&mut self) -> Result<()>

Unstable

fn cbox(&mut self, u: usize) -> Result<()>

Unstable

fn rbox(&mut self, u: usize, b: Breaks) -> Result<()>

Unstable

fn nbsp(&mut self) -> Result<()>

Unstable

fn word_nbsp(&mut self, w: &str) -> Result<()>

Unstable

fn word_space(&mut self, w: &str) -> Result<()>

Unstable

fn popen(&mut self) -> Result<()>

Unstable

fn pclose(&mut self) -> Result<()>

Unstable

fn head(&mut self, w: &str) -> Result<()>

Unstable

fn bopen(&mut self) -> Result<()>

Unstable

fn bclose_(&mut self, span: Span, indented: usize) -> Result<()>

Unstable

fn bclose_maybe_open(&mut self, span: Span, indented: usize, close_box: bool) -> Result<()>

Unstable

fn bclose(&mut self, span: Span) -> Result<()>

Unstable

fn is_begin(&mut self) -> bool

Unstable

fn is_end(&mut self) -> bool

Unstable

fn is_bol(&mut self) -> bool

Unstable

fn in_cbox(&self) -> bool

Unstable

fn hardbreak_if_not_bol(&mut self) -> Result<()>

Unstable

fn space_if_not_bol(&mut self) -> Result<()>

Unstable

fn break_offset_if_not_bol(&mut self, n: usize, off: isize) -> Result<()>

Unstable

fn synth_comment(&mut self, text: String) -> Result<()>

Unstable

fn commasep<T, F>(&mut self, b: Breaks, elts: &[T], op: F) -> Result<()> where F: FnMut(&mut State, &T) -> Result<()>

Unstable

fn commasep_cmnt<T, F, G>(&mut self, b: Breaks, elts: &[T], op: F, get_span: G) -> Result<()> where F: FnMut(&mut State, &T) -> Result<()>, G: FnMut(&T) -> Span

Unstable

fn commasep_exprs(&mut self, b: Breaks, exprs: &[P<Expr>]) -> Result<()>

Unstable

fn print_mod(&mut self, _mod: &Mod, attrs: &[Attribute]) -> Result<()>

Unstable

fn print_foreign_mod(&mut self, nmod: &ForeignMod, attrs: &[Attribute]) -> Result<()>

Unstable

fn print_opt_lifetime(&mut self, lifetime: &Option<Lifetime>) -> Result<()>

Unstable

fn print_type(&mut self, ty: &Ty) -> Result<()>

Unstable

fn print_foreign_item(&mut self, item: &ForeignItem) -> Result<()>

Unstable

fn print_item(&mut self, item: &Item) -> Result<()>

Unstable

Pretty-print an item

fn print_enum_def(&mut self, enum_definition: &EnumDef, generics: &Generics, ident: Ident, span: Span, visibility: Visibility) -> Result<()>

Unstable

fn print_variants(&mut self, variants: &[P<Variant>], span: Span) -> Result<()>

Unstable

fn print_visibility(&mut self, vis: Visibility) -> Result<()>

Unstable

fn print_struct(&mut self, struct_def: &StructDef, generics: &Generics, ident: Ident, span: Span) -> Result<()>

Unstable

fn print_tt(&mut self, tt: &TokenTree) -> Result<()>

Unstable

This doesn't deserve to be called "pretty" printing, but it should be meaning-preserving. A quick hack that might help would be to look at the spans embedded in the TTs to decide where to put spaces and newlines. But it'd be better to parse these according to the grammar of the appropriate macro, transcribe back into the grammar we just parsed from, and then pretty-print the resulting AST nodes (so, e.g., we print expression arguments as expressions). It can be done! I think.

fn print_tts(&mut self, tts: &[TokenTree]) -> Result<()>

Unstable

fn print_variant(&mut self, v: &Variant) -> Result<()>

Unstable

fn print_method_sig(&mut self, ident: Ident, m: &MethodSig, vis: Visibility) -> Result<()>

Unstable

fn print_trait_item(&mut self, ti: &TraitItem) -> Result<()>

Unstable

fn print_impl_item(&mut self, ii: &ImplItem) -> Result<()>

Unstable

fn print_outer_attributes(&mut self, attrs: &[Attribute]) -> Result<()>

Unstable

fn print_inner_attributes(&mut self, attrs: &[Attribute]) -> Result<()>

Unstable

fn print_attribute(&mut self, attr: &Attribute) -> Result<()>

Unstable

fn print_stmt(&mut self, st: &Stmt) -> Result<()>

Unstable

fn print_block(&mut self, blk: &Block) -> Result<()>

Unstable

fn print_block_unclosed(&mut self, blk: &Block) -> Result<()>

Unstable

fn print_block_unclosed_indent(&mut self, blk: &Block, indented: usize) -> Result<()>

Unstable

fn print_block_with_attrs(&mut self, blk: &Block, attrs: &[Attribute]) -> Result<()>

Unstable

fn print_block_maybe_unclosed(&mut self, blk: &Block, indented: usize, attrs: &[Attribute], close_box: bool) -> Result<()>

Unstable

fn print_if(&mut self, test: &Expr, blk: &Block, elseopt: Option<&Expr>) -> Result<()>

Unstable

fn print_if_let(&mut self, pat: &Pat, expr: &Expr, blk: &Block, elseopt: Option<&Expr>) -> Result<()>

Unstable

fn print_mac(&mut self, m: &Mac, delim: DelimToken) -> Result<()>

Unstable

fn print_expr_maybe_paren(&mut self, expr: &Expr) -> Result<()>

Unstable

fn print_expr(&mut self, expr: &Expr) -> Result<()>

Unstable

fn print_local_decl(&mut self, loc: &Local) -> Result<()>

Unstable

fn print_decl(&mut self, decl: &Decl) -> Result<()>

Unstable

fn print_ident(&mut self, ident: Ident) -> Result<()>

Unstable

fn print_usize(&mut self, i: usize) -> Result<()>

Unstable

fn print_name(&mut self, name: Name) -> Result<()>

Unstable

fn print_for_decl(&mut self, loc: &Local, coll: &Expr) -> Result<()>

Unstable

fn print_pat(&mut self, pat: &Pat) -> Result<()>

Unstable

fn print_fn(&mut self, decl: &FnDecl, unsafety: Unsafety, abi: Abi, name: Option<Ident>, generics: &Generics, opt_explicit_self: Option<&ExplicitSelf_>, vis: Visibility) -> Result<()>

Unstable

fn print_fn_args(&mut self, decl: &FnDecl, opt_explicit_self: Option<&ExplicitSelf_>) -> Result<()>

Unstable

fn print_fn_args_and_ret(&mut self, decl: &FnDecl, opt_explicit_self: Option<&ExplicitSelf_>) -> Result<()>

Unstable

fn print_fn_block_args(&mut self, decl: &FnDecl) -> Result<()>

Unstable

fn print_capture_clause(&mut self, capture_clause: CaptureClause) -> Result<()>

Unstable

fn print_bounds(&mut self, prefix: &str, bounds: &[TyParamBound]) -> Result<()>

Unstable

fn print_lifetime(&mut self, lifetime: &Lifetime) -> Result<()>

Unstable

fn print_lifetime_def(&mut self, lifetime: &LifetimeDef) -> Result<()>

Unstable

fn print_generics(&mut self, generics: &Generics) -> Result<()>

Unstable

fn print_ty_param(&mut self, param: &TyParam) -> Result<()>

Unstable

fn print_where_clause(&mut self, where_clause: &WhereClause) -> Result<()>

Unstable

fn print_meta_item(&mut self, item: &MetaItem) -> Result<()>

Unstable

fn print_view_path(&mut self, vp: &ViewPath) -> Result<()>

Unstable

fn print_mutability(&mut self, mutbl: Mutability) -> Result<()>

Unstable

fn print_mt(&mut self, mt: &MutTy) -> Result<()>

Unstable

fn print_arg(&mut self, input: &Arg) -> Result<()>

Unstable

fn print_fn_output(&mut self, decl: &FnDecl) -> Result<()>

Unstable

fn print_ty_fn(&mut self, abi: Abi, unsafety: Unsafety, decl: &FnDecl, name: Option<Ident>, generics: &Generics, opt_explicit_self: Option<&ExplicitSelf_>) -> Result<()>

Unstable

fn maybe_print_trailing_comment(&mut self, span: Span, next_pos: Option<BytePos>) -> Result<()>

Unstable

fn print_remaining_comments(&mut self) -> Result<()>

Unstable

fn print_literal(&mut self, lit: &Lit) -> Result<()>

Unstable

fn next_lit(&mut self, pos: BytePos) -> Option<Literal>

Unstable

fn maybe_print_comment(&mut self, pos: BytePos) -> Result<()>

Unstable

fn print_comment(&mut self, cmnt: &Comment) -> Result<()>

Unstable

fn print_string(&mut self, st: &str, style: StrStyle) -> Result<()>

Unstable

fn next_comment(&mut self) -> Option<Comment>

Unstable

fn print_opt_abi_and_extern_if_nondefault(&mut self, opt_abi: Option<Abi>) -> Result<()>

Unstable

fn print_extern_opt_abi(&mut self, opt_abi: Option<Abi>) -> Result<()>

Unstable

fn print_fn_header_info(&mut self, unsafety: Unsafety, abi: Abi, vis: Visibility) -> Result<()>

Unstable

fn print_unsafety(&mut self, s: Unsafety) -> Result<()>

Unstable

Trait Implementations

impl<'a> NodePrinter for State<'a>

fn print_node(&mut self, node: &Node) -> Result<()>