linera-views: make the context an associated type (#4031)

## Motivation

Since I'm working with `linera-views` pretty heavily, I'd like to make
it easier to modify. One source of pain is that we parameterize the
`View` trait by its context type. This is semantically incorrect, as
each view can have only a single context type that is fully determined
by its fully-instantiated type (specifically, by the type of the context
contained within the view), and pragmatically speaking means we can't
write down the requirements on that context in the `View` trait itself,
and have to duplicate them at use sites, which makes modifying those
bounds painful.

## Proposal

Make the `Context` an associated type on the `View` trait, with all
necessary bounds (except some `Sync`s: see below).

## Test Plan

CI.

## Release Plan
- Nothing to do / These changes follow the usual release cycle.

## Links

- [reviewer
checklist](https://github.com/linera-io/linera-protocol/blob/main/CONTRIBUTING.md#reviewer-checklist)

## Future work

There remains a `V: View + Sync` bound on some of the implementers (e.g.
`MapView`) that forbids using those implementers on the Web, where views
are not `Sync` as the `IndexedDbStore` is not `Sync`. Removing this
bound is non-trivial because there is a `ReadKeyValueStore`
implementation for `storage-service` that is decidedly not `Sync`. I
will need to make that implementation `Sync`, remove the need for the
`Sync` bound, or do some complex conditional compilation, but this is at
least a step in the right direction.

Author: Twey

linera-indexer/lib/src/plugin.rs

@@ -63,7 +63,7 @@ pub fn route<Q: ObjectType + 'static>(name: &str, query: Q, app: axum::Router) -
     .layer(tower_http::cors::CorsLayer::permissive())
 }
 
-pub async fn load<S, V: View<ViewContext<(), S>>>(
+pub async fn load<S, V: View<Context = ViewContext<(), S>>>(
     store: S,
     name: &str,
 ) -> Result<Arc<Mutex<V>>, IndexerError>

linera-views-derive/src/lib.rs

@@ -6,57 +6,30 @@
 use proc_macro::TokenStream;
 use proc_macro2::{Span, TokenStream as TokenStream2};
 use quote::{format_ident, quote};
-use syn::{parse_macro_input, parse_quote, ItemStruct, Type, TypePath};
+use syn::{parse_macro_input, parse_quote, ItemStruct, Type};
 
 #[derive(Debug, deluxe::ParseAttributes)]
 #[deluxe(attributes(view))]
 struct StructAttrs {
     context: Option<syn::Type>,
 }
 
-struct ContextAndConstraints<'a> {
-    context: syn::Type,
-    context_constraints: Vec<syn::WherePredicate>,
+struct Constraints<'a> {
     input_constraints: Vec<&'a syn::WherePredicate>,
     impl_generics: syn::ImplGenerics<'a>,
     type_generics: syn::TypeGenerics<'a>,
 }
 
-impl<'a> ContextAndConstraints<'a> {
+impl<'a> Constraints<'a> {
     fn get(item: &'a syn::ItemStruct) -> Self {
-        let attrs: StructAttrs = deluxe::parse_attributes(item).unwrap();
-
         let (impl_generics, type_generics, maybe_where_clause) = item.generics.split_for_impl();
         let input_constraints = maybe_where_clause
             .map(|w| w.predicates.iter())
             .into_iter()
             .flatten()
             .collect();
 
-        let (context, context_constraints) = if let Some(context) = attrs.context {
-            (context, vec![])
-        } else {
-            let first_type_param = item
-                .generics
-                .type_params()
-                .map(|param| &param.ident)
-                .next()
-                .expect("no context provided and no type parameters");
-            let context = Type::Path(TypePath {
-                qself: None,
-                path: first_type_param.clone().into(),
-            });
-
-            let constraints = vec![parse_quote! {
-                #context: linera_views::context::Context + Send + Sync + Clone + 'static
-            }];
-
-            (context, constraints)
-        };
-
         Self {
-            context,
-            context_constraints,
             input_constraints,
             impl_generics,
             type_generics,
@@ -75,14 +48,25 @@ fn get_extended_entry(e: Type) -> TokenStream2 {
 }
 
 fn generate_view_code(input: ItemStruct, root: bool) -> TokenStream2 {
-    let ContextAndConstraints {
-        context,
-        context_constraints,
+    let Constraints {
         input_constraints,
         impl_generics,
         type_generics,
-    } = ContextAndConstraints::get(&input);
+    } = Constraints::get(&input);
+
+    let attrs: StructAttrs = deluxe::parse_attributes(&input).unwrap();
+    let context = attrs.context.unwrap_or_else(|| {
+        let ident = &input
+            .generics
+            .type_params()
+            .next()
+            .expect("no `context` given and no type parameters")
+            .ident;
+        parse_quote! { #ident }
+    });
+
     let struct_name = &input.ident;
+    let field_types: Vec<_> = input.fields.iter().map(|field| &field.ty).collect();
 
     let mut name_quotes = Vec::new();
     let mut rollback_quotes = Vec::new();
@@ -93,15 +77,12 @@ fn generate_view_code(input: ItemStruct, root: bool) -> TokenStream2 {
     let mut num_init_keys_quotes = Vec::new();
     let mut pre_load_keys_quotes = Vec::new();
     let mut post_load_keys_quotes = Vec::new();
-    let mut field_constraints = vec![];
     for (idx, e) in input.fields.iter().enumerate() {
         let name = e.ident.clone().unwrap();
-        let ty = &e.ty;
         let test_flush_ident = format_ident!("deleted{}", idx);
         let idx_lit = syn::LitInt::new(&idx.to_string(), Span::call_site());
         let g = get_extended_entry(e.ty.clone());
         name_quotes.push(quote! { #name });
-        field_constraints.push(quote! { #ty: linera_views::views::View<#context> });
         rollback_quotes.push(quote! { self.#name.rollback(); });
         flush_quotes.push(quote! { let #test_flush_ident = self.#name.flush(batch)?; });
         test_flush_quotes.push(quote! { #test_flush_ident });
@@ -147,14 +128,15 @@ fn generate_view_code(input: ItemStruct, root: bool) -> TokenStream2 {
     };
 
     quote! {
-        impl #impl_generics linera_views::views::View<#context> for #struct_name #type_generics
+        impl #impl_generics linera_views::views::View for #struct_name #type_generics
         where
+            #context: linera_views::context::Context,
             #(#input_constraints,)*
-            #(#context_constraints,)*
-            #(#field_constraints,)*
-            Self: Send + Sync,
+            #(#field_types: linera_views::views::View<Context = #context>,)*
         {
-            const NUM_INIT_KEYS: usize = #(#num_init_keys_quotes)+*;
+            const NUM_INIT_KEYS: usize = #(<#field_types as linera_views::views::View>::NUM_INIT_KEYS)+*;
+
+            type Context = #context;
 
             fn context(&self) -> &#context {
                 use linera_views::views::View;
@@ -211,21 +193,12 @@ fn generate_view_code(input: ItemStruct, root: bool) -> TokenStream2 {
 }
 
 fn generate_root_view_code(input: ItemStruct) -> TokenStream2 {
-    let ContextAndConstraints {
-        context,
-        context_constraints,
+    let Constraints {
         input_constraints,
         impl_generics,
         type_generics,
-    } = ContextAndConstraints::get(&input);
+    } = Constraints::get(&input);
     let struct_name = &input.ident;
-    let mut flushes = Vec::new();
-    let mut deletes = Vec::new();
-    for e in &input.fields {
-        let name = e.ident.clone().unwrap();
-        flushes.push(quote! { self.#name.flush(&mut batch)?; });
-        deletes.push(quote! { self.#name.delete(batch); });
-    }
 
     let increment_counter = if cfg!(feature = "metrics") {
         quote! {
@@ -241,17 +214,16 @@ fn generate_root_view_code(input: ItemStruct) -> TokenStream2 {
     };
 
     quote! {
-        impl #impl_generics linera_views::views::RootView<#context> for #struct_name #type_generics
+        impl #impl_generics linera_views::views::RootView for #struct_name #type_generics
         where
             #(#input_constraints,)*
-            #(#context_constraints,)*
-            Self: Send + Sync,
+            Self: linera_views::views::View + Sync,
         {
             async fn save(&mut self) -> Result<(), linera_views::ViewError> {
                 use linera_views::{context::Context, batch::Batch, store::WritableKeyValueStore as _, views::View};
                 #increment_counter
                 let mut batch = Batch::new();
-                #(#flushes)*
+                self.flush(&mut batch)?;
                 if !batch.is_empty() {
                     self.context().store().write_batch(batch).await?;
                 }
@@ -261,28 +233,15 @@ fn generate_root_view_code(input: ItemStruct) -> TokenStream2 {
     }
 }
 
-fn hash_view_constraints(input: &ItemStruct, context: &syn::Type) -> Vec<syn::WherePredicate> {
-    input
-        .fields
-        .iter()
-        .map(|field| {
-            let ty = &field.ty;
-            parse_quote! { #ty: linera_views::views::HashableView<#context> }
-        })
-        .collect()
-}
-
 fn generate_hash_view_code(input: ItemStruct) -> TokenStream2 {
-    let ContextAndConstraints {
-        context,
-        context_constraints,
+    let Constraints {
         input_constraints,
         impl_generics,
         type_generics,
-    } = ContextAndConstraints::get(&input);
+    } = Constraints::get(&input);
     let struct_name = &input.ident;
-    let hash_constraints = hash_view_constraints(&input, &context);
 
+    let field_types = input.fields.iter().map(|field| &field.ty);
     let mut field_hashes_mut = Vec::new();
     let mut field_hashes = Vec::new();
     for e in &input.fields {
@@ -292,12 +251,11 @@ fn generate_hash_view_code(input: ItemStruct) -> TokenStream2 {
     }
 
     quote! {
-        impl #impl_generics linera_views::views::HashableView<#context> for #struct_name #type_generics
+        impl #impl_generics linera_views::views::HashableView for #struct_name #type_generics
         where
+            #(#field_types: linera_views::views::HashableView,)*
             #(#input_constraints,)*
-            #(#context_constraints,)*
-            #(#hash_constraints,)*
-            Self: Send + Sync,
+            Self: linera_views::views::View + Sync,
         {
             type Hasher = linera_views::sha3::Sha3_256;
 
@@ -321,24 +279,21 @@ fn generate_hash_view_code(input: ItemStruct) -> TokenStream2 {
 }
 
 fn generate_crypto_hash_code(input: ItemStruct) -> TokenStream2 {
-    let ContextAndConstraints {
-        context,
-        context_constraints,
+    let Constraints {
         input_constraints,
         impl_generics,
         type_generics,
-    } = ContextAndConstraints::get(&input);
-    let hash_constraints = hash_view_constraints(&input, &context);
+    } = Constraints::get(&input);
+    let field_types = input.fields.iter().map(|field| &field.ty);
     let struct_name = &input.ident;
     let hash_type = syn::Ident::new(&format!("{struct_name}Hash"), Span::call_site());
     quote! {
-        impl #impl_generics linera_views::views::CryptoHashView<#context>
+        impl #impl_generics linera_views::views::CryptoHashView
         for #struct_name #type_generics
         where
+            #(#field_types: linera_views::views::HashableView,)*
             #(#input_constraints,)*
-            #(#context_constraints,)*
-            #(#hash_constraints,)*
-            Self: Send + Sync,
+            Self: linera_views::views::View + Sync,
         {
             async fn crypto_hash(&self) -> Result<linera_base::crypto::CryptoHash, linera_views::ViewError> {
                 use linera_base::crypto::{BcsHashable, CryptoHash};
@@ -376,13 +331,11 @@ fn generate_crypto_hash_code(input: ItemStruct) -> TokenStream2 {
 }
 
 fn generate_clonable_view_code(input: ItemStruct) -> TokenStream2 {
-    let ContextAndConstraints {
-        context,
-        context_constraints,
+    let Constraints {
         input_constraints,
         impl_generics,
         type_generics,
-    } = ContextAndConstraints::get(&input);
+    } = Constraints::get(&input);
     let struct_name = &input.ident;
 
     let mut clone_constraints = vec![];
@@ -391,17 +344,16 @@ fn generate_clonable_view_code(input: ItemStruct) -> TokenStream2 {
     for field in &input.fields {
         let name = &field.ident;
         let ty = &field.ty;
-        clone_constraints.push(quote! { #ty: ClonableView<#context> });
+        clone_constraints.push(quote! { #ty: ClonableView });
         clone_fields.push(quote! { #name: self.#name.clone_unchecked()? });
     }
 
     quote! {
-        impl #impl_generics linera_views::views::ClonableView<#context> for #struct_name #type_generics
+        impl #impl_generics linera_views::views::ClonableView for #struct_name #type_generics
         where
-            #(#context_constraints,)*
             #(#input_constraints,)*
             #(#clone_constraints,)*
-            Self: Send + Sync,
+            Self: linera_views::views::View + Sync,
         {
             fn clone_unchecked(&mut self) -> Result<Self, linera_views::ViewError> {
                 Ok(Self {

linera-views-derive/src/snapshots/linera_views_derive__tests__generate_clonable_view_code-2.snap

@@ -2,13 +2,12 @@
 source: linera-views-derive/src/lib.rs
 expression: pretty(generate_clonable_view_code(input))
 ---
-impl<C, MyParam> linera_views::views::ClonableView<C> for TestView<C, MyParam>
+impl<C, MyParam> linera_views::views::ClonableView for TestView<C, MyParam>
 where
-    C: linera_views::context::Context + Send + Sync + Clone + 'static,
     MyParam: Send + Sync + 'static,
-    RegisterView<C, usize>: ClonableView<C>,
-    CollectionView<C, usize, RegisterView<C, usize>>: ClonableView<C>,
-    Self: Send + Sync,
+    RegisterView<C, usize>: ClonableView,
+    CollectionView<C, usize, RegisterView<C, usize>>: ClonableView,
+    Self: linera_views::views::View + Sync,
 {
     fn clone_unchecked(&mut self) -> Result<Self, linera_views::ViewError> {
         Ok(Self {

linera-views-derive/src/snapshots/linera_views_derive__tests__generate_clonable_view_code-3.snap

@@ -2,15 +2,15 @@
 source: linera-views-derive/src/lib.rs
 expression: pretty(generate_clonable_view_code(input))
 ---
-impl linera_views::views::ClonableView<CustomContext> for TestView
+impl linera_views::views::ClonableView for TestView
 where
-    RegisterView<CustomContext, usize>: ClonableView<CustomContext>,
+    RegisterView<CustomContext, usize>: ClonableView,
     CollectionView<
         CustomContext,
         usize,
         RegisterView<CustomContext, usize>,
-    >: ClonableView<CustomContext>,
-    Self: Send + Sync,
+    >: ClonableView,
+    Self: linera_views::views::View + Sync,
 {
     fn clone_unchecked(&mut self) -> Result<Self, linera_views::ViewError> {
         Ok(Self {

linera-views-derive/src/snapshots/linera_views_derive__tests__generate_clonable_view_code-4.snap

@@ -2,16 +2,16 @@
 source: linera-views-derive/src/lib.rs
 expression: pretty(generate_clonable_view_code(input))
 ---
-impl<MyParam> linera_views::views::ClonableView<CustomContext> for TestView<MyParam>
+impl<MyParam> linera_views::views::ClonableView for TestView<MyParam>
 where
     MyParam: Send + Sync + 'static,
-    RegisterView<CustomContext, usize>: ClonableView<CustomContext>,
+    RegisterView<CustomContext, usize>: ClonableView,
     CollectionView<
         CustomContext,
         usize,
         RegisterView<CustomContext, usize>,
-    >: ClonableView<CustomContext>,
-    Self: Send + Sync,
+    >: ClonableView,
+    Self: linera_views::views::View + Sync,
 {
     fn clone_unchecked(&mut self) -> Result<Self, linera_views::ViewError> {
         Ok(Self {

linera-views-derive/src/snapshots/linera_views_derive__tests__generate_clonable_view_code-5.snap

@@ -2,18 +2,15 @@
 source: linera-views-derive/src/lib.rs
 expression: pretty(generate_clonable_view_code(input))
 ---
-impl linera_views::views::ClonableView<custom::path::to::ContextType> for TestView
+impl linera_views::views::ClonableView for TestView
 where
-    RegisterView<
-        custom::path::to::ContextType,
-        usize,
-    >: ClonableView<custom::path::to::ContextType>,
+    RegisterView<custom::path::to::ContextType, usize>: ClonableView,
     CollectionView<
         custom::path::to::ContextType,
         usize,
         RegisterView<custom::path::to::ContextType, usize>,
-    >: ClonableView<custom::path::to::ContextType>,
-    Self: Send + Sync,
+    >: ClonableView,
+    Self: linera_views::views::View + Sync,
 {
     fn clone_unchecked(&mut self) -> Result<Self, linera_views::ViewError> {
         Ok(Self {