Fix chunks_exact when the chunk size is zero (#4731)

## Motivation

See #4727 

## Proposal

`chunks_exact` may face a "0 divided by 0" situation, but in this case
we can return an infinite stream of empty chunks.

## Test Plan

CI

## Release Plan

- These changes should be backported to the latest `testnet` branch,
then
    - be released in a new SDK,

---------

Co-authored-by: Mathieu Dutour Sikiric <[email protected]>

Author: ma2bd

Cargo.lock

@@ -44,6 +44,7 @@ derive_more = { workspace = true, features = ["from"] }
 futures.workspace = true
 generic-array.workspace = true
 hex = { workspace = true, optional = true }
+itertools.workspace = true
 linera-base.workspace = true
 linera-views-derive.workspace = true
 linera-witty.workspace = true

examples/Cargo.lock

@@ -9,8 +9,10 @@ use std::{
         Bound,
         Bound::{Excluded, Included, Unbounded},
     },
+    slice::ChunksExact,
 };
 
+use itertools::Either;
 use serde::de::DeserializeOwned;
 
 use crate::ViewError;
@@ -313,6 +315,30 @@ pub(crate) const fn get_uleb128_size(len: usize) -> usize {
     expo
 }
 
+/// Extention trait for slices.
+pub trait SliceExt<T> {
+    /// Same as `chunks_exact` but we allow the `chunk_size` to be zero when the slice is empty.
+    fn chunks_exact_or_repeat(
+        &self,
+        chunk_size: usize,
+    ) -> Either<ChunksExact<'_, T>, std::iter::Repeat<&[T]>>;
+}
+
+impl<T> SliceExt<T> for [T] {
+    fn chunks_exact_or_repeat(
+        &self,
+        chunk_size: usize,
+    ) -> Either<ChunksExact<'_, T>, std::iter::Repeat<&[T]>> {
+        if chunk_size > 0 {
+            Either::Left(self.chunks_exact(chunk_size))
+        } else if self.is_empty() {
+            Either::Right(std::iter::repeat(&[]))
+        } else {
+            panic!("chunk_size must be nonzero unless the slice is empty")
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::collections::BTreeSet;

linera-sdk/tests/fixtures/Cargo.lock

@@ -16,7 +16,7 @@ use serde::{de::DeserializeOwned, Serialize};
 
 use crate::{
     batch::Batch,
-    common::{CustomSerialize, HasherOutput, Update},
+    common::{CustomSerialize, HasherOutput, SliceExt as _, Update},
     context::{BaseKey, Context},
     hashable_wrapper::WrappedHashableContainerView,
     store::ReadableKeyValueStore as _,
@@ -396,8 +396,9 @@ impl<W: View> ByteCollectionView<W::Context, W> {
             .read_multi_values_bytes(keys_to_load)
             .await?;
 
-        for (loaded_values, (position, context)) in
-            values.chunks_exact(W::NUM_INIT_KEYS).zip(entries_to_load)
+        for (loaded_values, (position, context)) in values
+            .chunks_exact_or_repeat(W::NUM_INIT_KEYS)
+            .zip(entries_to_load)
         {
             let view = W::post_load(context, loaded_values)?;
             let updates = self.updates.read().await;

linera-views/Cargo.toml

@@ -17,7 +17,7 @@ use serde::{de::DeserializeOwned, Serialize};
 
 use crate::{
     batch::Batch,
-    common::{CustomSerialize, HasherOutput, Update},
+    common::{CustomSerialize, HasherOutput, SliceExt as _, Update},
     context::{BaseKey, Context},
     hashable_wrapper::WrappedHashableContainerView,
     store::ReadableKeyValueStore as _,
@@ -540,7 +540,7 @@ impl<W: View> ReentrantByteCollectionView<W::Context, W> {
         }
         let values = self.context.store().read_multi_values_bytes(keys).await?;
         for (loaded_values, short_key) in values
-            .chunks_exact(W::NUM_INIT_KEYS)
+            .chunks_exact_or_repeat(W::NUM_INIT_KEYS)
             .zip(short_keys_to_load)
         {
             let key = self
@@ -637,8 +637,9 @@ impl<W: View> ReentrantByteCollectionView<W::Context, W> {
                 .store()
                 .read_multi_values_bytes(keys_to_load)
                 .await?;
-            for (loaded_values, (position, short_key, context)) in
-                values.chunks_exact(W::NUM_INIT_KEYS).zip(entries_to_load)
+            for (loaded_values, (position, short_key, context)) in values
+                .chunks_exact_or_repeat(W::NUM_INIT_KEYS)
+                .zip(entries_to_load)
             {
                 let view = W::post_load(context, loaded_values)?;
                 let wrapped_view = Arc::new(RwLock::new(view));
@@ -698,7 +699,7 @@ impl<W: View> ReentrantByteCollectionView<W::Context, W> {
             }
             let values = self.context.store().read_multi_values_bytes(keys).await?;
             for (loaded_values, (short_key, index)) in values
-                .chunks_exact(W::NUM_INIT_KEYS)
+                .chunks_exact_or_repeat(W::NUM_INIT_KEYS)
                 .zip(short_keys_and_indexes)
             {
                 let key = self
@@ -772,7 +773,7 @@ impl<W: View> ReentrantByteCollectionView<W::Context, W> {
 
             let values = self.context.store().read_multi_values_bytes(keys).await?;
             for (loaded_values, short_key) in values
-                .chunks_exact(W::NUM_INIT_KEYS)
+                .chunks_exact_or_repeat(W::NUM_INIT_KEYS)
                 .zip(short_keys_to_load)
             {
                 let key = self

linera-views/src/common.rs

@@ -15,16 +15,16 @@ use linera_views::{
         Batch, WriteOperation,
         WriteOperation::{Delete, DeletePrefix, Put},
     },
-    collection_view::HashedCollectionView,
+    collection_view::{CollectionView, HashedCollectionView},
     context::{Context, MemoryContext, ViewContext},
     key_value_store_view::{KeyValueStoreView, ViewContainer},
     log_view::HashedLogView,
     lru_caching::LruCachingMemoryDatabase,
-    map_view::{ByteMapView, HashedMapView},
+    map_view::{ByteMapView, HashedMapView, MapView},
     memory::MemoryDatabase,
     queue_view::HashedQueueView,
     random::make_deterministic_rng,
-    reentrant_collection_view::HashedReentrantCollectionView,
+    reentrant_collection_view::{HashedReentrantCollectionView, ReentrantCollectionView},
     register_view::HashedRegisterView,
     set_view::HashedSetView,
     store::{KeyValueDatabase, TestKeyValueDatabase as _, WritableKeyValueStore as _},
@@ -614,6 +614,52 @@ where
     .await
 }
 
+#[derive(RootView)]
+pub struct NestedCollectionMapView<C> {
+    pub map: CollectionView<C, String, MapView<C, String, u64>>,
+}
+
+// This test exercise the case W::NUM_INIT_KEYS == 0
+// in CollectionView.
+#[tokio::test]
+async fn test_nested_collection_map_view() -> anyhow::Result<()> {
+    let context = MemoryContext::new_for_testing(());
+    {
+        let mut view = NestedCollectionMapView::load(context.clone()).await?;
+        let subview = view.map.load_entry_mut("Bonjour").await?;
+        subview.insert("A bientot", 49)?;
+        view.save().await?;
+    }
+    let view = NestedCollectionMapView::load(context).await?;
+    let keys = vec!["Bonjour".to_string()];
+    let subviews = view.map.try_load_entries(&keys).await?;
+    assert!(subviews[0].is_some());
+    Ok(())
+}
+
+#[derive(RootView)]
+pub struct NestedReentrantCollectionMapView<C> {
+    pub map: ReentrantCollectionView<C, String, MapView<C, String, u64>>,
+}
+
+#[tokio::test]
+async fn test_nested_reentrant_collection_map_view() -> anyhow::Result<()> {
+    let context = MemoryContext::new_for_testing(());
+    {
+        let mut view = NestedReentrantCollectionMapView::load(context.clone()).await?;
+        {
+            let mut subview = view.map.try_load_entry_mut("Bonjour").await?;
+            subview.insert("A bientot", 49)?;
+        }
+        view.save().await?;
+    }
+    let view = NestedReentrantCollectionMapView::load(context).await?;
+    let keys = vec!["Bonjour".to_string()];
+    let subviews = view.map.try_load_entries(&keys).await?;
+    assert!(subviews[0].is_some());
+    Ok(())
+}
+
 #[derive(CryptoHashRootView)]
 pub struct ByteMapStateView<C> {
     pub map: ByteMapView<C, u8>,