Struct rustfmt_nightly::visitor::FmtVisitor

pub(crate) struct FmtVisitor<'a> {

    parent_context: Option<&'a RewriteContext<'a>>,
    pub(crate) parse_sess: &'a ParseSess,
    pub(crate) buffer: String,
    pub(crate) last_pos: BytePos,
    pub(crate) block_indent: Indent,
    pub(crate) config: &'a Config,
    pub(crate) is_if_else_block: bool,
    pub(crate) snippet_provider: &'a SnippetProvider,
    pub(crate) line_number: usize,
    pub(crate) skipped_range: Rc<RefCell<Vec<(usize, usize)>>>,
    pub(crate) macro_rewrite_failure: bool,
    pub(crate) report: FormatReport,
    pub(crate) skip_context: SkipContext,
    pub(crate) is_macro_def: bool,
}

Fields

parent_context: Option<&'a RewriteContext<'a>>

parse_sess: &'a ParseSess

buffer: String

last_pos: BytePos

block_indent: Indent

config: &'a Config

is_if_else_block: bool

snippet_provider: &'a SnippetProvider

line_number: usize

skipped_range: Rc<RefCell<Vec<(usize, usize)>>>

List of 1-based line ranges which were annotated with skip Both bounds are inclusifs.

macro_rewrite_failure: bool

report: FormatReport

skip_context: SkipContext

is_macro_def: bool

Implementations

impl<'a> FmtVisitor<'a>

pub(crate) fn format_import(&mut self, item: &Item, tree: &UseTree)

impl<'a> FmtVisitor<'a>

fn format_item(&mut self, item: &Item<'_>)

fn format_body_element(&mut self, element: &BodyElement<'_>)

pub(crate) fn format_foreign_mod(&mut self, fm: &ForeignMod, span: Span)

fn format_foreign_item(&mut self, item: &ForeignItem)

pub(crate) fn rewrite_fn_before_block(
    &mut self,
    indent: Indent,
    ident: Ident,
    fn_sig: &FnSig<'_>,
    span: Span
) -> Option<(String, FnBraceStyle)>

pub(crate) fn rewrite_required_fn(
    &mut self,
    indent: Indent,
    ident: Ident,
    sig: &FnSig,
    generics: &Generics,
    span: Span
) -> Option<String>

pub(crate) fn single_line_fn(
    &self,
    fn_str: &str,
    block: &Block,
    inner_attrs: Option<&[Attribute]>
) -> Option<String>

pub(crate) fn visit_static(&mut self, static_parts: &StaticParts<'_>)

pub(crate) fn visit_struct(&mut self, struct_parts: &StructParts<'_>)

pub(crate) fn visit_enum(
    &mut self,
    ident: Ident,
    vis: &Visibility,
    enum_def: &EnumDef,
    generics: &Generics,
    span: Span
)

fn format_variant_list(
    &mut self,
    enum_def: &EnumDef,
    body_lo: BytePos,
    body_hi: BytePos
) -> Option<String>

fn format_variant(
    &self,
    field: &Variant,
    one_line_width: usize,
    pad_discrim_ident_to: usize
) -> Option<String>

fn visit_impl_items(&mut self, items: &[P<AssocItem>])

impl<'a> FmtVisitor<'a>

fn output_at_start(&self) -> bool

pub(crate) fn format_missing(&mut self, end: BytePos)

pub(crate) fn format_missing_with_indent(&mut self, end: BytePos)

pub(crate) fn format_missing_no_indent(&mut self, end: BytePos)

fn format_missing_inner<F: Fn(&mut FmtVisitor<'_>, &str, &str)>(
    &mut self,
    end: BytePos,
    process_last_snippet: F
)

fn push_vertical_spaces(&mut self, newline_count: usize)

fn write_snippet<F>(&mut self, span: Span, process_last_snippet: F) where
    F: Fn(&mut FmtVisitor<'_>, &str, &str), 

fn write_snippet_inner<F>(
    &mut self,
    big_snippet: &str,
    old_snippet: &str,
    big_diff: usize,
    span: Span,
    process_last_snippet: F
) where
    F: Fn(&mut FmtVisitor<'_>, &str, &str), 

fn process_comment(
    &mut self,
    status: &mut SnippetStatus,
    snippet: &str,
    big_snippet: &str,
    offset: usize,
    subslice: &str
)

fn process_missing_code(
    &mut self,
    status: &mut SnippetStatus,
    snippet: &str,
    subslice: &str,
    offset: usize,
    file_name: &FileName
)

impl<'b, 'a: 'b> FmtVisitor<'a>

fn walk_reorderable_or_regroupable_items(
    &mut self,
    items: &[&Item],
    item_kind: ReorderableItemKind,
    in_group: bool
) -> usize

Format items with the same item kind and reorder them, regroup them, or both. If in_group is true, then the items separated by an empty line will not be reordered together.

pub(crate) fn visit_items_with_reordering(&mut self, items: &[&Item])

Visits and format the given items. Items are reordered If they are consecutive and reorderable.

impl<'b, 'a: 'b> FmtVisitor<'a>

fn set_parent_context(&mut self, context: &'a RewriteContext<'_>)

pub(crate) fn shape(&self) -> Shape

fn next_span(&self, hi: BytePos) -> Span

fn visit_stmt(&mut self, stmt: &Stmt<'_>, include_empty_semi: bool)

fn trim_spaces_after_opening_brace(
    &mut self,
    b: &Block,
    inner_attrs: Option<&[Attribute]>
)

Remove spaces between the opening brace and the first statement or the inner attribute of the block.

pub(crate) fn visit_block(
    &mut self,
    b: &Block,
    inner_attrs: Option<&[Attribute]>,
    has_braces: bool
)

fn close_block(&mut self, span: Span, unindent_comment: bool)

fn unindent_comment_on_closing_brace(&self, b: &Block) -> bool

pub(crate) fn visit_fn(
    &mut self,
    fk: FnKind<'_>,
    generics: &Generics,
    fd: &FnDecl,
    s: Span,
    defaultness: Defaultness,
    inner_attrs: Option<&[Attribute]>
)

pub(crate) fn visit_item(&mut self, item: &Item)

pub(crate) fn visit_trait_item(&mut self, ti: &AssocItem)

pub(crate) fn visit_impl_item(&mut self, ii: &AssocItem)

fn visit_mac(&mut self, mac: &MacCall, ident: Option<Ident>, pos: MacroPosition)

pub(crate) fn push_str(&mut self, s: &str)

fn push_rewrite_inner(&mut self, span: Span, rewrite: Option<String>)

pub(crate) fn push_rewrite(&mut self, span: Span, rewrite: Option<String>)

pub(crate) fn push_skipped_with_span(
    &mut self,
    attrs: &[Attribute],
    item_span: Span,
    main_span: Span
)

pub(crate) fn from_context(ctx: &'a RewriteContext<'_>) -> FmtVisitor<'a>

pub(crate) fn from_parse_sess(
    parse_session: &'a ParseSess,
    config: &'a Config,
    snippet_provider: &'a SnippetProvider,
    report: FormatReport
) -> FmtVisitor<'a>

pub(crate) fn opt_snippet(&'b self, span: Span) -> Option<&'a str>

pub(crate) fn snippet(&'b self, span: Span) -> &'a str

pub(crate) fn visit_attrs(
    &mut self,
    attrs: &[Attribute],
    style: AttrStyle
) -> bool

fn is_unknown_rustfmt_attr(&self, segments: &[PathSegment]) -> bool

fn walk_mod_items(&mut self, items: &[P<Item>])

fn walk_stmts(&mut self, stmts: &[Stmt<'_>], include_current_empty_semi: bool)

fn walk_block_stmts(&mut self, b: &Block)

fn format_mod(
    &mut self,
    mod_kind: &ModKind,
    unsafety: Unsafe,
    vis: &Visibility,
    s: Span,
    ident: Ident,
    attrs: &[Attribute]
)

pub(crate) fn format_separate_mod(&mut self, m: &Module<'_>, end_pos: BytePos)

pub(crate) fn skip_empty_lines(&mut self, end_pos: BytePos)

pub(crate) fn with_context<F>(&mut self, f: F) -> Option<String> where
    F: Fn(&RewriteContext<'_>) -> Option<String>, 

pub(crate) fn get_context(&self) -> RewriteContext<'_>

Trait Implementations

impl<'a> Drop for FmtVisitor<'a>

fn drop(&mut self)

Executes the destructor for this type.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.

Size: 176 bytes