define name -> accessor in views, reducer and table

Author: Shubham8287

crates/bindings-macro/src/procedure.rs

@@ -29,11 +29,11 @@ impl ProcedureArgs {
     }
 }
 
-pub(crate) fn procedure_impl(args: ProcedureArgs, original_function: &ItemFn) -> syn::Result<TokenStream> {
+pub(crate) fn procedure_impl(_args: ProcedureArgs, original_function: &ItemFn) -> syn::Result<TokenStream> {
     let func_name = &original_function.sig.ident;
     let vis = &original_function.vis;
 
-    let procedure_name = args.name.unwrap_or_else(|| ident_to_litstr(func_name));
+    let procedure_name = ident_to_litstr(func_name);
 
     assert_only_lifetime_generics(original_function, "procedures")?;
 

crates/bindings-macro/src/reducer.rs

@@ -96,7 +96,7 @@ pub(crate) fn reducer_impl(args: ReducerArgs, original_function: &ItemFn) -> syn
     let func_name = &original_function.sig.ident;
     let vis = &original_function.vis;
 
-    let reducer_name = args.name.unwrap_or_else(|| ident_to_litstr(func_name));
+    let reducer_name = ident_to_litstr(func_name);
 
     assert_only_lifetime_generics(original_function, "reducers")?;
 

crates/bindings-macro/src/table.rs

@@ -17,6 +17,7 @@ use syn::{parse_quote, Ident, Path, Token};
 
 pub(crate) struct TableArgs {
     access: Option<TableAccess>,
+    _name: Option<LitStr>,
     scheduled: Option<ScheduledArg>,
     accessor: Ident,
     indices: Vec<IndexArg>,
@@ -77,6 +78,7 @@ impl TableArgs {
         let mut access = None;
         let mut scheduled = None;
         let mut accessor = None;
+        let mut name = None;
         let mut indices = Vec::new();
         syn::meta::parser(|meta| {
             match_meta!(match meta {
@@ -93,6 +95,11 @@ impl TableArgs {
                     let value = meta.value()?;
                     accessor = Some(value.parse()?);
                 }
+                sym::name => {
+                    check_duplicate(&accessor, &meta)?;
+                    let value = meta.value()?;
+                    name = Some(value.parse()?);
+                }
                 sym::index => indices.push(IndexArg::parse_meta(meta)?),
                 sym::scheduled => {
                     check_duplicate(&scheduled, &meta)?;
@@ -114,6 +121,7 @@ impl TableArgs {
             scheduled,
             accessor,
             indices,
+            _name: name,
         })
     }
 }

crates/bindings-macro/src/view.rs

@@ -3,53 +3,63 @@ use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
 use syn::ext::IdentExt;
 use syn::parse::Parser;
-use syn::{FnArg, ItemFn};
+use syn::{FnArg, ItemFn, LitStr};
 
 use crate::sym;
 use crate::util::{check_duplicate_msg, match_meta};
 
 pub(crate) struct ViewArgs {
-    name: Ident,
+    _name: Option<LitStr>,
+    accessor: Ident,
     #[allow(unused)]
     public: bool,
 }
 
 impl ViewArgs {
-    /// Parse `#[view(name = ..., public)]` where both `name` and `public` are required.
+    /// Parse `#[view(accessor = ..., public)]` where both `name` and `public` are required.
     pub(crate) fn parse(input: TokenStream, func_ident: &Ident) -> syn::Result<Self> {
         let mut name = None;
+        let mut accessor = None;
         let mut public = None;
         syn::meta::parser(|meta| {
             match_meta!(match meta {
                 sym::name => {
                     check_duplicate_msg(&name, &meta, "`name` already specified")?;
-                    name = Some(meta.value()?.parse()?);
+                    name = Some(meta.value()?.parse::<LitStr>()?);
                 }
                 sym::public => {
                     check_duplicate_msg(&public, &meta, "`public` already specified")?;
                     public = Some(());
                 }
+                sym::accessor => {
+                    check_duplicate_msg(&accessor, &meta, "`accessor` already specified")?;
+                    accessor = Some(meta.value()?.parse()?);
+                }
             });
             Ok(())
         })
         .parse2(input)?;
-        let name = name.ok_or_else(|| {
+        let accessor = accessor.ok_or_else(|| {
             let view = func_ident.to_string().to_snake_case();
             syn::Error::new(
                 Span::call_site(),
-                format_args!("must specify view name, e.g. `#[spacetimedb::view(name = {view})]"),
+                format_args!("must specify view accessor, e.g. `#[spacetimedb::view(accessor = {view})]"),
             )
         })?;
         let () = public
             .ok_or_else(|| syn::Error::new(Span::call_site(), "views must be `public`, e.g. `#[view(public)]`"))?;
-        Ok(Self { name, public: true })
+        Ok(Self {
+            _name: name,
+            public: true,
+            accessor,
+        })
     }
 }
 
 pub(crate) fn view_impl(args: ViewArgs, original_function: &ItemFn) -> syn::Result<TokenStream> {
     let vis = &original_function.vis;
     let func_name = &original_function.sig.ident;
-    let view_ident = args.name;
+    let view_ident = args.accessor;
     let view_name = view_ident.unraw().to_string();
 
     for param in &original_function.sig.generics.params {

crates/bindings/README.md

@@ -606,13 +606,13 @@ struct PlayerAndLevel {
 }
 
 // At-most-one row: return Option<T>
-#[view(name = my_player, public)]
+#[view(accessor = my_player, public)]
 fn my_player(ctx: &ViewContext) -> Option<Player> {
     ctx.db.player().identity().find(ctx.sender())
 }
 
 // Multiple rows: return Vec<T>
-#[view(name = players_for_level, public)]
+#[view(accessor = players_for_level, public)]
 fn players_for_level(ctx: &AnonymousViewContext) -> Vec<PlayerAndLevel> {
     ctx.db
         .player_level()

crates/bindings/src/lib.rs

@@ -814,19 +814,19 @@ pub use spacetimedb_bindings_macro::procedure;
 /// }
 ///
 /// // A view that selects at most one row from a table
-/// #[view(name = my_player, public)]
+/// #[view(accessor = my_player, public)]
 /// fn my_player(ctx: &ViewContext) -> Option<Player> {
 ///     ctx.db.player().identity().find(ctx.sender())
 /// }
 ///
 /// // An example of column projection
-/// #[view(name = my_player_id, public)]
+/// #[view(accessor = my_player_id, public)]
 /// fn my_player_id(ctx: &ViewContext) -> Option<PlayerId> {
 ///     ctx.db.player().identity().find(ctx.sender()).map(|Player { id, .. }| PlayerId { id })
 /// }
 ///
 /// // An example that is analogous to a semijoin in sql
-/// #[view(name = players_at_coordinates, public)]
+/// #[view(accessor = players_at_coordinates, public)]
 /// fn players_at_coordinates(ctx: &AnonymousViewContext) -> Vec<Player> {
 ///     ctx
 ///         .db
@@ -838,7 +838,7 @@ pub use spacetimedb_bindings_macro::procedure;
 /// }
 ///
 /// // An example of a join that combines fields from two different tables
-/// #[view(name = players_with_coordinates, public)]
+/// #[view(accessor = players_with_coordinates, public)]
 /// fn players_with_coordinates(ctx: &AnonymousViewContext) -> Vec<PlayerAndLocation> {
 ///     ctx
 ///         .db

crates/bindings/tests/ui/views-more.rs

@@ -9,7 +9,7 @@ struct PlayerInfo {
     age: u8,
 }
 /// Comparing incompatible types in `where` condition: u8 != u32 implicitly
-#[view(name = view_bad_where_int_types_implicit, public)]
+#[view(accessor = view_bad_where_int_types_implicit, public)]
 fn view_bad_where_int_types_implicit(ctx: &ViewContext) -> Query<PlayerInfo> {
     ctx.from.player_info().r#where(|a| a.age.eq(4200)).build()
 }

crates/bindings/tests/ui/views.rs

@@ -73,73 +73,73 @@ struct Player {
 struct NotSpacetimeType {}
 
 /// Private views not allowed; must be `#[view(public, ...)]`
-#[view(name = view_def_no_public)]
+#[view(accessor = view_def_no_public)]
 fn view_def_no_public(_: &ViewContext) -> Vec<Player> {
     vec![]
 }
 
 /// Duplicate `public`
-#[view(name = view_def_dup_public, public, public)]
+#[view(accessor = view_def_dup_public, public, public)]
 fn view_def_dup_public() -> Vec<Player> {
     vec![]
 }
 
 /// Duplicate `name`
-#[view(name = view_def_dup_name, name = view_def_dup_name, public)]
+#[view(accessor = view_def_dup_name, name = view_def_dup_name, public)]
 fn view_def_dup_name() -> Vec<Player> {
     vec![]
 }
 
 /// Unsupported attribute arg
-#[view(name = view_def_unsupported_arg, public, anonymous)]
+#[view(accessor = view_def_unsupported_arg, public, anonymous)]
 fn view_def_unsupported_arg() -> Vec<Player> {
     vec![]
 }
 
 /// A `ViewContext` is required
-#[view(name = view_def_no_context, public)]
+#[view(accessor = view_def_no_context, public)]
 fn view_def_no_context() -> Vec<Player> {
     vec![]
 }
 
 /// A `ViewContext` is required
-#[view(name = view_def_wrong_context, public)]
+#[view(accessor = view_def_wrong_context, public)]
 fn view_def_wrong_context(_: &ReducerContext) -> Vec<Player> {
     vec![]
 }
 
 /// Must pass the `ViewContext` by ref
-#[view(name = view_def_pass_context_by_value, public)]
+#[view(accessor = view_def_pass_context_by_value, public)]
 fn view_def_pass_context_by_value(_: ViewContext) -> Vec<Player> {
     vec![]
 }
 
 /// The view context must be the first parameter
-#[view(name = view_def_wrong_context_position, public)]
+#[view(accessor = view_def_wrong_context_position, public)]
 fn view_def_wrong_context_position(_: &u32, _: &ViewContext) -> Vec<Player> {
     vec![]
 }
 
 /// Must return `Vec<T>` or `Option<T>` where `T` is a SpacetimeType
-#[view(name = view_def_no_return, public)]
+#[view(accessor = view_def_no_return, public)]
 fn view_def_no_return(_: &ViewContext) {}
 
 /// Must return `Vec<T>` or `Option<T>` where `T` is a SpacetimeType
-#[view(name = view_def_wrong_return, public)]
+#[view(accessor = view_def_wrong_return, public)]
 fn view_def_wrong_return(_: &ViewContext) -> Player {
     Player {
         identity: Identity::ZERO,
     }
 }
 
 /// Must return `Vec<T>` or `Option<T>` where `T` is a SpacetimeType
-#[view(name = view_def_returns_not_a_spacetime_type, public)]
+#[view(accessor = view_def_returns_not_a_spacetime_type, public)]
 fn view_def_returns_not_a_spacetime_type(_: &AnonymousViewContext) -> Option<NotSpacetimeType> {
     None
 }
 
 /// Cannot use a view as a scheduled function
-#[view(name = sched_table_view, public)]
+#[view(accessor = sched_table_view, public)]
 fn sched_table_view(_: &ViewContext, _args: ScheduledTable) -> Vec<PlayerInfo> {
     vec![]
 }
@@ -155,20 +155,20 @@ struct PlayerInfo {
 }
 
 /// Comparing incompatible types in `where` condition: Identity != int
-#[view(name = view_bad_where, public)]
+#[view(accessor = view_bad_where, public)]
 fn view_bad_where(ctx: &ViewContext) -> Query<Player> {
     ctx.from.player().r#where(|a| a.identity.eq(42)).build()
 }
 
 /// Comparing incompatible types in `where` condition: u8 != u32
-#[view(name = view_bad_where_int_types, public)]
+#[view(accessor = view_bad_where_int_types, public)]
 fn view_bad_where_int_types(ctx: &ViewContext) -> Query<PlayerInfo> {
     ctx.from.player_info().r#where(|a| a.age.eq(4200u32)).build()
 }
 
 /// Joining incompatible types
 /// -- weight is u32, identity is Identity
-#[view(name = view_bad_join, public)]
+#[view(accessor = view_bad_join, public)]
 fn view_bad_join(ctx: &ViewContext) -> Query<PlayerInfo> {
     ctx.from
         .player_info()
@@ -178,7 +178,7 @@ fn view_bad_join(ctx: &ViewContext) -> Query<PlayerInfo> {
 
 /// Joining non-index columns
 /// -- age is not indexed
-#[view(name = view_join_non_indexed_column, public)]
+#[view(accessor = view_join_non_indexed_column, public)]
 fn view_join_non_indexed_column(ctx: &ViewContext) -> Query<PlayerInfo> {
     ctx.from
         .player()
@@ -188,7 +188,7 @@ fn view_join_non_indexed_column(ctx: &ViewContext) -> Query<PlayerInfo> {
 
 /// Right join returns right table's type
 /// -- should be PlayerInfo, not Player
-#[view(name = view_right_join_wrong_return_type, public)]
+#[view(accessor = view_right_join_wrong_return_type, public)]
 fn view_right_join_wrong_return_type(ctx: &ViewContext) -> Query<Player> {
     ctx.from
         .player()
@@ -198,7 +198,7 @@ fn view_right_join_wrong_return_type(ctx: &ViewContext) -> Query<Player> {
 
 /// Using non-existent table
 /// -- xyz table does not exist
-#[view(name = view_nonexistent_table, public)]
+#[view(accessor = view_nonexistent_table, public)]
 fn view_nonexistent_table(ctx: &ViewContext) -> Query<T> {
     ctx.from.xyz().build()
 }