lint: fix clippy::format_push_string

magistau · magistau · commit ea3412a9c3d3 · 2025-08-05T22:07:53.000+03:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -18,7 +18,6 @@ print_stderr = "allow"
 dbg_macro = "warn"
 pedantic = {level = "warn", priority = -1}
 inline_always = "allow"  # TODO: benchmark inlines
-format_push_string = "allow"  # 27
 missing_panics_doc = "allow"  # 37
 used_underscore_binding = "allow"  # 39
 float_cmp = "allow"  # 40
diff --git a/pad/editor/src/lib.rs b/pad/editor/src/lib.rs
@@ -3,6 +3,7 @@ pub mod utils;
 
 use std::{
     cell::Cell,
+    fmt::Write,
     iter::{once, repeat_n},
     mem::take,
     path::PathBuf,
@@ -2275,7 +2276,7 @@ pub fn Prim(
     let href = format!("/docs/{}", prim.name());
     let mut title = String::new();
     if let Some(ascii) = prim.ascii() {
-        title.push_str(&format!("({ascii})"));
+        write!(title, "({ascii})").ok();
     }
     if prim.glyph().is_some() && glyph_only {
         if !title.is_empty() {
diff --git a/site/src/main.rs b/site/src/main.rs
@@ -403,6 +403,7 @@ fn NotFound() -> impl IntoView {
 
 #[cfg(test)]
 fn prim_html(prim: Primitive, glyph_only: bool, hide_docs: bool) -> String {
+    use std::fmt::Write;
     use uiua::PrimDoc;
 
     let symbol_class = format!("prim-glyph {}", uiua_editor::prim_class(prim));
@@ -415,7 +416,7 @@ fn prim_html(prim: Primitive, glyph_only: bool, hide_docs: bool) -> String {
     let href = format!("/docs/{}", prim.name());
     let mut title = String::new();
     if let Some(ascii) = prim.ascii() {
-        title.push_str(&format!("({ascii})"));
+        write!(title, "({ascii})").ok();
     }
     if prim.glyph().is_some() && glyph_only {
         if !title.is_empty() {
diff --git a/site/src/markdown.rs b/site/src/markdown.rs
@@ -353,7 +353,7 @@ fn node_html<'a>(node: &'a AstNode<'a>) -> String {
                                 line.push('\n');
                                 for formatted in formatted {
                                     for fline in formatted.lines() {
-                                        line.push_str(&format!("\n# {fline}"));
+                                        write!(line, "\n# {fline}").ok();
                                     }
                                 }
                             } else {
@@ -372,7 +372,9 @@ fn node_html<'a>(node: &'a AstNode<'a>) -> String {
                     {
                         break;
                     }
-                    Err(e) => line.push_str(&format!("# {e}")),
+                    Err(e) => {
+                        write!(line, "# {e}").ok();
+                    }
                 }
             }
             let text = lines.join("\n");
diff --git a/site/src/other.rs b/site/src/other.rs
@@ -1,5 +1,6 @@
 use leptos::*;
 use leptos_meta::*;
+use std::fmt::Write;
 use uiua::{ConstClass, Primitive, SysOp, CONSTANTS};
 use uiua_editor::{lang, Editor};
 
@@ -459,7 +460,7 @@ pub fn Combinators() -> impl IntoView {
                 if !line.starts_with('#') {
                     for i in 0..inputs {
                         let a = i * 3 + 1;
-                        ex.push_str(&format!(" {}_{}_{}", a, a + 1, a + 2));
+                        write!(ex, " {}_{}_{}", a, a+1, a+2).ok();
                     }
                     ex.push_str("  ");
                 }
diff --git a/site/src/primitive.rs b/site/src/primitive.rs
@@ -1,5 +1,6 @@
 use leptos::*;
 use leptos_router::*;
+use std::fmt::Write;
 use uiua::{PrimClass, PrimDoc, PrimDocFragment, PrimDocLine, Primitive, SysOp};
 use uiua_editor::Editor;
 
@@ -49,11 +50,12 @@ pub fn PrimDocs(prim: Primitive) -> impl IntoView {
         sig.push_str("Constant");
     } else if let Some(margs) = prim.modifier_args() {
         match margs {
-            1 => sig.push_str("Monadic"),
-            2 => sig.push_str("Dyadic"),
-            3 => sig.push_str("Triadic"),
-            n => sig.push_str(&format!("{n}-function")),
+            1 => write!(sig, "Monadic"),
+            2 => write!(sig, "Dyadic"),
+            3 => write!(sig, "Triadic"),
+            n => write!(sig, "{n}-function"),
         }
+        .ok();
         if let Some(args) = prim.args() {
             sig.push(' ');
             sig.push_str(&args.to_string());
@@ -62,16 +64,17 @@ pub fn PrimDocs(prim: Primitive) -> impl IntoView {
         sig.push_str(" modifier");
     } else {
         match prim.args() {
-            Some(0) => sig.push_str("Noadic"),
-            Some(1) => sig.push_str("Monadic"),
-            Some(2) => sig.push_str("Dyadic"),
-            Some(3) => sig.push_str("Triadic"),
-            Some(n) => sig.push_str(&format!("{n}-argument")),
-            None => sig.push_str("Variadic"),
+            Some(0) => write!(sig, "Noadic"),
+            Some(1) => write!(sig, "Monadic"),
+            Some(2) => write!(sig, "Dyadic"),
+            Some(3) => write!(sig, "Triadic"),
+            Some(n) => write!(sig, "{n}-argument"),
+            None => write!(sig, "Variadic"),
         }
+        .ok();
         if let Some(outputs) = prim.outputs() {
             if outputs != 1 {
-                sig.push_str(&format!(" {outputs}-output"));
+                write!(sig, " {outputs}-output").ok();
             }
         } else {
             sig.push_str(" variable-output");
diff --git a/src/assembly.rs b/src/assembly.rs
@@ -1,5 +1,5 @@
 use std::{
-    fmt,
+    fmt::{self, Write},
     hash::{DefaultHasher, Hash, Hasher},
     ops::{Index, IndexMut},
     path::PathBuf,
@@ -263,7 +263,7 @@ impl Assembly {
                 if map.len() == 1 {
                     let key = map.keys().next().unwrap();
                     let value = map.values().next().unwrap();
-                    uasm.push_str(&format!("{key} {value}\n"));
+                    writeln!(uasm, "{key} {value}").ok();
                     continue;
                 }
             }
@@ -293,7 +293,7 @@ impl Assembly {
         for entry in &self.inputs.files {
             let key = entry.key();
             let value = entry.value();
-            uasm.push_str(&format!("{}: {:?}\n", key.display(), value));
+            writeln!(uasm, "{}: {:?}", key.display(), value).ok();
         }
 
         if !self.inputs.strings.is_empty() {
diff --git a/src/format.rs b/src/format.rs
@@ -113,6 +113,7 @@ macro_rules! create_config {
 
         #[test]
         fn generate_format_cfg_docs() {
+            use std::fmt::Write;
             paste! {
                 let mut s: String = r"
 # Uiua Formatter Configuration
@@ -125,19 +126,20 @@ Example with default values:
 ```uiua
 ".into();
                 $(
-                    s.push_str(&format!("{} ← {}\n", stringify!([<$name:camel>]), default_to_uiua!($default)));
+                    write!(s, "{} ← {}\n", stringify!([<$name:camel>]), default_to_uiua!($default)).ok()
+                    ;
                 )*
                 s.push_str(r"```
 The following configuration options are available:
 
 ");
 
                 $(
-                    s.push_str(&format!("### {}\n", stringify!([<$name:camel>])));
-                    s.push_str(&format!("Type: {}\n\n", param_type!($ty)));
-                    s.push_str(&format!("Default: `{}`\n\n", default_to_uiua!($default)));
-                    $(s.push_str(&format!("{}\n", $doc.trim()));)*
-                    s.push_str("\n---\n\n");
+                    writeln!(s, "### {}", stringify!([<$name:camel>])).ok();
+                    writeln!(s, "Type: {}\n", param_type!($ty)).ok();
+                    writeln!(s, "Default: `{}`\n", default_to_uiua!($default)).ok();
+                    $(writeln!(s, "{}", $doc.trim()).ok();)*
+                    writeln!(s, "\n---\n").ok();
                 )*
 
                 fs::write("site/text/format_config.md", s).unwrap();
diff --git a/src/grid_fmt.rs b/src/grid_fmt.rs
@@ -3,6 +3,7 @@
 use std::{
     collections::HashMap,
     f64::consts::{E, PI, TAU},
+    fmt::Write,
     iter::{once, repeat_n},
     mem::take,
 };
@@ -274,10 +275,12 @@ impl GridFmt for f64 {
                 round_sig_dec(mean, 4).grid_string(false)
             );
             if nan_count > 0 {
-                s.push_str(&format!(
+                write!(
+                    s,
                     " ({nan_count} NaN{})",
                     if nan_count > 1 { "s" } else { "" }
-                ));
+                )
+                .ok();
             }
             s
         }
diff --git a/src/lsp.rs b/src/lsp.rs
@@ -845,7 +845,7 @@ pub use server::run_language_server;
 
 #[cfg(feature = "lsp")]
 mod server {
-    use std::{char::decode_utf16, env::current_dir, path::Path, sync::Arc};
+    use std::{char::decode_utf16, env::current_dir, fmt::Write, path::Path, sync::Arc};
 
     use dashmap::DashMap;
     use tower_lsp::{
@@ -1127,7 +1127,7 @@ mod server {
                     span.as_str(&doc.asm.inputs, |s| value.push_str(s));
                     match docs.kind {
                         BindingDocsKind::Function { sig, .. } => {
-                            value.push_str(&format!(" {sig}"));
+                            write!(value, " {sig}").ok();
                         }
                         _ => {}
                     }
@@ -1148,7 +1148,7 @@ mod server {
                     }
                     value.push_str("\n```");
                     if let Some(escape) = &docs.escape {
-                        value.push_str(&format!("\n`{escape}`"));
+                        write!(value, "\n`{escape}`").ok();
                     }
                     match docs.kind {
                         BindingDocsKind::Function {
@@ -2435,20 +2435,21 @@ mod server {
 
     fn doc_frag_markdown(md: &mut String, frag: &PrimDocFragment) {
         match frag {
-            PrimDocFragment::Text(text) => md.push_str(text),
-            PrimDocFragment::Code(text) => md.push_str(&format!("`{text}`")),
-            PrimDocFragment::Emphasis(text) => md.push_str(&format!("*{text}*")),
-            PrimDocFragment::Strong(text) => md.push_str(&format!("**{text}**")),
-            PrimDocFragment::Link { text, url } => md.push_str(&format!("[{text}]({url})")),
+            PrimDocFragment::Text(text) => write!(md, "{text}"),
+            PrimDocFragment::Code(text) => write!(md, "`{text}`"),
+            PrimDocFragment::Emphasis(text) => write!(md, "*{text}*"),
+            PrimDocFragment::Strong(text) => write!(md, "**{text}**"),
+            PrimDocFragment::Link { text, url } => write!(md, "[{text}]({url})"),
             PrimDocFragment::Primitive { prim, named } => {
                 let text = if *named {
                     format!("`{}`", prim.format())
                 } else {
                     prim.to_string()
                 };
-                md.push_str(&format!("[{text}](https://uiua.org/docs/{})", prim.name()))
+                write!(md, "[{}](https://uiua.org/docs/{})", text, prim.name())
             }
         }
+        .ok();
     }
 
     fn full_prim_doc_markdown(prim: Primitive) -> String {
@@ -2459,12 +2460,12 @@ mod server {
         for frag in &doc.short {
             doc_frag_markdown(&mut value, frag);
         }
-        value.push_str("\n\n");
-        value.push_str(&format!(
-            "[Documentation](https://uiua.org/docs/{})",
+        write!(
+            value,
+            "\n\n[Documentation](https://uiua.org/docs/{})\n\n",
             prim.name()
-        ));
-        value.push_str("\n\n");
+        )
+        .ok();
         for line in &doc.lines {
             match line {
                 PrimDocLine::Text(frags) => {
@@ -2474,22 +2475,26 @@ mod server {
                     value.push('\n');
                 }
                 PrimDocLine::Example(ex) => {
-                    value.push_str(&format!(
+                    write!(
+                        value,
                         "\
 ```uiua
 {}
 ```
 > ```
 ",
                         ex.input()
-                    ));
+                    )
+                    .ok();
                     match ex.output_strings() {
                         Ok(lines) => {
                             for line in lines.iter().flat_map(|l| l.lines()) {
-                                value.push_str(&format!("> {line}\n"));
+                                writeln!(value, "> {line}").ok();
                             }
                         }
-                        Err(err) => value.push_str(&format!("> Error: {err}\n")),
+                        Err(err) => {
+                            writeln!(value, "> Error: {err}").ok();
+                        }
                     }
                     value.push_str("> ```\n\n");
                 }

Original file line number	Diff line number	Diff line change
`@@ -353,7 +353,7 @@ fn node_html<'a>(node: &'a AstNode<'a>) -> String {`
`353`	`353`	`line.push('\n');`
`354`	`354`	`for formatted in formatted {`
`355`	`355`	`for fline in formatted.lines() {`
`356`		`- line.push_str(&format!("\n# {fline}"));`
	`356`	`+ write!(line, "\n# {fline}").ok();`
`357`	`357`	`}`
`358`	`358`	`}`
`359`	`359`	`} else {`
`@@ -372,7 +372,9 @@ fn node_html<'a>(node: &'a AstNode<'a>) -> String {`
`372`	`372`	`{`
`373`	`373`	`break;`
`374`	`374`	`}`
`375`		`- Err(e) => line.push_str(&format!("# {e}")),`
	`375`	`+ Err(e) => {`
	`376`	`+ write!(line, "# {e}").ok();`
	`377`	`+ }`
`376`	`378`	`}`
`377`	`379`	`}`
`378`	`380`	`let text = lines.join("\n");`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`use leptos::*;`
`2`	`2`	`use leptos_meta::*;`
	`3`	`+use std::fmt::Write;`
`3`	`4`	`use uiua::{ConstClass, Primitive, SysOp, CONSTANTS};`
`4`	`5`	`use uiua_editor::{lang, Editor};`
`5`	`6`
`@@ -459,7 +460,7 @@ pub fn Combinators() -> impl IntoView {`
`459`	`460`	`if !line.starts_with('#') {`
`460`	`461`	`for i in 0..inputs {`
`461`	`462`	`let a = i * 3 + 1;`
`462`		`- ex.push_str(&format!(" {}_{}_{}", a, a + 1, a + 2));`
	`463`	`+ write!(ex, " {}_{}_{}", a, a+1, a+2).ok();`
`463`	`464`	`}`
`464`	`465`	`ex.push_str(" ");`
`465`	`466`	`}`