polyxml 0.19.2__tar.gz → 0.20.1__tar.gz

{polyxml-0.19.2 → polyxml-0.20.1}/Cargo.lock

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

{polyxml-0.19.2 → polyxml-0.20.1}/Cargo.toml

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

{polyxml-0.19.2 → polyxml-0.20.1}/PKG-INFO

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

{polyxml-0.19.2 → polyxml-0.20.1}/crates/polyxml-core/src/codegen/cpp/mod.rs

@@ -4,7 +4,9 @@ use std::fmt::Write as FmtWrite;
 use heck::{AsPascalCase, AsSnakeCase};
 use serde::{Deserialize, Serialize};
 
-use crate::codegen::{sanitize_keyword, LanguageContext};
+use crate::codegen::{
+    build_type_name_map, lookup_type_name, sanitize_keyword, set_type_name_map, LanguageContext,
+};
 use crate::ir::{
     EnumDef, PrimitiveType, QName, RestrictionFacets, SchemaIR, SimpleTypeDef, StructDef, TypeDef,
     TypeRef, UnionDef,
@@ -157,7 +159,7 @@ impl LanguageContext for CppLanguageContext {
     fn map_type_ref(&self, type_ref: &TypeRef) -> String {
         match type_ref {
             TypeRef::Primitive(prim) => self.map_primitive(*prim).to_string(),
-            TypeRef::Named(qname) => to_cpp_type_name(&qname.local),
+            TypeRef::Named(qname) => type_ident(qname),
             TypeRef::Boxed(inner) => format!("std::unique_ptr<{}>", self.map_type_ref(inner)),
             TypeRef::List(inner) => format!("std::vector<{}>", self.map_type_ref(inner)),
         }
@@ -239,6 +241,12 @@ pub struct CppCodegen {
     context: CppLanguageContext,
 }
 
+/// Emitted C++ identifier for a named type, disambiguated across namespaces
+/// for the IR currently being generated (issue #51 item 3).
+fn type_ident(q: &QName) -> String {
+    lookup_type_name(q, || to_cpp_type_name(&q.local))
+}
+
 impl CppCodegen {
     pub fn new(options: CppOptions) -> Self {
         Self {
@@ -249,6 +257,7 @@ impl CppCodegen {
 
     /// Generate complete header-only source (`.hpp`).
     pub fn generate_header(&self, ir: &SchemaIR) -> String {
+        set_type_name_map(build_type_name_map(ir, to_cpp_type_name));
         let mut out = String::new();
         if let Some(ref header) = self.options.custom_header {
             let trimmed = header.trim();
@@ -286,6 +295,7 @@ impl CppCodegen {
 
     /// Generate complete C++20 module interface unit (`.cppm`).
     pub fn generate_module_unit(&self, ir: &SchemaIR, module_name: &str) -> String {
+        set_type_name_map(build_type_name_map(ir, to_cpp_type_name));
         let mut out = String::new();
         if let Some(ref header) = self.options.custom_header {
             let trimmed = header.trim();
@@ -470,7 +480,7 @@ endif()
         // 1. Enums
         for type_def in ir.types.values() {
             if let TypeDef::Enum(enum_def) = type_def {
-                let enum_name = to_cpp_type_name(&enum_def.qname.local);
+                let enum_name = type_ident(&enum_def.qname);
                 let full_type = format!("{}::{}", ns, enum_name);
                 writeln!(out, "template <>").unwrap();
                 writeln!(out, "struct glz::meta<{}> {{", full_type).unwrap();
@@ -498,7 +508,7 @@ endif()
         let sorted_qnames = self.topological_sort_types(ir);
         for qname in sorted_qnames {
             if let Some(TypeDef::Struct(s)) = ir.types.get(&qname) {
-                let struct_name = to_cpp_type_name(&s.qname.local);
+                let struct_name = type_ident(&s.qname);
                 let full_type = format!("{}::{}", ns, struct_name);
                 writeln!(out, "template <>").unwrap();
                 writeln!(out, "struct glz::meta<{}> {{", full_type).unwrap();
@@ -570,7 +580,7 @@ concept XmlModel = requires(T a) {{
             .values()
             .filter_map(|t| {
                 if let TypeDef::Struct(s) = t {
-                    Some(to_cpp_type_name(&s.qname.local))
+                    Some(type_ident(&s.qname))
                 } else {
                     None
                 }
@@ -622,7 +632,7 @@ concept XmlModel = requires(T a) {{
                 writeln!(out, "/// {}", line).unwrap();
             }
         }
-        let type_name = to_cpp_type_name(&simple.qname.local);
+        let type_name = type_ident(&simple.qname);
         let base_type = self.context.map_type_ref(&simple.base_type);
         writeln!(out, "using {} = {};\n", type_name, base_type).unwrap();
     }
@@ -634,7 +644,7 @@ concept XmlModel = requires(T a) {{
             }
         }
 
-        let enum_name = to_cpp_type_name(&enum_def.qname.local);
+        let enum_name = type_ident(&enum_def.qname);
         writeln!(out, "enum class {} {{", enum_name).unwrap();
 
         for variant in &enum_def.variants {
@@ -668,8 +678,16 @@ concept XmlModel = requires(T a) {{
             writeln!(out, "    return \"\";").unwrap();
             writeln!(out, "}}\n").unwrap();
 
-            // from_string
-            let func_name = format!("{}_from_string", AsSnakeCase(&enum_def.qname.local));
+            // from_string — stem follows the disambiguated type name only when
+            // it differs from the natural one, preserving the historical
+            // snake-of-local form otherwise (issue #51 item 3).
+            let natural = to_cpp_type_name(&enum_def.qname.local);
+            let stem = if enum_name == natural {
+                AsSnakeCase(&enum_def.qname.local).to_string()
+            } else {
+                AsSnakeCase(&enum_name).to_string()
+            };
+            let func_name = format!("{stem}_from_string");
             writeln!(
                 out,
                 "[[nodiscard]] inline std::optional<{}> {}(std::string_view s) noexcept {{",
@@ -697,7 +715,7 @@ concept XmlModel = requires(T a) {{
             }
         }
 
-        let union_name = to_cpp_type_name(&u.qname.local);
+        let union_name = type_ident(&u.qname);
 
         // Check if branches have distinct types and no primitives
         let mut branch_types = Vec::new();
@@ -758,17 +776,17 @@ concept XmlModel = requires(T a) {{
             }
         }
 
-        let struct_name = to_cpp_type_name(&s.qname.local);
+        let struct_name = type_ident(&s.qname);
         let mut base_clause = String::new();
         let mut simple_content_base: Option<String> = None;
 
         if let Some(ref base_qname) = s.base_type {
             if matches!(ir.types.get(base_qname), Some(TypeDef::Struct(_))) {
-                base_clause = format!(" : public {}", to_cpp_type_name(&base_qname.local));
+                base_clause = format!(" : public {}", type_ident(base_qname));
             } else if let Some(prim) = PrimitiveType::from_xsd_name(&base_qname.local) {
                 simple_content_base = Some(self.context.map_primitive(prim).to_string());
             } else if let Some(TypeDef::Simple(st)) = ir.types.get(base_qname) {
-                simple_content_base = Some(to_cpp_type_name(&st.qname.local));
+                simple_content_base = Some(type_ident(&st.qname));
             }
         }
 

{polyxml-0.19.2 → polyxml-0.20.1}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -8,9 +8,11 @@ use std::fmt::Write as FmtWrite;
 use heck::{AsLowerCamelCase, AsPascalCase};
 use serde::{Deserialize, Serialize};
 
-use crate::codegen::{sanitize_keyword, LanguageContext};
+use crate::codegen::{
+    build_type_name_map, lookup_type_name, sanitize_keyword, set_type_name_map, LanguageContext,
+};
 use crate::ir::{
-    EnumDef, FieldDef, FieldKind, PrimitiveType, RestrictionFacets, SchemaIR, SimpleTypeDef,
+    EnumDef, FieldDef, FieldKind, PrimitiveType, QName, RestrictionFacets, SchemaIR, SimpleTypeDef,
     StructDef, TypeDef, TypeRef, UnionDef,
 };
 
@@ -51,6 +53,9 @@ pub struct CSharpOptions {
     pub emit_validation: bool,
     /// Record emission kind (record class vs record struct)
     pub record_kind: CSharpRecordKind,
+    /// Emit immutable records (default) instead of mutable classes.
+    #[serde(default = "default_use_records")]
+    pub use_records: bool,
     /// Use modern C# 10+ file-scoped namespaces (`namespace Foo;`)
     pub use_file_scoped_namespaces: bool,
     /// Emit root element wrapper records or aliases
@@ -59,6 +64,10 @@ pub struct CSharpOptions {
     pub custom_header: Option<String>,
 }
 
+fn default_use_records() -> bool {
+    true
+}
+
 impl Default for CSharpOptions {
     fn default() -> Self {
         Self {
@@ -69,6 +78,7 @@ impl Default for CSharpOptions {
             source_gen_context_name: "PolyXmlJsonContext".to_string(),
             emit_validation: true,
             record_kind: CSharpRecordKind::Class,
+            use_records: true,
             use_file_scoped_namespaces: true,
             emit_root_records: true,
             custom_header: None,
@@ -210,7 +220,7 @@ impl LanguageContext for CSharpLanguageContext {
     fn map_type_ref(&self, type_ref: &TypeRef) -> String {
         match type_ref {
             TypeRef::Primitive(prim) => self.map_primitive(*prim).to_string(),
-            TypeRef::Named(qname) => to_csharp_type_name(&qname.local),
+            TypeRef::Named(qname) => type_ident(qname),
             TypeRef::Boxed(inner) => self.map_type_ref(inner),
             TypeRef::List(inner) => format!("List<{}>", self.map_type_ref(inner)),
         }
@@ -223,6 +233,12 @@ pub struct CSharpCodegen {
     context: CSharpLanguageContext,
 }
 
+/// Emitted C# identifier for a named type, disambiguated across namespaces
+/// for the IR currently being generated (issue #51 item 3).
+fn type_ident(q: &QName) -> String {
+    lookup_type_name(q, || to_csharp_type_name(&q.local))
+}
+
 impl CSharpCodegen {
     /// Creates a new C# code generator with the given configuration options.
     pub fn new(options: CSharpOptions) -> Self {
@@ -234,6 +250,7 @@ impl CSharpCodegen {
 
     /// Emits all types in the given SchemaIR as a single C# compilation unit.
     pub fn generate_module(&self, ir: &SchemaIR) -> String {
+        set_type_name_map(build_type_name_map(ir, to_csharp_type_name));
         let mut out = String::new();
 
         if let Some(ref header) = self.options.custom_header {
@@ -342,7 +359,7 @@ impl CSharpCodegen {
         // Enums
         for def in ir.types.values() {
             if let TypeDef::Enum(e) = def {
-                let name = to_csharp_type_name(&e.qname.local);
+                let name = type_ident(&e.qname);
                 writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
             }
         }
@@ -350,7 +367,7 @@ impl CSharpCodegen {
         // Simple types
         for def in ir.types.values() {
             if let TypeDef::Simple(s) = def {
-                let name = to_csharp_type_name(&s.qname.local);
+                let name = type_ident(&s.qname);
                 writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
             }
         }
@@ -358,7 +375,7 @@ impl CSharpCodegen {
         // Unions
         for def in ir.types.values() {
             if let TypeDef::Union(u) = def {
-                let name = to_csharp_type_name(&u.qname.local);
+                let name = type_ident(&u.qname);
                 writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
             }
         }
@@ -366,12 +383,20 @@ impl CSharpCodegen {
         // Structs
         for def in ir.types.values() {
             if let TypeDef::Struct(s) = def {
-                let name = to_csharp_type_name(&s.qname.local);
+                let name = type_ident(&s.qname);
                 writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
                 writeln!(out, "{}[JsonSerializable(typeof(List<{}>))]", indent, name).unwrap();
             }
         }
 
+        if !self.options.use_records && self.options.emit_root_records {
+            for elem in ir.elements.values() {
+                let name = to_csharp_type_name(&elem.qname.local);
+                if name != self.context.map_type_ref(&elem.type_ref) {
+                    writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
+                }
+            }
+        }
         let ctx_name = &self.options.source_gen_context_name;
         writeln!(
             out,
@@ -383,7 +408,7 @@ impl CSharpCodegen {
     }
 
     fn emit_enum(&self, out: &mut String, e: &EnumDef, indent: &str) {
-        let enum_name = to_csharp_type_name(&e.qname.local);
+        let enum_name = type_ident(&e.qname);
         if let Some(ref doc) = e.documentation {
             self.emit_docstring(out, doc, indent);
         }
@@ -465,14 +490,51 @@ impl CSharpCodegen {
     }
 
     fn emit_simple(&self, out: &mut String, s: &SimpleTypeDef, indent: &str) {
-        if !s.facets.is_empty() {
-            let type_name = to_csharp_type_name(&s.qname.local);
+        if !s.facets.is_empty() || !self.options.use_records {
+            let type_name = type_ident(&s.qname);
             let base_type = self.context.map_type_ref(&s.base_type);
 
             if let Some(ref doc) = s.documentation {
                 self.emit_docstring(out, doc, indent);
             }
 
+            if !self.options.use_records {
+                writeln!(
+                    out,
+                    "{}public class {}{}\n{}{{",
+                    indent,
+                    type_name,
+                    if self.options.emit_validation {
+                        " : IValidatableObject"
+                    } else {
+                        ""
+                    },
+                    indent
+                )
+                .unwrap();
+                if self.options.emit_xml_attributes {
+                    writeln!(out, "{}    [XmlText]", indent).unwrap();
+                }
+                writeln!(
+                    out,
+                    "{}    public {} Value {{ get; set; }} = default!;",
+                    indent, base_type
+                )
+                .unwrap();
+                writeln!(
+                    out,
+                    "{}    public {}() {{ }}\n{}    public {}({} value) {{ Value = value; }}",
+                    indent, type_name, indent, type_name, base_type
+                )
+                .unwrap();
+                if self.options.emit_validation {
+                    writeln!(out, "{}    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)\n{}    {{", indent, indent).unwrap();
+                    self.emit_facet_checks(out, &s.facets, "Value", &format!("{}        ", indent));
+                    writeln!(out, "{}        yield break;\n{}    }}", indent, indent).unwrap();
+                }
+                writeln!(out, "{}}}\n", indent).unwrap();
+                return;
+            }
             writeln!(
                 out,
                 "{}public sealed record {}([property: XmlText] {} Value) : IValidatableObject",
@@ -504,7 +566,7 @@ impl CSharpCodegen {
     }
 
     fn emit_union(&self, out: &mut String, u: &UnionDef, indent: &str) {
-        let choice_name = to_csharp_type_name(&u.qname.local);
+        let choice_name = type_ident(&u.qname);
         if let Some(ref doc) = u.documentation {
             self.emit_docstring(out, doc, indent);
         }
@@ -522,7 +584,31 @@ impl CSharpCodegen {
             }
         }
 
-        writeln!(out, "{}public abstract record {}", indent, choice_name).unwrap();
+        if !self.options.use_records && self.options.emit_json_attributes {
+            for branch in &u.branches {
+                writeln!(
+                    out,
+                    "{}[JsonDerivedType(typeof({}.{}), {:?})]",
+                    indent,
+                    choice_name,
+                    to_csharp_type_name(&branch.variant_name),
+                    branch.xml_name
+                )
+                .unwrap();
+            }
+        }
+        writeln!(
+            out,
+            "{}public abstract {} {}",
+            indent,
+            if self.options.use_records {
+                "record"
+            } else {
+                "class"
+            },
+            choice_name
+        )
+        .unwrap();
         writeln!(out, "{}{{", indent).unwrap();
 
         for branch in &u.branches {
@@ -546,6 +632,24 @@ impl CSharpCodegen {
                 format!("[property: {}] ", branch_attrs.join(", "))
             };
 
+            if !self.options.use_records {
+                writeln!(
+                    out,
+                    "{}    public sealed class {} : {}\n{}    {{",
+                    indent, variant_name, choice_name, indent
+                )
+                .unwrap();
+                writeln!(
+                    out,
+                    "{}        {}public {} Value {{ get; set; }} = default!;",
+                    indent,
+                    xml_attr.replace("[property: ", "["),
+                    branch_type
+                )
+                .unwrap();
+                writeln!(out, "{}        public {}() {{ }}\n{}        public {}({} value) {{ Value = value; }}\n{}    }}", indent, variant_name, indent, variant_name, branch_type, indent).unwrap();
+                continue;
+            }
             writeln!(
                 out,
                 "{}    public sealed record {}({}{} Value) : {}",
@@ -567,7 +671,7 @@ impl CSharpCodegen {
     }
 
     fn emit_struct(&self, out: &mut String, s: &StructDef, ir: &SchemaIR, indent: &str) {
-        let struct_name = to_csharp_type_name(&s.qname.local);
+        let struct_name = type_ident(&s.qname);
         if let Some(ref doc) = s.documentation {
             self.emit_docstring(out, doc, indent);
         }
@@ -595,7 +699,7 @@ impl CSharpCodegen {
         let mut base_clause = Vec::new();
         if let Some(ref base_qname) = s.base_type {
             if matches!(ir.types.get(base_qname), Some(TypeDef::Struct(_))) {
-                let base_name = to_csharp_type_name(&base_qname.local);
+                let base_name = type_ident(base_qname);
                 base_clause.push(base_name);
             }
         }
@@ -609,6 +713,39 @@ impl CSharpCodegen {
             format!(" : {}", base_clause.join(", "))
         };
 
+        if !self.options.use_records {
+            writeln!(
+                out,
+                "{}public class {}{}\n{}{{",
+                indent, struct_name, implements_str, indent
+            )
+            .unwrap();
+            writeln!(out, "{}    public {}() {{ }}", indent, struct_name).unwrap();
+            for f in &s.fields {
+                let name = to_csharp_property_name(&f.name, Some(&struct_name));
+                let ty = self.map_field_type(f, ir);
+                let attrs = self
+                    .build_field_attributes(f, ir)
+                    .replace("[property: ", "[");
+                let initial = if f.cardinality.is_list() || f.type_ref.is_list() {
+                    "new()"
+                } else {
+                    "default!"
+                };
+                writeln!(
+                    out,
+                    "{}    {}public {} {} {{ get; set; }} = {};",
+                    indent, attrs, ty, name, initial
+                )
+                .unwrap();
+            }
+            if self.options.emit_validation {
+                self.emit_struct_validator(out, s, indent);
+            }
+            writeln!(out, "{}}}\n", indent).unwrap();
+            return;
+        }
+
         // Collect fields and parameters
         if s.fields.is_empty() {
             writeln!(
@@ -688,8 +825,18 @@ impl CSharpCodegen {
     }
 
     fn emit_struct_validator(&self, out: &mut String, s: &StructDef, indent: &str) {
-        let struct_name = to_csharp_type_name(&s.qname.local);
-        let new_kw = if s.base_type.is_some() { "new " } else { "" };
+        let struct_name = type_ident(&s.qname);
+        let new_kw = if !self.options.use_records {
+            if s.base_type.is_some() {
+                "override "
+            } else {
+                "virtual "
+            }
+        } else if s.base_type.is_some() {
+            "new "
+        } else {
+            ""
+        };
         writeln!(
             out,
             "{}    public {}IEnumerable<ValidationResult> Validate(ValidationContext validationContext)",
@@ -698,6 +845,9 @@ impl CSharpCodegen {
         .unwrap();
         writeln!(out, "{}    {{", indent).unwrap();
 
+        if !self.options.use_records && s.base_type.is_some() {
+            writeln!(out, "{}        foreach (var result in base.Validate(validationContext)) yield return result;", indent).unwrap();
+        }
         let mut has_checks = false;
         for f in &s.fields {
             let prop_name = to_csharp_property_name(&f.name, Some(&struct_name));
@@ -799,9 +949,9 @@ impl CSharpCodegen {
             TypeRef::Primitive(p) => self.context.map_primitive(*p).to_string(),
             TypeRef::Named(qn) => {
                 if let Some(TypeDef::Union(u)) = ir.types.get(qn) {
-                    to_csharp_type_name(&u.qname.local)
+                    type_ident(&u.qname)
                 } else {
-                    to_csharp_type_name(&qn.local)
+                    type_ident(qn)
                 }
             }
             TypeRef::Boxed(inner) => self.context.map_type_ref(inner),
@@ -828,7 +978,7 @@ impl CSharpCodegen {
             // If the field is a choice (UnionDef), emit XmlElement("branchXml", typeof(BranchType))
             if let TypeRef::Named(ref qname) = f.type_ref {
                 if let Some(TypeDef::Union(u)) = ir.types.get(qname) {
-                    let choice_name = to_csharp_type_name(&u.qname.local);
+                    let choice_name = type_ident(&u.qname);
                     for branch in &u.branches {
                         let variant_name = to_csharp_type_name(&branch.variant_name);
                         parts.push(format!(
@@ -888,10 +1038,46 @@ impl CSharpCodegen {
                         writeln!(out, "{}[XmlRoot(\"{}\")]", indent, elem.qname.local).unwrap();
                     }
                 }
+                if !self.options.use_records {
+                    let can_extend = matches!(&elem.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Struct(_) | TypeDef::Simple(_))));
+                    if !can_extend {
+                        writeln!(
+                            out,
+                            "{}public sealed class {}\n{}{{",
+                            indent, elem_name, indent
+                        )
+                        .unwrap();
+                        if self.options.emit_xml_attributes {
+                            let attribute = if matches!(&elem.type_ref, TypeRef::Named(q)
+                                if matches!(ir.types.get(q), Some(TypeDef::Union(_))))
+                            {
+                                "XmlElement"
+                            } else {
+                                "XmlText"
+                            };
+                            writeln!(out, "{}    [{}]", indent, attribute).unwrap();
+                        }
+                        writeln!(
+                            out,
+                            "{}    public {} Value {{ get; set; }} = default!;\n{}}}\n",
+                            indent, target_type, indent
+                        )
+                        .unwrap();
+                        continue;
+                    }
+                }
                 writeln!(
                     out,
-                    "{}public sealed record {} : {}\n{}{{",
-                    indent, elem_name, target_type, indent
+                    "{}public sealed {} {} : {}\n{}{{",
+                    indent,
+                    if self.options.use_records {
+                        "record"
+                    } else {
+                        "class"
+                    },
+                    elem_name,
+                    target_type,
+                    indent
                 )
                 .unwrap();
                 writeln!(out, "{}    public {}() : base() {{ }}", indent, elem_name).unwrap();