Struct State 

pub(crate) struct State<'sess, 'ast> {

    pub(crate) s: Printer,
    ind: isize,
    sm: &'sess SourceMap,
    pub(crate) comments: Comments,
    config: Arc<FormatterConfig>,
    inline_config: InlineConfig<()>,
    cursor: SourcePos,
    has_crlf: bool,
    contract: Option<&'ast ItemContract<'ast>>,
    single_line_stmt: Option<bool>,
    named_call_expr: bool,
    binary_expr: Option<BinOpGroup>,
    return_bin_expr: bool,
    var_init: bool,
    block_depth: usize,
    call_stack: CallStack,
}

Fields

s: Printer

ind: isize

sm: &'sess SourceMap

comments: Comments

config: Arc<FormatterConfig>

inline_config: InlineConfig<()>

cursor: SourcePos

has_crlf: bool

contract: Option<&'ast ItemContract<'ast>>

single_line_stmt: Option<bool>

named_call_expr: bool

binary_expr: Option<BinOpGroup>

return_bin_expr: bool

var_init: bool

block_depth: usize

call_stack: CallStack

Implementations

impl<'ast> State<'_, 'ast>

Language-specific pretty printing. Common for both: Solidity + Yul.

pub(super) fn print_lit(&mut self, lit: &'ast Lit<'ast>)

fn print_num_literal(&mut self, source: &str)

pub(super) fn print_str_lit( &mut self, kind: StrKind, quote_pos: BytePos, s: &str, )

s should be the unescaped contents of the string literal.

fn str_lit_to_string( &self, kind: StrKind, quote_pos: BytePos, s: &str, ) -> String

s should be the unescaped contents of the string literal.

pub(super) fn print_tuple_empty(&mut self, pos_lo: BytePos, pos_hi: BytePos)

pub(super) fn print_tuple<'a, T, P, S>( &mut self, values: &'a [T], pos_lo: BytePos, pos_hi: BytePos, print: P, get_span: S, format: ListFormat, )

where P: FnMut(&mut Self, &'a T), S: FnMut(&T) -> Span,

pub(super) fn print_array<'a, T, P, S>( &mut self, values: &'a [T], span: Span, print: P, get_span: S, )

where P: FnMut(&mut Self, &'a T), S: FnMut(&T) -> Span,

pub(super) fn commasep_opening_logic<T, S>( &mut self, values: &[T], get_span: S, format: ListFormat, ) -> bool

where S: FnMut(&T) -> Span,

pub(super) fn commasep<'a, T, P, S>( &mut self, values: &'a [T], _pos_lo: BytePos, pos_hi: BytePos, print: P, get_span: S, format: ListFormat, )

where P: FnMut(&mut Self, &'a T), S: FnMut(&T) -> Span,

pub(super) fn print_path( &mut self, path: &'ast PathSlice, consistent_break: bool, )

pub(super) fn print_block_inner<T: Debug>( &mut self, block: &'ast [T], block_format: BlockFormat, print: impl FnMut(&mut Self, &'ast T), get_block_span: impl FnMut(&'ast T) -> Span, pos_hi: BytePos, )

fn print_single_line_block<T: Debug>( &mut self, block: &'ast [T], block_format: BlockFormat, print: impl FnMut(&mut Self, &'ast T), get_block_span: impl FnMut(&'ast T) -> Span, )

fn print_empty_block(&mut self, block_format: BlockFormat, pos_hi: BytePos)

impl<'ast> State<'_, 'ast>

Language-specific pretty printing: Solidity.

pub(crate) fn print_source_unit(&mut self, source_unit: &'ast SourceUnit<'ast>)

fn separate_items(&mut self, next_item: &'ast Item<'ast>, advance: bool)

Prints a hardbreak if the item needs an isolated line break.

fn print_item(&mut self, item: &'ast Item<'ast>, skip_ws: bool)

fn print_pragma(&mut self, pragma: &'ast PragmaDirective<'ast>)

fn print_commasep_aliases<'a, I>(&mut self, aliases: I)

where I: Iterator<Item = &'a (Ident, Option<Ident>)>, 'ast: 'a,

fn print_import(&mut self, import: &'ast ImportDirective<'ast>)

fn print_using(&mut self, using: &'ast UsingDirective<'ast>)

fn print_contract(&mut self, c: &'ast ItemContract<'ast>, span: Span)

fn print_struct(&mut self, strukt: &'ast ItemStruct<'ast>, span: Span)

fn print_enum(&mut self, enm: &'ast ItemEnum<'ast>, span: Span)

fn print_udvt(&mut self, udvt: &'ast ItemUdvt<'ast>)

fn print_function(&mut self, func: &'ast ItemFunction<'ast>)

fn print_fn_attribute( &mut self, span: Span, map: &mut HashMap<BytePos, (Vec<Comment>, Vec<Comment>, Vec<Comment>)>, print_fn: &mut dyn FnMut(&mut Self), )

fn is_modifier_a_base_contract( &self, kind: FunctionKind, modifier: &'ast Modifier<'ast>, ) -> bool

fn print_error(&mut self, err: &'ast ItemError<'ast>)

fn print_event(&mut self, event: &'ast ItemEvent<'ast>)

fn print_var_def(&mut self, var: &'ast VariableDefinition<'ast>)

fn print_var(&mut self, var: &'ast VariableDefinition<'ast>, is_var_def: bool)

fn print_attribute( &mut self, attribute: Option<&'static str>, is_var_def: bool, size: &mut usize, )

fn print_parameter_list( &mut self, parameters: &'ast [VariableDefinition<'ast>], span: Span, format: ListFormat, )

fn print_ident_or_strlit(&mut self, value: &'ast IdentOrStrLit)

fn print_ast_str_lit(&mut self, strlit: &'ast StrLit)

Prints a raw AST string literal, which is unescaped.

fn print_ty(&mut self, ty: &'ast Type<'ast>)

fn print_override(&mut self, override_: &'ast Override<'ast>)

fn print_expr(&mut self, expr: &'ast Expr<'ast>)

Prints an expression by matching on its variant and delegating to the appropriate printer method, handling all Solidity expression kinds.

fn print_assign_expr(&mut self, lhs: &'ast Expr<'ast>, rhs: &'ast Expr<'ast>)

Prints a simple assignment expression of the form lhs = rhs.

fn print_bin_expr( &mut self, lhs: &'ast Expr<'ast>, bin_op: &BinOp, rhs: &'ast Expr<'ast>, is_assign: bool, )

Prints a binary operator expression. Handles operator chains and formatting.

fn print_index_expr( &mut self, span: Span, expr: &'ast Expr<'ast>, kind: &'ast IndexKind<'ast>, )

Prints an indexing expression.

fn print_ternary_expr( &mut self, cond: &'ast Expr<'ast>, then: &'ast Expr<'ast>, els: &'ast Expr<'ast>, )

Prints a ternary expression of the form cond ? then : else.

fn print_modifier_call( &mut self, modifier: &'ast Modifier<'ast>, add_parens_if_empty: bool, )

fn print_member_or_call_chain<F>( &mut self, child_expr: &'ast Expr<'ast>, member_or_args: MemberOrCallArgs, print_suffix: F, )

where F: FnOnce(&mut Self),

fn print_call_args( &mut self, args: &'ast CallArgs<'ast>, format: ListFormat, callee_size: usize, )

fn print_named_args(&mut self, args: &'ast [NamedArg<'ast>], pos_hi: BytePos)

fn print_stmt(&mut self, stmt: &'ast Stmt<'ast>)

Prints the given statement in the source code, handling formatting, inline documentation, trailing comments and layout logic for various statement kinds.

fn print_assembly_stmt( &mut self, span: Span, dialect: &'ast Option<StrLit>, flags: &'ast [StrLit], block: &'ast Block<'ast>, )

Prints an assembly statement, including optional dialect and flags, followed by its Yul block.

fn print_multi_decl_stmt( &mut self, span: Span, vars: &'ast BoxSlice<'ast, SpannedOption<VariableDefinition<'ast>>>, init_expr: &'ast Expr<'ast>, )

Prints a multiple-variable declaration with a single initializer expression, formatted as a tuple-style assignment (e.g., (a, b) = foo();).

fn print_for_stmt( &mut self, span: Span, init: &'ast Option<&mut Stmt<'ast>>, cond: &'ast Option<&mut Expr<'ast>>, next: &'ast Option<&mut Expr<'ast>>, body: &'ast Stmt<'ast>, )

Prints a for loop statement, including its initializer, condition, increment expression, and loop body, with formatting and spacing.

fn print_if_stmt( &mut self, span: Span, cond: &'ast Expr<'ast>, then: &'ast Stmt<'ast>, els_opt: &'ast Option<&mut Stmt<'ast>>, )

Prints an if statement, including its condition, then block, and any chained else or else if branches, handling inline formatting decisions and comments.

fn print_return_stmt( &mut self, force_break: bool, expr: &'ast Option<&mut Expr<'ast>>, )

Prints a return statement, optionally including a return expression. Handles spacing, line breaking, and formatting.

fn print_try_stmt( &mut self, expr: &'ast Expr<'ast>, clauses: &'ast [TryCatchClause<'ast>], )

Prints a try statement along with its associated catch clauses, following Solidity’s try ... returns (...) { ... } catch (...) { ... } syntax.

fn print_if_no_else( &mut self, cond: &'ast Expr<'ast>, then: &'ast Stmt<'ast>, inline: bool, )

fn print_if_cond( &mut self, kw: &'static str, cond: &'ast Expr<'ast>, pos_hi: BytePos, )

fn print_emit_or_revert( &mut self, kw: &'static str, path: &'ast PathSlice, args: &'ast CallArgs<'ast>, )

fn print_block(&mut self, block: &'ast [Stmt<'ast>], span: Span)

fn print_block_without_braces( &mut self, block: &'ast [Stmt<'ast>], pos_hi: BytePos, offset: Option<isize>, )

fn print_stmt_as_block( &mut self, stmt: &'ast Stmt<'ast>, pos_hi: BytePos, inline: bool, )

fn is_single_line_block( &mut self, cond: &'ast Expr<'ast>, then: &'ast Stmt<'ast>, els_opt: Option<&'ast &'ast mut Stmt<'ast>>, ) -> Decision

Determines if an if/else block should be inlined. Also returns if the value was cached, so that it can be cleaned afterwards.

Returns

A tuple (should_inline, was_cached). The second boolean is true if the decision was retrieved from the cache or is a final decision based on config, preventing the caller from clearing a cache value that was never set.

fn is_inline_stmt(&self, stmt: &'ast Stmt<'ast>, cond_len: usize) -> bool

fn is_stmt_in_new_line( &self, cond: &'ast Expr<'ast>, then: &'ast Stmt<'ast>, ) -> bool

Checks if a statement was explicitly written in a new line.

fn is_multiline_block_stmt( &self, stmt: &'ast Stmt<'ast>, empty_as_multiline: bool, ) -> bool

Checks if a block statement { ... } contains more than one line of actual code.

fn is_multiline_block( &self, block: &'ast Block<'ast>, empty_as_multiline: bool, ) -> bool

Checks if a block statement { ... } contains more than one line of actual code.

fn can_stmts_be_inlined( &mut self, cond: &'ast Expr<'ast>, then: &'ast Stmt<'ast>, els_opt: Option<&'ast &'ast mut Stmt<'ast>>, ) -> bool

Performs a size estimation to see if the if/else can fit on one line.

fn can_header_be_inlined(&mut self, header: &FunctionHeader<'_>) -> bool

fn estimate_header_params_size(&mut self, header: &FunctionHeader<'_>) -> usize

fn can_header_params_be_inlined(&mut self, header: &FunctionHeader<'_>) -> bool

fn has_comments_between_elements<I>(&self, limits: Span, elements: I) -> bool

where I: IntoIterator<Item = &'ast Expr<'ast>>,

impl<'ast> State<'_, 'ast>

Language-specific pretty printing: Yul.

pub(crate) fn print_yul_stmt(&mut self, stmt: &'ast Stmt<'ast>)

fn print_yul_expr(&mut self, expr: &'ast Expr<'ast>)

pub(super) fn print_yul_block( &mut self, block: &'ast Block<'ast>, span: Span, skip_opening_brace: bool, )

fn is_multiline_yul_block(&self, block: &'ast Block<'ast>) -> bool

Checks if a block statement { ... } contains more than one line of actual code.

fn estimate_yul_header_params_size(&mut self, func: &Function<'_>) -> usize

fn can_yul_header_params_be_inlined(&mut self, func: &Function<'_>) -> bool

impl<'sess> State<'sess, '_>

Generic methods

pub(crate) fn new( sm: &'sess SourceMap, config: Arc<FormatterConfig>, inline_config: InlineConfig<()>, comments: Comments, ) -> Self

fn check_crlf(&mut self, span: Span)

Checks a span of the source for a carriage return (\r) to determine if the file uses CRLF line endings.

If a \r is found, self.has_crlf is set to true. This is intended to be called once at the beginning of the formatting process for efficiency.

fn is_at_crlf(&self) -> bool

Checks if the cursor is currently positioned at the start of a CRLF sequence (\r\n). The check is only meaningful if self.has_crlf is true.

fn space_left(&self) -> usize

fn break_offset_if_not_bol(&mut self, n: usize, off: isize, search: bool)

fn braces_break(&mut self)

impl State<'_, '_>

Span to source.

fn char_at(&self, pos: BytePos) -> Option<char>

fn print_span(&mut self, span: Span)

fn handle_span(&mut self, span: Span, skip_prev_cmnts: bool) -> bool

Returns true if the span is disabled and has been printed as-is.

fn print_span_if_disabled(&mut self, span: Span) -> bool

Returns true if the span is disabled and has been printed as-is.

fn print_span_cold(&mut self, span: Span)

fn print_tokens(&mut self, tokens: &[Token])

fn print_word(&mut self, w: impl Into<Cow<'static, str>>)

fn print_sep(&mut self, sep: Separator)

fn print_sep_unhandled(&mut self, sep: Separator)

fn print_ident(&mut self, ident: &Ident)

fn print_inside_parens<F>(&mut self, f: F)

where F: FnOnce(&mut Self),

fn estimate_size(&self, span: Span) -> usize

fn same_source_line(&self, a: BytePos, b: BytePos) -> bool

impl<'sess> State<'sess, '_>

Comment-related methods.

fn handle_comment(&mut self, cmnt: Comment, skip_break: bool) -> Option<Comment>

Returns None if the span is disabled and has been printed as-is.

fn cmnt_config(&self) -> CommentConfig

fn print_docs(&mut self, docs: &DocComments<'_>)

fn print_comments( &mut self, pos: BytePos, config: CommentConfig, ) -> Option<CommentStyle>

Prints comments that are before the given position.

Returns Some with the style of the last comment printed, or None if no comment was printed.

fn print_wrapped_line( &mut self, line: &str, prefix: &'static str, break_offset: isize, is_doc: bool, )

Prints a line, wrapping it if it starts with the given prefix.

fn merge_comment_lines(&self, lines: &[String], prefix: &str) -> Vec<String>

Merges consecutive line comments to avoid orphan words.

fn print_comment(&mut self, cmnt: Comment, config: CommentConfig)

fn peek_comment<'b>(&'b self) -> Option<&'b Comment>

where 'sess: 'b,

fn peek_comment_before<'b>(&'b self, pos: BytePos) -> Option<&'b Comment>

where 'sess: 'b,

fn has_comment_before_with<F>(&self, pos: BytePos, f: F) -> bool

where F: FnMut(&Comment) -> bool,

fn peek_comment_between<'b>( &'b self, pos_lo: BytePos, pos_hi: BytePos, ) -> Option<&'b Comment>

where 'sess: 'b,

fn has_comment_between(&self, start_pos: BytePos, end_pos: BytePos) -> bool

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

fn peek_trailing_comment<'b>( &'b self, span_pos: BytePos, next_pos: Option<BytePos>, ) -> Option<&'b Comment>

where 'sess: 'b,

fn print_trailing_comment_inner( &mut self, span_pos: BytePos, next_pos: Option<BytePos>, config: Option<CommentConfig>, ) -> bool

fn print_trailing_comment( &mut self, span_pos: BytePos, next_pos: Option<BytePos>, ) -> bool

fn print_trailing_comment_no_break( &mut self, span_pos: BytePos, next_pos: Option<BytePos>, )

fn print_remaining_comments(&mut self, skip_leading_ws: bool)

Methods from Deref<Target = Printer>

pub fn rbox(&mut self, indent: isize, breaks: Breaks)

“raw box”

pub fn ibox(&mut self, indent: isize)

Inconsistent breaking box

pub fn cbox(&mut self, indent: isize)

Consistent breaking box

pub fn visual_align(&mut self)

pub fn break_offset(&mut self, n: usize, off: isize)

pub fn end(&mut self)

pub fn word(&mut self, w: impl Into<Cow<'static, str>>)

fn spaces(&mut self, n: usize)

pub fn zerobreak(&mut self)

pub fn space(&mut self)

pub fn hardbreak(&mut self)

pub fn last_token_is_neverbreak(&self) -> bool

pub fn last_token_is_break(&self) -> bool

pub fn last_token_is_space(&self) -> bool

pub fn is_beginning_of_line(&self) -> bool

pub fn is_bol_or_only_ind(&self) -> bool

Attempts to identify whether the current position is:

1. the beginning of a line (empty)
2. a line with only indentation (just whitespaces)

NOTE: this is still an educated guess, based on a heuristic.

pub fn hardbreak_if_nonempty(&mut self)

pub fn neverbreak(&mut self)

pub fn word_space(&mut self, w: impl Into<Cow<'static, str>>)

pub fn hardbreak_if_not_bol(&mut self)

Adds a new hardbreak if not at the beginning of the line. If there was a buffered break token, replaces it (ensures hardbreak) keeping the offset.

pub fn space_if_not_bol(&mut self)

pub fn nbsp(&mut self)

pub fn space_or_nbsp(&mut self, breaks: bool)

pub fn word_nbsp(&mut self, w: impl Into<Cow<'static, str>>)

pub(crate) fn space_left(&self) -> usize

Predicts available space on the current or next line based on pending breaks.

This function provides a heuristic for estimating available space by checking if an unconditional hard break is pending in the buffer. The printer’s internal self.space value may not accurately reflect pending formatting decisions.

Returns

• The full margin if an unconditional hard break is pending, signaling that a new line will be created. Callers should apply their own indentation logic as they have more semantic context about the code structure.
• The current space left (self.space) if no hard break is found, which can be trusted when no line breaks are imminent.

Trade-offs

This heuristic may overestimate available space, but provides a reliable signal for hard breaks while keeping the implementation simple.

pub(crate) fn last_token(&self) -> Option<&Token>

pub(crate) fn last_token_still_buffered(&self) -> Option<&Token>

pub(crate) fn replace_last_token_still_buffered(&mut self, token: Token)

Be very careful with this!

pub(crate) fn find_and_replace_last_token_still_buffered<F>( &mut self, new_token: Token, predicate: F, )

where F: FnOnce(&Token) -> bool,

WARNING: Be very careful with this!

Searches backwards through the buffer to find and replace the last token that satisfies a predicate. This is a specialized and sensitive operation.

This function’s traversal logic is specifically designed to handle cases where formatting boxes have been closed (e.g., after a multi-line comment). It will automatically skip over any trailing Token::End tokens to find the substantive token before them.

The search stops as soon as it encounters any token other than End (i.e., a String, Break, or Begin). The provided predicate is then called on that token. If the predicate returns true, the token is replaced.

This function will only ever evaluate the predicate on one token.

fn scan_eof(&mut self)

fn scan_begin(&mut self, token: BeginToken)

fn scan_end(&mut self)

pub(crate) fn scan_break(&mut self, token: BreakToken)

fn scan_string(&mut self, string: Cow<'static, str>)

pub(crate) fn offset(&mut self, offset: isize)

pub(crate) fn ends_with(&self, ch: char) -> bool

fn check_stream(&mut self)

fn advance_left(&mut self)

fn check_stack(&mut self, depth: usize)

fn get_top(&self) -> PrintFrame

fn print_begin(&mut self, token: BeginToken, size: isize)

fn print_end(&mut self)

fn print_break(&mut self, token: BreakToken, size: isize)

fn print_string(&mut self, string: &str)

fn print_indent(&mut self)

Trait Implementations

impl Deref for State<'_, '_>

type Target = Printer

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for State<'_, '_>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

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: 408 bytes