build: bump toolchain to nightly-2024-03-12

.github/workflows/nightly-rust.yml

@@ -5,6 +5,9 @@ name: Build with Latest Nightly Rust
 on:
   schedule:
     - cron: "0 0 * * *"
+  push:
+    branches:
+      - xxchan/latest-nightly-rust
   workflow_dispatch:
 
 jobs:

src/batch/src/lib.rs

@@ -25,13 +25,11 @@
 #![feature(is_sorted)]
 #![recursion_limit = "256"]
 #![feature(let_chains)]
-#![feature(bound_map)]
 #![feature(int_roundings)]
 #![feature(allocator_api)]
 #![feature(impl_trait_in_assoc_type)]
 #![feature(assert_matches)]
 #![feature(lazy_cell)]
-#![feature(array_methods)]
 #![feature(error_generic_member_access)]
 
 pub mod error;

src/common/src/estimate_size/collections/btreemap.rs

@@ -92,7 +92,11 @@ where
 
         // [ left, [mid], right ]
         let mut mid_right = self.inner.split_off(start);
-        let mid_right_split_key = mid_right.lower_bound(Bound::Excluded(end)).key().cloned();
+        let mid_right_split_key = mid_right
+            .lower_bound(Bound::Excluded(end))
+            .peek_next()
+            .map(|(k, _)| k)
+            .cloned();
         let right = if let Some(ref mid_right_split_key) = mid_right_split_key {
             mid_right.split_off(mid_right_split_key)
         } else {

src/common/src/lib.rs

@@ -34,15 +34,12 @@
 #![feature(inline_const_pat)]
 #![allow(incomplete_features)]
 #![feature(iterator_try_collect)]
-#![feature(round_ties_even)]
 #![feature(iter_order_by)]
 #![feature(exclusive_range_pattern)]
 #![feature(binary_heap_into_iter_sorted)]
 #![feature(impl_trait_in_assoc_type)]
 #![feature(map_entry_replace)]
 #![feature(negative_impls)]
-#![feature(bound_map)]
-#![feature(array_methods)]
 #![feature(btree_cursors)]
 
 #[cfg_attr(not(test), allow(unused_extern_crates))]

src/expr/impl/src/lib.rs

@@ -27,7 +27,6 @@
 #![feature(iterator_try_collect)]
 #![feature(exclusive_range_pattern)]
 #![feature(lazy_cell)]
-#![feature(round_ties_even)]
 #![feature(coroutines)]
 #![feature(test)]
 #![feature(iter_array_chunks)]

src/frontend/src/lib.rs

@@ -32,7 +32,6 @@
 #![feature(impl_trait_in_assoc_type)]
 #![feature(result_flattening)]
 #![feature(error_generic_member_access)]
-#![feature(round_ties_even)]
 #![feature(iterator_try_collect)]
 #![feature(used_with_arg)]
 #![recursion_limit = "256"]

src/storage/hummock_sdk/src/compaction_group/hummock_version_ext.rs

@@ -1224,13 +1224,7 @@ pub fn validate_version(version: &HummockVersion) -> Vec<String> {
             let mut prev_table_info: Option<&SstableInfo> = None;
             for table_info in &level.table_infos {
                 // Ensure table_ids are sorted and unique
-                if !table_info.table_ids.is_sorted_by(|a, b| {
-                    if a < b {
-                        Some(Ordering::Less)
-                    } else {
-                        Some(Ordering::Greater)
-                    }
-                }) {
+                if !table_info.table_ids.is_sorted_by(|a, b| a < b) {
                     res.push(format!(
                         "{} SST {}: table_ids not sorted",
                         level_identifier, table_info.object_id

src/storage/hummock_sdk/src/key.rs

@@ -476,7 +476,11 @@ impl<T: AsRef<[u8]>> TableKey<T> {
             "too short table key: {:?}",
             self.0.as_ref()
         );
-        let (vnode, inner_key) = self.0.as_ref().split_array_ref::<{ VirtualNode::SIZE }>();
+        let (vnode, inner_key) = self
+            .0
+            .as_ref()
+            .split_first_chunk::<{ VirtualNode::SIZE }>()
+            .unwrap();
         (VirtualNode::from_be_bytes(*vnode), inner_key)
     }
 

src/storage/hummock_sdk/src/lib.rs

@@ -17,13 +17,11 @@
 #![feature(hash_extract_if)]
 #![feature(lint_reasons)]
 #![feature(map_many_mut)]
-#![feature(bound_map)]
 #![feature(type_alias_impl_trait)]
 #![feature(impl_trait_in_assoc_type)]
 #![feature(is_sorted)]
 #![feature(let_chains)]
 #![feature(btree_cursors)]
-#![feature(split_array)]
 
 mod key_cmp;
 use std::cmp::Ordering;

src/storage/hummock_sdk/src/table_watermark.rs

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::cmp::Ordering;
 use std::collections::hash_map::Entry;
 use std::collections::{btree_map, BTreeMap, HashMap, HashSet};
 use std::mem::size_of;
@@ -93,7 +92,8 @@ impl TableWatermarksIndex {
         self.index.get(&vnode).and_then(|epoch_watermarks| {
             epoch_watermarks
                 .upper_bound(Included(&epoch))
-                .value()
+                .peek_next()
+                .map(|(_, v)| v)
                 .cloned()
         })
     }
@@ -554,13 +554,8 @@ impl TableWatermarks {
         // epoch watermark are added from later epoch to earlier epoch.
         // reverse to ensure that earlier epochs are at the front
         result_epoch_watermark.reverse();
-        assert!(
-            result_epoch_watermark.is_sorted_by(|(first_epoch, _), (second_epoch, _)| {
-                let ret = first_epoch.cmp(second_epoch);
-                assert_ne!(ret, Ordering::Equal);
-                Some(ret)
-            })
-        );
+        assert!(result_epoch_watermark
+            .is_sorted_by(|(first_epoch, _), (second_epoch, _)| { first_epoch < second_epoch }));
         *self = TableWatermarks {
             watermarks: result_epoch_watermark,
             direction: self.direction,

src/storage/hummock_test/src/bin/replay/main.rs

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(bound_map)]
 #![feature(coroutines)]
 #![feature(stmt_expr_attributes)]
 #![feature(proc_macro_hygiene)]

src/storage/hummock_test/src/lib.rs

@@ -14,7 +14,6 @@
 #![feature(proc_macro_hygiene, stmt_expr_attributes)]
 #![feature(custom_test_frameworks)]
 #![test_runner(risingwave_test_runner::test_runner::run_failpont_tests)]
-#![feature(bound_map)]
 #![feature(type_alias_impl_trait)]
 #![feature(associated_type_bounds)]
 

src/storage/hummock_trace/src/lib.rs

@@ -14,7 +14,6 @@
 
 #![feature(lazy_cell)]
 #![feature(cursor_remaining)]
-#![feature(bound_map)]
 #![feature(trait_alias)]
 #![feature(coroutines)]
 

src/storage/src/hummock/store/version.rs

@@ -86,7 +86,7 @@ impl StagingSstableInfo {
         imm_size: usize,
     ) -> Self {
         // the epochs are sorted from higher epoch to lower epoch
-        assert!(epochs.is_sorted_by(|epoch1, epoch2| epoch2.partial_cmp(epoch1)));
+        assert!(epochs.is_sorted_by(|epoch1, epoch2| epoch2 <= epoch1));
         Self {
             sstable_infos,
             epochs,

src/storage/src/lib.rs

@@ -14,7 +14,6 @@
 
 #![feature(allocator_api)]
 #![feature(bound_as_ref)]
-#![feature(bound_map)]
 #![feature(custom_test_frameworks)]
 #![feature(extract_if)]
 #![feature(coroutines)]

src/stream/spill_test/src/lib.rs

@@ -13,7 +13,6 @@
 // limitations under the License.
 #![feature(proc_macro_hygiene, stmt_expr_attributes)]
 #![feature(custom_test_frameworks)]
-#![feature(bound_map)]
 #![feature(type_alias_impl_trait)]
 #![feature(associated_type_bounds)]
 

src/stream/src/executor/over_window/over_partition.rs

@@ -90,25 +90,25 @@ pub(super) fn shrink_partition_cache(
 
             let mut cursor = range_cache.inner().upper_bound(Bound::Excluded(&ck_start));
             for _ in 0..MAGIC_JITTER_PREVENTION {
-                if cursor.key().is_none() {
+                if cursor.prev().is_none() {
                     break;
                 }
-                cursor.move_prev();
             }
             let start = cursor
-                .key()
+                .peek_prev()
+                .map(|(k, _)| k)
                 .unwrap_or_else(|| range_cache.first_key_value().unwrap().0)
                 .clone();
 
-            let mut cursor = range_cache.inner().lower_bound(Bound::Excluded(&ck_end));
+            let mut cursor = range_cache.inner().lower_bound(Bound::Included(&ck_start));
             for _ in 0..MAGIC_JITTER_PREVENTION {
-                if cursor.key().is_none() {
+                if cursor.next().is_none() {
                     break;
                 }
-                cursor.move_next();
             }
             let end = cursor
-                .key()
+                .peek_next()
+                .map(|(k, _)| k)
                 .unwrap_or_else(|| range_cache.last_key_value().unwrap().0)
                 .clone();
 
@@ -127,27 +127,27 @@ pub(super) fn shrink_partition_cache(
                 let mut cursor = range_cache.inner().upper_bound(Bound::Excluded(&ck_start));
                 // go back for at most `MAGIC_JITTER_PREVENTION` entries
                 for _ in 0..MAGIC_JITTER_PREVENTION {
-                    if cursor.key().is_none() {
+                    if cursor.prev().is_none() {
                         break;
                     }
-                    cursor.move_prev();
                     capacity_remain -= 1;
                 }
                 let start = cursor
-                    .key()
+                    .peek_prev()
+                    .map(|(k, _)| k)
                     .unwrap_or_else(|| range_cache.first_key_value().unwrap().0)
                     .clone();
 
                 let mut cursor = range_cache.inner().lower_bound(Bound::Included(&ck_start));
                 // go forward for at most `capacity_remain` entries
                 for _ in 0..capacity_remain {
-                    if cursor.key().is_none() {
+                    if cursor.next().is_none() {
                         break;
                     }
-                    cursor.move_next();
                 }
                 let end = cursor
-                    .key()
+                    .peek_next()
+                    .map(|(k, _)| k)
                     .unwrap_or_else(|| range_cache.last_key_value().unwrap().0)
                     .clone();
 
@@ -167,27 +167,27 @@ pub(super) fn shrink_partition_cache(
                 let mut cursor = range_cache.inner().lower_bound(Bound::Excluded(&ck_end));
                 // go forward for at most `MAGIC_JITTER_PREVENTION` entries
                 for _ in 0..MAGIC_JITTER_PREVENTION {
-                    if cursor.key().is_none() {
+                    if cursor.next().is_none() {
                         break;
                     }
-                    cursor.move_next();
                     capacity_remain -= 1;
                 }
                 let end = cursor
-                    .key()
+                    .peek_next()
+                    .map(|(k, _)| k)
                     .unwrap_or_else(|| range_cache.last_key_value().unwrap().0)
                     .clone();
 
                 let mut cursor = range_cache.inner().upper_bound(Bound::Included(&ck_end));
                 // go back for at most `capacity_remain` entries
                 for _ in 0..capacity_remain {
-                    if cursor.key().is_none() {
+                    if cursor.prev().is_none() {
                         break;
                     }
-                    cursor.move_prev();
                 }
                 let start = cursor
-                    .key()
+                    .peek_prev()
+                    .map(|(k, _)| k)
                     .unwrap_or_else(|| range_cache.first_key_value().unwrap().0)
                     .clone();
 

src/stream/src/lib.rs

@@ -32,7 +32,6 @@
 #![feature(lazy_cell)]
 #![feature(error_generic_member_access)]
 #![feature(btree_extract_if)]
-#![feature(bound_map)]
 #![feature(iter_order_by)]
 #![feature(exact_size_is_empty)]
 #![feature(impl_trait_in_assoc_type)]

src/tests/compaction_test/src/lib.rs

@@ -22,7 +22,6 @@
 #![warn(clippy::map_flatten)]
 #![warn(clippy::await_holding_lock)]
 #![deny(rustdoc::broken_intra_doc_links)]
-#![feature(bound_map)]
 #![feature(register_tool)]
 #![register_tool(rw)]
 #![allow(rw::format_error)] // test code