polyxml 0.16.0__tar.gz → 0.17.0__tar.gz

{polyxml-0.16.0 → polyxml-0.17.0}/Cargo.lock

@@ -549,7 +549,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.16.0"
+version = "0.17.0"
 dependencies = [
  "criterion",
  "heck",
@@ -567,14 +567,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.16.0"
+version = "0.17.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.16.0"
+version = "0.17.0"
 dependencies = [
  "clap",
  "glob",
@@ -588,7 +588,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.16.0"
+version = "0.17.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -598,7 +598,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.16.0"
+version = "0.17.0"
 dependencies = [
  "lexical-core",
  "polyxml",

{polyxml-0.16.0 → polyxml-0.17.0}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/polyxml-core", "crates/polyxml-python"]
 
 [workspace.package]
-version = "0.16.0"
+version = "0.17.0"
 edition = "2021"
 rust-version = "1.80"
 license = "MIT"

{polyxml-0.16.0 → polyxml-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyxml
-Version: 0.16.0
+Version: 0.17.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyxml-0.16.0 → polyxml-0.17.0}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -24,6 +24,16 @@ pub enum CSharpRecordKind {
     Struct,
 }
 
+impl CSharpRecordKind {
+    pub fn from_str_loose(s: &str) -> Option<Self> {
+        match s.to_lowercase().trim() {
+            "class" | "record" | "record-class" | "reference" => Some(Self::Class),
+            "struct" | "record-struct" | "value" => Some(Self::Struct),
+            _ => None,
+        }
+    }
+}
+
 /// Options configuring C# 12 / .NET 8+ code generation.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CSharpOptions {
@@ -33,6 +43,10 @@ pub struct CSharpOptions {
     pub emit_xml_attributes: bool,
     /// Emit System.Text.Json.Serialization attributes ([JsonPropertyName], etc.)
     pub emit_json_attributes: bool,
+    /// Emit System.Text.Json compile-time source generation context (JsonSerializerContext)
+    pub emit_source_gen: bool,
+    /// Name of the generated JsonSerializerContext partial class (default: "PolyXmlJsonContext")
+    pub source_gen_context_name: String,
     /// Emit IValidatableObject and restriction facet validation logic
     pub emit_validation: bool,
     /// Record emission kind (record class vs record struct)
@@ -49,6 +63,8 @@ impl Default for CSharpOptions {
             namespace: "Generated".to_string(),
             emit_xml_attributes: true,
             emit_json_attributes: true,
+            emit_source_gen: false,
+            source_gen_context_name: "PolyXmlJsonContext".to_string(),
             emit_validation: true,
             record_kind: CSharpRecordKind::Class,
             use_file_scoped_namespaces: true,
@@ -228,7 +244,7 @@ impl CSharpCodegen {
         if self.options.emit_xml_attributes {
             writeln!(out, "using System.Xml.Serialization;").unwrap();
         }
-        if self.options.emit_json_attributes {
+        if self.options.emit_json_attributes || self.options.emit_source_gen {
             writeln!(out, "using System.Text.Json.Serialization;").unwrap();
         }
         writeln!(out).unwrap();
@@ -274,6 +290,11 @@ impl CSharpCodegen {
             self.emit_root_elements(&mut out, ir, indent);
         }
 
+        // Emit Source Generator Context if requested
+        if self.options.emit_source_gen {
+            self.emit_source_gen_context(&mut out, ir, indent);
+        }
+
         if !self.options.use_file_scoped_namespaces {
             writeln!(out, "}}").unwrap();
         }
@@ -288,6 +309,64 @@ impl CSharpCodegen {
         vec![(filename, code)]
     }
 
+    fn emit_source_gen_context(&self, out: &mut String, ir: &SchemaIR, indent: &str) {
+        writeln!(out).unwrap();
+        writeln!(
+            out,
+            "{}/// <summary>\n{}/// Source-generated JsonSerializerContext for Native AOT and high-throughput serialization.\n{}/// </summary>",
+            indent, indent, indent
+        )
+        .unwrap();
+        writeln!(
+            out,
+            "{}[JsonSourceGenerationOptions(WriteIndented = true)]",
+            indent
+        )
+        .unwrap();
+
+        // Enums
+        for def in ir.types.values() {
+            if let TypeDef::Enum(e) = def {
+                let name = to_csharp_type_name(&e.qname.local);
+                writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
+            }
+        }
+
+        // Simple types
+        for def in ir.types.values() {
+            if let TypeDef::Simple(s) = def {
+                let name = to_csharp_type_name(&s.qname.local);
+                writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
+            }
+        }
+
+        // Unions
+        for def in ir.types.values() {
+            if let TypeDef::Union(u) = def {
+                let name = to_csharp_type_name(&u.qname.local);
+                writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
+            }
+        }
+
+        // Structs
+        for def in ir.types.values() {
+            if let TypeDef::Struct(s) = def {
+                let name = to_csharp_type_name(&s.qname.local);
+                writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
+                writeln!(out, "{}[JsonSerializable(typeof(List<{}>))]", indent, name).unwrap();
+            }
+        }
+
+        let ctx_name = &self.options.source_gen_context_name;
+        writeln!(
+            out,
+            "{}public partial class {} : JsonSerializerContext\n{}{{",
+            indent, ctx_name, indent
+        )
+        .unwrap();
+        writeln!(out, "{}}}", indent).unwrap();
+    }
+
     fn emit_enum(&self, out: &mut String, e: &EnumDef, indent: &str) {
         let enum_name = to_csharp_type_name(&e.qname.local);
         if let Some(ref doc) = e.documentation {

{polyxml-0.16.0 → polyxml-0.17.0}/crates/polyxml-core/src/codegen/go/mod.rs

@@ -9,9 +9,34 @@ use crate::ir::{
     StructDef, TypeDef, TypeRef, UnionDef,
 };
 
+/// Target serialization backend for Go codegen.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub enum GoBackend {
+    /// Standard library `encoding/json` and `encoding/xml` (default)
+    #[default]
+    Standard,
+    /// Mailru/EasyJSON static reflectionless serialization generator (`//easyjson:json`)
+    EasyJson,
+    /// ByteDance Sonic high-performance JIT serialization (`sonic:"..."` struct tags)
+    Sonic,
+}
+
+impl GoBackend {
+    pub fn from_str_loose(s: &str) -> Option<Self> {
+        match s.to_lowercase().trim() {
+            "standard" | "std" | "default" => Some(Self::Standard),
+            "easyjson" | "easy-json" | "easy_json" => Some(Self::EasyJson),
+            "sonic" | "bytedance" => Some(Self::Sonic),
+            _ => None,
+        }
+    }
+}
+
 /// Options configuring Go 1.22+ code generation.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct GoOptions {
+    /// Target serialization backend (default: GoBackend::Standard)
+    pub backend: GoBackend,
     /// Package name for generated Go code (default: "models")
     pub package_name: String,
     /// Emit encoding/xml tags (default: true)
@@ -29,6 +54,7 @@ pub struct GoOptions {
 impl Default for GoOptions {
     fn default() -> Self {
         Self {
+            backend: GoBackend::Standard,
             package_name: "models".to_string(),
             emit_xml_tags: true,
             emit_json_tags: true,
@@ -407,6 +433,10 @@ impl GoCodegen {
             }
         }
 
+        if self.options.backend == GoBackend::EasyJson {
+            writeln!(out, "//easyjson:json").unwrap();
+        }
+
         // Choice container struct
         writeln!(out, "type {} struct {{", choice_name).unwrap();
         for branch in &u.branches {
@@ -415,12 +445,22 @@ impl GoCodegen {
             }
             let field_name = to_go_field_name(&branch.variant_name);
             let mapped_type = self.context.map_type_ref(&branch.type_ref);
-            let xml_tag = if self.options.emit_xml_tags {
-                format!(" `xml:\"{},omitempty\"`", branch.xml_name)
-            } else {
+            let mut tag_parts = Vec::new();
+            if self.options.emit_xml_tags {
+                tag_parts.push(format!("xml:\"{},omitempty\"", branch.xml_name));
+            }
+            if self.options.emit_json_tags {
+                tag_parts.push(format!("json:\"{},omitempty\"", branch.xml_name));
+            }
+            if self.options.backend == GoBackend::Sonic {
+                tag_parts.push(format!("sonic:\"{},omitempty\"", branch.xml_name));
+            }
+            let tag = if tag_parts.is_empty() {
                 String::new()
+            } else {
+                format!(" `{}`", tag_parts.join(" "))
             };
-            writeln!(out, "    {} *{}{}", field_name, mapped_type, xml_tag).unwrap();
+            writeln!(out, "    {} *{}{}", field_name, mapped_type, tag).unwrap();
         }
         writeln!(out, "}}\n").unwrap();
 
@@ -539,14 +579,25 @@ impl GoCodegen {
             }
         }
 
+        if self.options.backend == GoBackend::EasyJson {
+            writeln!(out, "//easyjson:json").unwrap();
+        }
+
         writeln!(out, "type {} struct {{", struct_name).unwrap();
 
         // Emit XMLName if xml tags enabled
         if self.options.emit_xml_tags {
+            let mut xml_tags = Vec::new();
             if self.options.emit_json_tags {
-                writeln!(out, "    XMLName xml.Name `json:\"-\"`").unwrap();
-            } else {
+                xml_tags.push("json:\"-\"");
+            }
+            if self.options.backend == GoBackend::Sonic {
+                xml_tags.push("sonic:\"-\"");
+            }
+            if xml_tags.is_empty() {
                 writeln!(out, "    XMLName xml.Name").unwrap();
+            } else {
+                writeln!(out, "    XMLName xml.Name `{}`", xml_tags.join(" ")).unwrap();
             }
         }
 
@@ -576,6 +627,9 @@ impl GoCodegen {
                 if self.options.emit_json_tags {
                     parts.push("json:\"value,omitempty\"".to_string());
                 }
+                if self.options.backend == GoBackend::Sonic {
+                    parts.push("sonic:\"value,omitempty\"".to_string());
+                }
                 let tag = if parts.is_empty() {
                     String::new()
                 } else {
@@ -647,7 +701,7 @@ impl GoCodegen {
             parts.push(format!("xml:\"{}\"", xml_val));
         }
 
-        if self.options.emit_json_tags {
+        if self.options.emit_json_tags || self.options.backend == GoBackend::Sonic {
             let is_opt = f.cardinality.is_optional() || f.nillable;
             let json_name = if f.kind == FieldKind::Text {
                 "value".to_string()
@@ -659,7 +713,12 @@ impl GoCodegen {
             } else {
                 json_name
             };
-            parts.push(format!("json:\"{}\"", json_val));
+            if self.options.emit_json_tags {
+                parts.push(format!("json:\"{}\"", json_val));
+            }
+            if self.options.backend == GoBackend::Sonic {
+                parts.push(format!("sonic:\"{}\"", json_val));
+            }
         }
 
         if parts.is_empty() {

{polyxml-0.16.0 → polyxml-0.17.0}/crates/polyxml-core/src/codegen/mod.rs

@@ -15,11 +15,11 @@ pub mod typescript;
 
 pub use cpp::{CppBackend, CppCodegen, CppMode, CppOptions};
 pub use csharp::{CSharpCodegen, CSharpOptions, CSharpRecordKind};
-pub use go::{GoCodegen, GoOptions};
+pub use go::{GoBackend, GoCodegen, GoOptions};
 pub use java::{JavaBackend, JavaCodegen, JavaOptions};
 pub use python::{PythonBackend, PythonCodegen, PythonOptions};
 pub use rust::{RustCodegen, RustOptions};
-pub use typescript::{TypeScriptCodegen, TypeScriptOptions};
+pub use typescript::{TypeScriptBackend, TypeScriptCodegen, TypeScriptOptions};
 
 use crate::ir::{PrimitiveType, TypeRef};
 

{polyxml-0.16.0 → polyxml-0.17.0}/crates/polyxml-core/src/codegen/rust/mod.rs

@@ -25,6 +25,8 @@ pub struct RustOptions {
     pub emit_root_aliases: bool,
     /// Emit streaming XML codecs (from_xml, to_xml, decode_xml, encode_xml) (default: true).
     pub emit_codecs: bool,
+    /// Derive rkyv::{Archive, Serialize, Deserialize} zero-copy wire format serialization (default: false).
+    pub emit_rkyv: bool,
 }
 
 impl Default for RustOptions {
@@ -36,6 +38,7 @@ impl Default for RustOptions {
             emit_polyxml_attrs: false,
             emit_root_aliases: true,
             emit_codecs: true,
+            emit_rkyv: false,
         }
     }
 }
@@ -431,6 +434,13 @@ impl RustCodegen {
         }
 
         let _ = writeln!(out, "#[derive({})]", derives.join(", "));
+        if self.options.emit_rkyv {
+            let _ = writeln!(
+                out,
+                "#[cfg_attr(feature = \"rkyv\", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]"
+            );
+            let _ = writeln!(out, "#[cfg_attr(feature = \"rkyv\", rkyv(check_bytes))]");
+        }
         let _ = writeln!(out, "pub enum {} {{", enum_name);
 
         let mut seen_variants = HashSet::new();
@@ -520,6 +530,13 @@ impl RustCodegen {
         }
 
         let _ = writeln!(out, "#[derive({})]", derives.join(", "));
+        if self.options.emit_rkyv {
+            let _ = writeln!(
+                out,
+                "#[cfg_attr(feature = \"rkyv\", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]"
+            );
+            let _ = writeln!(out, "#[cfg_attr(feature = \"rkyv\", rkyv(check_bytes))]");
+        }
         let type_signature = if needs_lifetime {
             format!("{}<'a>", union_name)
         } else {
@@ -587,6 +604,13 @@ impl RustCodegen {
         }
 
         let _ = writeln!(out, "#[derive({})]", derives.join(", "));
+        if self.options.emit_rkyv {
+            let _ = writeln!(
+                out,
+                "#[cfg_attr(feature = \"rkyv\", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]"
+            );
+            let _ = writeln!(out, "#[cfg_attr(feature = \"rkyv\", rkyv(check_bytes))]");
+        }
 
         let struct_decl = if needs_lifetime {
             format!("pub struct {}<'a>", struct_name)