Impl macro rework

Author: coolreader18

crates/bindings-macro/src/lib.rs

@@ -1,73 +1,43 @@
-use std::marker::PhantomData;
-
-use syn::parse::{Lookahead1, Parse, ParseStream};
-use syn::token::Token;
+pub(crate) fn one_of(options: &[crate::sym::Symbol]) -> String {
+    match options {
+        [] => "unexpected attribute".to_owned(),
+        [a] => {
+            format!("expected `{a}`")
+        }
+        [a, b] => {
+            format!("expected `{a}` or `{b}`")
+        }
+        _ => {
+            let join = options.join("`, `");
+            format!("expected one of: `{}`", join)
+        }
+    }
+}
 
-macro_rules! match_tok {
-    (match $input:ident { $($matches:tt)* }) => {{
-        use $crate::macros::PeekParse;
-        let input: syn::parse::ParseStream = $input;
-        let lookahead = input.lookahead1();
-        match_tok!(@match lookahead, input { $($matches)* })
+macro_rules! match_meta {
+    (match $meta:ident { $($matches:tt)* }) => {{
+        let meta: &syn::meta::ParseNestedMeta = &$meta;
+        match_meta!(@match (), (), meta { $($matches)* })
     }};
 
-    (@match $lookahead:ident, $input:ident { $binding:tt @ $tok:ty => $body:block $($rest:tt)* }) => {
-        match_tok!(@case $lookahead, $input, $binding, $tok, $body, { $($rest)* })
+    (@match $acc:tt, $comparisons:tt, $meta:ident { $sym:path => $body:block $($rest:tt)* }) => {
+        match_meta!(@case $acc, $comparisons, $meta, _, $sym, $body, { $($rest)* })
     };
-    (@match $lookahead:ident, $input:ident { $tok:ty => $body:block $($rest:tt)* }) => {
-        match_tok!(@case $lookahead, $input, _, $tok, $body, { $($rest)* })
-    };
-    (@match $lookahead:ident, $input:ident { $binding:tt @ $tok:ty => $body:expr, $($rest:tt)* }) => {
-        match_tok!(@case $lookahead, $input, $binding, $tok, $body, { $($rest)* })
-    };
-    (@match $lookahead:ident, $input:ident { $tok:ty => $body:expr, $($rest:tt)* }) => {
-        match_tok!(@case $lookahead, $input, _, $tok, $body, { $($rest)* })
+    (@match $acc:tt, $comparisons:tt, $meta:ident { $sym:path => $body:expr, $($rest:tt)* }) => {
+        match_meta!(@case $acc, $comparisons, $meta, _, $sym, $body, { $($rest)* })
     };
 
-    (@match $lookahead:ident, $input:ident {}) => {
-        return Err($lookahead.error())
-    };
-
-    (@case $lookahead:ident, $input:ident, $binding:tt, $tok:ty, $body:expr, { $($rest:tt)* }) => {
-        if $crate::macros::peekparser::<$tok>().peekparse_peek(&$lookahead, $input) {
-            let $binding = $crate::macros::peekparser::<$tok>().peekparse_parse($input)?;
-            $body
-        } else {
-            match_tok!(@match $lookahead, $input { $($rest)* })
+    (@match ($($acc:tt)*), ($($comparisons:expr),*), $meta:ident {}) => {
+        match () {
+            $($acc)*
+            _ => return Err($meta.error($crate::macros::one_of(&[$($comparisons),*]))),
         }
     };
-}
 
-pub fn peekparser<T>() -> &'static PhantomData<T> {
-    &PhantomData
-}
-
-pub trait PeekParse {
-    type Output;
-    fn peekparse_peek(&self, lookahead1: &Lookahead1, input: ParseStream) -> bool;
-    fn peekparse_parse(&self, input: ParseStream) -> syn::Result<Self::Output>;
-}
-
-impl<T: Token + Parse> PeekParse for PhantomData<T> {
-    type Output = T;
-    fn peekparse_peek(&self, lookahead1: &Lookahead1, _input: ParseStream) -> bool {
-        lookahead1.peek(|x| -> T { match x {} })
-    }
-    fn peekparse_parse(&self, input: ParseStream) -> syn::Result<Self::Output> {
-        input.parse()
-    }
-}
-
-impl<T1, T2> PeekParse for &PhantomData<(T1, T2)>
-where
-    T1: Token + Parse,
-    T2: Token + Parse,
-{
-    type Output = (T1, T2);
-    fn peekparse_peek(&self, lookahead1: &Lookahead1, input: ParseStream) -> bool {
-        lookahead1.peek(|x| -> T1 { match x {} }) && input.peek2(|x| -> T2 { match x {} })
-    }
-    fn peekparse_parse(&self, input: ParseStream) -> syn::Result<Self::Output> {
-        Ok((input.parse()?, input.parse()?))
-    }
+    (@case ($($acc:tt)*), ($($comparisons:expr),*), $meta:ident, $binding:tt, $sym:path, $body:expr, { $($rest:tt)* }) => {
+        match_meta!(@match (
+            $($acc)*
+            _ if $meta.path == $sym => $body,
+        ), ($($comparisons,)* $sym), $meta { $($rest)* })
+    };
 }

crates/bindings-macro/src/macros.rs

@@ -7,17 +7,17 @@ use syn::punctuated::Pair;
 use syn::spanned::Spanned;
 use syn::{LitStr, Token};
 
-use crate::{check_duplicate_meta, sym};
+use crate::{check_duplicate, sym};
 
 pub(crate) struct SatsType<'a> {
     pub ident: &'a syn::Ident,
     pub generics: &'a syn::Generics,
     pub name: String,
     pub krate: TokenStream,
+    // may want to use in the future
+    #[allow(unused)]
     pub original_attrs: &'a [syn::Attribute],
     pub data: SatsTypeData<'a>,
-    pub public: Option<Span>,
-    pub scheduled: Option<String>,
 }
 
 pub(crate) enum SatsTypeData<'a> {
@@ -40,6 +40,7 @@ pub(crate) struct SatsVariant<'a> {
     pub name: String,
     pub ty: Option<&'a syn::Type>,
     pub member: Option<syn::Member>,
+    // may want to use in the future
     #[allow(unused)]
     pub original_attrs: &'a [syn::Attribute],
 }
@@ -87,37 +88,25 @@ pub(crate) fn extract_sats_type<'a>(
 ) -> syn::Result<SatsType<'a>> {
     let mut name = None;
     let mut krate = None;
-    let mut public = None;
-    let mut scheduled = None;
     for attr in attrs {
-        if attr.path() != sym::SATS {
+        if attr.path() != sym::sats {
             continue;
         }
         attr.parse_nested_meta(|meta| {
-            if meta.path == sym::CRATE {
-                check_duplicate_meta(&krate, &meta)?;
-                let value = meta.value()?;
-                let v = value.call(syn::Path::parse_mod_style)?;
-                krate = Some(v.into_token_stream());
-            } else if meta.path == sym::NAME {
-                check_duplicate_meta(&name, &meta)?;
-                let value = meta.value()?;
-                let v = value.parse::<LitStr>()?;
-                name = Some(v.value());
-            } else if meta.path == sym::PUBLIC {
-                check_duplicate_meta(&public, &meta)?;
-                if !meta.input.is_empty() {
-                    return Err(meta.error("public modifier must be empty"));
+            match_meta!(match meta {
+                sym::crate_ => {
+                    check_duplicate(&krate, &meta)?;
+                    let value = meta.value()?;
+                    let v = value.call(syn::Path::parse_mod_style)?;
+                    krate = Some(v.into_token_stream());
                 }
-                public = Some(meta.path.span());
-            } else if meta.path == sym::SCHEDULED {
-                check_duplicate_meta(&scheduled, &meta)?;
-                let value = meta.value()?;
-                let v = value.parse::<LitStr>()?;
-                scheduled = Some(v.value());
-            } else {
-                return Err(meta.error("unknown sats attribute"));
-            }
+                sym::name => {
+                    check_duplicate(&name, &meta)?;
+                    let value = meta.value()?;
+                    let v = value.parse::<LitStr>()?;
+                    name = Some(v.value());
+                }
+            });
             Ok(())
         })?;
     }
@@ -131,19 +120,9 @@ pub(crate) fn extract_sats_type<'a>(
         krate,
         original_attrs: attrs,
         data,
-        public,
-        scheduled,
     })
 }
 
-/// Ensures that the `public` modifier is not present.
-pub(crate) fn ensure_no_public(ty: &SatsType<'_>, mut ts: TokenStream) -> TokenStream {
-    if let Some(span) = ty.public {
-        ts.extend(syn::Error::new(span, "the `public` specifier is not allowed in this context").into_compile_error());
-    }
-    ts
-}
-
 pub(crate) fn derive_satstype(ty: &SatsType<'_>, gen_type_alias: bool) -> TokenStream {
     let ty_name = &ty.name;
     let name = &ty.ident;

crates/bindings-macro/src/module.rs

@@ -32,7 +32,9 @@ pub use rand;
 #[cfg(feature = "rand")]
 pub use rng::{random, rng, StdbRng};
 pub use sats::SpacetimeType;
-pub use spacetimedb_bindings_macro::{duration, query, spacetimedb, TableType};
+#[doc(hidden)]
+pub use spacetimedb_bindings_macro::__TableHelper;
+pub use spacetimedb_bindings_macro::{duration, query, reducer, table};
 pub use spacetimedb_bindings_sys as sys;
 pub use spacetimedb_lib;
 pub use spacetimedb_lib::de::{Deserialize, DeserializeOwned};
@@ -469,7 +471,7 @@ pub mod query {
     /// according to the column's schema and then `Ord for AlgebraicValue`.
     ///
     /// **NOTE:** Do not use directly.
-    /// This is exposed as `filter_by_{$field_name}` on types with `#[spacetimedb(table)]`.
+    /// This is exposed as `filter_by_{$field_name}` on types with `#[spacetimedb::table]`.
     #[doc(hidden)]
     pub fn filter_by_unique_field<
         Table: TableType + FieldAccess<COL_IDX, Field = T>,
@@ -503,7 +505,7 @@ pub mod query {
     /// according to the column's schema and then `Ord for AlgebraicValue`.
     ///
     /// **NOTE:** Do not use directly.
-    /// This is exposed as `filter_by_{$field_name}` on types with `#[spacetimedb(table)]`.
+    /// This is exposed as `filter_by_{$field_name}` on types with `#[spacetimedb::table]`.
     #[doc(hidden)]
     pub fn filter_by_field<Table: TableType, T: FilterableValue, const COL_IDX: u16>(val: &T) -> TableIter<Table> {
         let iter = iter_by_col_eq(Table::table_id(), COL_IDX.into(), val).expect("iter_by_col_eq failed");
@@ -517,7 +519,7 @@ pub mod query {
     /// Returns the number of deleted rows.
     ///
     /// **NOTE:** Do not use directly.
-    /// This is exposed as `delete_by_{$field_name}` on types with `#[spacetimedb(table)]`
+    /// This is exposed as `delete_by_{$field_name}` on types with `#[spacetimedb::table]`
     /// where the field does not have a unique constraint.
     #[doc(hidden)]
     pub fn delete_by_field<Table: TableType, T: FilterableValue, const COL_IDX: u16>(val: &T) -> u32 {
@@ -534,7 +536,7 @@ pub mod query {
     /// Returns whether any rows were deleted.
     ///
     /// **NOTE:** Do not use directly.
-    /// This is exposed as `delete_by_{$field_name}` on types with `#[spacetimedb(table)]`
+    /// This is exposed as `delete_by_{$field_name}` on types with `#[spacetimedb::table]`
     /// where the field has a unique constraint.
     pub fn delete_by_unique_field<Table: TableType, T: FilterableValue, const COL_IDX: u16>(val: &T) -> bool {
         let count = delete_by_field::<Table, T, COL_IDX>(val);
@@ -548,7 +550,7 @@ pub mod query {
     /// according to the column's schema and then `Ord for AlgebraicValue`.
     ///
     /// **NOTE:** Do not use directly.
-    /// This is exposed as `update_by_{$field_name}` on types with `#[spacetimedb(table)]`.
+    /// This is exposed as `update_by_{$field_name}` on types with `#[spacetimedb::table]`.
     #[doc(hidden)]
     pub fn update_by_field<Table: TableType, T: FilterableValue, const COL_IDX: u16>(old: &T, new: Table) -> bool {
         // Delete the existing row, if any.

crates/bindings/src/lib.rs

@@ -106,8 +106,7 @@ impl ReducerArg<'_> for ReducerContext {}
 pub fn assert_reducer_arg<'de, T: ReducerArg<'de>>() {}
 /// Assert that `T: IntoReducerResult`.
 pub fn assert_reducer_ret<T: IntoReducerResult>() {}
-/// Assert that `T: TableType`.
-pub const fn assert_table<T: TableType>() {}
+pub const fn assert_reducer_typecheck<'de, A: Args<'de>, T>(_: impl Reducer<'de, A, T> + Copy) {}
 
 /// Used in the last type parameter of `Reducer` to indicate that the
 /// context argument *should* be passed to the reducer logic.

crates/bindings/src/rt.rs

@@ -1,31 +1,31 @@
-use spacetimedb::{spacetimedb, ReducerContext};
+use spacetimedb::ReducerContext;
 
-#[spacetimedb(table)]
+#[spacetimedb::table]
 pub struct Person {
     name: String
 }
 
-#[spacetimedb(init)]
+#[spacetimedb::reducer(init)]
 pub fn init() {
     // Called when the module is initially published
 }
 
-#[spacetimedb(connect)]
+#[spacetimedb::reducer(client_connected)]
 pub fn identity_connected(_ctx: ReducerContext) {
     // Called everytime a new client connects
 }
 
-#[spacetimedb(disconnect)]
+#[spacetimedb::reducer(client_disconnected)]
 pub fn identity_disconnected(_ctx: ReducerContext) {
     // Called everytime a client disconnects
 }
 
-#[spacetimedb(reducer)]
+#[spacetimedb::reducer]
 pub fn add(name: String) {
     Person::insert(Person { name });
 }
 
-#[spacetimedb(reducer)]
+#[spacetimedb::reducer]
 pub fn say_hello() {
     for person in Person::iter() {
         log::info!("Hello, {}!", person.name);

crates/cli/src/subcommands/project/rust/lib._rs

@@ -262,7 +262,7 @@ impl CommittedState {
     /// Compute the system table schemas from the system tables,
     /// and store those schemas in the in-memory [`Table`] structures.
     ///
-    /// Necessary during bootstrap because system tables include autoinc IDs
+    /// Necessary during bootstrap because system tables include auto_inc IDs
     /// for objects like indexes and constraints
     /// which are computed at insert-time,
     /// and therefore not included in the hardcoded schemas.

crates/core/src/db/datastore/locking_tx_datastore/committed_state.rs

@@ -143,7 +143,7 @@ impl Locking {
     /// - Populate those tables with all rows in `snapshot`.
     /// - Construct a [`HashMapBlobStore`] containing all the large blobs referenced by `snapshot`,
     ///   with reference counts specified in `snapshot`.
-    /// - Do [`CommittedState::reset_system_table_schemas`] to fix-up autoinc IDs in the system tables,
+    /// - Do [`CommittedState::reset_system_table_schemas`] to fix-up auto_inc IDs in the system tables,
     ///   to ensure those schemas match what [`Self::bootstrap`] would install.
     /// - Notably, **do not** construct indexes or sequences.
     ///   This should be done by [`Self::rebuild_state_after_replay`],
@@ -201,7 +201,7 @@ impl Locking {
                 .set(table_size as i64);
         }
 
-        // Fix up autoinc IDs in the cached system table schemas.
+        // Fix up auto_inc IDs in the cached system table schemas.
         committed_state.reset_system_table_schemas(database_address)?;
 
         // The next TX offset after restoring from a snapshot is one greater than the snapshotted offset.
@@ -1901,7 +1901,7 @@ mod tests {
 
         // Insert a row and commit the tx.
         let row = u32_str_u32(0, "Foo", 18); // 0 will be ignored.
-                                             // Because of autoinc columns, we will get a slightly different
+                                             // Because of auto_inc columns, we will get a slightly different
                                              // value than the one we inserted.
         let row = datastore.insert_mut_tx(&mut tx, table_id, row)?.1.to_product_value();
         datastore.commit_mut_tx_for_test(tx)?;
@@ -1922,7 +1922,7 @@ mod tests {
 
         // Update the db with the same actual value for that row, in a new tx.
         let mut tx = datastore.begin_mut_tx(IsolationLevel::Serializable);
-        // Iterate over all rows with the value 1 (from the autoinc) in column 0.
+        // Iterate over all rows with the value 1 (from the auto_inc) in column 0.
         let rows = all_rows_col_0_eq_1(&tx);
         assert_eq!(rows.len(), 1);
         assert_eq!(row, rows[0]);
@@ -1973,7 +1973,7 @@ mod tests {
 
     // TODO: Add the following tests
     // - Create index with unique constraint and immediately insert a row that violates the constraint before committing.
-    // - Create a tx that inserts 2000 rows with an autoinc column
-    // - Create a tx that inserts 2000 rows with an autoinc column and then rolls back
+    // - Create a tx that inserts 2000 rows with an auto_inc column
+    // - Create a tx that inserts 2000 rows with an auto_inc column and then rolls back
     // - Test creating sequences pre_commit, post_commit, post_rollback
 }

crates/core/src/db/datastore/locking_tx_datastore/datastore.rs

@@ -297,12 +297,12 @@ fn schema_compat_and_updates_hack(
     //
     // UNSET = {}
     // INDEXED = { indexed }
-    // AUTO_INC = { autoinc }
+    // AUTO_INC = { auto_inc }
     // UNIQUE = INDEXED | { unique } = { unique, indexed }
-    // IDENTITY = UNIQUE | AUTO_INC = { unique, indexed, autoinc }
+    // IDENTITY = UNIQUE | AUTO_INC = { unique, indexed, auto_inc }
     // PRIMARY_KEY = UNIQUE | { pk } = { unique, indexed, pk }
-    // PRIMARY_KEY_AUTO = PRIMARY_KEY | AUTO_INC = { unique, indexed, autoinc, pk }
-    // PRIMARY_KEY_IDENTITY = PRIMARY_KEY | IDENTITY =  = { unique, indexed, autoinc, pk }
+    // PRIMARY_KEY_AUTO = PRIMARY_KEY | AUTO_INC = { unique, indexed, auto_inc, pk }
+    // PRIMARY_KEY_IDENTITY = PRIMARY_KEY | IDENTITY =  = { unique, indexed, auto_inc, pk }
     //
     // This entails that all attributes with `indexed`,
     // that have something additional,