fix: many clippy --tests lints.

src/generation/cmark/parse_cmark_ast.rs

@@ -252,7 +252,7 @@ fn parse_heading(level: HeadingLevel, iterator: &mut EventIterator) -> Result<He
         }
         return Err(ParseError::new(
           iterator.get_last_range(),
-          &format!("Found end tag with level {}, but expected {}", end_level, level),
+          format!("Found end tag with level {}, but expected {}", end_level, level),
         ));
       }
       _ => children.push(parse_event(event, iterator)?),
@@ -440,9 +440,8 @@ fn parse_html_block(iterator: &mut EventIterator) -> Result<Html, ParseError> {
   iterator.allow_empty_text_events = true;
 
   while let Some(event) = iterator.next() {
-    match event {
-      Event::End(TagEnd::HtmlBlock) => break,
-      _ => {}
+    if let Event::End(TagEnd::HtmlBlock) = event {
+      break;
     }
   }
 
@@ -570,7 +569,7 @@ fn parse_table(column_alignment: Vec<Alignment>, iterator: &mut EventIterator) -
   } else {
     return Err(ParseError::new(
       iterator.get_last_range(),
-      &format!("Expected a table head event, but found: {:?}", head_event),
+      format!("Expected a table head event, but found: {:?}", head_event),
     ));
   };
 
@@ -582,7 +581,7 @@ fn parse_table(column_alignment: Vec<Alignment>, iterator: &mut EventIterator) -
       _ => {
         return Err(ParseError::new(
           iterator.get_last_range(),
-          &format!("Unexpected event kind in table: {:?}", event),
+          format!("Unexpected event kind in table: {:?}", event),
         ))
       }
     }
@@ -617,7 +616,7 @@ fn parse_table_head(iterator: &mut EventIterator) -> Result<TableHead, ParseErro
       _ => {
         return Err(ParseError::new(
           iterator.get_last_range(),
-          &format!("Unexpected event kind in table head: {:?}", event),
+          format!("Unexpected event kind in table head: {:?}", event),
         ))
       }
     }
@@ -640,7 +639,7 @@ fn parse_table_row(iterator: &mut EventIterator) -> Result<TableRow, ParseError>
       _ => {
         return Err(ParseError::new(
           iterator.get_last_range(),
-          &format!("Unexpected event kind in table row: {:?}", event),
+          format!("Unexpected event kind in table row: {:?}", event),
         ))
       }
     }

src/generation/cmark/parsing/common.rs

@@ -24,20 +24,20 @@ fn parse_text_in_container(
           start: byte_pos,
           end: byte_pos + c.len_utf8(),
         },
-        &format!("Unexpected open container char `{}`.", open_char),
+        format!("Unexpected open container char `{}`.", open_char),
       ));
     } else {
       text.push(c);
     }
   }
 
-  return Err(ParseError::new(
+  Err(ParseError::new(
     Range {
       start: start_pos,
       end: char_scanner.pos(),
     },
-    &format!("Did not find container close char `{}`.", close_char),
-  ));
+    format!("Did not find container close char `{}`.", close_char),
+  ))
 }
 
 pub fn parse_link_url_and_title(text: &str) -> (String, Option<String>) {

src/generation/cmark/parsing/parse_image.rs

@@ -20,7 +20,7 @@ pub fn parse_image(offset: usize, text: &str, link_type: LinkType) -> Result<Nod
         start: offset,
         end: offset,
       },
-      &format!("Link type not implemented {:?}", link_type),
+      format!("Link type not implemented {:?}", link_type),
     )),
   }
 }

src/generation/cmark/parsing/parse_link_reference_definitions.rs

@@ -22,7 +22,7 @@ pub fn parse_link_reference_definitions(offset: usize, text: &str) -> Result<Vec
           start: byte_pos,
           end: byte_pos + c.len_utf8(),
         },
-        &format!("Unexpected token `{}` while parsing link reference definition.", c),
+        format!("Unexpected token `{}` while parsing link reference definition.", c),
       ));
     }
   }

src/generation/common/ast_nodes.rs

@@ -261,9 +261,9 @@ macro_rules! generate_node {
             }
         }
 
-        impl Into<Node> for $node_name {
-            fn into(self) -> Node {
-                Node::$node_name(self)
+        impl From<$node_name> for Node {
+            fn from(n: $node_name) -> Node {
+                Node::$node_name(n)
             }
         }
         )*

src/generation/common/char_scanner.rs

@@ -89,7 +89,7 @@ impl<'a> CharScanner<'a> {
             start: byte_pos,
             end: byte_pos + c.len_utf8(),
           },
-          &format!("Unexpected token `{}` when expected `{}`.", c, searching_char),
+          format!("Unexpected token `{}` when expected `{}`.", c, searching_char),
         ));
       }
     }
@@ -99,7 +99,7 @@ impl<'a> CharScanner<'a> {
         start: self.pos,
         end: self.end(),
       },
-      &format!("Did not find expected char of `{}`", searching_char),
+      format!("Did not find expected char of `{}`", searching_char),
     ))
   }
 

src/generation/generate.rs

@@ -1017,7 +1017,7 @@ fn gen_metadata_block(node: &MetadataBlock, context: &mut Context) -> PrintItems
     MetadataBlockKind::PlusesStyle => sc!("+++"),
   };
 
-  items.push_sc(&delimiter);
+  items.push_sc(delimiter);
   items.push_signal(Signal::NewLine);
   match node.kind {
     MetadataBlockKind::YamlStyle => {
@@ -1034,7 +1034,7 @@ fn gen_metadata_block(node: &MetadataBlock, context: &mut Context) -> PrintItems
     }
   }
   items.push_signal(Signal::NewLine);
-  items.push_sc(&delimiter);
+  items.push_sc(delimiter);
 
   items
 }
@@ -1064,7 +1064,7 @@ fn get_items_text(items: PrintItems) -> String {
     ir_helpers::with_no_new_lines(items),
     PrintOptions {
       indent_width: 0,
-      max_width: std::u32::MAX,
+      max_width: u32::MAX,
       use_tabs: false,
       new_line_text: "",
     },

src/generation/metadata.rs

@@ -19,8 +19,8 @@ pub fn strip_metadata_header(text: &str) -> &str {
   }
 
   while scanner.has_next() {
-    if scanner.is_next_text(&delimiter) {
-      scanner.move_text(&delimiter);
+    if scanner.is_next_text(delimiter) {
+      scanner.move_text(delimiter);
       if scanner.move_new_line() || scanner.pos() == scanner.end() {
         let range = std::ops::Range {
           start: 0,

tests/newline_test.rs

@@ -4,15 +4,15 @@ use dprint_plugin_markdown::*;
 #[test]
 fn test_issue22_with_carriage_return_line_feeds() {
   let config = ConfigurationBuilder::new().build();
-  let result = format_text(&"```\r\ntest\r\n\r\ntest\r\n```\r\n", &config, |_, _, _| Ok(None)).unwrap();
+  let result = format_text("```\r\ntest\r\n\r\ntest\r\n```\r\n", &config, |_, _, _| Ok(None)).unwrap();
   assert_eq!(result.unwrap(), "```\ntest\n\ntest\n```\n");
 }
 
 #[test]
 fn test_issue26_with_carriage_return_line_feeds() {
   let config = ConfigurationBuilder::new().build();
   let result = format_text(
-    &"Testing:\r\n<!-- dprint-ignore -->\r\n```json\r\ntesting\r\n```\r\n",
+    "Testing:\r\n<!-- dprint-ignore -->\r\n```json\r\ntesting\r\n```\r\n",
     &config,
     |_, _, _| Ok(None),
   )
@@ -28,13 +28,13 @@ fn test_issue35_convert_two_spaces_end_of_line_to_hard_break() {
   // In markdown, two spaces at the end of the line is a hard break.
   // To make this easier to see, we convert it to a hard break.
   let config = ConfigurationBuilder::new().build();
-  let result = format_text(&"testing  \nasdf", &config, |_, _, _| Ok(None)).unwrap();
+  let result = format_text("testing  \nasdf", &config, |_, _, _| Ok(None)).unwrap();
   assert_eq!(result.unwrap(), "testing\\\nasdf\n");
 }
 
 #[test]
 fn test_issue35_ignore_two_spaces_before_hard_break() {
   let config = ConfigurationBuilder::new().build();
-  let result = format_text(&"testing  \\\nasdf", &config, |_, _, _| Ok(None)).unwrap();
+  let result = format_text("testing  \\\nasdf", &config, |_, _, _| Ok(None)).unwrap();
   assert_eq!(result.unwrap(), "testing\\\nasdf\n");
 }

tests/spec_test.rs

@@ -29,10 +29,10 @@ fn main() {
         let config_result = resolve_config(spec_config, &global_config);
         ensure_no_diagnostics(&config_result.diagnostics);
 
-        format_text(&file_text, &config_result.config, |tag, file_text, line_width| {
+        format_text(file_text, &config_result.config, |tag, file_text, line_width| {
           let end = format!("_formatted_{}", line_width);
           if tag == "format" && !file_text.ends_with(&end) {
-            Ok(Some(format!("{}{}\n\n", file_text.to_string(), end)))
+            Ok(Some(format!("{}{}\n\n", file_text, end)))
           } else {
             Ok(None)
           }
@@ -45,19 +45,19 @@ fn main() {
         let spec_config: ConfigKeyMap = serde_json::from_value(_spec_config.clone().into()).unwrap();
         let config_result = resolve_config(spec_config, &global_config);
         ensure_no_diagnostics(&config_result.diagnostics);
-        return serde_json::to_string(&trace_file(
-          &_file_text,
+        serde_json::to_string(&trace_file(
+          _file_text,
           &config_result.config,
           |tag, file_text, line_width| {
             let end = format!("_formatted_{}", line_width);
             if tag == "format" && !file_text.ends_with(&end) {
-              Ok(Some(format!("{}{}\n\n", file_text.to_string(), end)))
+              Ok(Some(format!("{}{}\n\n", file_text, end)))
             } else {
               Ok(None)
             }
           },
         ))
-        .unwrap();
+        .unwrap()
       }
 
       #[cfg(not(feature = "tracing"))]