fix(clippy): make clippy = host libs + riscv programs (shared PROGRAMS); libkos alloc spinlock (was unlocked across threads); keystore Account; gpu Rect; factory Entry; Default impls, let-chains, div_ceil, iter loops

crates/keystore/src/lib.rs

@@ -21,6 +21,7 @@ mod user;
 mod tests;
 
 pub use record::{
+    Account,
     Copies, Entry, KdfParams, Outcome, RECORD_SIZE, Record, Refused, SLOTS, Session, State,
 };
 pub use user::{Name, Role, User, UserId};

crates/keystore/src/record.rs

@@ -154,6 +154,15 @@ fn parse_user(role: u8, id: &[u8], name: &[u8]) -> Option<User> {
     })
 }
 
+/// A user about to be added: who, and the passcodes that will open their
+/// slot (and, if given, their duress slot).
+pub struct Account<'a> {
+    pub name: Name,
+    pub role: Role,
+    pub passcode: &'a [u8],
+    pub duress: Option<&'a [u8]>,
+}
+
 impl Record {
     fn name_tag(&self, name: &Name) -> [u8; NAME_TAG] {
         let mut m = <Blake2sMac256 as KeyInit>::new_from_slice(&self.pepper)
@@ -273,7 +282,7 @@ impl Record {
             admin: Some(admin),
         };
         let (record, user) = first
-            .add_user(&owner, name, Role::Owner, passcode, duress, memory, rng)
+            .add_user(&owner, Account { name, role: Role::Owner, passcode, duress }, memory, rng)
             .ok()?;
         let session = record.unlock(name.as_bytes(), passcode, memory);
         let _ = user;
@@ -371,16 +380,8 @@ impl Record {
     }
 
     /// An owner adds a user; the new record and the user.
-    pub fn add_user(
-        &self,
-        by: &Session,
-        name: Name,
-        role: Role,
-        passcode: &[u8],
-        duress: Option<&[u8]>,
-        memory: &mut [Block],
-        rng: &mut impl Random,
-    ) -> Result<(Self, User), Refused> {
+    pub fn add_user(&self, by: &Session, account: Account, memory: &mut [Block], rng: &mut impl Random) -> Result<(Self, User), Refused> {
+        let Account { name, role, passcode, duress } = account;
         let admin = by.admin.clone().ok_or(Refused::NotOwner)?;
         let mut entries = self.entries(&admin).ok_or(Refused::Failed)?;
         if entries.iter().flatten().any(|e| e.user.name == name) {
@@ -467,10 +468,10 @@ impl Record {
             return Err(Refused::LastOwner);
         }
         let mut r = self.next(|_| {});
-        for i in 0..SLOTS {
-            if entries[i].is_some_and(|e| e.user.id == gone.id) {
-                r.slots[i] = Slot(noise(rng).ok_or(Refused::Failed)?);
-                entries[i] = None;
+        for (entry, slot) in entries.iter_mut().zip(r.slots.iter_mut()) {
+            if entry.is_some_and(|e| e.user.id == gone.id) {
+                *slot = Slot(noise(rng).ok_or(Refused::Failed)?);
+                *entry = None;
             }
         }
         if !r.seal_directory(&admin, &entries, rng) {

crates/keystore/src/tests.rs

@@ -79,15 +79,7 @@ fn users_have_their_own_keys_and_may_even_share_a_passcode() {
     let (r, owner) = setup(None, 2);
     let mut rng = Counter(40);
     let (r, work) = r
-        .add_user(
-            &owner,
-            name("work"),
-            Role::Standard,
-            b"1234",
-            None,
-            &mut memory(),
-            &mut rng,
-        )
+        .add_user(&owner, Account { name: name("work"), role: Role::Standard, passcode: b"1234", duress: None }, &mut memory(), &mut rng)
         .unwrap();
     let w = signed_in(&r, "work", b"1234").unwrap();
     let g = signed_in(&r, "gabriel", b"1234").unwrap();
@@ -105,15 +97,7 @@ fn users_have_their_own_keys_and_may_even_share_a_passcode() {
         "not even hidden in their slot"
     );
     assert_eq!(
-        r.add_user(
-            &w,
-            name("x"),
-            Role::Standard,
-            b"9",
-            None,
-            &mut memory(),
-            &mut rng
-        )
+        r.add_user(&w, Account { name: name("x"), role: Role::Standard, passcode: b"9", duress: None }, &mut memory(), &mut rng)
         .err(),
         Some(Refused::NotOwner)
     );
@@ -125,26 +109,10 @@ fn owners_see_and_manage_the_users() {
     let (r, owner) = setup(Some(b"0000"), 3);
     let mut rng = Counter(50);
     let (r, _) = r
-        .add_user(
-            &owner,
-            name("work"),
-            Role::Standard,
-            b"5678",
-            Some(b"8765"),
-            &mut memory(),
-            &mut rng,
-        )
+        .add_user(&owner, Account { name: name("work"), role: Role::Standard, passcode: b"5678", duress: Some(b"8765") }, &mut memory(), &mut rng)
         .unwrap();
     let (r, second) = r
-        .add_user(
-            &owner,
-            name("anna"),
-            Role::Owner,
-            b"4321",
-            None,
-            &mut memory(),
-            &mut rng,
-        )
+        .add_user(&owner, Account { name: name("anna"), role: Role::Owner, passcode: b"4321", duress: None }, &mut memory(), &mut rng)
         .unwrap();
     let names: Vec<_> = r
         .users(&owner)
@@ -155,15 +123,7 @@ fn owners_see_and_manage_the_users() {
         .collect();
     assert_eq!(names.len(), 3, "duress slots are not listed: {names:?}");
     assert_eq!(
-        r.add_user(
-            &owner,
-            name("work"),
-            Role::Standard,
-            b"x",
-            None,
-            &mut memory(),
-            &mut rng
-        )
+        r.add_user(&owner, Account { name: name("work"), role: Role::Standard, passcode: b"x", duress: None }, &mut memory(), &mut rng)
         .err(),
         Some(Refused::NameTaken)
     );
@@ -205,15 +165,7 @@ fn slots_run_out() {
     let mut added = 0;
     for i in 0..SLOTS {
         let n = std::format!("u{i}");
-        match r.add_user(
-            &owner,
-            name(&n),
-            Role::Standard,
-            b"pass",
-            None,
-            &mut memory(),
-            &mut rng,
-        ) {
+        match r.add_user(&owner, Account { name: name(&n), role: Role::Standard, passcode: b"pass", duress: None }, &mut memory(), &mut rng) {
             Ok((next, _)) => {
                 r = next;
                 added += 1;