c# codegen: revert to always using List<T> for arrays

Author: Centril

crates/cli/src/subcommands/generate/csharp.rs

@@ -55,7 +55,13 @@ fn ty_fmt<'a>(ctx: &'a GenCtx, ty: &'a AlgebraicType, namespace: &'a str) -> imp
         }
         // Arbitrary product types should fail.
         AlgebraicType::Product(_) => unimplemented!(),
-        AlgebraicType::Array(ArrayType { elem_ty }) => write!(f, "{}[]", ty_fmt(ctx, elem_ty, namespace)),
+        AlgebraicType::Array(ArrayType { elem_ty }) => {
+            write!(
+                f,
+                "System.Collections.Generic.List<{}>",
+                ty_fmt(ctx, elem_ty, namespace)
+            )
+        }
         AlgebraicType::Ref(r) => {
             let name = csharp_typename(ctx, *r);
             match &ctx.typespace[*r] {
@@ -82,18 +88,17 @@ fn ty_fmt<'a>(ctx: &'a GenCtx, ty: &'a AlgebraicType, namespace: &'a str) -> imp
     })
 }
 
-fn default_init(ctx: &GenCtx, ty: &AlgebraicType, namespace: &str) -> Option<String> {
+fn default_init(ctx: &GenCtx, ty: &AlgebraicType) -> Option<&'static str> {
     match ty {
         // Options have a default value of null which is fine for us, and simple enums have their own default.
         AlgebraicType::Sum(sum_type) if sum_type.is_option() || sum_type.is_simple_enum() => None,
         // TODO: generate some proper default here (what would it be for tagged enums?).
-        AlgebraicType::Sum(_) => Some("null!".into()),
-        AlgebraicType::Array(arr_ty) => Some(format!("Array.Empty<{}>()", ty_fmt(ctx, &arr_ty.elem_ty, namespace))),
-        // For product types, we can use the default constructor.
-        AlgebraicType::Product(_) => Some("new()".into()),
+        AlgebraicType::Sum(_) => Some("null!"),
+        // For product types and arrays, we can use the default constructor.
+        AlgebraicType::Product(_) | AlgebraicType::Array(_) => Some("new()"),
         // Strings must have explicit default value of "".
-        AlgebraicType::String => Some(r#""""#.into()),
-        AlgebraicType::Ref(r) => default_init(ctx, &ctx.typespace[*r], namespace),
+        AlgebraicType::String => Some(r#""""#),
+        AlgebraicType::Ref(r) => default_init(ctx, &ctx.typespace[*r]),
         _ => {
             debug_assert!(ty.is_scalar());
             None
@@ -342,7 +347,7 @@ fn autogen_csharp_product_table_common(
             writeln!(output, "public {name}()");
             indented_block(output, |output| {
                 for ((field_name, _ty), field) in fields.iter().zip(&*product_type.elements) {
-                    if let Some(default) = default_init(ctx, &field.algebraic_type, namespace) {
+                    if let Some(default) = default_init(ctx, &field.algebraic_type) {
                         writeln!(output, "this.{field_name} = {default};");
                     }
                 }
@@ -524,7 +529,7 @@ pub fn autogen_csharp_reducer(ctx: &GenCtx, reducer: &ReducerDef, namespace: &st
 
             write!(output, "public {arg_type_str} {field_name}");
             // Skip default initializer if it's the same as the implicit default.
-            if let Some(default) = default_init(ctx, &arg.algebraic_type, namespace) {
+            if let Some(default) = default_init(ctx, &arg.algebraic_type) {
                 write!(output, " = {default}");
             }
             writeln!(output, ";");