[base] Enable and fix some extra clippy warnings.

Author: youngman-g

base/src/bitselect.rs

@@ -45,11 +45,13 @@ pub struct BitSelector {
 }
 
 impl BitSelector {
+    #[must_use]
     pub const fn raw_mask(&self) -> u64 {
         let shift = (self.quarter as u32) * 9 + (self.bitpos as u32);
         1_u64 << shift
     }
 
+    #[must_use]
     pub fn mask(&self) -> Unsigned36Bit {
         Unsigned36Bit::try_from(self.raw_mask())
             .expect("bit selector mask values cannot be outside the range of Unsigned36Bit")
@@ -284,6 +286,7 @@ fn all_bit_selectors() -> Vec<BitSelector> {
     result
 }
 
+#[must_use]
 pub const fn bit_select(value: Unsigned36Bit, selector: BitSelector) -> bool {
     value.bits & selector.raw_mask() != 0
 }

base/src/charset.rs

@@ -51,7 +51,14 @@ impl Display for NoSubscriptKnown {
 
 impl Error for NoSubscriptKnown {}
 
-pub fn subscript_char(ch: char) -> Result<char, NoSubscriptKnown> {
+/// Return the corresponding subscript representation for `ch`.
+///
+/// # Errors
+/// `NoSubscriptKnown` when no corresponding subscript is known,
+pub const fn subscript_char(ch: char) -> Result<char, NoSubscriptKnown> {
+    // The cases here are ordered so as to make it obvious when an
+    // item is missing, and so we expect that some of the failure
+    // cases will have the same bodies.
     match ch {
         '0' => Ok('\u{2080}'), // ₀
         '1' => Ok('\u{2081}'), // ₁
@@ -85,7 +92,15 @@ impl Display for NoSuperscriptKnown {
 
 impl Error for NoSuperscriptKnown {}
 
+/// Return the corresponding superscript representation for `ch`.
+///
+/// # Errors
+/// `NoSuperscriptKnown` when no corresponding superscript is known,
 pub fn superscript_char(ch: char) -> Result<char, NoSuperscriptKnown> {
+    // The cases here are ordered so as to make it obvious when an
+    // item is missing, and so we expect that some of the failure
+    // cases will have the same bodies.
+    #[allow(clippy::match_same_arms)]
     match ch {
         '0' => Ok('\u{2070}'),
         '1' => Ok('\u{00B9}'),
@@ -174,6 +189,7 @@ pub enum Script {
 }
 
 impl Script {
+    #[must_use]
     pub fn shift(&self) -> u32 {
         match self {
             Script::Super => 30, // This is a config value.
@@ -209,7 +225,7 @@ pub enum LwKeyboardCase {
 }
 
 impl LwKeyboardCase {
-    fn as_str(&self) -> &'static str {
+    fn as_str(self) -> &'static str {
         match self {
             LwKeyboardCase::Lower => "lower",
             LwKeyboardCase::Upper => "upper",
@@ -305,7 +321,7 @@ pub struct DescribedChar {
     /// or normal character, and what colour it is.
     pub base_char: LincolnChar,
     /// If the character has a direct Unicode translation, that is in
-    /// unicode_representation.  Some characters, for example
+    /// `unicode_representation`.  Some characters, for example
     /// superscript Y, have no Unicode representation.
     pub unicode_representation: Option<char>,
     /// Specifies whether the character is upper-case, lower-case
@@ -330,7 +346,7 @@ fn unprintable(c: Unsigned6Bit, state: LincolnState) -> DescribedChar {
         label_matches_unicode: false,
     }
 }
-fn bycase(lower: char, upper: char, state: &LincolnState) -> Option<char> {
+const fn bycase(lower: char, upper: char, state: LincolnState) -> Option<char> {
     Some(match state.case {
         LwKeyboardCase::Upper => upper,
         LwKeyboardCase::Lower => lower,
@@ -408,7 +424,7 @@ pub fn lincoln_char_to_described_char(
 ) -> Option<DescribedChar> {
     lincoln_writer_state_update(lin_ch, state);
     let advance: bool = lin_ch != 0o12 && lin_ch != 0o13;
-    let by_case = |lower, upper: char| -> Option<char> { bycase(lower, upper, state) };
+    let by_case = |lower, upper: char| -> Option<char> { bycase(lower, upper, *state) };
     let base_char: Option<char> = match u8::from(lin_ch) {
         0o00 => by_case('0', '☛'), // \U261B, black hand pointing right
         0o01 => by_case('1', 'Σ'), // \U03A3, Greek capital letter Sigma

base/src/instruction.rs

@@ -712,7 +712,7 @@ mod tests {
 
     #[test]
     fn test_instruction_jmp() {
-        let inst = Instruction(Unsigned36Bit::from(0o0500377750_u32));
+        let inst = Instruction(Unsigned36Bit::from(0o0_500_377_750_u32));
         assert_eq!(
             inst.operand_address(),
             OperandAddress::direct(Address::from(u18!(0o377_750u32))),
@@ -750,7 +750,7 @@ mod tests {
         assert_eq!(
             disassemble_word(u36!(0o000_500_377_750)),
             Ok(SymbolicInstruction {
-                operand_address: OperandAddress::direct(Address::from(u18!(0o0377750))),
+                operand_address: OperandAddress::direct(Address::from(u18!(0o_377_750))),
                 index: Unsigned6Bit::ZERO,
                 opcode: Opcode::Jmp,
                 configuration: config_value(0),
@@ -767,7 +767,7 @@ mod tests {
                     .expect("test data should be in range")
             ),
             Ok(SymbolicInstruction {
-                operand_address: OperandAddress::direct(Address::from(u18!(0o0377752))),
+                operand_address: OperandAddress::direct(Address::from(u18!(0o0_377_752))),
                 index: Unsigned6Bit::try_from(3_u8).unwrap(),
                 opcode: Opcode::Jpx,
                 configuration: config_value(24), // -7
@@ -781,7 +781,7 @@ mod tests {
                     .expect("test data should be in range")
             ),
             Ok(SymbolicInstruction {
-                operand_address: OperandAddress::direct(Address::from(u18!(0o0377751))),
+                operand_address: OperandAddress::direct(Address::from(u18!(0o0_377_751))),
                 index: Unsigned6Bit::ONE,
                 opcode: Opcode::Jpx,
                 configuration: config_value(30),

base/src/instruction/format.rs

@@ -342,7 +342,7 @@ mod tests {
     #[test]
     fn test_display_jmp() {
         let sinst = SymbolicInstruction {
-            operand_address: OperandAddress::direct(Address::from(u18!(0o0377750))),
+            operand_address: OperandAddress::direct(Address::from(u18!(0o0_377_750))),
             index: Unsigned6Bit::ZERO,
             opcode: Opcode::Jmp,
             configuration: Unsigned5Bit::ZERO,
@@ -401,7 +401,7 @@ mod tests {
 
         // Example from Program I, address 377 765, instruction word 36 06 01 377 751.
         let sinst1 = SymbolicInstruction {
-            operand_address: OperandAddress::direct(Address::from(u18!(0o0377751))),
+            operand_address: OperandAddress::direct(Address::from(u18!(0o0_377_751))),
             index: Unsigned6Bit::ONE,
             opcode: Opcode::Jpx,
             // 036 = 30 decimal = 0b11110, which is one's complement -1.
@@ -427,7 +427,7 @@ mod tests {
 
         // Example from Program II ("Inchworm"), address 15, instruction word not stated,
         let sinst2 = SymbolicInstruction {
-            operand_address: OperandAddress::direct(Address::from(u18!(0o0377752))),
+            operand_address: OperandAddress::direct(Address::from(u18!(0o0_377_752))),
             index: Unsigned6Bit::try_from(3_u8).unwrap(),
             opcode: Opcode::Jpx,
             // In the Program II example, the configuration value is
@@ -447,7 +447,7 @@ mod tests {
         // indicating the hold bit.  We use 'h' instead since ':' is
         // not actually part of the Lincoln Writer character set.
         let sinst = SymbolicInstruction {
-            operand_address: OperandAddress::direct(Address::from(u18!(0o377762))),
+            operand_address: OperandAddress::direct(Address::from(u18!(0o377_762))),
             index: Unsigned6Bit::try_from(0o71_u8).unwrap(),
             opcode: Opcode::Rsx,
             configuration: config_value(0o34),

base/src/lib.rs

@@ -6,6 +6,21 @@
 #![deny(unreachable_pub)]
 #![deny(unsafe_code)]
 #![deny(unused_crate_dependencies)]
+//#![warn(clippy::as_conversions)]
+//#![warn(clippy::cast_lossless)]
+//#![warn(clippy::pedantic)] // enable later
+#![warn(clippy::cast_possible_truncation)]
+#![warn(clippy::cast_possible_wrap)]
+#![warn(clippy::cast_precision_loss)]
+#![warn(clippy::cast_ptr_alignment)]
+#![warn(clippy::clone_on_ref_ptr)]
+#![warn(clippy::cloned_instead_of_copied)]
+#![warn(clippy::unreadable_literal)]
+#![allow(clippy::cast_possible_wrap)]
+#![allow(clippy::cast_sign_loss)]
+#![allow(clippy::needless_continue)] // fix these later
+#![allow(clippy::redundant_else)] // fix these later
+#![allow(clippy::missing_panics_doc)] // fix these later
 
 pub mod bitselect;
 pub mod charset;

base/src/onescomplement/signed/tests18.rs

@@ -405,7 +405,7 @@ fn test_signed18bit_checked_add() {
     assert!(dbg!(minus_one) < Signed18Bit::ZERO);
     assert_eq!(
         i32::from(Signed18Bit::MAX.checked_add(minus_one).unwrap()),
-        0o377776_i32
+        0o377_776_i32
     );
     assert_eq!(Signed18Bit::ZERO.checked_add(minus_one).unwrap(), minus_one);
 }
@@ -442,7 +442,7 @@ fn test_signed18bit_checked_sub() {
 
     assert_eq!(
         i32::from(Signed18Bit::MAX.checked_sub(Signed18Bit::ONE).unwrap()),
-        0o377776_i32
+        0o377_776_i32
     );
     assert_eq!(
         Signed18Bit::ZERO.checked_sub(Signed18Bit::ONE).unwrap(),

base/src/onescomplement/unsigned.rs

@@ -548,7 +548,7 @@ pub struct Unsigned12Bit {
 #[cfg_attr(test, derive(Arbitrary))]
 #[derive(Clone, Copy, Serialize)]
 pub struct Unsigned18Bit {
-    #[cfg_attr(test, strategy(0..262143u32))]
+    #[cfg_attr(test, strategy(0..262_143u32))]
     pub(crate) bits: u32,
 }
 
@@ -559,7 +559,7 @@ pub struct Unsigned18Bit {
 #[cfg_attr(test, derive(Arbitrary))]
 #[derive(Clone, Copy, Serialize)]
 pub struct Unsigned36Bit {
-    #[cfg_attr(test, strategy(0..68719476735u64))]
+    #[cfg_attr(test, strategy(0..68_719_476_735u64))]
     pub(crate) bits: u64,
 }
 

base/src/onescomplement/unsigned/tests.rs

@@ -649,7 +649,7 @@ mod u18_proptests {
 
     #[derive(Debug, Arbitrary)]
     struct U18SubtractionTestInput {
-        #[strategy(0..0o1000000u32)]
+        #[strategy(0..0o1_000_000u32)]
         greater: u32,
         #[strategy(0..=#greater)]
         lesser: u32,
@@ -692,7 +692,7 @@ mod u36_proptests {
 
     #[derive(Debug, Arbitrary)]
     struct U36SubtractionTestInput {
-        #[strategy(0..0o1000000000000u64)]
+        #[strategy(0..0o1_000_000_000_000u64)]
         greater: u64,
         #[strategy(0..=#greater)]
         lesser: u64,

base/src/splay.rs

@@ -23,7 +23,7 @@ pub fn cycle_and_splay(target: Unsigned36Bit, bits: Unsigned6Bit) -> Unsigned36B
     // bit 5 (4 counting from 0) goes to 3.7 = 1 << 24 (dec)
     // bit 6 (5 counting from 0) goes to 4.4 = 1 << 30 (dec)
     let src = u64::from(bits);
-    let lowest_bits = Unsigned36Bit::from(0o010101010101_u32);
+    let lowest_bits = Unsigned36Bit::from(0o010_101_010_101_u32);
     let newbits: u64 = (src & 1)
         | ((src & 0o2) << 5)
         | ((src & 0o4) << 10)
@@ -177,7 +177,7 @@ fn test_round_trip_selected() {
         Unsigned36Bit::from(0o77_u32),
         Unsigned36Bit::from(0o7700_u32),
         Unsigned36Bit::MAX,
-        Unsigned36Bit::from(0o23574373_u32),
+        Unsigned36Bit::from(0o23_574_373_u32),
     ] {
         if let Err(e) = round_trip(value) {
             panic!("round_trip failed for {value:012o}: {e}");