[literal_string_with_formatting_args] support for `lazy_format`

[madonuko]

Summary

literal_string_with_formatting_args does not support lazy_format::lazy_format!.

Lint Name

literal_string_with_formatting_args

Reproducer

warning: this looks like a formatting argument but it is not part of a formatting macro
   --> src/util.rs:387:54
    |
387 |             .note(lazy_format::lazy_format!("Status: {status}")),
    |                                                      ^^^^^^^^
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#literal_string_with_formatting_args

Version

rustc 1.86.0 (05f9846f8 2025-03-31)
binary: rustc
commit-hash: 05f9846f893b09a1be1fc8560e33fc3c815cfecb
commit-date: 2025-03-31
host: x86_64-unknown-linux-gnu
release: 1.86.0
LLVM version: 19.1.7

Additional Labels

No response

[blyxyas]

Could you provide an example where this false positive is active?

[madonuko]

#[warn(clippy::literal_string_with_formatting_args)]
fn main() {
  let x = 1;
  println!("{}", lazy_format::lazy_format!("{x}"));
}

[blyxyas]

Bisection result: This bug is present from the lint's addition.

lazy_format expands to:

#![feature(prelude_import)]
#![feature(print_internals)]
#[prelude_import]
use std::prelude::rust_2024::*;
#[macro_use]
extern crate std;
#[deny(clippy::literal_string_with_formatting_args)]
fn main() {
    let x = 1;
    {
        ::std::io::_print(
            format_args!(
                "{0}\n",
                {
                    struct LazyFormat<
                        F: Fn(&mut ::core::fmt::Formatter) -> ::core::fmt::Result,
                    >(
                        F,
                    );
                    #[automatically_derived]
                    impl<
                        F: ::core::clone::Clone
                            + Fn(&mut ::core::fmt::Formatter) -> ::core::fmt::Result,
                    > ::core::clone::Clone for LazyFormat<F> {
                        #[inline]
                        fn clone(&self) -> LazyFormat<F> {
                            LazyFormat(::core::clone::Clone::clone(&self.0))
                        }
                    }
                    #[automatically_derived]
                    impl<
                        F: ::core::marker::Copy
                            + Fn(&mut ::core::fmt::Formatter) -> ::core::fmt::Result,
                    > ::core::marker::Copy for LazyFormat<F> {}
                    impl<
                        F: Fn(&mut ::core::fmt::Formatter) -> ::core::fmt::Result,
                    > ::core::fmt::Debug for LazyFormat<F> {
                        #[inline]
                        fn fmt(
                            &self,
                            f: &mut ::core::fmt::Formatter,
                        ) -> ::core::fmt::Result {
                            f.write_str(
                                "make_lazy_format!(| f | $crate :: write! (f, \"{x}\"))",
                            )
                        }
                    }
                    impl<
                        F: Fn(&mut ::core::fmt::Formatter) -> ::core::fmt::Result,
                    > ::core::fmt::Display for LazyFormat<F> {
                        #[inline]
                        fn fmt(
                            &self,
                            f: &mut ::core::fmt::Formatter,
                        ) -> ::core::fmt::Result {
                            (self.0)(f)
                        }
                    }
                    LazyFormat(move |
                        f: &mut ::core::fmt::Formatter,
                    | -> ::core::fmt::Result {
                        {
                            enum Style {
                                Empty,
                                Plain,
                                Format,
                            }
                            match {
                                const STYLE: Style = match "{x}".as_bytes().split_first() {
                                    ::core::option::Option::None => Style::Empty,
                                    ::core::option::Option::Some((&(b'}' | b'{'), _)) => {
                                        Style::Format
                                    }
                                    ::core::option::Option::Some((_, mut s)) => {
                                        loop {
                                            s = match s.split_first() {
                                                None => break Style::Plain,
                                                Some((&(b'}' | b'{'), _)) => break Style::Format,
                                                Some((_, s)) => s,
                                            };
                                        }
                                    }
                                };
                                STYLE
                            } {
                                Style::Empty => ::core::fmt::Result::Ok(()),
                                Style::Plain => ::core::fmt::Write::write_str(f, "{x}"),
                                Style::Format => {
                                    ::core::fmt::Write::write_fmt(f, format_args!("{0}", x))
                                }
                            }
                        }
                    })
                },
            ),
        );
    };
}

Note that Style::Plain => ::core::fmt::Write::write_str(f, "{x}"),.