Add omitempty for fields with default in go-gen

Author: chipshort

packages/go-gen/src/go.rs

@@ -50,7 +50,7 @@ impl Display for GoField {
             self.ty,
             self.rust_name
         )?;
-        if self.ty.is_nullable {
+        if let Nullability::OmitEmpty | Nullability::Nullable = self.ty.nullability {
             f.write_str(",omitempty")?;
         }
         f.write_str("\"`")
@@ -60,10 +60,19 @@ impl Display for GoField {
 pub struct GoType {
     /// The name of the type in Go
     pub name: String,
-    /// Whether the type should be nullable
-    /// This will add `omitempty` to the json tag and use a pointer type if
-    /// the type is not a basic type
-    pub is_nullable: bool,
+    /// Whether the type should be nullable / omitempty / etc.
+    pub nullability: Nullability,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Nullability {
+    /// The type should be nullable
+    /// In Go, this will use a pointer type and add `omitempty` to the json tag
+    Nullable,
+    /// The type should not be nullable, use the type as is
+    NonNullable,
+    /// The type should be nullable by omitting it from the json object if it is empty
+    OmitEmpty,
 }
 
 impl GoType {
@@ -95,7 +104,7 @@ impl GoType {
 
 impl Display for GoType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if self.is_nullable && !self.is_basic_type() {
+        if self.nullability == Nullability::Nullable && !self.is_basic_type() {
             // if the type is nullable and not a basic type, use a pointer
             f.write_char('*')?;
         }
@@ -122,23 +131,23 @@ mod tests {
     fn go_type_display_works() {
         let ty = GoType {
             name: "string".to_string(),
-            is_nullable: true,
+            nullability: Nullability::Nullable,
         };
         let ty2 = GoType {
             name: "string".to_string(),
-            is_nullable: false,
+            nullability: Nullability::NonNullable,
         };
         assert_eq!(format!("{}", ty), "string");
         assert_eq!(format!("{}", ty2), "string");
 
         let ty = GoType {
             name: "FooBar".to_string(),
-            is_nullable: true,
+            nullability: Nullability::Nullable,
         };
         assert_eq!(format!("{}", ty), "*FooBar");
         let ty = GoType {
             name: "FooBar".to_string(),
-            is_nullable: false,
+            nullability: Nullability::NonNullable,
         };
         assert_eq!(format!("{}", ty), "FooBar");
     }
@@ -150,7 +159,7 @@ mod tests {
             docs: None,
             ty: GoType {
                 name: "string".to_string(),
-                is_nullable: true,
+                nullability: Nullability::Nullable,
             },
         };
         assert_eq!(
@@ -163,7 +172,7 @@ mod tests {
             docs: None,
             ty: GoType {
                 name: "string".to_string(),
-                is_nullable: false,
+                nullability: Nullability::NonNullable,
             },
         };
         assert_eq!(format!("{}", field), "FooBar string `json:\"foo_bar\"`");
@@ -173,7 +182,7 @@ mod tests {
             docs: None,
             ty: GoType {
                 name: "FooBar".to_string(),
-                is_nullable: true,
+                nullability: Nullability::Nullable,
             },
         };
         assert_eq!(
@@ -189,7 +198,7 @@ mod tests {
             docs: Some("foo_bar is a test field".to_string()),
             ty: GoType {
                 name: "string".to_string(),
-                is_nullable: true,
+                nullability: Nullability::Nullable,
             },
         };
         assert_eq!(
@@ -208,7 +217,7 @@ mod tests {
                 docs: None,
                 ty: GoType {
                     name: "string".to_string(),
-                    is_nullable: true,
+                    nullability: Nullability::Nullable,
                 },
             }],
         };
@@ -225,7 +234,7 @@ mod tests {
                 docs: None,
                 ty: GoType {
                     name: "string".to_string(),
-                    is_nullable: true,
+                    nullability: Nullability::Nullable,
                 },
             }],
         };

packages/go-gen/src/main.rs

@@ -186,7 +186,7 @@ pub fn build_enum_variant(
         docs,
         ty: GoType {
             name: ty,
-            is_nullable: true, // always nullable
+            nullability: Nullability::Nullable, // always nullable
         },
     })
 }
@@ -548,4 +548,40 @@ mod tests {
             "#,
         );
     }
+
+    #[test]
+    fn serde_default_works() {
+        fn default_u32() -> u32 {
+            42
+        }
+        #[cw_serde]
+        #[derive(Default)]
+        struct Nested {
+            a: u32,
+        }
+        #[cw_serde]
+        struct A {
+            #[serde(default)]
+            payload: Binary,
+            #[serde(default = "default_u32")]
+            int: u32,
+            #[serde(default)]
+            nested: Nested,
+        }
+
+        let code = generate_go(cosmwasm_schema::schema_for!(A)).unwrap();
+        assert_code_eq(
+            code,
+            r#"
+            type A struct {
+                Int uint32 `json:"int,omitempty"`
+                Nested Nested `json:"nested,omitempty"`
+                Payload []byte `json:"payload,omitempty"`
+            }
+            type Nested struct {
+                A uint32 `json:"a"`
+            }
+            "#,
+        );
+    }
 }

packages/go-gen/src/schema.rs

@@ -4,7 +4,7 @@ use inflector::Inflector;
 use schemars::schema::{InstanceType, Schema, SchemaObject, SingleOrVec};
 
 use crate::{
-    go::{GoField, GoStruct, GoType},
+    go::{GoField, GoStruct, GoType, Nullability},
     utils::{replace_acronyms, suffixes},
 };
 
@@ -36,9 +36,21 @@ pub fn schema_object_type(
     type_context: TypeContext,
     additional_structs: &mut Vec<GoStruct>,
 ) -> Result<GoType> {
-    let mut is_nullable = is_null(schema);
+    let mut nullability = if is_null(schema) {
+        Nullability::Nullable
+    } else {
+        Nullability::NonNullable
+    };
+
+    if schema
+        .metadata
+        .as_ref()
+        .and_then(|m| m.default.as_ref())
+        .is_some()
+    {
+        nullability = Nullability::OmitEmpty;
+    }
 
-    // if it has a title, use that
     let ty = if let Some(title) = schema.metadata.as_ref().and_then(|m| m.title.as_ref()) {
         replace_custom_type(title)
     } else if let Some(reference) = &schema.reference {
@@ -56,7 +68,7 @@ pub fn schema_object_type(
         let nullable = nullable_type(subschemas)?;
         if let Some(non_null) = nullable {
             ensure!(subschemas.len() == 2, "multiple subschemas in anyOf");
-            is_nullable = true;
+            nullability = Nullability::Nullable;
             // extract non-null type
             let GoType { name, .. } =
                 schema_object_type(non_null, type_context, additional_structs)?;
@@ -78,7 +90,7 @@ pub fn schema_object_type(
 
     Ok(GoType {
         name: ty,
-        is_nullable,
+        nullability,
     })
 }
 
@@ -197,7 +209,7 @@ pub fn type_from_instance_type(
         // for nullable array item types, we have to use a pointer type, even for basic types,
         // so we can pass null as elements
         // otherwise they would just be omitted from the array
-        replace_custom_type(&if item_type.is_nullable {
+        replace_custom_type(&if item_type.nullability == Nullability::Nullable {
             format!("[]*{}", item_type.name)
         } else {
             format!("[]{}", item_type.name)