Fix clippy.

src/wasm_test/compare.rs

@@ -13,19 +13,19 @@ use crate::compare::Token;
 use crate::wasm::WasmAstNodeWrapper;
 use crate::wasm::WasmDocument;
 
-pub fn wasm_compare_document<'e, 's, 'w>(
+pub fn wasm_compare_document<'s>(
     source: &'s str,
-    emacs: &'e Token<'s>,
-    wasm: &'w WasmAstNodeWrapper<WasmDocument>,
+    emacs: &Token<'s>,
+    wasm: &WasmAstNodeWrapper<WasmDocument>,
 ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
     let wasm_json = serde_json::to_string(&wasm)?;
     let wasm_json_parsed = serde_json::from_str(&wasm_json)?;
     compare_json_value(source, emacs, &wasm_json_parsed)
 }
 
-fn compare_json_value<'b, 's>(
+fn compare_json_value<'s>(
     source: &'s str,
-    emacs: &'b Token<'s>,
+    emacs: &Token<'s>,
     wasm: &serde_json::Value,
 ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
     // println!("XXXXXXXXXXXXXX compare_json_value XXXXXXXXXXXXXX");
@@ -147,9 +147,9 @@ fn compare_json_value<'b, 's>(
     }
 }
 
-fn compare_optional_json_value<'b, 's>(
+fn compare_optional_json_value<'s>(
     source: &'s str,
-    emacs: Option<&'b Token<'s>>,
+    emacs: Option<&Token<'s>>,
     wasm: Option<&serde_json::Value>,
 ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
     match (emacs, wasm) {
@@ -175,10 +175,10 @@ fn compare_optional_json_value<'b, 's>(
     }
 }
 
-fn compare_ast_node<'e, 's, 'w>(
+fn compare_ast_node<'s>(
     source: &'s str,
-    emacs: &'e Vec<Token<'s>>,
-    wasm: &'w serde_json::Map<String, serde_json::Value>,
+    emacs: &[Token<'s>],
+    wasm: &serde_json::Map<String, serde_json::Value>,
 ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
     let mut result = WasmDiffResult::default();
     let mut emacs_list_iter = emacs.iter();
@@ -277,11 +277,13 @@ fn compare_ast_node<'e, 's, 'w>(
     {
         // Compare attributes.
         for attribute_name in wasm_attributes_map.keys() {
-            let mut layer = WasmDiffResult::default();
-            layer.name = Cow::Owned(attribute_name.clone());
+            let mut layer = WasmDiffResult::<'_> {
+                name: Cow::Owned(attribute_name.clone()),
+                ..Default::default()
+            };
             let wasm_attribute_value = wasm_attributes_map.get(attribute_name);
             let emacs_key = wasm_key_to_emacs_key(attribute_name);
-            let emacs_attribute_value = emacs_attributes_map.get(emacs_key.as_str()).map(|e| *e);
+            let emacs_attribute_value = emacs_attributes_map.get(emacs_key.as_str()).copied();
             let inner_layer =
                 compare_optional_json_value(source, emacs_attribute_value, wasm_attribute_value)?;
             if !inner_layer.name.is_empty() {
@@ -295,8 +297,10 @@ fn compare_ast_node<'e, 's, 'w>(
 
     {
         // Compare standard-properties.
-        let mut layer = WasmDiffResult::default();
-        layer.name = "standard-properties".into();
+        let mut layer = WasmDiffResult::<'_> {
+            name: "standard-properties".into(),
+            ..Default::default()
+        };
         let emacs_standard_properties = wasm_get_emacs_standard_properties(&emacs_attributes_map)?;
         let wasm_standard_properties = wasm
             .get("standard-properties")
@@ -349,12 +353,13 @@ fn compare_ast_node<'e, 's, 'w>(
 
     {
         // Compare children.
-        let mut layer = WasmDiffResult::default();
-        layer.name = "children".into();
+        let mut layer = WasmDiffResult::<'_> {
+            name: "children".into(),
+            ..Default::default()
+        };
         if let Some(wasm_iter) = wasm
             .get("children")
-            .map(|children| children.as_array())
-            .flatten()
+            .and_then(|children| children.as_array())
             .map(|children| children.iter())
         {
             layer.extend(wasm_compare_list(source, emacs_list_iter, wasm_iter)?)?;
@@ -375,10 +380,10 @@ fn wasm_key_to_emacs_key<WK: std::fmt::Display>(wasm_key: WK) -> String {
     format!(":{key}", key = wasm_key)
 }
 
-fn compare_quoted_string<'e, 's, 'w>(
+fn compare_quoted_string<'s>(
     _source: &'s str,
-    emacs: &'e str,
-    wasm: &'w String,
+    emacs: &str,
+    wasm: &String,
 ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
     let mut result = WasmDiffResult::default();
     let emacs_text = unquote(emacs)?;
@@ -448,10 +453,8 @@ where
 {
     let emacs_length = emacs.len();
     let wasm_length = wasm.len();
-    if emacs_length == 1 && wasm_length == 0 {
-        if emacs.all(|t| matches!(t.as_atom(), Ok(r#""""#))) {
-            return Ok(WasmDiffResult::default());
-        }
+    if emacs_length == 1 && wasm_length == 0 && emacs.all(|t| matches!(t.as_atom(), Ok(r#""""#))) {
+        return Ok(WasmDiffResult::default());
     }
     if emacs_length != wasm_length {
         return Ok(WasmDiffResult {
@@ -479,10 +482,10 @@ where
     })
 }
 
-fn compare_optional_pair<'e, 's, 'w>(
+fn compare_optional_pair<'s>(
     source: &'s str,
-    emacs: &'e Vec<Token<'s>>,
-    wasm: &'w serde_json::Map<String, serde_json::Value>,
+    emacs: &Vec<Token<'s>>,
+    wasm: &serde_json::Map<String, serde_json::Value>,
 ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
     let mut result = WasmDiffResult::default();
     let wasm_optval = wasm
@@ -540,10 +543,10 @@ fn compare_optional_pair<'e, 's, 'w>(
     Ok(result)
 }
 
-fn compare_object_tree<'e, 's, 'w>(
+fn compare_object_tree<'s>(
     source: &'s str,
-    emacs: &'e Vec<Token<'s>>,
-    wasm: &'w serde_json::Map<String, serde_json::Value>,
+    emacs: &[Token<'s>],
+    wasm: &serde_json::Map<String, serde_json::Value>,
 ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
     let mut result = WasmDiffResult::default();
     let wasm_attributes = wasm
@@ -657,10 +660,10 @@ fn compare_object_tree<'e, 's, 'w>(
     Ok(result)
 }
 
-fn compare_number_lines<'e, 's, 'w>(
+fn compare_number_lines<'s>(
     _source: &'s str,
-    emacs: &'e Vec<Token<'s>>,
-    wasm: &'w serde_json::Map<String, serde_json::Value>,
+    emacs: &[Token<'s>],
+    wasm: &serde_json::Map<String, serde_json::Value>,
 ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
     let mut result = WasmDiffResult::default();
     let mut emacs_iter = emacs.iter();
@@ -669,8 +672,7 @@ fn compare_number_lines<'e, 's, 'w>(
         .ok_or("Emacs number lines should have 3 children.")?
         .as_atom()?;
     let emacs_number: i64 = emacs_iter
-        .skip(1)
-        .next()
+        .nth(1)
         .ok_or("Emacs number lines should have 3 children.")?
         .as_atom()?
         .parse()?;
@@ -744,10 +746,10 @@ fn compare_number_lines<'e, 's, 'w>(
     Ok(result)
 }
 
-fn compare_string_set<'e, 's, 'w>(
+fn compare_string_set<'s>(
     _source: &'s str,
-    emacs: &'e Vec<Token<'s>>,
-    wasm: &'w serde_json::Map<String, serde_json::Value>,
+    emacs: &[Token<'s>],
+    wasm: &serde_json::Map<String, serde_json::Value>,
 ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
     let mut result = WasmDiffResult::default();
     let wasm_list = wasm
@@ -764,7 +766,7 @@ fn compare_string_set<'e, 's, 'w>(
         .map(|v| v.as_atom())
         .collect::<Result<Vec<_>, Box<dyn std::error::Error>>>()?
         .into_iter()
-        .map(|s| unquote(s))
+        .map(unquote)
         .collect::<Result<Vec<_>, Box<dyn std::error::Error>>>()?;
     let emacs_strings = emacs_strings
         .iter()
@@ -788,7 +790,7 @@ fn compare_string_set<'e, 's, 'w>(
     Ok(result)
 }
 
-fn is_plain_text<'e, 's, 'w>(wasm: &'w serde_json::Map<String, serde_json::Value>) -> bool {
+fn is_plain_text(wasm: &serde_json::Map<String, serde_json::Value>) -> bool {
     if let Some(serde_json::Value::String(node_type)) = wasm.get("ast-node") {
         node_type == "plain-text"
     } else {
@@ -796,13 +798,15 @@ fn is_plain_text<'e, 's, 'w>(wasm: &'w serde_json::Map<String, serde_json::Value
     }
 }
 
-fn compare_plain_text<'e, 's, 'w>(
+fn compare_plain_text<'s>(
     source: &'s str,
-    emacs: &'e TextWithProperties<'s>,
-    wasm: &'w serde_json::Map<String, serde_json::Value>,
+    emacs: &TextWithProperties<'s>,
+    wasm: &serde_json::Map<String, serde_json::Value>,
 ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
-    let mut result = WasmDiffResult::default();
-    result.name = "plain-text".into();
+    let mut result = WasmDiffResult::<'_> {
+        name: "plain-text".into(),
+        ..Default::default()
+    };
     if !is_plain_text(wasm) {
         result.status.push(WasmDiffStatus::Bad(
             format!(