[assembler] Clippy: enable, fix redundant_closure_for_method_calls.

Author: youngman-g

assembler/src/asmlib/ast.rs

@@ -549,7 +549,7 @@ impl RegistersContaining {
         let tmp_rc: OneOrMore<Option<RegisterContaining>> = self
             .0
             .map(|rc| rc.substitute_macro_parameters(param_values, on_missing, macros));
-        if tmp_rc.iter().all(|maybe_rc| maybe_rc.is_some()) {
+        if tmp_rc.iter().all(Option::is_some) {
             Some(RegistersContaining(tmp_rc.into_map(|maybe_rc| {
                 maybe_rc.expect("we already checked this wasn't None")
             })))
@@ -1389,9 +1389,9 @@ impl CommaDelimitedFragment {
     ) -> Self {
         let span: Span = {
             let spans: [Option<Span>; 3] = [
-                leading_commas.as_ref().map(|c| c.span()),
+                leading_commas.as_ref().map(Spanned::span),
                 Some(instruction.span),
-                trailing_commas.as_ref().map(|c| c.span()),
+                trailing_commas.as_ref().map(Spanned::span),
             ];
             match spans {
                 [_, None, _] => {
@@ -1496,7 +1496,7 @@ impl UntaggedProgramInstruction {
         let tmp_frags: OneOrMore<Option<CommaDelimitedFragment>> = self
             .fragments
             .map(|frag| frag.substitute_macro_parameters(param_values, on_missing, macros));
-        if tmp_frags.iter().any(|frag| frag.is_none()) {
+        if tmp_frags.iter().any(Option::is_none) {
             None
         } else {
             Some(UntaggedProgramInstruction {
@@ -1830,7 +1830,9 @@ impl InstructionSequence {
     }
 
     pub(crate) fn emitted_word_count(&self) -> Unsigned18Bit {
-        self.iter().map(|st| st.emitted_word_count()).sum()
+        self.iter()
+            .map(TaggedProgramInstruction::emitted_word_count)
+            .sum()
     }
 
     #[allow(clippy::too_many_arguments)]

assembler/src/asmlib/directive.rs

@@ -67,7 +67,7 @@ impl Directive {
     pub(super) fn position_rc_block(&mut self) -> Address {
         self.blocks
             .values()
-            .map(|block| block.following_addr())
+            .map(LocatedBlock::following_addr)
             .max()
             .unwrap_or_else(Origin::default_address)
     }

assembler/src/asmlib/driver.rs

@@ -239,7 +239,7 @@ pub struct Binary {
 
 impl Binary {
     fn count_words(&self) -> usize {
-        self.chunks().iter().map(|chunk| chunk.count_words()).sum()
+        self.chunks().iter().map(BinaryChunk::count_words).sum()
     }
 
     fn entry_point(&self) -> Option<Address> {

assembler/src/asmlib/eval.rs

@@ -85,7 +85,7 @@ impl Display for EvaluationFailure {
                 deps_in_order,
                 span: _,
             } => {
-                let names: Vec<String> = deps_in_order.iter().map(|dep| dep.to_string()).collect();
+                let names: Vec<String> = deps_in_order.iter().map(ToString::to_string).collect();
                 write!(
                     f,
                     "definition of {} has a dependency loop ({})",

assembler/src/asmlib/lib.rs

@@ -21,7 +21,6 @@
 #![allow(clippy::default_trait_access)] // fix later
 #![allow(clippy::match_wild_err_arm)] // fix later
 #![allow(clippy::verbose_bit_mask)] // fix later
-#![allow(clippy::redundant_closure_for_method_calls)] // fix later
 #![allow(clippy::manual_assert)] // fix soon
 #![allow(clippy::if_not_else)] // fix soon
 #![allow(clippy::doc_markdown)] // fix soon
@@ -32,7 +31,7 @@
 #![allow(clippy::match_wildcard_for_single_variants)] // fix soon
 #![allow(clippy::trivially_copy_pass_by_ref)] // fix soon
 #![allow(clippy::unnecessary_wraps)] // fix soon
-#![warn(clippy::inconsistent_struct_constructor)] // fix soon
+#![warn(clippy::redundant_closure_for_method_calls)]
 
 mod ast;
 mod collections;

assembler/src/asmlib/manuscript.rs

@@ -94,7 +94,7 @@ impl SourceFile {
         let uses_in_global_assignments = self
             .global_equalities
             .iter()
-            .flat_map(|eq| eq.symbol_uses());
+            .flat_map(Equality::symbol_uses);
         uses_in_instructions.chain(uses_in_global_assignments)
     }
 
@@ -410,7 +410,7 @@ impl ManuscriptBlock {
     pub(crate) fn instruction_count(&self) -> Unsigned18Bit {
         self.sequences
             .iter()
-            .map(|seq| seq.emitted_word_count())
+            .map(InstructionSequence::emitted_word_count)
             .sum()
     }
 

assembler/src/asmlib/memorymap.rs

@@ -168,7 +168,7 @@ impl LocatedBlock {
     pub(super) fn emitted_word_count(&self) -> Unsigned18Bit {
         self.sequences
             .iter()
-            .map(|seq| seq.emitted_word_count())
+            .map(InstructionSequence::emitted_word_count)
             .sum()
     }
 

assembler/src/asmlib/parser/tests.rs

@@ -476,7 +476,7 @@ fn test_parse_multi_syllable_symex() {
             parse_successfully_with(input, zero_or_more_symexes.clone(), no_state_setup);
         let got_canonicals: Vec<String> =
             got.into_iter().map(|symbol| symbol.to_string()).collect();
-        let expected_canonicals: Vec<String> = expected.iter().map(|s| s.to_string()).collect();
+        let expected_canonicals: Vec<String> = expected.iter().map(ToString::to_string).collect();
         assert_eq!(got_canonicals, expected_canonicals);
     }
 }
@@ -499,7 +499,7 @@ fn test_parse_single_syllable_symex() {
             parse_successfully_with(input, zero_or_more_symexes.clone(), no_state_setup);
         let got_canonicals: Vec<String> =
             got.into_iter().map(|symbol| symbol.to_string()).collect();
-        let expected_canonicals: Vec<String> = expected.iter().map(|s| s.to_string()).collect();
+        let expected_canonicals: Vec<String> = expected.iter().map(ToString::to_string).collect();
         assert_eq!(got_canonicals, expected_canonicals);
     }
 }

assembler/src/asmlib/source.rs

@@ -49,7 +49,7 @@ impl<'s> Source<'s> {
             Some(n) => n + 1,
         };
         let prefix = &self.body[line_start..pos];
-        if prefix.chars().all(|ch| ch.is_whitespace()) {
+        if prefix.chars().all(char::is_whitespace) {
             prefix
         } else {
             ""