Documented that writec!(buff, "{foo}") works for local variables.

Added test for `writec!(buff, "{foo}")`

Author: rodrimati1992

const_format/src/fmt.rs

@@ -53,6 +53,10 @@
 //! - Named, from constant (eg: `formatc!("{FOO}")`):
 //! Uses the `FOO` constant from the enclosing scope.
 //!
+//! - Named, from locals (eg: `formatc!("{foo}")`):
+//! Uses the `foo` local variable from the enclosing scope,
+//! only usable with the [`writec`] macro.
+//!
 //! ### Formatters
 //!
 //! The format arguments can be formatted in these ways:
@@ -282,7 +286,7 @@
 //! ```
 //!
 //!
-//!
+//! [`writec`]: ../macro.writec.html
 //! [`Formatter`]: ./struct.Formatter.html
 //! [`FormatMarker`]: ../marker_traits/trait.FormatMarker.html
 //! [`ConstDebug`]: ../derive.ConstDebug.html

const_format/src/lib.rs

@@ -428,5 +428,3 @@ pub mod pmr {
 
 #[cfg(all(test, not(feature = "testing")))]
 compile_error! { "tests must be run with the \"testing\" feature" }
-
-const _: &str = concatcp!(0u8);

const_format/src/macros/fmt_macros.rs

@@ -474,7 +474,7 @@ macro_rules! formatc {
 /// ```
 ///
 /// The syntax is otherwise the same as described in
-/// [the const_format::fmt module](./fmt/index.html#fmtsyntax).
+/// [the `const_format::fmt` module](./fmt/index.html#fmtsyntax).
 ///
 /// # Writers
 ///
@@ -607,6 +607,31 @@ macro_rules! formatc {
 /// # Ok::<(), const_format::Error>(())
 /// ```
 ///
+/// ### Locals in the format string
+///
+/// This example demonstrates how you can format local variables,
+/// by using their identifiers in the format string.
+///
+/// ```rust
+/// #![feature(const_mut_refs)]
+///
+/// use const_format::{Formatter, FormattingFlags, StrWriter, try_, writec};
+///
+/// const fn writeit(mut fmt: Formatter<'_>, foo: u32, bar: &str) -> const_format::Result {
+///     try_!(writec!(fmt, "{foo},{foo:?},{foo:#x},{foo:#b};"));
+///     try_!(writec!(fmt, "{bar},{bar:?}"));
+///     Ok(())
+/// }
+///
+/// let writer: &mut StrWriter = &mut StrWriter::new([0; 128]);
+///
+/// writeit(writer.make_formatter(FormattingFlags::NEW), 100, "hello")?;
+///
+/// assert_eq!(writer.as_str(), r#"100,100,0x64,0b1100100;hello,"hello""#);
+///
+/// # Ok::<(), const_format::Error>(())
+/// ```
+///
 /// [`Formatter`]: ./fmt/struct.Formatter.html
 /// [`WriteMarker`]: ./marker_traits/trait.WriteMarker.html
 ///

const_format/tests/misc_tests/writec_macro.rs

@@ -100,6 +100,30 @@ fn named_parameters() {
     assert_eq!(writer.as_str(), "8,13,21,34,1000,D,55..89");
 }
 
+#[test]
+fn write_from_locals() {
+    const fn inner(f: &mut Formatter<'_>) -> Result<(), Error> {
+        let foo = 13u8;
+        let bar = "58";
+
+        innerb(f, foo, bar)
+    }
+    const fn innerb(f: &mut Formatter<'_>, foo: u8, bar: &str) -> Result<(), Error> {
+        writec!(
+            f,
+            "{foo},{bar},{foo:?},{bar:?},{foo:x},{bar:x},{foo:b},{bar:b}"
+        )
+    }
+
+    let writer: &mut StrWriter = &mut StrWriter::new([0; 96]);
+    inner(&mut writer.make_formatter(FormattingFlags::NEW)).unwrap();
+    assert_eq!(writer.as_str(), r#"13,58,13,"58",D,"58",1101,"58""#);
+
+    writer.clear();
+    inner(&mut writer.make_formatter(FormattingFlags::NEW)).unwrap();
+    assert_eq!(writer.as_str(), r#"13,58,13,"58",D,"58",1101,"58""#);
+}
+
 #[test]
 #[cfg(feature = "fmt")]
 fn access_formatter() {

const_format/tests/misc_tests_modules.rs

@@ -9,19 +9,23 @@ pub const _ASSERT_NOT_CF: [(); 13] = [(); const_format::NOT_CF];
 
 mod misc_tests {
     #[cfg(feature = "assert")]
+    #[cfg(not(feature = "only_new_tests"))]
     mod asserts;
 
     #[cfg(feature = "fmt")]
     #[cfg(not(feature = "only_new_tests"))]
     mod call_debug_fmt_macro;
 
     #[cfg(feature = "fmt")]
+    #[cfg(not(feature = "only_new_tests"))]
     mod concatc_macro_tests;
 
     #[cfg(feature = "derive")]
+    #[cfg(not(feature = "only_new_tests"))]
     mod derive_tests;
 
     #[cfg(feature = "assert")]
+    #[cfg(not(feature = "only_new_tests"))]
     mod equality_tests;
 
     #[cfg(not(feature = "only_new_tests"))]
@@ -31,14 +35,15 @@ mod misc_tests {
     #[cfg(not(feature = "only_new_tests"))]
     mod impl_fmt_macro_tests;
 
-    // #[cfg(not(feature = "only_new_tests"))]
+    #[cfg(feature = "assert")]
+    #[cfg(not(feature = "only_new_tests"))]
     mod shared_cp_macro_tests;
 
     #[cfg(feature = "fmt")]
     #[cfg(not(feature = "only_new_tests"))]
     mod type_kind_coercion_macro_tests;
 
     #[cfg(feature = "fmt")]
-    #[cfg(not(feature = "only_new_tests"))]
+    //#[cfg(not(feature = "only_new_tests"))]
     mod writec_macro;
 }

const_format_proc_macros/src/format_args.rs

@@ -1,11 +1,11 @@
 use crate::{
     format_str_parsing::FormatStr, formatting::FormattingFlags, parse_utils::StrRawness,
-    shared_arg_parsing::ExprArg, spanned::Spans,
+    parse_utils::TokenStream2Ext, shared_arg_parsing::ExprArg, spanned::Spans,
 };
 
 use proc_macro2::{Ident, Span, TokenStream as TokenStream2};
 
-use quote::quote_spanned;
+use quote::{quote_spanned, TokenStreamExt};
 
 ////////////////////////////////////////////////
 
@@ -101,10 +101,15 @@ impl ExpandInto {
                 let local_variable = &fmted.local_variable;
                 let span = local_variable.span();
 
-                quote_spanned!(span=>
+                let mut tokens = quote::quote!(
                     __cf_osRcTFl4A::coerce_to_fmt!(&#local_variable)
-                        .#fmt_method(&mut #formatter.make_formatter(#flags))
+                        .#fmt_method
                 )
+                .set_span_recursive(span);
+
+                tokens.append_all(quote::quote!( (&mut #formatter.make_formatter(#flags)) ));
+
+                tokens
             }
             ExpandInto::WithFormatter(ExpandWithFormatter {
                 format,

print_errors/src/using_writec_macro.rs

@@ -11,5 +11,11 @@ fn using_writec(writer: &mut StrWriter) -> cfmt::Result {
     // trying to write an uninferred integer type
     writec!(writer, "{}", 0)?;
 
+    let a = 0;
+    writec!(writer, "{}", a)?;
+    writec!(writer, "{b}", b = a)?;
+    writec!(writer, "{a}")?;
+    writec!(writer, "{a:?}")?;
+
     Ok(())
 }