polyxml 0.34.4__tar.gz → 0.34.5__tar.gz

{polyxml-0.34.4 → polyxml-0.34.5}/Cargo.lock

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

{polyxml-0.34.4 → polyxml-0.34.5}/Cargo.toml

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

{polyxml-0.34.4 → polyxml-0.34.5}/PKG-INFO

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

{polyxml-0.34.4 → polyxml-0.34.5}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -277,7 +277,7 @@ fn root_names(ir: &SchemaIR) -> HashMap<QName, String> {
     names
 }
 
-fn choice_variant_name(branch: &UnionBranch) -> String {
+fn choice_variant_base(branch: &UnionBranch) -> String {
     let name = to_csharp_type_name(&branch.variant_name);
     if matches!(
         name.as_str(),
@@ -290,6 +290,33 @@ fn choice_variant_name(branch: &UnionBranch) -> String {
     }
 }
 
+fn choice_variant_names(union: &UnionDef) -> Vec<String> {
+    let mut used = HashSet::from([type_ident(&union.qname)]);
+    for branch in &union.branches {
+        let mut ty = &branch.type_ref;
+        while let TypeRef::List(inner) | TypeRef::Boxed(inner) = ty {
+            ty = inner;
+        }
+        if let TypeRef::Named(name) = ty {
+            used.insert(type_ident(name));
+        }
+    }
+    union
+        .branches
+        .iter()
+        .map(|branch| {
+            let base = choice_variant_base(branch);
+            let mut name = base.clone();
+            let mut suffix = 2;
+            while !used.insert(name.clone()) {
+                name = format!("{base}{suffix}");
+                suffix += 1;
+            }
+            name
+        })
+        .collect()
+}
+
 fn simple_value_target(base: &TypeRef, ir: &SchemaIR) -> String {
     let mut target = "Value".to_string();
     let mut current = base;
@@ -298,6 +325,10 @@ fn simple_value_target(base: &TypeRef, ir: &SchemaIR) -> String {
         if !seen.insert(qname.clone()) {
             break;
         }
+        if matches!(ir.types.get(qname), Some(TypeDef::Enum(_))) {
+            target.push_str(".ToXmlValue()");
+            break;
+        }
         let Some(TypeDef::Simple(simple)) = ir.types.get(qname) else {
             break;
         };
@@ -340,6 +371,41 @@ impl CSharpCodegen {
 
     /// Emits all types in the given SchemaIR as a single C# compilation unit.
     pub fn generate_module(&self, ir: &SchemaIR) -> String {
+        let has_duplicate_items = ir.types.values().any(|def| {
+            let TypeDef::Union(union) = def else {
+                return false;
+            };
+            if !union.is_mixed_content() {
+                return false;
+            }
+            let mut seen = HashSet::new();
+            union
+                .branches
+                .iter()
+                .any(|b| !seen.insert((&b.xml_name, &b.namespace, &b.type_ref)))
+        });
+        let mut canonical = if has_duplicate_items {
+            std::borrow::Cow::Owned(ir.clone())
+        } else {
+            std::borrow::Cow::Borrowed(ir)
+        };
+        if let std::borrow::Cow::Owned(canonical) = &mut canonical {
+            for def in canonical.types.values_mut() {
+                if let TypeDef::Union(union) = def {
+                    if union.is_mixed_content() {
+                        let mut seen = HashSet::new();
+                        union.branches.retain(|b| {
+                            seen.insert((
+                                b.xml_name.clone(),
+                                b.namespace.clone(),
+                                b.type_ref.clone(),
+                            ))
+                        });
+                    }
+                }
+            }
+        }
+        let ir = canonical.as_ref();
         set_type_name_map(build_type_name_map(ir, to_csharp_type_name));
         let mut out = String::new();
 
@@ -438,6 +504,13 @@ impl CSharpCodegen {
             writeln!(out, "}}").unwrap();
         }
 
+        if out.contains(".Select(") || out.contains(".Any(") {
+            out = out.replacen(
+                "using System.Collections.Generic;",
+                "using System.Collections.Generic;\nusing System.Linq;",
+                1,
+            );
+        }
         out
     }
 
@@ -749,8 +822,7 @@ impl CSharpCodegen {
 
         // XmlInclude attributes for element-choice polymorphism.
         if self.options.emit_xml_attributes && !u.is_lexical() && !u.is_mixed_content() {
-            for branch in &u.branches {
-                let variant_name = choice_variant_name(branch);
+            for variant_name in choice_variant_names(u) {
                 writeln!(
                     out,
                     "{}[XmlInclude(typeof({}.{}))]",
@@ -761,14 +833,11 @@ impl CSharpCodegen {
         }
 
         if !self.options.use_records && self.options.emit_json_attributes {
-            for branch in &u.branches {
+            for (branch, variant_name) in u.branches.iter().zip(choice_variant_names(u)) {
                 writeln!(
                     out,
                     "{}[JsonDerivedType(typeof({}.{}), {:?})]",
-                    indent,
-                    choice_name,
-                    choice_variant_name(branch),
-                    branch.xml_name
+                    indent, choice_name, variant_name, branch.xml_name
                 )
                 .unwrap();
             }
@@ -787,8 +856,7 @@ impl CSharpCodegen {
         .unwrap();
         writeln!(out, "{}{{", indent).unwrap();
 
-        for branch in &u.branches {
-            let variant_name = choice_variant_name(branch);
+        for (branch, variant_name) in u.branches.iter().zip(choice_variant_names(u)) {
             let branch_type = self.context.map_type_ref(&branch.type_ref);
 
             if let Some(ref doc) = branch.documentation {
@@ -864,8 +932,11 @@ impl CSharpCodegen {
         );
         let _ = writeln!(out, "{}    {{", indent);
         let _ = writeln!(out, "{}        var value = text.Trim();", indent);
-        for (idx, branch) in u.branches.iter().enumerate() {
-            let variant = choice_variant_name(branch);
+        let mut exhaustive = false;
+        for (idx, (branch, variant_name)) in
+            u.branches.iter().zip(choice_variant_names(u)).enumerate()
+        {
+            let variant = variant_name;
             let mapped = self.context.map_type_ref(&branch.type_ref);
             if let TypeRef::Named(qname) = &branch.type_ref {
                 if let Some(TypeDef::Enum(def)) = ir.types.get(qname) {
@@ -894,6 +965,11 @@ impl CSharpCodegen {
             } else {
                 format!("candidate{}", idx)
             };
+            if matches!(base, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Union(nested)) if nested.is_lexical()))
+            {
+                writeln!(out, "{indent}        try {{ var candidate{idx}={base_name}.Parse(value);return new {variant}({wrap}); }}catch(FormatException){{}}").unwrap();
+                continue;
+            }
             if let Some(p) = super::unbounded_integer(&branch.type_ref, ir) {
                 let kind = match p {
                     PrimitiveType::PositiveInteger => 1,
@@ -927,6 +1003,8 @@ impl CSharpCodegen {
                         "{}        {{ var candidate{} = value; return new {}({}); }}",
                         indent, idx, variant, wrap
                     );
+                    exhaustive = true;
+                    break;
                 }
             } else if base_name == "bool" {
                 let _ = writeln!(out, "{}        if (value == \"true\" || value == \"1\") {{ var candidate{} = true; return new {}({}); }}", indent, idx, variant, wrap);
@@ -943,16 +1021,18 @@ impl CSharpCodegen {
                 );
             }
         }
-        let _ = writeln!(
-            out,
-            "{}        throw new FormatException(\"No {} union member accepts the value\");",
-            indent, name
-        );
+        if !exhaustive {
+            let _ = writeln!(
+                out,
+                "{}        throw new FormatException(\"No {} union member accepts the value\");",
+                indent, name
+            );
+        }
         let _ = writeln!(out, "{}    }}", indent);
         let _ = writeln!(out, "{indent}    private string? _lexical;\n{indent}    private string? _parsedCanonical;\n{indent}    private static {name} Preserve({name} member, string lexical) {{ member._parsedCanonical = member.FormatXmlValue(); member._lexical = lexical; return member; }}\n{indent}    public string ToXmlString() {{ var canonical = FormatXmlValue(); return canonical == _parsedCanonical ? _lexical! : canonical; }}\n{indent}    private string FormatXmlValue() => this switch");
         let _ = writeln!(out, "{}    {{", indent);
-        for branch in &u.branches {
-            let variant = choice_variant_name(branch);
+        for (branch, variant_name) in u.branches.iter().zip(choice_variant_names(u)) {
+            let variant = variant_name;
             let value = if matches!(
                 super::primitive_base(&branch.type_ref, ir),
                 TypeRef::Primitive(PrimitiveType::Date)
@@ -970,6 +1050,7 @@ impl CSharpCodegen {
                 "item.Value.ToString(\"HH:mm:ssK\", System.Globalization.CultureInfo.InvariantCulture)".to_string()
             } else {
                 match &branch.type_ref {
+                TypeRef::Named(qname) if matches!(ir.types.get(qname), Some(TypeDef::Union(nested)) if nested.is_lexical()) => "item.Value.ToXmlString()".to_string(),
                 TypeRef::Named(qname) if matches!(ir.types.get(qname), Some(TypeDef::Enum(_))) => "item.Value.ToXmlValue()".to_string(),
                 TypeRef::Named(qname) if matches!(ir.types.get(qname), Some(TypeDef::Simple(_))) => "Convert.ToString(item.Value.Value, System.Globalization.CultureInfo.InvariantCulture) ?? \"\"".to_string(),
                 _ => "Convert.ToString(item.Value, System.Globalization.CultureInfo.InvariantCulture) ?? \"\"".to_string(),
@@ -1031,17 +1112,30 @@ impl CSharpCodegen {
             "{indent}    [XmlIgnore] {json}public {ty} {name} {{get;set;}} = {default};"
         )
         .unwrap();
+        let optional = ty.ends_with('?');
         let validation = if field.cardinality.is_list() {
-            format!("{name}?.Select(v=>PolyxmlIntegerLexical.Validate(v,{kind})).ToList()")
-        } else {
+            if optional {
+                format!("{name}?.Select(v=>PolyxmlIntegerLexical.Validate(v,{kind})).ToList()")
+            } else {
+                format!("{name}.Select(v=>PolyxmlIntegerLexical.Validate(v,{kind})).ToList()")
+            }
+        } else if optional {
             format!("{name} is null ? null : PolyxmlIntegerLexical.Validate({name},{kind})")
+        } else {
+            format!("PolyxmlIntegerLexical.Validate({name} ?? throw new InvalidOperationException(\"Missing required integer\"),{kind})")
         };
         let parse = if field.cardinality.is_list() {
-            format!("value?.Select(v=>PolyxmlIntegerLexical.Validate(v,{kind})).ToList()!")
+            if optional {
+                format!("value?.Select(v=>PolyxmlIntegerLexical.Validate(v,{kind})).ToList()")
+            } else {
+                format!("value.Select(v=>PolyxmlIntegerLexical.Validate(v,{kind})).ToList()")
+            }
+        } else if optional {
+            format!("value is null ? null : PolyxmlIntegerLexical.Validate(value,{kind})")
         } else {
-            format!("value is null ? default! : PolyxmlIntegerLexical.Validate(value,{kind})")
+            format!("PolyxmlIntegerLexical.Validate(value,{kind})")
         };
-        writeln!(out,"{indent}    {attrs}{ignore}public {ty} {name}Xml {{ get => {validation}!; set => {name} = {parse}; }}").unwrap();
+        writeln!(out,"{indent}    {attrs}{ignore}public {ty} {name}Xml {{ get => {validation}; set => {name} = {parse}; }}").unwrap();
         true
     }
 
@@ -1166,6 +1260,22 @@ impl CSharpCodegen {
         }
         let ty = self.map_field_type(field, ir);
         let base = ty.trim_end_matches('?');
+        let can_be_null = ty.ends_with('?')
+            || !(matches!(
+                base,
+                "bool"
+                    | "byte"
+                    | "sbyte"
+                    | "short"
+                    | "ushort"
+                    | "int"
+                    | "uint"
+                    | "long"
+                    | "ulong"
+                    | "float"
+                    | "double"
+                    | "decimal"
+            ) || matches!(&field.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Enum(_)))));
         let namespace = field
             .namespace
             .as_ref()
@@ -1199,8 +1309,13 @@ impl CSharpCodegen {
             } else {
                 format!("object.Equals(value, {expected})")
             };
+            let present = if ty.ends_with('?') {
+                "value is not null && "
+            } else {
+                ""
+            };
             writeln!(out, "{indent}    private {ty} _{name} = {initial};
-{indent}    [XmlIgnore] public {ty} {name} {{ get => _{name}; set {{ if (value is not null && !({equal})) throw new System.ComponentModel.DataAnnotations.ValidationException(\"Fixed value constraint violated for {name}\"); _{name} = value; }} }}").unwrap();
+{indent}    [XmlIgnore] public {ty} {name} {{ get => _{name}; set {{ if ({present}!({equal})) throw new System.ComponentModel.DataAnnotations.ValidationException(\"Fixed value constraint violated for {name}\"); _{name} = value; }} }}").unwrap();
         } else {
             let initial = if field.kind == FieldKind::Attribute {
                 parse(&format!("{default:?}"))
@@ -1224,10 +1339,15 @@ impl CSharpCodegen {
             field.xml_name
         )
         .unwrap();
+        let null_guard = if can_be_null {
+            format!("if ({name} is null) return null; ")
+        } else {
+            String::new()
+        };
         if let Some(kind) = integer_kind {
-            writeln!(out,"{indent}        get {{ if ({name} is null) return null; return PolyxmlIntegerLexical.Validate({name},{kind}); }}").unwrap();
+            writeln!(out,"{indent}        get {{ {null_guard} return PolyxmlIntegerLexical.Validate({name},{kind}); }}").unwrap();
         } else {
-            writeln!(out, "{indent}        get {{ if ({name} is null) return null; var writer = new System.IO.StringWriter(System.Globalization.CultureInfo.InvariantCulture); new XmlSerializer(typeof({base}), new XmlRootAttribute(\"value\")).Serialize(writer, {name}); return System.Xml.Linq.XDocument.Parse(writer.ToString()).Root!.Value; }}").unwrap();
+            writeln!(out, "{indent}        get {{ {null_guard}var writer = new System.IO.StringWriter(System.Globalization.CultureInfo.InvariantCulture); new XmlSerializer(typeof({base}), new XmlRootAttribute(\"value\")).Serialize(writer, {name}); return System.Xml.Linq.XDocument.Parse(writer.ToString()).Root!.Value; }}").unwrap();
         }
         let text = if field.kind == FieldKind::Attribute {
             "value".into()
@@ -1274,12 +1394,24 @@ impl CSharpCodegen {
         };
         let item_name = &prop_names[item_index];
         let union_name = type_ident(&union.qname);
+        let text_variant = union
+            .branches
+            .iter()
+            .zip(choice_variant_names(union))
+            .find(|(branch, _)| branch.xml_name == "#text")
+            .map(|(_, name)| name)
+            .expect("mixed union text branch");
         let class_kind = if self.options.use_records {
             "record"
         } else {
             "class"
         };
-        let _ = writeln!(out, "{indent}public {class_kind} {struct_name} : System.Xml.Serialization.IXmlSerializable\n{indent}{{");
+        let validation_interface = if self.options.emit_validation {
+            ", IValidatableObject"
+        } else {
+            ""
+        };
+        let _ = writeln!(out, "{indent}public {class_kind} {struct_name} : System.Xml.Serialization.IXmlSerializable{validation_interface}\n{indent}{{");
         for (field, prop_name) in s.fields.iter().zip(prop_names) {
             let ty = self.map_field_type(field, ir);
             if field.kind == FieldKind::Attribute {
@@ -1307,22 +1439,23 @@ impl CSharpCodegen {
             if field.kind == FieldKind::Attribute {
                 let ty = self.map_field_type(field, ir);
                 let base_type = ty.trim_end_matches('?');
-                let _ = writeln!(out, "        {{ var raw = reader.GetAttribute({:?}); if (raw is not null) {prop_name} = ({ty})System.Convert.ChangeType(raw, typeof({base_type}), System.Globalization.CultureInfo.InvariantCulture); }}", field.xml_name);
+                let namespace = field.namespace.as_deref().unwrap_or("");
+                let _ = writeln!(out, "        {{ var raw = reader.GetAttribute({:?}, {namespace:?}); if (raw is not null) {prop_name} = ({ty})new XmlSerializer(typeof({base_type}), new XmlRootAttribute(\"value\")).Deserialize(new System.IO.StringReader(\"<value>\" + System.Security.SecurityElement.Escape(raw) + \"</value>\"))!; }}", field.xml_name);
             }
         }
         let _ = writeln!(out, "        {item_name} = new List<{union_name}>();");
         out.push_str("        bool empty = reader.IsEmptyElement;\n        reader.ReadStartElement();\n        if (empty) return;\n        while (reader.NodeType != System.Xml.XmlNodeType.EndElement && !reader.EOF)\n        {\n            switch (reader.NodeType)\n            {\n                case System.Xml.XmlNodeType.Text:\n                case System.Xml.XmlNodeType.CDATA:\n                case System.Xml.XmlNodeType.Whitespace:\n                case System.Xml.XmlNodeType.SignificantWhitespace:\n");
         let _ = writeln!(
             out,
-            "                    {item_name}.Add(new {union_name}.Text(reader.Value));"
+            "                    {item_name}.Add(new {union_name}.{text_variant}(reader.Value));"
         );
         out.push_str("                    reader.Read();\n                    break;\n                case System.Xml.XmlNodeType.Element:\n                    switch (reader.LocalName)\n                    {\n");
-        for branch in &union.branches {
+        for (branch, variant) in union.branches.iter().zip(choice_variant_names(union)) {
             if branch.xml_name == "#text" {
                 continue;
             }
             let branch_type = self.context.map_type_ref(&branch.type_ref);
-            let variant = choice_variant_name(branch);
+
             let namespace = branch.namespace.as_deref().unwrap_or("");
             let _ = writeln!(out, "                        case {:?}:\n                            {{ var serializer = new XmlSerializer(typeof({branch_type}), new XmlRootAttribute({:?}) {{ Namespace = {:?} }}); {item_name}.Add(new {union_name}.{variant}(({branch_type})serializer.Deserialize(reader)!)); break; }}", branch.xml_name, branch.xml_name, namespace);
         }
@@ -1334,12 +1467,34 @@ impl CSharpCodegen {
         );
         for (field, prop_name) in s.fields.iter().zip(prop_names) {
             if field.kind == FieldKind::Attribute {
-                let _ = writeln!(out, "        if ({prop_name} is not null) writer.WriteAttributeString({:?}, System.Convert.ToString({prop_name}, System.Globalization.CultureInfo.InvariantCulture));", field.xml_name);
+                let ty = self.map_field_type(field, ir);
+                let base = ty.trim_end_matches('?');
+                let is_value = matches!(
+                    base,
+                    "bool"
+                        | "byte"
+                        | "sbyte"
+                        | "short"
+                        | "ushort"
+                        | "int"
+                        | "uint"
+                        | "long"
+                        | "ulong"
+                        | "float"
+                        | "double"
+                        | "decimal"
+                ) || matches!(&field.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Enum(_))));
+                let guard = if ty.ends_with('?') || !is_value {
+                    format!("if ({prop_name} is not null) ")
+                } else {
+                    String::new()
+                };
+                let namespace = field.namespace.as_deref().unwrap_or("");
+                let _ = writeln!(out, "        {guard}{{ var text = new System.IO.StringWriter(System.Globalization.CultureInfo.InvariantCulture); new XmlSerializer(typeof({base}), new XmlRootAttribute(\"value\")).Serialize(text, {prop_name}); writer.WriteAttributeString({:?}, {namespace:?}, System.Xml.Linq.XDocument.Parse(text.ToString()).Root!.Value); }}", field.xml_name);
             }
         }
         let _ = writeln!(out, "        foreach (var item in {item_name})\n        {{\n            switch (item)\n            {{");
-        for branch in &union.branches {
-            let variant = choice_variant_name(branch);
+        for (branch, variant) in union.branches.iter().zip(choice_variant_names(union)) {
             if branch.xml_name == "#text" {
                 let _ = writeln!(out, "                case {union_name}.{variant} text: writer.WriteString(text.Value); break;");
             } else {
@@ -1349,10 +1504,27 @@ impl CSharpCodegen {
             }
         }
         out.push_str("            }\n        }\n");
-        let _ = writeln!(out, "{indent}    }}\n{indent}}}\n");
+        let _ = writeln!(out, "{indent}    }}");
+        if self.options.emit_validation {
+            self.emit_struct_validator(out, s, ir, prop_names, indent);
+        }
+        let _ = writeln!(out, "{indent}}}\n");
     }
 
     fn emit_struct(&self, out: &mut String, s: &StructDef, ir: &SchemaIR, indent: &str) {
+        if ir.has_ordered_content(s) && s.base_type.is_some() {
+            let fields = super::flatten_fields(s, ir);
+            if fields.iter().any(|f| {
+                matches!(&f.type_ref, TypeRef::Named(q)
+                if matches!(ir.types.get(q), Some(TypeDef::Union(u)) if u.is_mixed_content()))
+            }) {
+                let mut flat = s.clone();
+                flat.fields = fields.into_iter().cloned().collect();
+                flat.base_type = None;
+                self.emit_struct(out, &flat, ir, indent);
+                return;
+            }
+        }
         // Reuse inherited XML members. Simple-content IR includes a text
         // placeholder for non-inheriting targets; restrictions can repeat
         // attribute declarations already present on the generated base.
@@ -1436,7 +1608,13 @@ impl CSharpCodegen {
             .map(|f| self.unique_property_name(&f.name, &mut seen_props, Some(&struct_name)))
             .collect();
 
-        if ir.has_ordered_content(s) && self.options.emit_xml_attributes {
+        if ir.has_ordered_content(s)
+            && self.options.emit_xml_attributes
+            && s.fields.iter().any(|f| {
+                matches!(&f.type_ref, TypeRef::Named(q)
+                if matches!(ir.types.get(q), Some(TypeDef::Union(u)) if u.is_mixed_content()))
+            })
+        {
             self.emit_mixed_struct(out, s, ir, indent, &struct_name, &prop_names);
             return;
         }
@@ -1769,16 +1947,15 @@ impl CSharpCodegen {
             .as_ref()
             .map(|b| matches!(ir.types.get(b), Some(TypeDef::Struct(_))))
             .unwrap_or(false);
-        let new_kw = if !self.options.use_records {
-            if has_struct_base {
-                "override "
-            } else {
-                "virtual "
-            }
+        let new_kw = if self.options.use_records
+            && self.options.record_kind == CSharpRecordKind::Struct
+            && !ir.has_ordered_content(s)
+        {
+            ""
         } else if has_struct_base {
-            "new "
+            "override "
         } else {
-            ""
+            "virtual "
         };
         writeln!(
             out,
@@ -1788,7 +1965,7 @@ impl CSharpCodegen {
         .unwrap();
         writeln!(out, "{}    {{", indent).unwrap();
 
-        if !self.options.use_records && has_struct_base {
+        if has_struct_base {
             writeln!(out, "{}        foreach (var result in base.Validate(validationContext)) yield return result;", indent).unwrap();
         }
         let mut has_checks = false;
@@ -1872,11 +2049,12 @@ impl CSharpCodegen {
         target: &str,
         indent: &str,
     ) {
+        let member = target.split('.').next().unwrap_or(target);
         if let Some(min_len) = facets.min_length {
             writeln!(
                 out,
                 "{}if ({}.Length < {}) yield return new ValidationResult(\"{} length must be >= {}\", [nameof({})]);",
-                indent, target, min_len, target, min_len, target
+                indent, target, min_len, target, min_len, member
             )
             .unwrap();
         }
@@ -1884,7 +2062,7 @@ impl CSharpCodegen {
             writeln!(
                 out,
                 "{}if ({}.Length > {}) yield return new ValidationResult(\"{} length must be <= {}\", [nameof({})]);",
-                indent, target, max_len, target, max_len, target
+                indent, target, max_len, target, max_len, member
             )
             .unwrap();
         }
@@ -1895,7 +2073,7 @@ impl CSharpCodegen {
             writeln!(
                 out,
                 "{}if (!Regex.IsMatch({}.ToString() ?? \"\", \"{}\")) yield return new ValidationResult(\"{} does not match pattern {}\", [nameof({})]);",
-                indent, target, escaped, target, escaped, target
+                indent, target, escaped, target, escaped, member
             )
             .unwrap();
         }
@@ -1903,7 +2081,7 @@ impl CSharpCodegen {
             writeln!(
                 out,
                 "{}if ({} < {}) yield return new ValidationResult(\"{} must be >= {}\", [nameof({})]);",
-                indent, target, min_inc, target, min_inc, target
+                indent, target, min_inc, target, min_inc, member
             )
             .unwrap();
         }
@@ -1911,7 +2089,7 @@ impl CSharpCodegen {
             writeln!(
                 out,
                 "{}if ({} > {}) yield return new ValidationResult(\"{} must be <= {}\", [nameof({})]);",
-                indent, target, max_inc, target, max_inc, target
+                indent, target, max_inc, target, max_inc, member
             )
             .unwrap();
         }
@@ -1919,7 +2097,7 @@ impl CSharpCodegen {
             writeln!(
                 out,
                 "{}if ({} <= {}) yield return new ValidationResult(\"{} must be > {}\", [nameof({})]);",
-                indent, target, min_exc, target, min_exc, target
+                indent, target, min_exc, target, min_exc, member
             )
             .unwrap();
         }
@@ -1927,7 +2105,7 @@ impl CSharpCodegen {
             writeln!(
                 out,
                 "{}if ({} >= {}) yield return new ValidationResult(\"{} must be < {}\", [nameof({})]);",
-                indent, target, max_exc, target, max_exc, target
+                indent, target, max_exc, target, max_exc, member
             )
             .unwrap();
         }
@@ -1984,8 +2162,7 @@ impl CSharpCodegen {
             if let Some(qname) = named_qname {
                 if let Some(TypeDef::Union(u)) = ir.types.get(qname) {
                     let choice_name = type_ident(&u.qname);
-                    for branch in &u.branches {
-                        let variant_name = choice_variant_name(branch);
+                    for (branch, variant_name) in u.branches.iter().zip(choice_variant_names(u)) {
                         parts.push(format!(
                             "XmlElement(\"{}\", typeof({}.{}), Namespace = {:?})",
                             branch.xml_name,

{polyxml-0.34.4 → polyxml-0.34.5}/crates/polyxml-core/src/codegen/go/mod.rs

@@ -419,13 +419,7 @@ impl GoCodegen {
         if body.contains("xml.") {
             imports.push("\"encoding/xml\"");
         }
-        if self.options.emit_xml_tags
-            && (!ir.content_models.is_empty()
-                || ir
-                    .types
-                    .values()
-                    .any(|def| matches!(def, TypeDef::Struct(s) if ir.has_ordered_content(s))))
-        {
+        if body.contains("bytes.") {
             imports.push("\"bytes\"");
         }
         if has_fmt || body.contains("fmt.") {

{polyxml-0.34.4 → polyxml-0.34.5}/crates/polyxml-core/src/codegen/rust/mod.rs

@@ -345,7 +345,7 @@ impl RustCodegen {
         let chunk_size = self.options.chunk_size.unwrap_or(250);
 
         let safe_mod = sanitize_rust_module_name(base_name);
-        let mod_export = if safe_mod == base_name {
+        let mut mod_export = if safe_mod == base_name {
             format!("pub mod {base_name};\npub use {base_name}::*;\n")
         } else {
             format!("#[path = \"{base_name}.rs\"]\npub mod {safe_mod};\npub use {safe_mod}::*;\n")
@@ -353,6 +353,13 @@ impl RustCodegen {
 
         if !should_split {
             let code = self.generate_module(ir);
+            if !code.lines().any(|line| line.starts_with("pub ")) {
+                mod_export = mod_export
+                    .lines()
+                    .filter(|line| !line.starts_with("pub use "))
+                    .map(|line| format!("{line}\n"))
+                    .collect();
+            }
             if base_name == "mod" {
                 return vec![("mod.rs".to_string(), code)];
             }
@@ -365,6 +372,13 @@ impl RustCodegen {
         let plan = ir.partition_topological_chunks(chunk_size);
         if plan.chunks.len() <= 1 {
             let code = self.generate_module(ir);
+            if !code.lines().any(|line| line.starts_with("pub ")) {
+                mod_export = mod_export
+                    .lines()
+                    .filter(|line| !line.starts_with("pub use "))
+                    .map(|line| format!("{line}\n"))
+                    .collect();
+            }
             if base_name == "mod" {
                 return vec![("mod.rs".to_string(), code)];
             }

{polyxml-0.34.4 → polyxml-0.34.5}/crates/polyxml-core/tests/test_csharp_codegen.rs

@@ -79,6 +79,9 @@ static DOTNET_LOCK: Mutex<()> = Mutex::new(());
 #[test]
 fn particle_wire_structure_round_trips() {
     for (schema, root, documents) in [
+        (r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:element name="Root"><xs:complexType mixed="true"><xs:sequence><xs:element name="Description" type="xs:string" minOccurs="0"/><xs:element name="Link" type="xs:string"/><xs:element name="Description" type="xs:string" minOccurs="0"/></xs:sequence></xs:complexType></xs:element></xs:schema>"#, "Root", vec!["<Root><Description>first</Description><Link>middle</Link><Description>second</Description></Root>"]),
+        (r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:complexType name="VehicleType"><xs:simpleContent><xs:extension base="xs:string"/></xs:simpleContent></xs:complexType><xs:complexType name="OtherType"><xs:simpleContent><xs:extension base="xs:string"/></xs:simpleContent></xs:complexType><xs:element name="Root"><xs:complexType mixed="true"><xs:choice minOccurs="0" maxOccurs="unbounded"><xs:element name="Vehicle" type="VehicleType"/><xs:element name="VehicleType" type="OtherType"/></xs:choice></xs:complexType></xs:element></xs:schema>"#, "Root", vec!["<Root><Vehicle>one</Vehicle><VehicleType>two</VehicleType></Root>"]),
+        (r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:simpleType name="Phase"><xs:restriction base="xs:string"><xs:enumeration value="on"/><xs:enumeration value="off"/></xs:restriction></xs:simpleType><xs:complexType name="Base" mixed="true"><xs:choice minOccurs="0" maxOccurs="unbounded"><xs:element name="ItemA" type="xs:string"/><xs:element name="item_a" type="xs:string"/></xs:choice><xs:attribute name="code" type="xs:string"/><xs:attribute name="enabled" type="xs:boolean" use="required"/><xs:attribute name="phase" type="Phase" use="required"/></xs:complexType><xs:complexType name="Derived" mixed="true"><xs:complexContent mixed="true"><xs:extension base="Base"><xs:attribute name="extra" type="xs:string"/></xs:extension></xs:complexContent></xs:complexType><xs:element name="Root" type="Derived"/></xs:schema>"#, "Root", vec![r#"<Root code="base" extra="leaf" enabled="true" phase="on">before<ItemA>A</ItemA>between<item_a>B</item_a>after</Root>"#]),
         (r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:element name="Query"><xs:complexType><xs:sequence><xs:element name="Equals" type="xs:string"/><xs:element name="EqualsValue" type="xs:string"/><xs:element name="GetHashCode" type="xs:string"/><xs:element name="ToString" type="xs:string"/></xs:sequence></xs:complexType></xs:element></xs:schema>"#, "Query", vec!["<Query><Equals>a</Equals><EqualsValue>b</EqualsValue><GetHashCode>c</GetHashCode><ToString>d</ToString></Query>"]),
         (include_str!("../../../research/fixtures/nested_sequence_choice.xsd"), "Root", vec!["<Root><First>A</First><Second>B</Second></Root>", "<Root><Alternative>C</Alternative></Root>"]),
         (include_str!("../../../research/fixtures/repeated_sequence.xsd"), "Root", vec!["<Root><First>A1</First><Second>B1</Second><First>A2</First><Second>B2</Second></Root>"]),
@@ -98,7 +101,7 @@ using System.Xml.Serialization;
 using System.Xml.Linq;
 using ParticleModels;
 var serializer = new XmlSerializer(typeof({root}));
-string Structure(XElement e) => e.Name.ToString()+"["+(e.HasElements ? string.Concat(e.Elements().Select(Structure)) : e.Value)+"]";
+string Structure(XElement e) => e.Name.ToString()+"("+string.Join(",",e.Attributes().Where(a=>!a.IsNamespaceDeclaration).OrderBy(a=>a.Name.ToString()).Select(a=>a.Name+"="+a.Value))+")["+string.Concat(e.Nodes().Select(n=>n is XElement child ? Structure(child) : n is XText text ? text.Value : ""))+"]";
 foreach (var document in new [] {{ {documents} }}) {{
  var value = serializer.Deserialize(new StringReader(document))!;
  var writer = new StringWriter(); serializer.Serialize(writer, value);

{polyxml-0.34.4 → polyxml-0.34.5}/crates/polyxml-core/tests/test_go_codegen.rs

@@ -1449,3 +1449,32 @@ func TestIntegers(t *testing.T) {
         String::from_utf8_lossy(&result.stderr)
     );
 }
+
+#[test]
+fn imported_ordered_types_do_not_add_unused_bytes_import() {
+    let mut ir=XsdParser::new().parse_str(r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:complexType name="Foreign" mixed="true"><xs:sequence><xs:element name="child" type="xs:string"/></xs:sequence></xs:complexType><xs:complexType name="Local"><xs:attribute name="id" type="xs:string"/></xs:complexType></xs:schema>"#).unwrap();
+    for name in ir.types.keys() {
+        if name.local != "Local" {
+            ir.external_types.insert(name.clone(), "shared".into());
+        }
+    }
+    ir.content_models.clear();
+    let dir = tempdir().unwrap();
+    fs::write(dir.path().join("go.mod"), "module importcheck\n\ngo 1.22\n").unwrap();
+    fs::write(
+        dir.path().join("models.go"),
+        GoCodegen::new(GoOptions::default()).generate_module(&ir),
+    )
+    .unwrap();
+    let result = Command::new("go")
+        .args(["test", "./..."])
+        .current_dir(dir.path())
+        .output()
+        .unwrap();
+    assert!(
+        result.status.success(),
+        "{}{}",
+        String::from_utf8_lossy(&result.stdout),
+        String::from_utf8_lossy(&result.stderr)
+    );
+}

{polyxml-0.34.4 → polyxml-0.34.5}/crates/polyxml-core/tests/test_qualified_attributes.rs

@@ -168,3 +168,95 @@ var json=System.Text.Json.JsonSerializer.Serialize(value);if(!json.Contains("att
         );
     }
 }
+
+#[test]
+fn derived_validators_preserve_base_constraints() {
+    use polyxml::ir::{QName, RestrictionFacets, TypeDef};
+    let mut ir=XsdParser::new().parse_str(r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:complexType name="Base"><xs:attribute name="code" type="xs:string"/></xs:complexType><xs:complexType name="Derived"><xs:complexContent><xs:extension base="Base"><xs:attribute name="extra" type="xs:string"/></xs:extension></xs:complexContent></xs:complexType></xs:schema>"#).unwrap();
+    let TypeDef::Struct(base) = ir.types.get_mut(&QName::local("Base")).unwrap() else {
+        panic!()
+    };
+    base.fields[0].facets = Some(RestrictionFacets {
+        min_length: Some(3),
+        ..Default::default()
+    });
+    for use_records in [true, false] {
+        let temp = tempdir().unwrap();
+        fs::write(temp.path().join("App.csproj"),r#"<Project Sdk="Microsoft.NET.Sdk"><PropertyGroup><OutputType>Exe</OutputType><TargetFramework>net8.0</TargetFramework><ImplicitUsings>enable</ImplicitUsings><Nullable>enable</Nullable><WarningsAsErrors>CS0108;CS0109;CS0114</WarningsAsErrors></PropertyGroup></Project>"#).unwrap();
+        fs::write(
+            temp.path().join("Models.cs"),
+            CSharpCodegen::new(CSharpOptions {
+                namespace: "Models".into(),
+                use_records,
+                ..Default::default()
+            })
+            .generate_module(&ir),
+        )
+        .unwrap();
+        fs::write(temp.path().join("Program.cs"),r#"using Models;using System.ComponentModel.DataAnnotations;
+var value=new Derived {Code="x",Extra="leaf"};
+if(!value.Validate(new ValidationContext(value)).Any())throw new Exception("base constraint lost");
+if(!((Base)value).Validate(new ValidationContext(value)).Any())throw new Exception("base dispatch lost");
+var results=new List<ValidationResult>();if(Validator.TryValidateObject(value,new ValidationContext(value),results,true))throw new Exception("interface validation lost");
+var valid=new Derived {Code="valid",Extra="leaf"};if(valid.Validate(new ValidationContext(valid)).Any())throw new Exception("valid value rejected");
+"#).unwrap();
+        let output = Command::new("dotnet")
+            .args(["run", "--disable-build-servers"])
+            .current_dir(temp.path())
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "records={use_records}: {}{}",
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+}
+
+#[test]
+fn lexical_dependencies_compile_and_round_trip_without_implicit_imports() {
+    let ir=XsdParser::new().parse_str(r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+      <xs:simpleType name="Code"><xs:restriction base="xs:string"><xs:enumeration value="A"/><xs:enumeration value="B"/><xs:enumeration value="LONG"/></xs:restriction></xs:simpleType>
+      <xs:simpleType name="ShortCode"><xs:restriction base="Code"><xs:maxLength value="1"/></xs:restriction></xs:simpleType><xs:simpleType name="Inner"><xs:union memberTypes="Code xs:int"/></xs:simpleType>
+      <xs:simpleType name="Outer"><xs:union memberTypes="Inner xs:token xs:anyURI"/></xs:simpleType>
+      <xs:simpleType name="Numbers"><xs:list itemType="xs:int"/></xs:simpleType>
+      <xs:complexType name="Payload"><xs:sequence><xs:element name="Flag" type="xs:boolean" default="true"/><xs:element name="Count" type="xs:int" fixed="7"/><xs:element name="Huge" type="xs:integer"/><xs:element name="Values" type="Numbers"/><xs:element name="Reason" type="Outer"/></xs:sequence><xs:attribute name="mode" type="Code" use="required" fixed="A"/></xs:complexType>
+    </xs:schema>"#).unwrap();
+    for use_records in [true, false] {
+        let temp = tempdir().unwrap();
+        fs::write(temp.path().join("App.csproj"),r#"<Project Sdk="Microsoft.NET.Sdk"><PropertyGroup><OutputType>Exe</OutputType><TargetFramework>net8.0</TargetFramework><Nullable>enable</Nullable><TreatWarningsAsErrors>true</TreatWarningsAsErrors></PropertyGroup></Project>"#).unwrap();
+        fs::write(
+            temp.path().join("Models.cs"),
+            CSharpCodegen::new(CSharpOptions {
+                namespace: "Models".into(),
+                use_records,
+                ..Default::default()
+            })
+            .generate_module(&ir),
+        )
+        .unwrap();
+        fs::write(temp.path().join("Program.cs"),r#"using System;using System.IO;using System.Xml.Serialization;using System.Xml.Linq;using Models;using System.ComponentModel.DataAnnotations;
+var invalidCode=new ShortCode((Code)2);if(!invalidCode.Validate(new ValidationContext(invalidCode)).GetEnumerator().MoveNext())throw new Exception("enum lexical facet ignored");
+var validCode=new ShortCode(Code.A);if(validCode.Validate(new ValidationContext(validCode)).GetEnumerator().MoveNext())throw new Exception("valid enum rejected");
+foreach(var lexical in new[]{"A","42","fallback"}) {
+var serializer=new XmlSerializer(typeof(Payload));var value=(Payload)serializer.Deserialize(new StringReader("<Payload mode='A'><Flag/><Count>7</Count><Huge>123456789012345678901234567890</Huge><Values>1 2</Values><Reason>"+lexical+"</Reason></Payload>"))!;
+if(!value.Flag||value.Count!=7||value.Huge!="123456789012345678901234567890"||value.Values.Value.Count!=2||value.Values.Value[1]!=2||value.Reason.ToXmlString()!=lexical)throw new Exception("lexical input lost");
+var writer=new StringWriter();serializer.Serialize(writer,value);var root=XDocument.Parse(writer.ToString()).Root!;
+if(root.Attribute("mode")!.Value!="A"||root.Element("Flag")!.Value!="true"||root.Element("Count")!.Value!="7"||root.Element("Values")!.Value!="1 2"||root.Element("Reason")!.Value!=lexical)throw new Exception(writer.ToString());
+value.Huge=null!;try{serializer.Serialize(new StringWriter(),value);throw new Exception("missing required integer emitted");}catch(InvalidOperationException){}
+}
+"#).unwrap();
+        let output = Command::new("dotnet")
+            .args(["run", "--disable-build-servers"])
+            .current_dir(temp.path())
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "records={use_records}: {}{}",
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+}

{polyxml-0.34.4 → polyxml-0.34.5}/crates/polyxml-core/tests/test_rust_codegen.rs

@@ -1423,3 +1423,41 @@ fn main() {
         );
     }
 }
+
+#[test]
+fn empty_modules_compile_without_unused_reexports() {
+    let core = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
+    for split_units in [false, true] {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::create_dir_all(dir.path().join("src/models")).unwrap();
+        let ir = SchemaIR::new();
+        for (name, code) in RustCodegen::new(RustOptions {
+            split_units: Some(split_units),
+            ..Default::default()
+        })
+        .generate_files(&ir, "models")
+        {
+            std::fs::write(dir.path().join("src/models").join(name), code).unwrap();
+        }
+        std::fs::write(
+            dir.path().join("src/lib.rs"),
+            "#![deny(unused_imports)]\npub mod models;\n",
+        )
+        .unwrap();
+        std::fs::write(dir.path().join("Cargo.toml"),format!("[package]\nname=\"empty-module-test\"\nversion=\"0.0.0\"\nedition=\"2021\"\n[dependencies]\npolyxml={{path={core:?}}}\nquick-xml=\"0.42\"\nserde={{version=\"1\",features=[\"derive\"]}}\nserde_json=\"1\"\n")).unwrap();
+        let result = std::process::Command::new("cargo")
+            .args(["check", "--quiet", "--offline"])
+            .env(
+                "CARGO_TARGET_DIR",
+                core.join("../../target/binary-lexical-tests"),
+            )
+            .current_dir(dir.path())
+            .output()
+            .unwrap();
+        assert!(
+            result.status.success(),
+            "split={split_units}: {}",
+            String::from_utf8_lossy(&result.stderr)
+        );
+    }
+}

{polyxml-0.34.4 → polyxml-0.34.5}/pyproject.toml

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