Struct clippy_utils::macros::FormatArgsExpn

pub struct FormatArgsExpn<'tcx> {
    pub format_string: FormatString,
    pub args: Vec<FormatArg<'tcx>>,
    pub newline: bool,
    comma_spans: Vec<Span>,
    explicit_values: Vec<&'tcx Expr<'tcx>>,
}

A parsed format_args! expansion.

Fields

format_string: FormatString

The format string literal.

args: Vec<FormatArg<'tcx>>

The format arguments, such as {:?}.

newline: bool

Has an added newline due to println!()/writeln!()/etc. The last format string part will include this added newline.

comma_spans: Vec<Span>

Spans of the commas between the format string and explicit values, excluding any trailing comma

format!("..", 1, 2, 3,)
//          ^  ^  ^

explicit_values: Vec<&'tcx Expr<'tcx>>

Explicit values passed after the format string, ignoring implicit captures. [1, z + 2] for format!("{x} {} {y}", 1, z + 2).

Implementations

impl<'tcx> FormatArgsExpn<'tcx>

fn comma_spans(
    cx: &LateContext<'_>,
    explicit_values: &[&Expr<'_>],
    fmt_span: Span
) -> Option<Vec<Span>>

Gets the spans of the commas inbetween the format string and explicit args, not including any trailing comma

format!("{} {}", a, b)
//             ^  ^

Ensures that the format string and values aren’t coming from a proc macro that sets the output span to that of its input

pub fn parse(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<Self>

pub fn find_nested(
    cx: &LateContext<'tcx>,
    expr: &'tcx Expr<'tcx>,
    expn_id: ExpnId
) -> Option<Self>

pub fn inputs_span(&self) -> Span

Source callsite span of all inputs

pub fn value_with_prev_comma_span(&self, value_id: HirId) -> Option<Span>

Get the span of a value expanded to the previous comma, e.g. for the value 10

format("{}.{}", 10, 11)
//            ^^^^

pub fn params(&'tcx self) -> impl Iterator<Item = FormatParam<'tcx>>

Iterator of all format params, both values and those referenced by width/precisions.

Trait Implementations

impl<'tcx> Debug for FormatArgsExpn<'tcx>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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