fix macro usages

make clippy happy

Author: yshavit

build.rs

@@ -52,7 +52,7 @@ fn generate_integ_test_cases(out_dir: &String) -> Result<(), String> {
             if let Some(files) = &spec_file_parsed.given.files {
                 out.with_indent(|out| {
                     for (file_name, file_content) in files {
-                        out.writeln(&format!("({:?}, {:?}),", file_name, file_content));
+                        out.writeln(&format!("({file_name:?}, {file_content:?}),"));
                     }
                 });
             }

src/md_elem/tree.rs

@@ -302,29 +302,29 @@ impl Display for InvalidMd {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             InvalidMd::Unsupported(node) => {
-                write!(f, "unsupported node: {:?}", node)
+                write!(f, "unsupported node: {node:?}")
             }
             InvalidMd::NonListItemDirectlyUnderList(node) => {
-                write!(f, "expected a list item, but found: {:?}", node)
+                write!(f, "expected a list item, but found: {node:?}")
             }
             InvalidMd::NonRowDirectlyUnderTable(node) => {
-                write!(f, "expected a row, but found: {:?}", node)
+                write!(f, "expected a row, but found: {node:?}")
             }
             InvalidMd::NonInlineWhereInlineExpected(node) => {
-                write!(f, "expected an inline element, but found: {:?}", node)
+                write!(f, "expected an inline element, but found: {node:?}")
             }
             InvalidMd::MissingReferenceDefinition(id) => {
-                write!(f, "couldn't find definition for link/image/footnote: {}", id)
+                write!(f, "couldn't find definition for link/image/footnote: {id}")
             }
             InvalidMd::ConflictingReferenceDefinition(id) => {
-                write!(f, "found multiple definitions for link/image/footnote: {}", id)
+                write!(f, "found multiple definitions for link/image/footnote: {id}")
             }
             InvalidMd::InternalError(err) => {
                 f.write_str("internal error\n")?;
                 std::fmt::Display::fmt(&err.backtrace, f)
             }
             InvalidMd::UnknownMarkdown(description) => {
-                write!(f, "encountered unknown markdown: {}\n\n", description)?;
+                write!(f, "encountered unknown markdown: {description}\n\n")?;
                 f.write_str("* Please consider reporting this at https://github.com/yshavit/mdq/issues\n")?;
                 f.write_str("* You can suppress this error by using --allow-unknown-markdown.")
             }
@@ -1948,7 +1948,7 @@ impl<'a> Lookups<'a> {
     }
 
     fn build_lookups(&mut self, node: &mdast::Node, read_opts: &ReadOptions) -> Result<(), InvalidMd> {
-        let x = format!("{:?}", node);
+        let x = format!("{node:?}");
         let _ = x;
         match node {
             mdast::Node::FootnoteDefinition(def) => {
@@ -3426,13 +3426,13 @@ mod tests {
         {
             match result {
                 Ok(lookups) => check(lookups),
-                Err(err) => panic!("expected good Lookups, but got: {:?}", err),
+                Err(err) => panic!("expected good Lookups, but got: {err:?}"),
             }
         }
 
         fn expect_absent(result: Result<Lookups<'static>, InvalidMd>, expect: InvalidMd) {
             match result {
-                Ok(_) => panic!("expected {:?}, but got good Lookups", expect),
+                Ok(_) => panic!("expected {expect:?}, but got good Lookups"),
                 Err(err) => assert_eq!(err, expect),
             }
         }
@@ -3870,14 +3870,14 @@ mod tests {
                 _ => ("", ""),
             };
             if !tag.is_empty() {
-                out.push_str(&format!("<{}>", tag))
+                out.push_str(&format!("<{tag}>"))
             }
             out.push_str(text);
             if let Some(children) = node.children() {
                 children.iter().for_each(|c| build(out, c));
             }
             if !tag.is_empty() {
-                out.push_str(&format!("</{}>", tag))
+                out.push_str(&format!("</{tag}>"))
             }
         }
         let mut s = String::with_capacity(32);

src/md_elem/tree_ref.rs

@@ -231,7 +231,7 @@ mod tests {
 
         fn cell_matches(substring: &str) -> impl Fn(&TableCell) -> Result<bool, ()> + '_ {
             move |line| {
-                let line_str = format!("{:?}", line);
+                let line_str = format!("{line:?}");
                 Ok(line_str.contains(substring))
             }
         }

src/output/fmt_plain_inline.rs

@@ -84,7 +84,7 @@ where
         MdElem::BlockQuote(block) => write_plain_result(out, block.body.iter()),
         MdElem::CodeBlock(CodeBlock { value: body, .. }) | MdElem::FrontMatter(FrontMatter { body, .. }) => {
             if !body.is_empty() {
-                writeln!(out, "{}", body)?;
+                writeln!(out, "{body}")?;
                 writeln!(out)?;
             }
             Ok(())

src/output/output_adapter.rs

@@ -57,7 +57,7 @@ impl<W: fmt::Write> SimpleWrite for IoAdapter<W> {
     fn write_char(&mut self, ch: char) -> io::Result<()> {
         self.0
             .write_char(ch)
-            .map_err(|err| io::Error::other(format!("while writing char: {}", err)))
+            .map_err(|err| io::Error::other(format!("while writing char: {err}")))
     }
 
     fn flush(&mut self) -> io::Result<()> {

src/util/output.rs

@@ -219,7 +219,7 @@ impl<W: SimpleWrite> Drop for Output<W> {
         }
         if let Err(e) = self.stream.flush() {
             if WritingState::Error != self.writing_state {
-                eprintln!("error while writing output: {}", e);
+                eprintln!("error while writing output: {e}");
                 self.writing_state = WritingState::Error;
             }
         }
@@ -469,7 +469,7 @@ impl WritingState {
             return;
         }
         if let Err(e) = out.write_char(ch) {
-            eprintln!("error while writing output: {}", e);
+            eprintln!("error while writing output: {e}");
             *self = WritingState::Error;
         }
         if matches!(*self, WritingState::HaveNotWrittenAnything) {

tests/integ_test.rs

@@ -32,7 +32,7 @@ impl<const N: usize> mdq::run::OsFacade for CaseRunner<'_, N> {
                 return Ok(content.to_string());
             }
         }
-        Err(io::Error::new(ErrorKind::NotFound, format!("File not found: {}", path)))
+        Err(io::Error::new(ErrorKind::NotFound, format!("File not found: {path}")))
     }
 
     fn stdout(&mut self) -> impl io::Write {