Idiom cleanup to prepare for Rust 1.84

Clippy requires .map_or(false, ...) change to .is_some_and(...).

Change-Id: I7d62bb4c2306b7e51455369339a64d4867344dd8
Reviewed-on: https://gerrit.readyset.name/c/readyset/+/8451
Tested-by: Buildkite CI
Reviewed-by: Jason Brown <[email protected]>

Author: rs-sac

dataflow-state/src/memory_state.rs

@@ -1213,11 +1213,11 @@ mod tests {
                         // Make sure we have a strict index with this tag, and then make sure that
                         // the hole hasn't already been filled, since we would never trigger a
                         // replay to a filled hole:
-                        self.strict_indexes.get(tag).map_or(false, |index| {
+                        self.strict_indexes.get(tag).is_some_and(|index| {
                             !self
                                 .filled_holes
                                 .get(index)
-                                .map_or(false, |filled| filled.contains(key))
+                                .is_some_and(|filled| filled.contains(key))
                         })
                     }
                     Operation::DeleteRow(row) => self.rows.contains(row),

mysql-srv/src/lib.rs

@@ -562,7 +562,7 @@ impl<B: MySqlShim<W> + Send, R: AsyncRead + Unpin, W: AsyncWrite + Unpin + Send>
             || self
                 .shim
                 .password_for_username(&username)
-                .map_or(false, |password| {
+                .is_some_and(|password| {
                     let expected = hash_password(&password, &auth_data);
                     let actual = handshake_password.as_slice();
                     trace!(?expected, ?actual);
@@ -641,7 +641,7 @@ impl<B: MySqlShim<W> + Send, R: AsyncRead + Unpin, W: AsyncWrite + Unpin + Send>
                     }
                     let plain_password = self.shim.password_for_username(&username);
                     let auth_success = !self.shim.require_authentication()
-                        || plain_password.as_ref().map_or(false, |password| {
+                        || plain_password.as_ref().is_some_and(|password| {
                             let expected = hash_password(password, &self.auth_data);
                             let actual = authpassword.as_slice();
                             trace!(?expected, ?actual);

reader-map/src/read.rs

@@ -234,7 +234,7 @@ where
         K: Borrow<Q>,
         Q: Ord + Hash + ?Sized,
     {
-        self.enter().map_or(false, |x| x.contains_key(key))
+        self.enter().is_ok_and(|x| x.contains_key(key))
     }
 
     /// Read all values in the map, and transform them into a new collection.

readyset-dataflow/src/domain/replay_paths.rs

@@ -233,7 +233,7 @@ impl ReplayPaths {
     {
         self.generated_columns
             .get(node)
-            .map_or(false, |by_cols| by_cols.contains_key(columns))
+            .is_some_and(|by_cols| by_cols.contains_key(columns))
     }
 
     /// Return a list of all replay paths that pass through `from` into `node`, represented as the

readyset-dataflow/src/node/mod.rs

@@ -318,12 +318,12 @@ impl Node {
     /// Returns true if this operator requires a full materialization
     pub fn requires_full_materialization(&self) -> bool {
         self.as_internal()
-            .map_or(false, Ingredient::requires_full_materialization)
+            .is_some_and(Ingredient::requires_full_materialization)
     }
 
     pub fn can_query_through(&self) -> bool {
         self.as_internal()
-            .map_or(false, Ingredient::can_query_through)
+            .is_some_and(Ingredient::can_query_through)
     }
 
     pub fn is_join(&self) -> ReadySetResult<bool> {
@@ -669,7 +669,7 @@ impl Node {
     }
 
     pub fn is_reader_for(&self, ni: NodeIndex) -> bool {
-        self.as_reader().map_or(false, |r| r.is_for() == ni)
+        self.as_reader().is_some_and(|r| r.is_for() == ni)
     }
 
     pub fn is_ingress(&self) -> bool {

readyset-logictest/src/ast.rs

@@ -682,7 +682,7 @@ impl Value {
         match other.typ() {
             None => *self == Value::Null,
             Some(typ) => Self::from_mysql_value_with_type(mysql_async::Value::from(self), &typ)
-                .map_or(false, |v| v == *other),
+                .is_ok_and(|v| v == *other),
         }
     }
 }

readyset-mysql/tests/vertical.rs

@@ -293,7 +293,7 @@ where
                     if deps.iter().all(|dep| {
                         self.rows
                             .get(dep)
-                            .map_or(false, |dep_rows| !dep_rows.is_empty())
+                            .is_some_and(|dep_rows| !dep_rows.is_empty())
                     }) {
                         Some(*table)
                     } else {
@@ -367,7 +367,7 @@ where
             | Operation::Delete { table, row } => self
                 .rows
                 .get(table)
-                .map_or(false, |table_rows| table_rows.contains(row)),
+                .is_some_and(|table_rows| table_rows.contains(row)),
             // Can always insert any row or query any key or request an eviction and we shouldn't
             // error out
             Operation::Insert { .. } | Operation::Query { .. } | Operation::Evict { .. } => true,

readyset-server/src/controller/migrate/materialization/plan.rs

@@ -78,7 +78,7 @@ impl<'a> Plan<'a> {
         dmp: &'a mut DomainMigrationPlan,
     ) -> Plan<'a> {
         let partial = m.partial.contains(&node);
-        let has_paths = m.paths.get(&node).map_or(false, |paths| !paths.is_empty());
+        let has_paths = m.paths.get(&node).is_some_and(|paths| !paths.is_empty());
         Plan {
             m,
             graph,

readyset-server/src/controller/state.rs

@@ -1012,11 +1012,9 @@ impl DfState {
 
     /// Have all domain replicas been placed onto workers in the cluster?
     pub(super) fn all_replicas_placed(&self) -> bool {
-        self.domain_nodes.keys().all(|d| {
-            self.domains
-                .get(d)
-                .map_or(false, |h| h.all_replicas_placed())
-        })
+        self.domain_nodes
+            .keys()
+            .all(|d| self.domains.get(d).is_some_and(|h| h.all_replicas_placed()))
     }
 
     /// Returns a map of nodes for domains which have not yet been placed onto a worker

replicators/tests/ddl_vertical_mysql.rs

@@ -569,8 +569,8 @@ impl ModelState for DDLModelState {
                 // row that we're trying to write:
                 self.pkeys
                     .get(table)
-                    .map_or(false, |table_keys| !table_keys.contains(pkey))
-                    && self.tables.get(table).map_or(false, |table_cols| {
+                    .is_some_and(|table_keys| !table_keys.contains(pkey))
+                    && self.tables.get(table).is_some_and(|table_cols| {
                         // Must compare lengths before zipping and comparing individual types
                         // because zip will drop elements if the Vec lengths don't match up:
                         table_cols.len() == col_types.len()
@@ -584,20 +584,20 @@ impl ModelState for DDLModelState {
             Operation::DeleteRow(table, key) => self
                 .pkeys
                 .get(table)
-                .map_or(false, |table_keys| table_keys.contains(key)),
+                .is_some_and(|table_keys| table_keys.contains(key)),
             Operation::AddColumn(table, column_spec) => self
                 .tables
                 .get(table)
-                .map_or(false, |t| t.iter().all(|cs| cs.name != *column_spec.name)),
+                .is_some_and(|t| t.iter().all(|cs| cs.name != *column_spec.name)),
             Operation::DropColumn(table, col_name) => self
                 .tables
                 .get(table)
-                .map_or(false, |t| t.iter().any(|cs| cs.name == *col_name)),
+                .is_some_and(|t| t.iter().any(|cs| cs.name == *col_name)),
             Operation::AlterColumnName {
                 table,
                 col_name,
                 new_name,
-            } => self.tables.get(table).map_or(false, |t| {
+            } => self.tables.get(table).is_some_and(|t| {
                 t.iter().any(|cs| cs.name == *col_name) && t.iter().all(|cs| cs.name != *new_name)
             }),
             Operation::CreateSimpleView { name, table_source } => {