[][src]Struct rustc_hir_pretty::State

pub struct State<'a> {
    pub s: Printer,
    comments: Option<Comments<'a>>,
    ann: &'a (dyn PpAnn + 'a),
}

Fields

s: Printercomments: Option<Comments<'a>>ann: &'a (dyn PpAnn + 'a)

Implementations

impl<'a> State<'a>[src]

pub fn print_node(&mut self, node: Node<'_>)[src]

impl<'a> State<'a>[src]

pub fn new_from_input(
    sm: &'a SourceMap,
    filename: FileName,
    input: String,
    ann: &'a dyn PpAnn
) -> State<'a>
[src]

impl<'a> State<'a>[src]

pub fn cbox(&mut self, u: usize)[src]

pub fn nbsp(&mut self)[src]

pub fn word_nbsp<S: Into<Cow<'static, str>>>(&mut self, w: S)[src]

pub fn head<S: Into<Cow<'static, str>>>(&mut self, w: S)[src]

pub fn bopen(&mut self)[src]

pub fn bclose_maybe_open(&mut self, span: Span, close_box: bool)[src]

pub fn bclose(&mut self, span: Span)[src]

pub fn space_if_not_bol(&mut self)[src]

pub fn break_offset_if_not_bol(&mut self, n: usize, off: isize)[src]

pub fn synth_comment(&mut self, text: String)[src]

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

pub fn commasep_exprs(&mut self, b: Breaks, exprs: &[Expr<'_>])[src]

pub fn print_mod(&mut self, _mod: &Mod<'_>, attrs: &[Attribute])[src]

pub fn print_foreign_mod(&mut self, nmod: &ForeignMod<'_>, attrs: &[Attribute])[src]

pub fn print_opt_lifetime(&mut self, lifetime: &Lifetime)[src]

pub fn print_type(&mut self, ty: &Ty<'_>)[src]

pub fn print_foreign_item(&mut self, item: &ForeignItem<'_>)[src]

fn print_associated_const(
    &mut self,
    ident: Ident,
    ty: &Ty<'_>,
    default: Option<BodyId>,
    vis: &Visibility<'_>
)
[src]

fn print_associated_type(
    &mut self,
    ident: Ident,
    generics: &Generics<'_>,
    bounds: Option<GenericBounds<'_>>,
    ty: Option<&Ty<'_>>
)
[src]

fn print_item_type(
    &mut self,
    item: &Item<'_>,
    generics: &Generics<'_>,
    inner: impl Fn(&mut Self)
)
[src]

pub fn print_item(&mut self, item: &Item<'_>)[src]

Pretty-print an item

pub fn print_trait_ref(&mut self, t: &TraitRef<'_>)[src]

fn print_formal_generic_params(&mut self, generic_params: &[GenericParam<'_>])[src]

fn print_poly_trait_ref(&mut self, t: &PolyTraitRef<'_>)[src]

pub fn print_enum_def(
    &mut self,
    enum_definition: &EnumDef<'_>,
    generics: &Generics<'_>,
    name: Symbol,
    span: Span,
    visibility: &Visibility<'_>
)
[src]

pub fn print_variants(&mut self, variants: &[Variant<'_>], span: Span)[src]

pub fn print_visibility(&mut self, vis: &Visibility<'_>)[src]

pub fn print_defaultness(&mut self, defaultness: Defaultness)[src]

pub fn print_struct(
    &mut self,
    struct_def: &VariantData<'_>,
    generics: &Generics<'_>,
    name: Symbol,
    span: Span,
    print_finalizer: bool
)
[src]

pub fn print_variant(&mut self, v: &Variant<'_>)[src]

pub fn print_method_sig(
    &mut self,
    ident: Ident,
    m: &FnSig<'_>,
    generics: &Generics<'_>,
    vis: &Visibility<'_>,
    arg_names: &[Ident],
    body_id: Option<BodyId>
)
[src]

pub fn print_trait_item(&mut self, ti: &TraitItem<'_>)[src]

pub fn print_impl_item(&mut self, ii: &ImplItem<'_>)[src]

pub fn print_local(&mut self, init: Option<&Expr<'_>>, decl: impl Fn(&mut Self))[src]

pub fn print_stmt(&mut self, st: &Stmt<'_>)[src]

pub fn print_block(&mut self, blk: &Block<'_>)[src]

pub fn print_block_unclosed(&mut self, blk: &Block<'_>)[src]

pub fn print_block_with_attrs(&mut self, blk: &Block<'_>, attrs: &[Attribute])[src]

pub fn print_block_maybe_unclosed(
    &mut self,
    blk: &Block<'_>,
    attrs: &[Attribute],
    close_box: bool
)
[src]

pub fn print_anon_const(&mut self, constant: &AnonConst)[src]

fn print_call_post(&mut self, args: &[Expr<'_>])[src]

pub fn print_expr_maybe_paren(&mut self, expr: &Expr<'_>, prec: i8)[src]

pub fn print_expr_as_cond(&mut self, expr: &Expr<'_>)[src]

Print an expr using syntax that's acceptable in a condition position, such as the cond in if cond { ... }.

fn print_expr_vec(&mut self, exprs: &[Expr<'_>])[src]

fn print_expr_repeat(&mut self, element: &Expr<'_>, count: &AnonConst)[src]

fn print_expr_struct(
    &mut self,
    qpath: &QPath<'_>,
    fields: &[Field<'_>],
    wth: &Option<&Expr<'_>>
)
[src]

fn print_expr_tup(&mut self, exprs: &[Expr<'_>])[src]

fn print_expr_call(&mut self, func: &Expr<'_>, args: &[Expr<'_>])[src]

fn print_expr_method_call(
    &mut self,
    segment: &PathSegment<'_>,
    args: &[Expr<'_>]
)
[src]

fn print_expr_binary(&mut self, op: BinOp, lhs: &Expr<'_>, rhs: &Expr<'_>)[src]

fn print_expr_unary(&mut self, op: UnOp, expr: &Expr<'_>)[src]

fn print_expr_addr_of(
    &mut self,
    kind: BorrowKind,
    mutability: Mutability,
    expr: &Expr<'_>
)
[src]

fn print_literal(&mut self, lit: &Lit)[src]

pub fn print_expr(&mut self, expr: &Expr<'_>)[src]

pub fn print_local_decl(&mut self, loc: &Local<'_>)[src]

pub fn print_usize(&mut self, i: usize)[src]

pub fn print_name(&mut self, name: Symbol)[src]

pub fn print_for_decl(&mut self, loc: &Local<'_>, coll: &Expr<'_>)[src]

pub fn print_path(&mut self, path: &Path<'_>, colons_before_params: bool)[src]

pub fn print_path_segment(&mut self, segment: &PathSegment<'_>)[src]

pub fn print_qpath(&mut self, qpath: &QPath<'_>, colons_before_params: bool)[src]

fn print_generic_args(
    &mut self,
    generic_args: &GenericArgs<'_>,
    infer_args: bool,
    colons_before_params: bool
)
[src]

pub fn print_pat(&mut self, pat: &Pat<'_>)[src]

pub fn print_param(&mut self, arg: &Param<'_>)[src]

pub fn print_arm(&mut self, arm: &Arm<'_>)[src]

pub fn print_fn(
    &mut self,
    decl: &FnDecl<'_>,
    header: FnHeader,
    name: Option<Symbol>,
    generics: &Generics<'_>,
    vis: &Visibility<'_>,
    arg_names: &[Ident],
    body_id: Option<BodyId>
)
[src]

fn print_closure_params(&mut self, decl: &FnDecl<'_>, body_id: BodyId)[src]

pub fn print_capture_clause(&mut self, capture_clause: CaptureBy)[src]

pub fn print_bounds<'b>(
    &mut self,
    prefix: &'static str,
    bounds: impl IntoIterator<Item = &'b GenericBound<'b>>
)
[src]

pub fn print_generic_params(&mut self, generic_params: &[GenericParam<'_>])[src]

pub fn print_generic_param(&mut self, param: &GenericParam<'_>)[src]

pub fn print_lifetime(&mut self, lifetime: &Lifetime)[src]

pub fn print_where_clause(&mut self, where_clause: &WhereClause<'_>)[src]

pub fn print_mutability(&mut self, mutbl: Mutability, print_const: bool)[src]

pub fn print_mt(&mut self, mt: &MutTy<'_>, print_const: bool)[src]

pub fn print_fn_output(&mut self, decl: &FnDecl<'_>)[src]

pub fn print_ty_fn(
    &mut self,
    abi: Abi,
    unsafety: Unsafety,
    decl: &FnDecl<'_>,
    name: Option<Symbol>,
    generic_params: &[GenericParam<'_>],
    arg_names: &[Ident]
)
[src]

pub fn maybe_print_trailing_comment(
    &mut self,
    span: Span,
    next_pos: Option<BytePos>
)
[src]

pub fn print_remaining_comments(&mut self)[src]

pub fn print_opt_abi_and_extern_if_nondefault(&mut self, opt_abi: Option<Abi>)[src]

pub fn print_extern_opt_abi(&mut self, opt_abi: Option<Abi>)[src]

pub fn print_fn_header_info(&mut self, header: FnHeader, vis: &Visibility<'_>)[src]

pub fn print_unsafety(&mut self, s: Unsafety)[src]

pub fn print_is_auto(&mut self, s: IsAuto)[src]

Trait Implementations

impl<'_> Deref for State<'_>[src]

type Target = Printer

The resulting type after dereferencing.

impl<'_> DerefMut for State<'_>[src]

impl<'a> PrintState<'a> for State<'a>[src]

Auto Trait Implementations

impl<'a> !RefUnwindSafe for State<'a>

impl<'a> !Send for State<'a>

impl<'a> !Sync for State<'a>

impl<'a> Unpin for State<'a>

impl<'a> !UnwindSafe for State<'a>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.