Upgrade Rust to 1.89.0

erikgrinaker · erikgrinaker · commit 5c48bd899f26 · 2025-08-17T00:48:05.000+02:00
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -11,7 +11,7 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
-    - uses: dtolnay/rust-toolchain@1.85.1
+    - uses: dtolnay/rust-toolchain@1.89.0
       id: toolchain
       with:
         components: clippy, rustfmt
diff --git a/rust-toolchain b/rust-toolchain
@@ -1 +1 @@
-1.85.1
+1.89.0
diff --git a/src/encoding/format.rs b/src/encoding/format.rs
@@ -192,10 +192,10 @@ impl Formatter for SQL {
 
     fn value(key: &[u8], value: &[u8]) -> String {
         // Special-case the applied_index key.
-        if key == sql::engine::Raft::APPLIED_INDEX_KEY {
-            if let Ok(applied_index) = bincode::deserialize::<raft::Index>(value) {
-                return applied_index.to_string();
-            }
+        if key == sql::engine::Raft::APPLIED_INDEX_KEY
+            && let Ok(applied_index) = bincode::deserialize::<raft::Index>(value)
+        {
+            return applied_index.to_string();
         }
 
         let Ok(key) = sql::engine::Key::decode(key) else {
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::all)]
+#![allow(clippy::large_enum_variant)]
 #![allow(clippy::module_inception)]
 #![allow(clippy::type_complexity)]
 
diff --git a/src/raft/log.rs b/src/raft/log.rs
@@ -240,7 +240,7 @@ impl Log {
     }
 
     /// Returns an iterator over log entries in the given index range.
-    pub fn scan(&mut self, range: impl RangeBounds<Index>) -> Iterator {
+    pub fn scan(&mut self, range: impl RangeBounds<Index>) -> Iterator<'_> {
         let from = match range.start_bound() {
             Bound::Excluded(&index) => Bound::Excluded(Key::Entry(index).encode()),
             Bound::Included(&index) => Bound::Included(Key::Entry(index).encode()),
@@ -256,7 +256,7 @@ impl Log {
 
     /// Returns an iterator over entries that are ready to apply, starting after
     /// the current applied index up to the commit index.
-    pub fn scan_apply(&mut self, applied_index: Index) -> Iterator {
+    pub fn scan_apply(&mut self, applied_index: Index) -> Iterator<'_> {
         // NB: we don't assert that commit_index >= applied_index, because the
         // local commit index is not flushed to durable storage -- if lost on
         // restart, it can be recovered from the logs of a quorum.
diff --git a/src/raft/node.rs b/src/raft/node.rs
@@ -425,11 +425,11 @@ impl RawNode<Follower> {
             Message::Campaign { last_index, last_term } => {
                 // Don't vote if we already voted for someone else in this term.
                 // We can repeat our vote for the same node though.
-                if let (_, Some(vote)) = self.log.get_term_vote() {
-                    if msg.from != vote {
-                        self.send(msg.from, Message::CampaignResponse { vote: false })?;
-                        return Ok(self.into());
-                    }
+                if let (_, Some(vote)) = self.log.get_term_vote()
+                    && msg.from != vote
+                {
+                    self.send(msg.from, Message::CampaignResponse { vote: false })?;
+                    return Ok(self.into());
                 }
 
                 // Only vote if the candidate's log is at least as long as ours.
@@ -2020,12 +2020,12 @@ mod tests {
                     let peer_len = symmetric.get(peer).map(|p| p.len()).unwrap_or(0);
                     // If this peer set is the smallest (or we're the higher ID),
                     // remove the entry. We may no longer be in the map.
-                    if len < peer_len || len == peer_len && id > peer {
-                        if let Some(peers) = symmetric.get_mut(id) {
-                            peers.remove(peer);
-                            if peers.is_empty() {
-                                symmetric.remove(id);
-                            }
+                    if (len < peer_len || len == peer_len && id > peer)
+                        && let Some(peers) = symmetric.get_mut(id)
+                    {
+                        peers.remove(peer);
+                        if peers.is_empty() {
+                            symmetric.remove(id);
                         }
                     }
                 }
diff --git a/src/server.rs b/src/server.rs
@@ -211,13 +211,13 @@ impl Server {
                 // forward it to the waiting client via the response channel.
                 recv(node_rx) -> result => {
                     let msg = result.expect("node_rx disconnected");
-                    if msg.to == node.id() {
-                        if let raft::Message::ClientResponse{ id, response } = msg.message {
-                            if let Some(response_tx) = response_txs.remove(&id) {
-                                response_tx.send(response).expect("response_tx disconnected");
-                            }
-                            continue
+                    if msg.to == node.id()
+                        && let raft::Message::ClientResponse{ id, response } = msg.message
+                    {
+                        if let Some(response_tx) = response_txs.remove(&id) {
+                            response_tx.send(response).expect("response_tx disconnected");
                         }
+                        continue
                     }
                     let peer_tx = peers_tx.get_mut(&msg.to).expect("unknown peer");
                     match peer_tx.try_send(msg) {
diff --git a/src/sql/engine/local.rs b/src/sql/engine/local.rs
@@ -229,13 +229,13 @@ impl<E: storage::Engine> super::Transaction for Transaction<E> {
 
         for id in ids {
             // Update any secondary index entries.
-            if !indexes.is_empty() {
-                if let Some(row) = self.get_row(&table.name, id)? {
-                    for (i, column) in indexes.iter().copied() {
-                        let mut ids = self.get_index(&table.name, &column.name, &row[i])?;
-                        ids.remove(id);
-                        self.set_index(&table.name, &column.name, &row[i], ids)?;
-                    }
+            if !indexes.is_empty()
+                && let Some(row) = self.get_row(&table.name, id)?
+            {
+                for (i, column) in indexes.iter().copied() {
+                    let mut ids = self.get_index(&table.name, &column.name, &row[i])?;
+                    ids.remove(id);
+                    self.set_index(&table.name, &column.name, &row[i], ids)?;
                 }
             }
 
diff --git a/src/sql/execution/executor.rs b/src/sql/execution/executor.rs
@@ -243,10 +243,10 @@ impl<'a, T: Transaction> Executor<'a, T> {
             if values.len() > table.columns.len() {
                 return errinput!("too many values for table {}", table.name);
             }
-            if let Some(column_map) = &column_map {
-                if column_map.len() != values.len() {
-                    return errinput!("column and value counts do not match");
-                }
+            if let Some(column_map) = &column_map
+                && column_map.len() != values.len()
+            {
+                return errinput!("column and value counts do not match");
             }
 
             // Map source columns to table columns, and fill in default values.
diff --git a/src/sql/execution/join.rs b/src/sql/execution/join.rs
@@ -75,7 +75,7 @@ impl NestedLoopJoiner {
                 return Ok(Some(
                     left.iter()
                         .cloned()
-                        .chain(std::iter::repeat(Value::Null).take(self.right_columns))
+                        .chain(std::iter::repeat_n(Value::Null, self.right_columns))
                         .collect(),
                 ));
             }
@@ -172,7 +172,7 @@ impl HashJoiner {
                 // join, emit a row with right NULLs.
                 return Ok(Some(
                     left.into_iter()
-                        .chain(std::iter::repeat(Value::Null).take(self.right_columns))
+                        .chain(std::iter::repeat_n(Value::Null, self.right_columns))
                         .collect(),
                 ));
             }
diff --git a/src/sql/mod.rs b/src/sql/mod.rs
@@ -5,11 +5,11 @@
 //!    `sql::execution::Session` in `Server::sql_session`.
 //!
 //! 2. `toySQL` submits a SQL `SELECT` string, which the server executes via
-//!     `Session::execute`.
+//!    `Session::execute`.
 //!
 //! 3. `Session::execute` calls `Parser::parse` to parse the SQL `SELECT` string
-//!     into an `ast::Statement::Select` AST (Abstract Syntax Tree). The parser
-//!     uses the `Lexer` for initial tokenization.
+//!    into an `ast::Statement::Select` AST (Abstract Syntax Tree). The parser
+//!    uses the `Lexer` for initial tokenization.
 //!     
 //! 4. `Session::execute` obtains a new read-only `sql::engine::Transaction` via
 //!    `Session::with_txn`. We'll gloss over the details here.
diff --git a/src/sql/parser/parser.rs b/src/sql/parser/parser.rs
@@ -44,7 +44,7 @@ impl Parser<'_> {
     }
 
     /// Creates a new parser for the given raw SQL string.
-    fn new(input: &str) -> Parser {
+    fn new(input: &str) -> Parser<'_> {
         Parser { lexer: Lexer::new(input).peekable() }
     }
 
diff --git a/src/sql/planner/optimizer.rs b/src/sql/planner/optimizer.rs
@@ -224,11 +224,11 @@ impl FilterPushdown {
         }
 
         // Push predicates down into the sources if possible.
-        if let Some(expr) = Expression::and_vec(push_left) {
-            if let Some(expr) = Self::push_into(expr, &mut left) {
-                // Pushdown failed, put it back into the join predicate.
-                predicate.push(expr)
-            }
+        if let Some(expr) = Expression::and_vec(push_left)
+            && let Some(expr) = Self::push_into(expr, &mut left)
+        {
+            // Pushdown failed, put it back into the join predicate.
+            predicate.push(expr)
         }
 
         if let Some(mut expr) = Expression::and_vec(push_right) {
diff --git a/src/sql/planner/planner.rs b/src/sql/planner/planner.rs
@@ -226,7 +226,7 @@ impl<'a, C: Catalog> Planner<'a, C> {
 
             // Add hidden columns for HAVING and ORDER BY columns not in SELECT.
             let hidden = self.build_select_hidden(&having, &order_by, &scope, &mut child_scope);
-            aliases.extend(std::iter::repeat(Label::None).take(hidden.len()));
+            aliases.extend(std::iter::repeat_n(Label::None, hidden.len()));
             expressions.extend(hidden);
 
             scope = child_scope;
@@ -461,12 +461,12 @@ impl<'a, C: Catalog> Planner<'a, C> {
             expr.walk(&mut |expr| {
                 // If this is an aggregate or GROUP BY expression that isn't
                 // already available in the child scope, add a hidden column.
-                if let Some(index) = scope.lookup_aggregate(expr) {
-                    if child_scope.lookup_aggregate(expr).is_none() {
-                        child_scope.add_passthrough(scope, index, true);
-                        hidden.push(Expression::Column(index));
-                        return true;
-                    }
+                if let Some(index) = scope.lookup_aggregate(expr)
+                    && child_scope.lookup_aggregate(expr).is_none()
+                {
+                    child_scope.add_passthrough(scope, index, true);
+                    hidden.push(Expression::Column(index));
+                    return true;
                 }
 
                 // Look for column references that don't exist post-projection,
diff --git a/src/sql/types/schema.rs b/src/sql/types/schema.rs
@@ -198,10 +198,10 @@ impl Table {
             let valueslice = &row[i..=i];
 
             // Validate datatype.
-            if let Some(ref vtype) = value.datatype() {
-                if vtype != ctype {
-                    return errinput!("invalid datatype {vtype} for {ctype} column {cname}");
-                }
+            if let Some(ref vtype) = value.datatype()
+                && vtype != ctype
+            {
+                return errinput!("invalid datatype {vtype} for {ctype} column {cname}");
             }
             if value == &Value::Null && !column.nullable {
                 return errinput!("NULL value not allowed for column {cname}");
diff --git a/src/storage/mvcc.rs b/src/storage/mvcc.rs
@@ -702,10 +702,10 @@ impl<E: Engine> Iterator for ScanIterator<E> {
     type Item = Result<(Vec<u8>, Vec<u8>)>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        if self.buffer.is_empty() {
-            if let Err(error) = self.fill_buffer() {
-                return Some(Err(error));
-            }
+        if self.buffer.is_empty()
+            && let Err(error) = self.fill_buffer()
+        {
+            return Some(Err(error));
         }
         self.buffer.pop_front().map(Ok)
     }

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`#![warn(clippy::all)]`
	`2`	`+#![allow(clippy::large_enum_variant)]`
`2`	`3`	`#![allow(clippy::module_inception)]`
`3`	`4`	`#![allow(clippy::type_complexity)]`
`4`	`5`
Original file line number	Diff line number	Diff line change
`@@ -243,10 +243,10 @@ impl<'a, T: Transaction> Executor<'a, T> {`
`243`	`243`	`if values.len() > table.columns.len() {`
`244`	`244`	`return errinput!("too many values for table {}", table.name);`
`245`	`245`	`}`
`246`		`- if let Some(column_map) = &column_map {`
`247`		`- if column_map.len() != values.len() {`
`248`		`- return errinput!("column and value counts do not match");`
`249`		`- }`
	`246`	`+ if let Some(column_map) = &column_map`
	`247`	`+ && column_map.len() != values.len()`
	`248`	`+ {`
	`249`	`+ return errinput!("column and value counts do not match");`
`250`	`250`	`}`
`251`	`251`
`252`	`252`	`// Map source columns to table columns, and fill in default values.`