Disable scheduling procedures (#3768)

# Description of Changes

We've been unable to get scheduled procedures into the initial release
of procedures due to a nondeterministic hang in some of our tests which
we don't have time to debug. As such, this commit disables scheduled
procedures by:

- Changing the `RawModuleDevV9` validator to reject scheduled
procedures.
- Changing the Rust bindings library's typechecking magic so that
scheduled table annotations referencing procedures will cause a type
error.
- Removes some docs from the Rust bindings library which reference
scheduled procedures.

# API and ABI breaking changes

N/a

# Expected complexity level and risk

1

# Testing

Automated tests should be sufficient.

Prior to merging #3774 , CI for this branch merged with master failed in
the intended way: modules which attempted to define scheduled procedures
failed to typecheck.

Author: gefjon

crates/bindings/src/lib.rs

@@ -728,16 +728,17 @@ pub use spacetimedb_bindings_macro::reducer;
 // TODO(procedure-http): add example with an HTTP request.
 // TODO(procedure-transaction): document obtaining and using a transaction within a procedure.
 ///
-/// # Scheduled procedures
+// TODO(scheduled-procedures): Uncomment below docs.
+// /// # Scheduled procedures
 // TODO(docs): after moving scheduled reducer docs into table secion, link there.
-///
-/// Like [reducer]s, procedures can be made **scheduled**.
-/// This allows calling procedures at a particular time, or in a loop.
-/// It also allows reducers to enqueue procedure runs.
-///
-/// Scheduled procedures are called on a best-effort basis and may be slightly delayed in their execution
-/// when a database is under heavy load.
-///
+// ///
+// /// Like [reducer]s, procedures can be made **scheduled**.
+// /// This allows calling procedures at a particular time, or in a loop.
+// /// It also allows reducers to enqueue procedure runs.
+// ///
+// /// Scheduled procedures are called on a best-effort basis and may be slightly delayed in their execution
+// /// when a database is under heavy load.
+// ///
 /// [clients]: https://spacetimedb.com/docs/#client
 // TODO(procedure-async): update docs and examples with `async`-ness.
 #[doc(inline)]

crates/bindings/src/rt.rs

@@ -424,7 +424,9 @@ pub struct FnKindView {
 /// See <https://willcrichton.net/notes/defeating-coherence-rust/> for details on this technique.
 #[cfg_attr(
     feature = "unstable",
-    doc = "It will be one of [`FnKindReducer`] or [`FnKindProcedure`] in modules that compile successfully."
+    // TODO(scheduled-procedures): uncomment this, delete other line
+    // doc = "It will be one of [`FnKindReducer`] or [`FnKindProcedure`] in modules that compile successfully."
+    doc = "It will be [`FnKindReducer`] in modules that compile successfully."
 )]
 #[cfg_attr(
     not(feature = "unstable"),
@@ -437,23 +439,24 @@ pub struct FnKindView {
     note = "views cannot be scheduled",
     note = "the scheduled function must take `{TableRow}` as its sole argument",
     note = "e.g: `fn scheduled_reducer(ctx: &ReducerContext, arg: {TableRow})`",
-    note = "or `fn scheduled_procedure(ctx: &mut ProcedureContext, arg: {TableRow})`"
+    // note = "or `fn scheduled_procedure(ctx: &mut ProcedureContext, arg: {TableRow})`"
 )]
 pub trait ExportFunctionForScheduledTable<'de, TableRow, FnKind> {}
 impl<'de, TableRow: SpacetimeType + Serialize + Deserialize<'de>, F: Reducer<'de, (TableRow,)>>
     ExportFunctionForScheduledTable<'de, TableRow, FnKindReducer> for F
 {
 }
 
-#[cfg(feature = "unstable")]
-impl<
-        'de,
-        TableRow: SpacetimeType + Serialize + Deserialize<'de>,
-        Ret: SpacetimeType + Serialize + Deserialize<'de>,
-        F: Procedure<'de, (TableRow,), Ret>,
-    > ExportFunctionForScheduledTable<'de, TableRow, FnKindProcedure<Ret>> for F
-{
-}
+// TODO(scheduled-procedures): uncomment this to syntactically allow scheduled procedures.
+// #[cfg(feature = "unstable")]
+// impl<
+//         'de,
+//         TableRow: SpacetimeType + Serialize + Deserialize<'de>,
+//         Ret: SpacetimeType + Serialize + Deserialize<'de>,
+//         F: Procedure<'de, (TableRow,), Ret>,
+//     > ExportFunctionForScheduledTable<'de, TableRow, FnKindProcedure<Ret>> for F
+// {
+// }
 
 // the macro generates <T as SpacetimeType>::make_type::<DummyTypespace>
 pub struct DummyTypespace;

crates/bindings/tests/ui/views.stderr

@@ -408,3 +408,29 @@ error[E0277]: the trait bound `NotSpacetimeType: SpacetimeType` is not satisfied
               ColId
             and $N others
     = note: required for `Option<NotSpacetimeType>` to implement `SpacetimeType`
+
+error[E0631]: type mismatch in function arguments
+   --> tests/ui/views.rs:142:56
+    |
+142 | #[spacetimedb::table(name = scheduled_table, scheduled(scheduled_table_view))]
+    | -------------------------------------------------------^^^^^^^^^^^^^^^^^^^^---
+    | |                                                      |
+    | |                                                      expected due to this
+    | required by a bound introduced by this call
+...
+154 | fn scheduled_table_view(_: &ViewContext, _args: ScheduledTable) -> Vec<Player> {
+    | ------------------------------------------------------------------------------ found signature defined here
+    |
+    = note: expected function signature `for<'a> fn(&'a ReducerContext, ScheduledTable) -> _`
+               found function signature `fn(&ViewContext, ScheduledTable) -> _`
+    = note: required for `for<'a> fn(&'a ViewContext, ScheduledTable) -> Vec<Player> {scheduled_table_view}` to implement `Reducer<'_, (ScheduledTable,)>`
+    = note: required for `for<'a> fn(&'a ViewContext, ScheduledTable) -> Vec<Player> {scheduled_table_view}` to implement `ExportFunctionForScheduledTable<'_, ScheduledTable, {type error}>`
+note: required by a bound in `scheduled_typecheck`
+   --> src/rt.rs
+    |
+    | pub const fn scheduled_typecheck<'de, Row, FnKind>(_x: impl ExportFunctionForScheduledTable<'de, Row, FnKind>)
+    |                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `scheduled_typecheck`
+help: consider wrapping the function in a closure
+    |
+142 | #[spacetimedb::table(name = scheduled_table, scheduled(|arg0: &ReducerContext, arg1: ScheduledTable| scheduled_table_view(/* &ViewContext */, arg1)))]
+    |                                                        +++++++++++++++++++++++++++++++++++++++++++++                     ++++++++++++++++++++++++++

crates/schema/src/def/validate/v9.rs

@@ -1197,7 +1197,7 @@ fn identifier(name: Box<str>) -> Result<Identifier> {
 fn check_scheduled_functions_exist(
     tables: &mut IdentifierMap<TableDef>,
     reducers: &IndexMap<Identifier, ReducerDef>,
-    procedures: &IndexMap<Identifier, ProcedureDef>,
+    _procedures: &IndexMap<Identifier, ProcedureDef>,
 ) -> Result<()> {
     let validate_params =
         |params_from_function: &ProductType, table_row_type_ref: AlgebraicTypeRef, function_name: &str| {
@@ -1222,10 +1222,13 @@ fn check_scheduled_functions_exist(
                 if let Some(reducer) = reducers.get(&schedule.function_name) {
                     schedule.function_kind = FunctionKind::Reducer;
                     validate_params(&reducer.params, table.product_type_ref, &reducer.name).map_err(Into::into)
-                } else if let Some(procedure) = procedures.get(&schedule.function_name) {
-                    schedule.function_kind = FunctionKind::Procedure;
-                    validate_params(&procedure.params, table.product_type_ref, &procedure.name).map_err(Into::into)
-                } else {
+                } else
+                // TODO(scheduled-procedures): Uncomment this
+                // if let Some(procedure) = procedures.get(&schedule.function_name) {
+                //     schedule.function_kind = FunctionKind::Procedure;
+                //     validate_params(&procedure.params, table.product_type_ref, &procedure.name).map_err(Into::into)
+                // } else
+                {
                     Err(ValidationError::MissingScheduledFunction {
                         schedule: schedule.name.clone(),
                         function: schedule.function_name.clone(),