polyxml 0.30.1__tar.gz → 0.30.3__tar.gz

{polyxml-0.30.1 → polyxml-0.30.3}/Cargo.lock

@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.30.1"
+version = "0.30.3"
 dependencies = [
  "criterion",
  "heck",
@@ -629,14 +629,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.30.1"
+version = "0.30.3"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.30.1"
+version = "0.30.3"
 dependencies = [
  "clap",
  "glob",
@@ -650,7 +650,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.30.1"
+version = "0.30.3"
 dependencies = [
  "napi",
  "napi-build",
@@ -660,7 +660,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.30.1"
+version = "0.30.3"
 dependencies = [
  "lexical-core",
  "polyxml",
@@ -670,7 +670,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-wasm"
-version = "0.30.1"
+version = "0.30.3"
 dependencies = [
  "polyxml",
  "quick-xml",

{polyxml-0.30.1 → polyxml-0.30.3}/Cargo.toml

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

{polyxml-0.30.1 → polyxml-0.30.3}/PKG-INFO

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

{polyxml-0.30.1 → polyxml-0.30.3}/crates/polyxml-core/src/codegen/cpp/mod.rs

@@ -656,9 +656,13 @@ concept XmlModel = requires(T a) {{
     }
 
     fn emit_types(&self, out: &mut String, ir: &SchemaIR) {
-        // Emit simple type aliases first
-        for type_def in ir.emitted_types() {
-            if let TypeDef::Simple(simple) = type_def {
+        let sorted_qnames = self.topological_sort_types(ir);
+
+        // Aliases must follow their base aliases, which may sort later by name.
+        for qname in &sorted_qnames {
+            if let Some(TypeDef::Simple(simple)) =
+                ir.types.get(qname).filter(|_| !ir.is_external_type(qname))
+            {
                 self.emit_simple_type(out, simple, ir);
             }
         }
@@ -671,8 +675,6 @@ concept XmlModel = requires(T a) {{
         }
 
         // Topologically sort structs and unions (DAG order)
-        let sorted_qnames = self.topological_sort_types(ir);
-
         for qname in sorted_qnames {
             if ir.is_external_type(&qname) {
                 continue;

{polyxml-0.30.1 → polyxml-0.30.3}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -244,13 +244,34 @@ fn type_ident(q: &QName) -> String {
 
 fn choice_variant_name(branch: &UnionBranch) -> String {
     let name = to_csharp_type_name(&branch.variant_name);
-    if matches!(&branch.type_ref, TypeRef::Named(qname) if type_ident(qname) == name) {
+    if matches!(
+        name.as_str(),
+        "Value" | "Equals" | "GetHashCode" | "ToString"
+    ) || matches!(&branch.type_ref, TypeRef::Named(qname) if type_ident(qname) == name)
+    {
         format!("{name}Branch")
     } else {
         name
     }
 }
 
+fn simple_value_target(base: &TypeRef, ir: &SchemaIR) -> String {
+    let mut target = "Value".to_string();
+    let mut current = base;
+    let mut seen = HashSet::new();
+    while let TypeRef::Named(qname) = current {
+        if !seen.insert(qname.clone()) {
+            break;
+        }
+        let Some(TypeDef::Simple(simple)) = ir.types.get(qname) else {
+            break;
+        };
+        target.push_str(".Value");
+        current = &simple.base_type;
+    }
+    target
+}
+
 impl CSharpCodegen {
     /// Creates a new C# code generator with the given configuration options.
     pub fn new(options: CSharpOptions) -> Self {
@@ -315,7 +336,7 @@ impl CSharpCodegen {
                 if !simple.facets.patterns.is_empty() {
                     simple.base_type = super::primitive_base(&simple.base_type, ir).clone();
                 }
-                self.emit_simple(&mut out, &simple, indent);
+                self.emit_simple(&mut out, &simple, ir, indent);
             }
         }
 
@@ -510,8 +531,10 @@ impl CSharpCodegen {
         writeln!(out, "{}}}\n", indent).unwrap();
     }
 
-    fn emit_simple(&self, out: &mut String, s: &SimpleTypeDef, indent: &str) {
-        if !s.facets.is_empty() || !self.options.use_records {
+    fn emit_simple(&self, out: &mut String, s: &SimpleTypeDef, ir: &SchemaIR, indent: &str) {
+        // Named simple types may be referenced by structs and choices even
+        // when they have no facets, so every one needs a declaration.
+        {
             let type_name = type_ident(&s.qname);
             let base_type = self.context.map_type_ref(&s.base_type);
 
@@ -550,7 +573,8 @@ impl CSharpCodegen {
                 .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));
+                    let value = simple_value_target(&s.base_type, ir);
+                    self.emit_facet_checks(out, &s.facets, &value, &format!("{}        ", indent));
                     writeln!(out, "{}        yield break;\n{}    }}", indent, indent).unwrap();
                 }
                 writeln!(out, "{}}}\n", indent).unwrap();
@@ -579,7 +603,8 @@ impl CSharpCodegen {
             )
             .unwrap();
             writeln!(out, "{}    {{", indent).unwrap();
-            self.emit_facet_checks(out, &s.facets, "Value", &format!("{}        ", indent));
+            let value = simple_value_target(&s.base_type, ir);
+            self.emit_facet_checks(out, &s.facets, &value, &format!("{}        ", indent));
             writeln!(out, "{}        yield break;", indent).unwrap();
             writeln!(out, "{}    }}", indent).unwrap();
             writeln!(out, "{}}}\n", indent).unwrap();
@@ -1076,12 +1101,24 @@ impl CSharpCodegen {
 
         // Collect fields and parameters
         if s.fields.is_empty() {
-            writeln!(
-                out,
-                "{}public {} {}{};",
-                indent, record_keyword, struct_name, implements_str
-            )
-            .unwrap();
+            if self.options.emit_validation {
+                writeln!(
+                    out,
+                    "{}public {} {}{}",
+                    indent, record_keyword, struct_name, implements_str
+                )
+                .unwrap();
+                writeln!(out, "{}{{", indent).unwrap();
+                self.emit_struct_validator(out, s, &prop_names, indent);
+                writeln!(out, "{}}}", indent).unwrap();
+            } else {
+                writeln!(
+                    out,
+                    "{}public {} {}{};",
+                    indent, record_keyword, struct_name, implements_str
+                )
+                .unwrap();
+            }
             writeln!(out).unwrap();
             return;
         }

{polyxml-0.30.1 → polyxml-0.30.3}/crates/polyxml-core/src/codegen/mod.rs

@@ -24,6 +24,16 @@ pub use python::{
 pub use rust::{RustCodegen, RustOptions};
 pub use typescript::{TypeScriptBackend, TypeScriptCodegen, TypeScriptOptions};
 
+/// Prefix every physical XSD documentation line so embedded newlines cannot
+/// escape a generated source comment.
+pub(crate) fn write_documentation_lines(out: &mut String, prefix: &str, doc: &str) {
+    for line in doc.trim().lines() {
+        out.push_str(prefix);
+        out.push_str(line.trim_end_matches('\r'));
+        out.push('\n');
+    }
+}
+
 use crate::ir::{FieldDef, PrimitiveType, QName, SchemaIR, StructDef, TypeRef};
 
 #[derive(Debug, Error)]

{polyxml-0.30.1 → polyxml-0.30.3}/crates/polyxml-core/src/codegen/python/mod.rs

@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::codegen::{
     build_type_name_map, lookup_type_name, normalize_symbol_name, sanitize_keyword,
-    set_type_name_map, LanguageContext,
+    set_type_name_map, write_documentation_lines, LanguageContext,
 };
 use crate::ir::{
     EnumDef, FieldDef, FieldKind, PrimitiveType, QName, RestrictionFacets, SchemaIR, SimpleTypeDef,
@@ -32,6 +32,15 @@ const PATTERN_VALIDATOR_HELPER: &str = r#"def _polyxml_patterns(*patterns: str):
 pub mod aot;
 pub use aot::{PythonAotCodegen, PythonAotCrate, PythonAotOptions};
 
+fn write_python_docstring(out: &mut String, indent: &str, doc: &str) {
+    let escaped = doc
+        .trim()
+        .replace('\\', "\\\\")
+        .replace("\"\"\"", "\\\"\\\"\\\"")
+        .replace('\r', "");
+    let _ = writeln!(out, "{indent}\"\"\"{escaped}\"\"\"");
+}
+
 /// Target backend for Python code emission.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
 pub enum PythonBackend {
@@ -444,7 +453,7 @@ impl PythonCodegen {
         let base_type = self.context.map_type_ref(&s.base_type);
 
         if let Some(ref doc) = s.documentation {
-            let _ = writeln!(out, "# {}", doc.trim());
+            write_documentation_lines(out, "# ", doc);
         }
 
         if self.options.backend == PythonBackend::Pydantic && !s.facets.is_empty() {
@@ -492,7 +501,7 @@ impl PythonCodegen {
         let _ = writeln!(out, "class {}(StrEnum):", enum_name);
 
         if let Some(ref doc) = e.documentation {
-            let _ = writeln!(out, "    \"\"\"{}\"\"\"", doc.trim());
+            write_python_docstring(out, "    ", doc);
         }
 
         if e.variants.is_empty() {
@@ -549,7 +558,7 @@ impl PythonCodegen {
         }
 
         if let Some(ref doc) = u.documentation {
-            let _ = writeln!(out, "# {}", doc.trim());
+            write_documentation_lines(out, "# ", doc);
         }
 
         if u.branches.is_empty() {
@@ -613,7 +622,8 @@ impl PythonCodegen {
         let mut has_body = false;
 
         if let Some(ref doc) = s.documentation {
-            let _ = writeln!(out, "    \"\"\"{}\"\"\"\n", doc.trim());
+            write_python_docstring(out, "    ", doc);
+            out.push('\n');
             has_body = true;
         }
 
@@ -763,7 +773,7 @@ impl PythonCodegen {
         };
 
         if let Some(ref doc) = field.documentation {
-            let _ = writeln!(out, "    # {}", doc.trim());
+            write_documentation_lines(out, "    # ", doc);
         }
 
         let _ = writeln!(out, "    {}: {} = {}", py_name, field_type, field_call);

{polyxml-0.30.1 → polyxml-0.30.3}/crates/polyxml-core/src/codegen/rust/mod.rs

@@ -5,8 +5,8 @@ use heck::{AsPascalCase, AsSnakeCase};
 use serde::{Deserialize, Serialize};
 
 use crate::codegen::{
-    build_type_name_map, flatten_fields, lookup_type_name, sanitize_keyword, set_type_name_map,
-    LanguageContext,
+    build_type_name_map, flatten_fields, lookup_type_name, primitive_base, sanitize_keyword,
+    set_type_name_map, write_documentation_lines, LanguageContext,
 };
 use crate::ir::{
     EnumDef, FieldDef, FieldKind, PrimitiveType, QName, SchemaIR, SimpleTypeDef, StructDef,
@@ -279,7 +279,10 @@ impl RustCodegen {
             self.emit_pymodule(&mut out, ir, &sorted_types);
         }
 
-        out
+        // A field may use a raw identifier such as `r#type`. Local codec
+        // variables have a `var_` prefix, so the raw marker is neither needed
+        // nor valid there (`var_r#type` is not a Rust identifier).
+        out.replace("var_r#", "var_")
     }
 
     /// Fixed-point analysis determining which types in SchemaIR require a lifetime parameter `<'a>`.
@@ -456,7 +459,7 @@ impl RustCodegen {
         let needs_lifetime = types_with_lifetime.contains(&s.qname);
 
         if let Some(ref doc) = s.documentation {
-            let _ = writeln!(out, "/// {}", doc.trim());
+            write_documentation_lines(out, "/// ", doc);
         }
 
         let base_type = self.format_rust_type_ref(&s.base_type, types_with_lifetime);
@@ -482,7 +485,7 @@ impl RustCodegen {
         let enum_name = type_ident(&e.qname);
 
         if let Some(ref doc) = e.documentation {
-            let _ = writeln!(out, "/// {}", doc.trim());
+            write_documentation_lines(out, "/// ", doc);
         }
 
         let mut derives = vec!["Debug", "Clone", "Copy", "PartialEq", "Eq", "Hash"];
@@ -520,7 +523,7 @@ impl RustCodegen {
             seen_variants.insert(var_id.clone());
 
             if let Some(ref doc) = variant.documentation {
-                let _ = writeln!(out, "    /// {}", doc.trim());
+                write_documentation_lines(out, "    /// ", doc);
             }
             if self.options.derive_serde {
                 let _ = writeln!(out, "    #[serde(rename = \"{}\")]", variant.value);
@@ -595,7 +598,7 @@ impl RustCodegen {
         let needs_lifetime = types_with_lifetime.contains(&u.qname);
 
         if let Some(ref doc) = u.documentation {
-            let _ = writeln!(out, "/// {}", doc.trim());
+            write_documentation_lines(out, "/// ", doc);
         }
 
         let mut derives = vec!["Debug", "Clone", "PartialEq"];
@@ -640,7 +643,7 @@ impl RustCodegen {
             let branch_type = self.format_rust_type_ref(&branch.type_ref, types_with_lifetime);
 
             if let Some(ref doc) = branch.documentation {
-                let _ = writeln!(out, "    /// {}", doc.trim());
+                write_documentation_lines(out, "    /// ", doc);
             }
             if self.options.derive_serde && !u.is_lexical() {
                 let _ = writeln!(out, "    #[serde(rename = \"{}\")]", branch.xml_name);
@@ -685,7 +688,7 @@ impl RustCodegen {
         let needs_lifetime = types_with_lifetime.contains(&s.qname);
 
         if let Some(ref doc) = s.documentation {
-            let _ = writeln!(out, "/// {}", doc.trim());
+            write_documentation_lines(out, "/// ", doc);
         }
 
         let mut derives = vec!["Debug", "Clone", "PartialEq"];
@@ -763,7 +766,7 @@ impl RustCodegen {
         has_boxed: bool,
     ) {
         if let Some(ref doc) = field.documentation {
-            let _ = writeln!(out, "    /// {}", doc.trim());
+            write_documentation_lines(out, "    /// ", doc);
         }
 
         let is_list = field.cardinality.is_list() || field.type_ref.is_list();
@@ -998,8 +1001,17 @@ impl RustCodegen {
         }
     }
 
+    fn unwrap_type_ref(mut ty: &TypeRef) -> &TypeRef {
+        while let TypeRef::Boxed(inner) | TypeRef::List(inner) = ty {
+            ty = inner;
+        }
+        ty
+    }
+
     fn field_is_string(&self, type_ref: &TypeRef, ir: &SchemaIR) -> bool {
-        match type_ref {
+        let ty = Self::unwrap_type_ref(type_ref);
+        let base = primitive_base(ty, ir);
+        match base {
             TypeRef::Primitive(prim) => matches!(
                 prim,
                 PrimitiveType::String
@@ -1030,19 +1042,14 @@ impl RustCodegen {
                     | PrimitiveType::HexBinary
                     | PrimitiveType::AnySimpleType
             ),
-            TypeRef::Named(qname) => {
-                if let Some(TypeDef::Simple(s)) = ir.types.get(qname) {
-                    self.field_is_string(&s.base_type, ir)
-                } else {
-                    false
-                }
-            }
-            TypeRef::Boxed(inner) | TypeRef::List(inner) => self.field_is_string(inner, ir),
+            _ => false,
         }
     }
 
     fn field_numeric_type(&self, type_ref: &TypeRef, ir: &SchemaIR) -> Option<&'static str> {
-        match type_ref {
+        let ty = Self::unwrap_type_ref(type_ref);
+        let base = primitive_base(ty, ir);
+        match base {
             TypeRef::Primitive(prim) => match prim {
                 PrimitiveType::Int => Some("i32"),
                 PrimitiveType::Integer
@@ -1061,30 +1068,14 @@ impl RustCodegen {
                 PrimitiveType::Float => Some("f32"),
                 _ => None,
             },
-            TypeRef::Named(qname) => {
-                if let Some(TypeDef::Simple(s)) = ir.types.get(qname) {
-                    self.field_numeric_type(&s.base_type, ir)
-                } else {
-                    None
-                }
-            }
-            TypeRef::Boxed(inner) | TypeRef::List(inner) => self.field_numeric_type(inner, ir),
+            _ => None,
         }
     }
 
     fn field_is_bool(&self, type_ref: &TypeRef, ir: &SchemaIR) -> bool {
-        match type_ref {
-            TypeRef::Primitive(PrimitiveType::Boolean) => true,
-            TypeRef::Named(qname) => {
-                if let Some(TypeDef::Simple(s)) = ir.types.get(qname) {
-                    self.field_is_bool(&s.base_type, ir)
-                } else {
-                    false
-                }
-            }
-            TypeRef::Boxed(inner) | TypeRef::List(inner) => self.field_is_bool(inner, ir),
-            _ => false,
-        }
+        let ty = Self::unwrap_type_ref(type_ref);
+        let base = primitive_base(ty, ir);
+        matches!(base, TypeRef::Primitive(PrimitiveType::Boolean))
     }
 
     fn field_is_enum(&self, type_ref: &TypeRef, ir: &SchemaIR) -> Option<String> {

{polyxml-0.30.1 → polyxml-0.30.3}/crates/polyxml-core/src/schema_parser/mod.rs

@@ -504,6 +504,7 @@ impl XsdParser {
                                     .push((fields.len(), resolve_qname(&r, target_ns, prefixes)));
                             }
                             skip_subtree(reader)?;
+                            depth -= 1;
                         }
                         "sequence" | "all" => {
                             let is_unbounded = get_attr_value(e, "maxOccurs")
@@ -560,6 +561,7 @@ impl XsdParser {
                                 self.consume_inline_element_type(
                                     reader, e, target_ns, prefixes, &name, &mut field, ir,
                                 )?;
+                                depth -= 1;
                                 if in_choice {
                                     if let Some(frame) = compositor_stack.last_mut() {
                                         if frame.kind == CompositorKind::Choice {
@@ -869,6 +871,7 @@ impl XsdParser {
                                 self.consume_inline_element_type(
                                     reader, e, target_ns, prefixes, "", &mut field, ir,
                                 )?;
+                                depth -= 1;
                                 def.fields.push(field);
                             }
                         }
@@ -880,6 +883,7 @@ impl XsdParser {
                                 ));
                             }
                             skip_subtree(reader)?;
+                            depth -= 1;
                         }
                         "any" => def.fields.push(parse_any_field(e)),
                         _ => {}

{polyxml-0.30.1 → polyxml-0.30.3}/crates/polyxml-core/tests/test_cpp_codegen.rs

@@ -11,6 +11,28 @@ use polyxml::ir::{
     SchemaIR, StructDef, TypeDef, TypeRef, UnionBranch, UnionDef,
 };
 
+#[test]
+fn simple_aliases_follow_their_base_types() {
+    let mut ir = SchemaIR::new().with_target_namespace("urn:test");
+    ir.add_type(TypeDef::Simple(Box::new(polyxml::ir::SimpleTypeDef {
+        qname: QName::new(Some("urn:test"), "AreaType"),
+        base_type: TypeRef::Named(QName::new(Some("urn:test"), "DoubleNonNegativeType")),
+        facets: RestrictionFacets::default(),
+        documentation: None,
+    })));
+    ir.add_type(TypeDef::Simple(Box::new(polyxml::ir::SimpleTypeDef {
+        qname: QName::new(Some("urn:test"), "DoubleNonNegativeType"),
+        base_type: TypeRef::Primitive(PrimitiveType::Double),
+        facets: RestrictionFacets::default(),
+        documentation: None,
+    })));
+    let code = CppCodegen::new(CppOptions::default()).generate_header(&ir);
+    assert!(
+        code.find("using DoubleNonNegativeType =").unwrap()
+            < code.find("using AreaType =").unwrap()
+    );
+}
+
 #[test]
 fn test_cpp_sanitization() {
     assert_eq!(to_cpp_field_name("class"), "class_");

{polyxml-0.30.1 → polyxml-0.30.3}/crates/polyxml-core/tests/test_csharp_codegen.rs

@@ -12,6 +12,68 @@ use polyxml::ir::{
 use std::sync::Mutex;
 use tempfile::tempdir;
 
+#[test]
+fn emits_unrestricted_simple_types_and_validates_empty_records() {
+    let mut ir = SchemaIR::new().with_target_namespace("urn:test");
+    ir.add_type(TypeDef::Simple(Box::new(polyxml::ir::SimpleTypeDef {
+        qname: QName::new(Some("urn:test"), "DistanceType"),
+        base_type: TypeRef::Primitive(PrimitiveType::Double),
+        facets: RestrictionFacets::default(),
+        documentation: None,
+    })));
+    ir.add_type(TypeDef::Simple(Box::new(polyxml::ir::SimpleTypeDef {
+        qname: QName::new(Some("urn:test"), "PositiveDistanceType"),
+        base_type: TypeRef::Named(QName::new(Some("urn:test"), "DistanceType")),
+        facets: RestrictionFacets {
+            min_inclusive: Some("0".into()),
+            ..Default::default()
+        },
+        documentation: None,
+    })));
+    ir.add_type(TypeDef::Struct(StructDef {
+        qname: QName::new(Some("urn:test"), "EmptyType"),
+        base_type: None,
+        is_abstract: false,
+        is_mixed: false,
+        fields: vec![],
+        documentation: None,
+    }));
+    let code = CSharpCodegen::new(CSharpOptions::default()).generate_module(&ir);
+    assert!(code.contains("record DistanceType("));
+    assert!(code.contains("if (Value.Value < 0)"));
+    assert!(code.contains("record EmptyType : IValidatableObject"));
+    assert!(code.contains("IEnumerable<ValidationResult> Validate"));
+}
+
+#[test]
+fn choice_variants_avoid_record_member_names() {
+    let mut ir = SchemaIR::new().with_target_namespace("urn:test");
+    ir.add_type(TypeDef::Union(UnionDef {
+        qname: QName::new(Some("urn:test"), "ParameterValueType"),
+        branches: vec![
+            UnionBranch {
+                variant_name: "Value".into(),
+                xml_name: "Value".into(),
+                namespace: None,
+                type_ref: TypeRef::Primitive(PrimitiveType::String),
+                documentation: None,
+            },
+            UnionBranch {
+                variant_name: "Equals".into(),
+                xml_name: "Equals".into(),
+                namespace: None,
+                type_ref: TypeRef::Primitive(PrimitiveType::Int),
+                documentation: None,
+            },
+        ],
+        documentation: None,
+    }));
+    let code = CSharpCodegen::new(CSharpOptions::default()).generate_module(&ir);
+    assert!(code.contains("record ValueBranch("));
+    assert!(code.contains("record EqualsBranch("));
+    assert!(code.contains("XmlElement(\"Value\")"));
+}
+
 static DOTNET_LOCK: Mutex<()> = Mutex::new(());
 
 fn dotnet_command() -> Command {

{polyxml-0.30.1 → polyxml-0.30.3}/crates/polyxml-core/tests/test_python_codegen.rs

@@ -5,6 +5,18 @@ use polyxml::ir::{
     Cardinality, EnumDef, EnumValue, FieldDef, FieldKind, OccursLimit, PrimitiveType, QName,
     RestrictionFacets, SchemaIR, SimpleTypeDef, StructDef, TypeDef, TypeRef, UnionBranch, UnionDef,
 };
+use polyxml::schema_parser::XsdParser;
+
+#[test]
+fn multiline_xsd_documentation_stays_inside_python_comments() {
+    let xsd = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:test">
+      <xs:simpleType name="Code"><xs:annotation><xs:documentation>First line
+        Second line</xs:documentation></xs:annotation><xs:restriction base="xs:string"/></xs:simpleType>
+    </xs:schema>"#;
+    let ir = XsdParser::new().parse_str(xsd).unwrap();
+    let code = PythonCodegen::new(PythonOptions::default()).generate_module(&ir);
+    assert!(code.contains("# First line\n#         Second line"));
+}
 
 #[test]
 fn test_identifier_sanitization() {

{polyxml-0.30.1 → polyxml-0.30.3}/crates/polyxml-core/tests/test_rust_codegen.rs

@@ -3,7 +3,7 @@ use polyxml::codegen::rust::{
 };
 use polyxml::ir::{
     Cardinality, EnumDef, EnumValue, FieldDef, FieldKind, PrimitiveType, QName, SchemaIR,
-    StructDef, TypeDef, TypeRef, UnionBranch, UnionDef,
+    SimpleTypeDef, StructDef, TypeDef, TypeRef, UnionBranch, UnionDef,
 };
 use polyxml::schema_parser::XsdParser;
 
@@ -35,6 +35,22 @@ fn test_rust_identifier_sanitization() {
     assert_eq!(to_rust_field_identifier("normalField"), "normal_field");
 }
 
+#[test]
+fn multiline_docs_and_raw_field_names_are_valid_source() {
+    let xsd = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:test">
+      <xs:complexType name="Sample"><xs:annotation><xs:documentation>First line
+        Second line</xs:documentation></xs:annotation><xs:sequence>
+        <xs:element name="type" type="xs:string"/>
+      </xs:sequence></xs:complexType>
+    </xs:schema>"#;
+    let ir = XsdParser::new().parse_str(xsd).unwrap();
+    let code = RustCodegen::new(RustOptions::default()).generate_module(&ir);
+    assert!(code.contains("/// First line\n///         Second line"));
+    assert!(code.contains("pub r#type:"));
+    assert!(code.contains("var_type"));
+    assert!(!code.contains("var_r#"));
+}
+
 #[test]
 fn test_rust_zero_copy_codegen() {
     let mut ir = SchemaIR::new().with_target_namespace("https://example.com/crm");
@@ -1147,3 +1163,44 @@ fn test_rust_phf_dispatch_uniquifies_like_field_metas() {
         "bare-string arm leaked into the Option match:\n{code}"
     );
 }
+
+#[test]
+fn test_rust_simple_type_cycle_resilience() {
+    let mut ir = SchemaIR::default();
+    let q_a = QName::new(Some("urn:cycle"), "TypeA");
+    let q_b = QName::new(Some("urn:cycle"), "TypeB");
+
+    // Mutual cycle between TypeA and TypeB
+    ir.add_type(TypeDef::Simple(Box::new(SimpleTypeDef {
+        qname: q_a.clone(),
+        base_type: TypeRef::Named(q_b.clone()),
+        facets: Default::default(),
+        documentation: None,
+    })));
+    ir.add_type(TypeDef::Simple(Box::new(SimpleTypeDef {
+        qname: q_b.clone(),
+        base_type: TypeRef::Named(q_a.clone()),
+        facets: Default::default(),
+        documentation: None,
+    })));
+
+    let struct_fields = vec![FieldDef::new(
+        "cyclic_field",
+        "cyclic_field",
+        FieldKind::Element,
+        TypeRef::Named(q_a),
+    )];
+
+    ir.add_type(TypeDef::Struct(StructDef {
+        qname: QName::new(Some("urn:cycle"), "CyclicStruct"),
+        fields: struct_fields,
+        base_type: None,
+        is_abstract: false,
+        is_mixed: false,
+        documentation: None,
+    }));
+
+    let codegen = RustCodegen::new(RustOptions::default());
+    let code = codegen.generate_module(&ir);
+    assert!(code.contains("pub struct CyclicStruct"));
+}

{polyxml-0.30.1 → polyxml-0.30.3}/crates/polyxml-core/tests/test_schema_ir.rs

@@ -7,6 +7,26 @@ use polyxml::ir::{
 };
 use polyxml::schema_parser::XsdParser;
 
+#[test]
+fn consumed_child_subtrees_do_not_swallow_following_types() {
+    let xsd = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:test">
+      <xs:complexType name="First"><xs:sequence>
+        <xs:element name="nested"><xs:complexType><xs:sequence><xs:element name="value" type="xs:string"/></xs:sequence></xs:complexType></xs:element>
+        <xs:group ref="missing"><xs:annotation><xs:documentation>ignored</xs:documentation></xs:annotation></xs:group>
+      </xs:sequence></xs:complexType>
+      <xs:complexType name="Second"><xs:sequence><xs:element name="other" type="xs:string"/></xs:sequence></xs:complexType>
+    </xs:schema>"#;
+    let ir = XsdParser::new().parse_str(xsd).unwrap();
+    let first = match &ir.types[&QName::new(Some("urn:test"), "First")] {
+        TypeDef::Struct(value) => value,
+        other => panic!("expected struct: {other:?}"),
+    };
+    assert_eq!(first.fields.len(), 1);
+    assert!(ir
+        .types
+        .contains_key(&QName::new(Some("urn:test"), "Second")));
+}
+
 #[test]
 fn test_parse_lexical_union_member_types_and_inline_members() {
     let xsd = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="urn:test" targetNamespace="urn:test">

{polyxml-0.30.1 → polyxml-0.30.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "polyxml"
-version = "0.30.1"
+version = "0.30.3"
 description = "High-performance, polyglot XML data-binding engine built in Rust"
 authors = [
     { name = "Bailey Nguyen", email = "bailey.tan.nguyen@gmail.com" }