[assembler] Fix some clippy warnings.

Author: youngman-g

assembler/src/asmlib/lexer/tests.rs

@@ -5,7 +5,7 @@ fn is_error_token(t: &Token) -> bool {
     matches!(t, Token::Error(_))
 }
 
-fn scan_slices<'a>(input: &'a str) -> Result<Vec<(Token, &'a str)>, Unrecognised> {
+fn scan_slices(input: &str) -> Result<Vec<(Token, &str)>, Unrecognised> {
     dbg!(input);
     dbg!(input.len());
 
@@ -20,7 +20,7 @@ fn scan_slices<'a>(input: &'a str) -> Result<Vec<(Token, &'a str)>, Unrecognised
     Lexer::new(input).spanned().map(mapping).collect()
 }
 
-fn scan_tokens_only<'a>(input: &'a str) -> Result<Vec<Token>, Unrecognised> {
+fn scan_tokens_only(input: &str) -> Result<Vec<Token>, Unrecognised> {
     Lexer::new(input).collect()
 }
 
@@ -1520,11 +1520,8 @@ fn test_superscript_symex_long() {
 fn test_superscript_symex_bad() {
     let result = scan_tokens_only("@sup_sps@");
     dbg!(&result);
-    match result {
-        Ok(tokens) => {
-            assert!(tokens.iter().any(is_error_token));
-        }
-        Err(_) => (),
+    if let Ok(tokens) = result {
+        assert!(tokens.iter().any(is_error_token));
     }
 }
 
@@ -1680,11 +1677,8 @@ fn test_subscript_symex_long() {
 fn test_subscript_symex_bad() {
     let result = scan_tokens_only("@sub_sps@");
     dbg!(&result);
-    match result {
-        Ok(tokens) => {
-            assert!(tokens.iter().any(is_error_token));
-        }
-        Err(_) => (),
+    if let Ok(tokens) = result {
+        assert!(tokens.iter().any(is_error_token));
     }
 }
 

assembler/src/asmlib/parser.rs

@@ -546,15 +546,15 @@ where
         state: &State,
         span: Span,
     ) -> Result<MacroDefinition, chumsky::error::Rich<'a, lexer::Token>> {
-        match state.get_macro_definition(&name) {
+        match state.get_macro_definition(name) {
             None => Err(Rich::custom(span, format!("unknown macro {name}"))),
             Some(macro_def) => Ok(macro_def.clone()),
         }
     }
 
     symex::parse_symex(SymexSyllableRule::OneOnly, Script::Normal).try_map_with(|name, extra| {
         let span: Span = extra.span();
-        let state: &State = &extra.state();
+        let state: &State = extra.state();
         mapping(&name, state, span)
     })
 }
@@ -593,7 +593,7 @@ where
 }
 
 #[cfg(test)] // not yet used outside tests.
-impl<'src, 'b, I> ExtParser<'src, I, MacroInvocation, ExtraWithoutContext<'src>>
+impl<'src, I> ExtParser<'src, I, MacroInvocation, ExtraWithoutContext<'src>>
     for MacroInvocationParser<'src, I>
 where
     I: Input<'src, Token = Tok, Span = Span> + ValueInput<'src>,

assembler/src/asmlib/parser/tests.rs

@@ -264,15 +264,7 @@ fn parse_multiple_instruction_fragments(input: &str) -> Vec<InstructionFragment>
     parse_result
         .fragments
         .into_iter()
-        .map(|comma_delimited_insn| match comma_delimited_insn {
-            CommaDelimitedFragment {
-                span: _,
-                leading_commas: _,
-                holdbit: _,
-                fragment: inst,
-                trailing_commas: _,
-            } => inst,
-        })
+        .map(|comma_delimited_insn| comma_delimited_insn.fragment)
         .collect()
 }
 
@@ -1043,7 +1035,7 @@ fn test_assignment_literal() {
         dbg!(&input);
         dbg!(&begin);
         assert_eq!(
-            parse_successfully_with(*input, assignment.clone(), no_state_setup),
+            parse_successfully_with(input, assignment.clone(), no_state_setup),
             assignment_of_literal(
                 "FOO",
                 span(0..(*begin + 1)),
@@ -1066,7 +1058,7 @@ fn test_assignment_superscript() {
         let val_span = span(*val_begin..*val_end);
         let assignment = grammar().assignment;
         assert_eq!(
-            parse_successfully_with(*input, assignment, no_state_setup),
+            parse_successfully_with(input, assignment, no_state_setup),
             Equality {
                 span: span(0..*val_end),
                 name: SymbolName::from("FOO"),
@@ -1108,7 +1100,7 @@ fn test_assignment_subscript() {
         dbg!(&val_begin);
         dbg!(&val_end);
         assert_eq!(
-            parse_successfully_with(*input, assignment.clone(), no_state_setup),
+            parse_successfully_with(input, assignment.clone(), no_state_setup),
             assignment_of_literal(
                 "FOO",
                 span(0..*val_end),
@@ -2106,7 +2098,7 @@ mod comma_tests {
 
     impl PartialEq<CommaDelimitedFragment> for Briefly {
         fn eq(&self, other: &CommaDelimitedFragment) -> bool {
-            self == other
+            &self.0 == other
         }
     }
 
@@ -2552,7 +2544,7 @@ fn test_make_bit_designator_literal() {
                         if (n & (!MASK)) != 0 {
                             panic!("bit designator {what} produced output {n:o} but that has bits set outside the allowed mask {MASK:o}");
                         }
-                        if let Some((prevq, prevb)) = seen.insert(n.clone(), (q, bit)) {
+                        if let Some((prevq, prevb)) = seen.insert(n, (q, bit)) {
                             panic!(
                                 "two distinct bit designators both evaluate to {n}: {what} and {}",
                                 makename(prevq, prevb)

assembler/src/asmlib/readerleader.rs

@@ -461,7 +461,7 @@ fn test_reader_leader() {
 
     assert_eq!(expected.len(), 0o24);
     assert_eq!(leader.len(), expected.len());
-    for (i, expected_value) in expected.iter().copied().map(u64::from).enumerate() {
+    for (i, expected_value) in expected.iter().copied().enumerate() {
         assert_eq!(
             leader[i],
             expected_value,