Use interface types for Go discriminators

.github/workflows/publish.yml

@@ -4,6 +4,7 @@ on:
 
 jobs:
   release_binary:
+    permissions: write-all
     runs-on: ${{ matrix.runs_on }}
     strategy:
       matrix:

crates/core/src/codegen/mod.rs

@@ -9,7 +9,7 @@ use crate::target::{
 use ast::{Ast, SchemaAst};
 use jtd::Schema;
 use namespace::Namespace;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 use std::fs::File;
 use std::io::Write;
 use std::path::Path;
@@ -36,6 +36,7 @@ struct CodeGenerator<'a, T> {
     out_dir: &'a Path,
     strategy: Strategy,
     definition_names: BTreeMap<String, String>,
+    recursive_definitions: BTreeSet<String>,
 }
 
 struct FileData<T> {
@@ -50,6 +51,7 @@ impl<'a, T: Target> CodeGenerator<'a, T> {
             out_dir,
             strategy: target.strategy(),
             definition_names: BTreeMap::new(),
+            recursive_definitions: BTreeSet::new(),
         }
     }
 
@@ -68,6 +70,18 @@ impl<'a, T: Target> CodeGenerator<'a, T> {
             self.definition_names.insert(name.clone(), ast_name);
         }
 
+        // Detect recursive definitions, as some target language need to handle
+        // them specifically (e.g. Rust).
+        // Note that a type is *not* considered to be recursive it it contains
+        // instances of itself only through "elements" or "values"
+        // (the underlying container is considered to break the recursion).
+        for (name, ast) in &schema_ast.definitions {
+            let mut visited = vec![];
+            if find_recursion(name, ast, &schema_ast.definitions, &mut visited) {
+                self.recursive_definitions.insert(name.clone());
+            }
+        }
+
         // If the target is using FilePerType partitioning, then this state
         // won't actually be used at all. If it's using SingleFile partitioning,
         // then this is the only file state that will be used.
@@ -120,8 +134,17 @@ impl<'a, T: Target> CodeGenerator<'a, T> {
             // Ref nodes are a special sort of "expr-like" node, where we
             // already know what the name of the expression is; it's the name of
             // the definition.
-            Ast::Ref { definition, .. } => self.definition_names[&definition].clone(),
-
+            // Note however that recursive definition may need some special
+            // treatment by the target.
+            Ast::Ref { metadata, definition } => {
+                let sub_expr = self.definition_names[&definition].clone();
+                if self.recursive_definitions.iter().any(|i| i == &definition) {
+                    self.target
+                        .expr(&mut file_data.state, metadata, Expr::RecursiveRef(sub_expr))
+                } else {
+                    sub_expr
+                }
+            }
             // The remaining "expr-like" node types just build up strings and
             // possibly alter the per-file state (usually in order to add
             // "imports" to the file).
@@ -479,3 +502,33 @@ impl<'a, T: Target> CodeGenerator<'a, T> {
         Ok(())
     }
 }
+
+fn find_recursion(name: &str, ast: &Ast, definitions: &BTreeMap<String, Ast>, visited: &mut Vec<String>) -> bool {
+    match ast {
+        Ast::Ref { definition, .. } => {
+            if definition == name {
+                true
+            } else if visited.iter().any(|i| i == &name) {
+                false
+            } else if let Some(ast2) = definitions.get(definition) {
+                visited.push(definition.clone());
+                find_recursion(name, &ast2, definitions, visited)
+            } else {
+                false
+            }
+        }
+        Ast::NullableOf { type_, .. } => {
+            find_recursion(name, type_, definitions, visited)
+        }
+        Ast::Struct { fields, .. } => {
+            fields.iter()
+                  .any(|f| find_recursion(name, &f.type_, definitions, visited))
+        }
+        Ast::Discriminator { variants, .. } => {
+            variants.iter()
+                    .flat_map(|v| v.fields.iter())
+                    .any(|f| find_recursion(name, &f.type_, definitions, visited))
+                }
+        _ => false,
+    }
+}

crates/core/src/target/mod.rs

@@ -87,6 +87,7 @@ pub enum Expr {
     ArrayOf(String),
     DictOf(String),
     NullableOf(String),
+    RecursiveRef(String),
 }
 
 #[derive(Debug)]

crates/target_csharp_system_text/src/lib.rs

@@ -125,6 +125,7 @@ impl jtd_codegen::target::Target for Target {
                 format!("IDictionary<string, {}>", sub_expr)
             }
             target::Expr::NullableOf(sub_expr) => format!("{}?", sub_expr),
+            target::Expr::RecursiveRef(sub_expr) => sub_expr,
         }
     }
 

crates/target_go/src/lib.rs

@@ -114,6 +114,7 @@ impl jtd_codegen::target::Target for Target {
             target::Expr::ArrayOf(sub_expr) => format!("[]{}", sub_expr),
             target::Expr::DictOf(sub_expr) => format!("map[string]{}", sub_expr),
             target::Expr::NullableOf(sub_expr) => format!("*{}", sub_expr),
+            target::Expr::RecursiveRef(sub_expr) => sub_expr,
         }
     }
 
@@ -259,27 +260,12 @@ impl jtd_codegen::target::Target for Target {
                 writeln!(out)?;
                 write!(out, "{}", description(&metadata, 0))?;
                 writeln!(out, "type {} struct {{", name)?;
-                writeln!(out, "\t{} string", tag_field_name)?;
-                for variant in &variants {
-                    writeln!(out)?;
-                    writeln!(out, "\t{} {}", &variant.field_name, &variant.type_name)?;
-                }
+                writeln!(out, "\tValue I{} `json:\"-\"`", name)?;
                 writeln!(out, "}}")?;
 
                 writeln!(out)?;
                 writeln!(out, "func (v {}) MarshalJSON() ([]byte, error) {{", name)?;
-                writeln!(out, "\tswitch v.{} {{", tag_field_name)?;
-                for variant in &variants {
-                    writeln!(out, "\tcase {:?}:", variant.tag_value)?;
-                    writeln!(out, "\t\treturn json.Marshal(struct {{ T string `json:\"{}\"`; {} }}{{ v.{}, v.{} }})", tag_json_name, variant.type_name, tag_field_name, variant.field_name)?;
-                }
-                writeln!(out, "\t}}")?;
-                writeln!(out)?;
-                writeln!(
-                    out,
-                    "\treturn nil, fmt.Errorf(\"bad {0} value: %s\", v.{0})",
-                    tag_field_name
-                )?;
+                writeln!(out, "\treturn json.Marshal(v.Value)")?;
                 writeln!(out, "}}")?;
 
                 writeln!(out)?;
@@ -293,32 +279,114 @@ impl jtd_codegen::target::Target for Target {
                 writeln!(out, "\t\treturn err")?;
                 writeln!(out, "\t}}")?;
                 writeln!(out)?;
+                writeln!(out, "\tvar value I{}", name)?;
                 writeln!(out, "\tvar err error")?;
+                writeln!(out)?;
                 writeln!(out, "\tswitch t.T {{")?;
                 for variant in &variants {
                     writeln!(out, "\tcase {:?}:", variant.tag_value)?;
-                    writeln!(
-                        out,
-                        "\t\terr = json.Unmarshal(b, &v.{})",
-                        variant.field_name
-                    )?;
+                    writeln!(out, "\t\tvar v {}", variant.type_name)?;
+                    writeln!(out, "\t\terr = json.Unmarshal(b, &v)")?;
+                    writeln!(out, "\t\tvalue = v")?;
                 }
                 writeln!(out, "\tdefault:")?;
                 writeln!(
                     out,
-                    "\t\terr = fmt.Errorf(\"bad {} value: %s\", t.T)",
-                    tag_field_name
+                    "\t\terr = fmt.Errorf(\"{}: bad {} value: %q\", t.T)",
+                    name, tag_json_name
                 )?;
                 writeln!(out, "\t}}")?;
                 writeln!(out)?;
                 writeln!(out, "\tif err != nil {{")?;
                 writeln!(out, "\t\treturn err")?;
                 writeln!(out, "\t}}")?;
                 writeln!(out)?;
-                writeln!(out, "\tv.{} = t.T", tag_field_name)?;
+                writeln!(out, "\tv.Value = value")?;
                 writeln!(out, "\treturn nil")?;
                 writeln!(out, "}}")?;
 
+                writeln!(out)?;
+                writeln!(
+                    out,
+                    "// I{} is an interface type that {} types implement.",
+                    name, name
+                )?;
+                writeln!(out, "// It can be the following types:")?;
+                writeln!(out, "//")?;
+                for variant in &variants {
+                    writeln!(
+                        out,
+                        "// - [{}] ({})",
+                        &variant.type_name, &variant.tag_value
+                    )?;
+                }
+                writeln!(out, "//")?;
+                writeln!(out, "type I{} interface {{", name)?;
+                writeln!(out, "\t{}() string", tag_field_name)?;
+                writeln!(out, "\tis{}()", name)?;
+                writeln!(out, "}}")?;
+                writeln!(out)?;
+
+                for variant in &variants {
+                    writeln!(
+                        out,
+                        "func ({}) {}() string {{ return {:?} }}",
+                        variant.type_name, tag_field_name, variant.tag_value
+                    )?;
+                }
+                writeln!(out)?;
+
+                for variant in &variants {
+                    writeln!(out, "func ({}) is{}() {{}}", variant.type_name, name)?;
+                }
+                writeln!(out)?;
+
+                for variant in &variants {
+                    writeln!(
+                        out,
+                        "func (v {}) MarshalJSON() ([]byte, error) {{",
+                        variant.type_name
+                    )?;
+                    writeln!(out, "\ttype Alias {}", variant.type_name)?;
+                    writeln!(out, "\treturn json.Marshal(struct {{")?;
+                    writeln!(out, "\t\tT string `json:\"{}\"`", tag_json_name)?;
+                    writeln!(out, "\t\tAlias")?;
+                    writeln!(out, "\t}}{{")?;
+                    writeln!(out, "\t\tv.{}(),", tag_field_name)?;
+                    writeln!(out, "\t\tAlias(v),")?;
+                    writeln!(out, "\t}})")?;
+                    writeln!(out, "}}")?;
+                    writeln!(out)?;
+
+                    writeln!(
+                        out,
+                        "func (v *{}) UnmarshalJSON(b []byte) error {{",
+                        variant.type_name
+                    )?;
+                    writeln!(out, "\ttype Alias {}", variant.type_name)?;
+                    writeln!(out, "\tvar a struct {{")?;
+                    writeln!(out, "\t\tT string `json:\"{}\"`", tag_json_name)?;
+                    writeln!(out, "\t\tAlias")?;
+                    writeln!(out, "\t}}")?;
+                    writeln!(out)?;
+                    writeln!(out, "\tif err := json.Unmarshal(b, &a); err != nil {{")?;
+                    writeln!(out, "\t\treturn err")?;
+                    writeln!(out, "\t}}")?;
+                    writeln!(out)?;
+                    writeln!(out, "\tif a.T != {:?} {{", variant.tag_value)?;
+                    writeln!(
+                        out,
+                        "\t\treturn fmt.Errorf(\"{}: bad {} value: %q\", a.T)",
+                        variant.type_name, tag_json_name
+                    )?;
+                    writeln!(out, "\t}}")?;
+                    writeln!(out)?;
+                    writeln!(out, "\t*v = {}(a.Alias)", variant.type_name)?;
+                    writeln!(out, "\treturn nil")?;
+                    writeln!(out, "}}")?;
+                    writeln!(out)?;
+                }
+
                 None
             }
 

crates/target_java_jackson/src/lib.rs

@@ -125,6 +125,7 @@ impl jtd_codegen::target::Target for Target {
                 format!("Map<String, {}>", sub_expr)
             }
             target::Expr::NullableOf(sub_expr) => sub_expr, // everything is already nullable
+            target::Expr::RecursiveRef(sub_expr) => sub_expr,
         }
     }
 

crates/target_python/src/lib.rs

@@ -135,6 +135,7 @@ impl jtd_codegen::target::Target for Target {
 
                 format!("Optional[{}]", sub_expr)
             }
+            target::Expr::RecursiveRef(sub_expr) => sub_expr,
         }
     }
 

crates/target_ruby/src/lib.rs

@@ -117,6 +117,7 @@ impl jtd_codegen::target::Target for Target {
                 format!("Hash[String, {}]", sub_expr)
             }
             target::Expr::NullableOf(sub_expr) => sub_expr,
+            target::Expr::RecursiveRef(sub_expr) => sub_expr,
         }
     }
 

crates/target_ruby_sig/src/lib.rs

@@ -116,6 +116,7 @@ impl jtd_codegen::target::Target for Target {
                 format!("Hash[String, {}]", sub_expr)
             }
             target::Expr::NullableOf(sub_expr) => format!("{}?", sub_expr),
+            target::Expr::RecursiveRef(sub_expr) => sub_expr,
         }
     }
 

crates/target_rust/output/custom_overrides/mod.rs

@@ -9,20 +9,20 @@ pub struct RootOverrideTypeDiscriminatorBaz {}
 #[derive(Serialize, Deserialize)]
 pub struct Root {
     #[serde(rename = "override_elements_container")]
-    pub overrideElementsContainer: Vec<String>,
+    pub override_elements_container: Vec<String>,
 
     #[serde(rename = "override_type_discriminator")]
-    pub overrideTypeDiscriminator: serde_json::Value,
+    pub override_type_discriminator: serde_json::Value,
 
     #[serde(rename = "override_type_enum")]
-    pub overrideTypeEnum: serde_json::Value,
+    pub override_type_enum: serde_json::Value,
 
     #[serde(rename = "override_type_expr")]
-    pub overrideTypeExpr: serde_json::Value,
+    pub override_type_expr: serde_json::Value,
 
     #[serde(rename = "override_type_properties")]
-    pub overrideTypeProperties: serde_json::Value,
+    pub override_type_properties: serde_json::Value,
 
     #[serde(rename = "override_values_container")]
-    pub overrideValuesContainer: HashMap<String, String>,
+    pub override_values_container: HashMap<String, String>,
 }

crates/target_rust/output/description/mod.rs

@@ -38,31 +38,31 @@ pub struct RootPropertiesWithDescription {}
 pub struct Root {
     /// A description for discriminator
     #[serde(rename = "discriminator_with_description")]
-    pub discriminatorWithDescription: RootDiscriminatorWithDescription,
+    pub discriminator_with_description: RootDiscriminatorWithDescription,
 
     /// A description for enum
     #[serde(rename = "enum_with_description")]
-    pub enumWithDescription: RootEnumWithDescription,
+    pub enum_with_description: RootEnumWithDescription,
 
     /// Whereas disregard and contempt for human rights have resulted in
     /// barbarous acts which have outraged the conscience of mankind, and the
     /// advent of a world in which human beings shall enjoy freedom of speech
     /// and belief and freedom from fear and want has been proclaimed as the
     /// highest aspiration of the common people,
     #[serde(rename = "long_description")]
-    pub longDescription: String,
+    pub long_description: String,
 
     /// A description for properties
     #[serde(rename = "properties_with_description")]
-    pub propertiesWithDescription: RootPropertiesWithDescription,
+    pub properties_with_description: RootPropertiesWithDescription,
 
     /// A description for ref
     #[serde(rename = "ref_with_description")]
-    pub refWithDescription: Baz,
+    pub ref_with_description: Baz,
 
     /// A description for string
     #[serde(rename = "string_with_description")]
-    pub stringWithDescription: String,
+    pub string_with_description: String,
 }
 
 /// A description for a definition