Switch Rust codegen to use new ModuleDef (#1675)

Author: coolreader18

crates/bindings-csharp/Runtime/Internal/Module.cs

@@ -26,11 +26,6 @@ private static string GetFriendlyName(Type type) =>
 
     private void RegisterTypeName<T>(AlgebraicType.Ref typeRef)
     {
-        // If it's a table, it doesn't need an alias as name will be registered automatically.
-        if (typeof(T).IsDefined(typeof(TableAttribute), false))
-        {
-            return;
-        }
         MiscExports.Add(
             new MiscModuleExport.TypeAlias(new(GetFriendlyName(typeof(T)), (uint)typeRef.Ref_))
         );

crates/bindings-macro/src/lib.rs

@@ -887,7 +887,7 @@ fn table_impl(mut args: TableArgs, mut item: MutItem<syn::DeriveInput>) -> syn::
 
     let deserialize_impl = derive_deserialize(&sats_ty);
     let serialize_impl = derive_serialize(&sats_ty);
-    let schema_impl = derive_satstype(&sats_ty, *original_struct_ident != table_name);
+    let schema_impl = derive_satstype(&sats_ty, true);
     let column_attrs = columns.iter().map(|col| {
         Ident::new(
             ColumnAttribute::FLAGS

crates/cli/examples/regen-csharp-moduledef.rs

@@ -21,7 +21,11 @@ fn main() -> anyhow::Result<()> {
         module.add_type::<RawModuleDef>();
     });
 
-    let mut results = generate(module, Language::Csharp, "SpacetimeDB.Internal")?;
+    let mut results = generate(
+        RawModuleDef::V8BackCompat(module),
+        Language::Csharp,
+        "SpacetimeDB.Internal",
+    )?;
 
     // Someday we might replace custom BSATN types with autogenerated ones as well,
     // but for now they're not very large and our copies are somewhat more optimised.

crates/cli/src/subcommands/call.rs

@@ -1,7 +1,6 @@
 use crate::common_args;
 use crate::config::Config;
 use crate::edit_distance::{edit_distance, find_best_match_for_name};
-use crate::generate::rust::{write_arglist_no_delimiters, write_type};
 use crate::util;
 use crate::util::{add_auth_header_opt, database_address, get_auth_header_only};
 use anyhow::{bail, Context, Error};
@@ -191,10 +190,10 @@ fn reducer_signature(schema_json: Value, reducer_name: &str) -> Option<String> {
     fn ctx(typespace: &Typespace, r: AlgebraicTypeRef) -> String {
         let ty = &typespace[r];
         let mut ty_str = String::new();
-        write_type(&|r| ctx(typespace, r), &mut ty_str, ty).unwrap();
+        write_type::write_type(&|r| ctx(typespace, r), &mut ty_str, ty).unwrap();
         ty_str
     }
-    write_arglist_no_delimiters(&|r| ctx(&typespace, r), &mut args, &params, None).unwrap();
+    write_type::write_arglist_no_delimiters(&|r| ctx(&typespace, r), &mut args, &params, None).unwrap();
     let args = args.trim().trim_end_matches(',').replace('\n', " ");
 
     // Print the full signature to `reducer_fmt`.
@@ -322,3 +321,136 @@ fn typespace(value: &serde_json::Value) -> Option<Typespace> {
     let types = value.as_object()?.get("typespace")?;
     deserialize_from(types).map(Typespace::new).ok()
 }
+
+// this is an old version of code in generate::rust that got
+// refactored, but reducer_signature() was using it
+// TODO: port reducer_signature() to use AlgebraicTypeUse et al, somehow.
+mod write_type {
+    use super::*;
+    use convert_case::{Case, Casing};
+    use spacetimedb_lib::sats::ArrayType;
+    use spacetimedb_lib::ProductType;
+    use std::fmt;
+    use std::ops::Deref;
+
+    pub fn write_type<W: fmt::Write>(
+        ctx: &impl Fn(AlgebraicTypeRef) -> String,
+        out: &mut W,
+        ty: &AlgebraicType,
+    ) -> fmt::Result {
+        match ty {
+            p if p.is_identity() => write!(out, "Identity")?,
+            p if p.is_address() => write!(out, "Address")?,
+            p if p.is_schedule_at() => write!(out, "ScheduleAt")?,
+            AlgebraicType::Sum(sum_type) => {
+                if let Some(inner_ty) = sum_type.as_option() {
+                    write!(out, "Option<")?;
+                    write_type(ctx, out, inner_ty)?;
+                    write!(out, ">")?;
+                } else {
+                    write!(out, "enum ")?;
+                    print_comma_sep_braced(out, &sum_type.variants, |out: &mut W, elem: &_| {
+                        if let Some(name) = &elem.name {
+                            write!(out, "{name}: ")?;
+                        }
+                        write_type(ctx, out, &elem.algebraic_type)
+                    })?;
+                }
+            }
+            AlgebraicType::Product(ProductType { elements }) => {
+                print_comma_sep_braced(out, elements, |out: &mut W, elem: &ProductTypeElement| {
+                    if let Some(name) = &elem.name {
+                        write!(out, "{name}: ")?;
+                    }
+                    write_type(ctx, out, &elem.algebraic_type)
+                })?;
+            }
+            AlgebraicType::Bool => write!(out, "bool")?,
+            AlgebraicType::I8 => write!(out, "i8")?,
+            AlgebraicType::U8 => write!(out, "u8")?,
+            AlgebraicType::I16 => write!(out, "i16")?,
+            AlgebraicType::U16 => write!(out, "u16")?,
+            AlgebraicType::I32 => write!(out, "i32")?,
+            AlgebraicType::U32 => write!(out, "u32")?,
+            AlgebraicType::I64 => write!(out, "i64")?,
+            AlgebraicType::U64 => write!(out, "u64")?,
+            AlgebraicType::I128 => write!(out, "i128")?,
+            AlgebraicType::U128 => write!(out, "u128")?,
+            AlgebraicType::I256 => write!(out, "i256")?,
+            AlgebraicType::U256 => write!(out, "u256")?,
+            AlgebraicType::F32 => write!(out, "f32")?,
+            AlgebraicType::F64 => write!(out, "f64")?,
+            AlgebraicType::String => write!(out, "String")?,
+            AlgebraicType::Array(ArrayType { elem_ty }) => {
+                write!(out, "Vec<")?;
+                write_type(ctx, out, elem_ty)?;
+                write!(out, ">")?;
+            }
+            AlgebraicType::Map(ty) => {
+                write!(out, "Map<")?;
+                write_type(ctx, out, &ty.key_ty)?;
+                write!(out, ", ")?;
+                write_type(ctx, out, &ty.ty)?;
+                write!(out, ">")?;
+            }
+            AlgebraicType::Ref(r) => {
+                write!(out, "{}", ctx(*r))?;
+            }
+        }
+        Ok(())
+    }
+
+    fn print_comma_sep_braced<W: fmt::Write, T>(
+        out: &mut W,
+        elems: &[T],
+        on: impl Fn(&mut W, &T) -> fmt::Result,
+    ) -> fmt::Result {
+        write!(out, "{{")?;
+
+        let mut iter = elems.iter();
+
+        // First factor.
+        if let Some(elem) = iter.next() {
+            write!(out, " ")?;
+            on(out, elem)?;
+        }
+        // Other factors.
+        for elem in iter {
+            write!(out, ", ")?;
+            on(out, elem)?;
+        }
+
+        if !elems.is_empty() {
+            write!(out, " ")?;
+        }
+
+        write!(out, "}}")?;
+
+        Ok(())
+    }
+
+    pub fn write_arglist_no_delimiters(
+        ctx: &impl Fn(AlgebraicTypeRef) -> String,
+        out: &mut impl Write,
+        elements: &[ProductTypeElement],
+
+        // Written before each line. Useful for `pub`.
+        prefix: Option<&str>,
+    ) -> fmt::Result {
+        for elt in elements {
+            if let Some(prefix) = prefix {
+                write!(out, "{prefix} ")?;
+            }
+
+            let Some(name) = &elt.name else {
+                panic!("Product type element has no name: {elt:?}");
+            };
+            let name = name.deref().to_case(Case::Snake);
+
+            write!(out, "{name}: ")?;
+            write_type(ctx, out, &elt.algebraic_type)?;
+            writeln!(out, ",")?;
+        }
+        Ok(())
+    }
+}