Fix some clippy complaints (having updated clippy).

Author: youngman-g

assembler/src/asmlib/driver/tests.rs

@@ -143,61 +143,58 @@ fn test_metacommand_dec_changes_default_base() {
             sequences,
         },
     ] = directive.blocks.values().collect::<Vec<_>>().as_slice()
-    {
-        if let [
+        && let [
             InstructionSequence {
                 local_symbols: None,
                 instructions,
             },
         ] = sequences.as_slice()
-        {
-            if let [
-                TaggedProgramInstruction {
-                    span: _,
-                    tags: tags1,
-                    instruction: first_instruction,
-                },
-                TaggedProgramInstruction {
-                    span: _,
-                    tags: tags2,
-                    instruction: second_instruction,
-                },
-            ] = instructions.as_slice()
-            {
-                assert!(tags1.is_empty());
-                assert!(tags2.is_empty());
-
-                let first_fragment = first_instruction.fragments.first();
-                let second_fragment = second_instruction.fragments.first();
-
-                assert_eq!(first_fragment.leading_commas, None);
-                assert_eq!(first_fragment.trailing_commas, None);
-                assert_eq!(second_fragment.leading_commas, None);
-                assert_eq!(second_fragment.trailing_commas, None);
-
-                // Then we should see that the first value is assembled as 10 octal...
-                assert_eq!(
-                    &first_fragment.fragment,
-                    &InstructionFragment::from((
-                        Span::from(0..2usize),
-                        Script::Normal,
-                        Unsigned36Bit::from(0o10_u32),
-                    )),
-                );
-                // ... and that the first value is assembled as 12
-                // octal (10 decimal).
-                assert_eq!(
-                    &second_fragment.fragment,
-                    &InstructionFragment::from((
-                        span(17..19),
-                        Script::Normal,
-                        Unsigned36Bit::from(0o12_u32),
-                    )),
-                );
-                return;
-            }
-        }
+        && let [
+            TaggedProgramInstruction {
+                span: _,
+                tags: tags1,
+                instruction: first_instruction,
+            },
+            TaggedProgramInstruction {
+                span: _,
+                tags: tags2,
+                instruction: second_instruction,
+            },
+        ] = instructions.as_slice()
+    {
+        assert!(tags1.is_empty());
+        assert!(tags2.is_empty());
+
+        let first_fragment = first_instruction.fragments.first();
+        let second_fragment = second_instruction.fragments.first();
+
+        assert_eq!(first_fragment.leading_commas, None);
+        assert_eq!(first_fragment.trailing_commas, None);
+        assert_eq!(second_fragment.leading_commas, None);
+        assert_eq!(second_fragment.trailing_commas, None);
+
+        // Then we should see that the first value is assembled as 10 octal...
+        assert_eq!(
+            &first_fragment.fragment,
+            &InstructionFragment::from((
+                Span::from(0..2usize),
+                Script::Normal,
+                Unsigned36Bit::from(0o10_u32),
+            )),
+        );
+        // ... and that the first value is assembled as 12
+        // octal (10 decimal).
+        assert_eq!(
+            &second_fragment.fragment,
+            &InstructionFragment::from((
+                span(17..19),
+                Script::Normal,
+                Unsigned36Bit::from(0o12_u32),
+            )),
+        );
+        return;
     }
+
     panic!(
         "expected two items with value 10 octal and 12 octal, got {:?}",
         &directive,

assembler/src/asmlib/glyph.rs

@@ -163,37 +163,35 @@ impl Glyph {
 #[test]
 fn test_subscript_char_agreement() {
     for g in ALL_GLYPHS {
-        if let Some(ch) = g.normal {
-            if let Some(glyph_sub_ch) = g.subscript {
-                if let Ok(charset_sub_ch) = subscript_char(ch) {
-                    assert_eq!(
-                        glyph_sub_ch,
-                        charset_sub_ch,
-                        "glyph {g:?} maps {ch} to {glyph_sub_ch} ({}) but subscript_char maps it to {charset_sub_ch} ({})",
-                        glyph_sub_ch.escape_unicode(),
-                        charset_sub_ch.escape_unicode(),
-                    );
-                }
-            }
+        if let Some(ch) = g.normal
+            && let Some(glyph_sub_ch) = g.subscript
+            && let Ok(charset_sub_ch) = subscript_char(ch)
+        {
+            assert_eq!(
+                glyph_sub_ch,
+                charset_sub_ch,
+                "glyph {g:?} maps {ch} to {glyph_sub_ch} ({}) but subscript_char maps it to {charset_sub_ch} ({})",
+                glyph_sub_ch.escape_unicode(),
+                charset_sub_ch.escape_unicode(),
+            );
         }
     }
 }
 
 #[test]
 fn test_superscript_char_agreement() {
     for g in ALL_GLYPHS {
-        if let Some(ch) = g.normal {
-            if let Some(glyph_sup_ch) = g.superscript {
-                if let Ok(charset_sup_ch) = superscript_char(ch) {
-                    assert_eq!(
-                        glyph_sup_ch,
-                        charset_sup_ch,
-                        "glyph {g:?} maps {ch} to {glyph_sup_ch} ({}) but superscript_char maps it to {charset_sup_ch} ({})",
-                        glyph_sup_ch.escape_unicode(),
-                        charset_sup_ch.escape_unicode(),
-                    );
-                }
-            }
+        if let Some(ch) = g.normal
+            && let Some(glyph_sup_ch) = g.superscript
+            && let Ok(charset_sup_ch) = superscript_char(ch)
+        {
+            assert_eq!(
+                glyph_sup_ch,
+                charset_sup_ch,
+                "glyph {g:?} maps {ch} to {glyph_sup_ch} ({}) but superscript_char maps it to {charset_sup_ch} ({})",
+                glyph_sup_ch.escape_unicode(),
+                charset_sup_ch.escape_unicode(),
+            );
         }
     }
 }

assembler/src/asmlib/parser/tests.rs

@@ -1249,7 +1249,7 @@ fn test_assignment_origin() {
 
 #[test]
 fn test_symbolic_origin() {
-    const INPUT: &str = concat!("BEGIN|2\n",);
+    const INPUT: &str = "BEGIN|2\n";
     let tree = parse_successfully_with(INPUT, source_file(), no_state_setup);
     assert_eq!(
         tree,
@@ -1314,7 +1314,9 @@ fn test_metacommand_octal() {
     );
 }
 
-fn parse_normal_arithmetic_expression(input: &str) -> Result<ArithmeticExpression, ParseErrors> {
+fn parse_normal_arithmetic_expression(
+    input: &str,
+) -> Result<ArithmeticExpression, ParseErrors<'_>> {
     let g = grammar();
     parse_with(
         input,
@@ -1325,7 +1327,7 @@ fn parse_normal_arithmetic_expression(input: &str) -> Result<ArithmeticExpressio
 
 fn parse_superscript_arithmetic_expression(
     input: &str,
-) -> Result<ArithmeticExpression, ParseErrors> {
+) -> Result<ArithmeticExpression, ParseErrors<'_>> {
     let g = grammar();
     parse_with(
         input,
@@ -1334,7 +1336,9 @@ fn parse_superscript_arithmetic_expression(
     )
 }
 
-fn parse_subscript_arithmetic_expression(input: &str) -> Result<ArithmeticExpression, ParseErrors> {
+fn parse_subscript_arithmetic_expression(
+    input: &str,
+) -> Result<ArithmeticExpression, ParseErrors<'_>> {
     let g = grammar();
     parse_with(
         input,