Fix some clippy complaints (having updated clippy).

Author: youngman-g

assembler/src/asmlib/collections.rs

@@ -47,7 +47,7 @@ impl<T> OneOrMore<T> {
         self.tail.push(item);
     }
 
-    pub fn iter(&self) -> OneOrMoreIter<T> {
+    pub fn iter(&self) -> OneOrMoreIter<'_, T> {
         OneOrMoreIter {
             inner: std::iter::once(&self.head).chain(self.tail.iter()),
         }
@@ -60,7 +60,7 @@ impl<T> OneOrMore<T> {
         }
     }
 
-    pub fn iter_mut(&mut self) -> OneOrMoreIterMut<T> {
+    pub fn iter_mut(&mut self) -> OneOrMoreIterMut<'_, T> {
         OneOrMoreIterMut {
             inner: std::iter::once(&mut self.head).chain(self.tail.iter_mut()),
         }

assembler/src/asmlib/driver.rs

@@ -91,14 +91,14 @@ fn assemble_pass1<'a, 'b: 'a>(
     let (mut sf, mut new_errors) = parse_source_file(source_file_body.as_str(), setup);
     errors.append(&mut new_errors);
 
-    if let Some(source_file) = sf.as_mut() {
-        if let Err(tag_errors) = source_file.build_local_symbol_tables() {
-            errors.extend(
-                tag_errors
-                    .into_iter()
-                    .map(|tag_err| Rich::custom(tag_err.span(), tag_err.to_string())),
-            );
-        }
+    if let Some(source_file) = sf.as_mut()
+        && let Err(tag_errors) = source_file.build_local_symbol_tables()
+    {
+        errors.extend(
+            tag_errors
+                .into_iter()
+                .map(|tag_err| Rich::custom(tag_err.span(), tag_err.to_string())),
+        );
     }
     Ok((sf, options))
 }
@@ -298,10 +298,10 @@ fn initial_symbol_table<'a>(
     for r in source_file.global_symbol_references() {
         match r {
             Ok((symbol, span, context)) => {
-                if !explicit_symbols.is_defined(&symbol) {
-                    if let Err(e) = implicit_symbols.record_usage_context(symbol.clone(), context) {
-                        errors.push(Rich::custom(span, e.to_string()));
-                    }
+                if !explicit_symbols.is_defined(&symbol)
+                    && let Err(e) = implicit_symbols.record_usage_context(symbol.clone(), context)
+                {
+                    errors.push(Rich::custom(span, e.to_string()));
                 }
             }
             Err(e) => {
@@ -461,15 +461,15 @@ fn assemble_pass3(
     let mut bad_symbol_definitions: BTreeMap<SymbolName, ProgramError> = Default::default();
     // TODO: consider moving this into pass 2.
     for block in blocks.values() {
-        if let Some(Origin::Symbolic(span, symbol_name)) = block.origin.as_ref() {
-            if !explicit_symtab.is_defined(symbol_name) {
-                final_symbols.define_if_undefined(
-                    symbol_name.clone(),
-                    FinalSymbolType::Tag, // actually origin
-                    body.extract(span.start..span.end).to_string(),
-                    FinalSymbolDefinition::PositionIndependent(block.location.into()),
-                );
-            }
+        if let Some(Origin::Symbolic(span, symbol_name)) = block.origin.as_ref()
+            && !explicit_symtab.is_defined(symbol_name)
+        {
+            final_symbols.define_if_undefined(
+                symbol_name.clone(),
+                FinalSymbolType::Tag, // actually origin
+                body.extract(span.start..span.end).to_string(),
+                FinalSymbolDefinition::PositionIndependent(block.location.into()),
+            );
         }
     }
 

assembler/src/asmlib/driver/tests.rs

@@ -260,8 +260,7 @@ fn test_super_hash_value() {
 #[test]
 fn test_sub_hash_value() {
     // Given a program which assembles at address 1 the value of # ("here"), when we assemble it
-    let program =
-        assemble_source(concat!("1| @sub_hash@\n",), Default::default()).expect("program is valid");
+    let program = assemble_source("1| @sub_hash@\n", Default::default()).expect("program is valid");
 
     // Then we should see that # evaluates as 1, the address of the
     // insruction containing it.

assembler/src/asmlib/manuscript.rs

@@ -417,10 +417,10 @@ impl ManuscriptBlock {
         if let Some(origin) = self.origin.as_ref() {
             origin.span()
         } else {
-            if let Some(s) = self.sequences.first() {
-                if let Some(first) = s.first() {
-                    return first.span();
-                }
+            if let Some(s) = self.sequences.first()
+                && let Some(first) = s.first()
+            {
+                return first.span();
             }
             Span::from(0..0)
         }

assembler/src/asmlib/span.rs

@@ -28,7 +28,7 @@ impl Ord for OrderableSpan {
 
 impl PartialOrd for OrderableSpan {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.0.start.cmp(&other.0.start))
+        Some(self.cmp(other))
     }
 }
 

assembler/src/asmlib/symbol.rs

@@ -1,6 +1,6 @@
 use std::collections::BTreeSet;
 use std::error::Error;
-use std::fmt::{self, Debug, Display, Formatter, Write};
+use std::fmt::{self, Debug, Display, Formatter};
 use std::hash::{Hash, Hasher};
 
 use base::charset::Script;
@@ -54,32 +54,6 @@ impl Hash for SymbolName {
     }
 }
 
-#[derive(Clone, Eq, PartialOrd, Ord, PartialEq, Debug)]
-pub(crate) enum SymbolOrHere {
-    Named(SymbolName),
-    Here,
-}
-
-impl From<&str> for SymbolOrHere {
-    fn from(value: &str) -> Self {
-        match value {
-            "#" => SymbolOrHere::Here,
-            name => SymbolOrHere::Named(SymbolName {
-                canonical: name.to_owned(),
-            }),
-        }
-    }
-}
-
-impl Display for SymbolOrHere {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            SymbolOrHere::Named(name) => write!(f, "{name}"),
-            SymbolOrHere::Here => f.write_char('#'),
-        }
-    }
-}
-
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub(crate) enum ConfigOrIndexUsage {
     Configuration,

assembler/src/asmlib/symtab.rs

@@ -425,25 +425,25 @@ pub(super) fn assign_default_rc_word_tags<R: RcAllocator>(
     final_symbols: &mut FinalSymbolTable,
 ) -> Result<(), RcWordAllocationFailure> {
     for (name, def) in implicit_symtab.definitions.iter_mut() {
-        if let ImplicitDefinition::Undefined(context) = def {
-            if context.requires_rc_word_allocation() {
-                let span: Span = *context.any_span();
-                let value = Unsigned36Bit::ZERO;
-                let addr = rcblock.allocate(
-                    RcWordSource {
-                        span,
-                        kind: RcWordKind::DefaultAssignment,
-                    },
-                    value,
-                )?;
-                final_symbols.define(
-                    name.clone(),
-                    FinalSymbolType::Equality,
-                    value.to_string(),
-                    FinalSymbolDefinition::PositionIndependent(value),
-                );
-                *def = ImplicitDefinition::DefaultAssigned(addr.into(), context.clone());
-            }
+        if let ImplicitDefinition::Undefined(context) = def
+            && context.requires_rc_word_allocation()
+        {
+            let span: Span = *context.any_span();
+            let value = Unsigned36Bit::ZERO;
+            let addr = rcblock.allocate(
+                RcWordSource {
+                    span,
+                    kind: RcWordKind::DefaultAssignment,
+                },
+                value,
+            )?;
+            final_symbols.define(
+                name.clone(),
+                FinalSymbolType::Equality,
+                value.to_string(),
+                FinalSymbolDefinition::PositionIndependent(value),
+            );
+            *def = ImplicitDefinition::DefaultAssigned(addr.into(), context.clone());
         }
     }
     Ok(())

assembler/src/tx2maketape/main.rs

@@ -145,11 +145,9 @@ fn read_binary(input_file: File) -> Result<Binary, Fail> {
             Some(expected) => expected != addr,
         };
 
-        if non_contiuguous {
-            if let Some(old) = chunk.take() {
-                assert!(!old.is_empty());
-                binary.add_chunk(old);
-            }
+        if non_contiuguous && let Some(old) = chunk.take() {
+            assert!(!old.is_empty());
+            binary.add_chunk(old);
         }
         let ch: &mut BinaryChunk = chunk.get_or_insert_with(|| BinaryChunk {
             address: Address::from(addr),
@@ -158,10 +156,10 @@ fn read_binary(input_file: File) -> Result<Binary, Fail> {
         prev_addr = Some(addr);
         ch.push(word);
     }
-    if let Some(current) = chunk.take() {
-        if !current.is_empty() {
-            binary.add_chunk(current);
-        }
+    if let Some(current) = chunk.take()
+        && !current.is_empty()
+    {
+        binary.add_chunk(current);
     }
     Ok(binary)
 }

cli/src/main.rs

@@ -312,10 +312,10 @@ fn run_simulator() -> Result<(), Box<dyn std::error::Error>> {
     };
     let initial_context = clk.make_fresh_context();
     let mut tx2 = Tx2::new(&initial_context, panic_on_unmasked_alarm, &mem_config);
-    if let Some(tape) = tape_data {
-        if let Err(e) = tx2.mount_tape(&initial_context, tape) {
-            return Err(Box::new(e));
-        }
+    if let Some(tape) = tape_data
+        && let Err(e) = tx2.mount_tape(&initial_context, tape)
+    {
+        return Err(Box::new(e));
     }
     run(&mut tx2, &mut clk, sleep_multiplier)
 }

cpu/src/io/dev_petr.rs

@@ -245,19 +245,19 @@ impl Petr {
         );
         match self.activity {
             Activity::Started => {
-                if let Some(t) = self.time_of_next_read {
-                    if t > *system_time {
-                        // The next line has not yet appeared under the read
-                        // head.
-                        let to_wait = || t - *system_time;
-                        event!(
-                            Level::TRACE,
-                            "motor running ({}) but next line will not be read for {:?} yet",
-                            self.direction,
-                            to_wait()
-                        );
-                        return;
-                    }
+                if let Some(t) = self.time_of_next_read
+                    && t > *system_time
+                {
+                    // The next line has not yet appeared under the read
+                    // head.
+                    let to_wait = || t - *system_time;
+                    event!(
+                        Level::TRACE,
+                        "motor running ({}) but next line will not be read for {:?} yet",
+                        self.direction,
+                        to_wait()
+                    );
+                    return;
                 }
                 match self.direction {
                     Direction::Bin => {
@@ -304,21 +304,21 @@ fn compute_throughput(
     connect_time: Option<Duration>,
     now: Duration,
 ) -> Option<Throughput> {
-    if let Some(connected_at) = connect_time {
-        if let Some(elapsed) = now.checked_sub(connected_at) {
-            let elapsed = elapsed.as_secs_f64();
+    if let Some(connected_at) = connect_time
+        && let Some(elapsed) = now.checked_sub(connected_at)
+    {
+        let elapsed = elapsed.as_secs_f64();
 
-            // It seems that in a WASM build, f64::value_from(usize)
-            // is irrefutable.  But clippy doesn't warn about it in
-            // non-WASM builds because it's not always irrefutable.
-            #[allow(irrefutable_let_patterns)]
-            if let Ok(n) = f64::value_from(pos) {
-                let throughput = n / elapsed;
-                return Some(Throughput {
-                    lines_per_second: throughput,
-                    total_seconds: elapsed,
-                });
-            }
+        // It seems that in a WASM build, f64::value_from(usize)
+        // is irrefutable.  But clippy doesn't warn about it in
+        // non-WASM builds because it's not always irrefutable.
+        #[allow(irrefutable_let_patterns)]
+        if let Ok(n) = f64::value_from(pos) {
+            let throughput = n / elapsed;
+            return Some(Throughput {
+                lines_per_second: throughput,
+                total_seconds: elapsed,
+            });
         }
     }
     None