polyxml 0.26.0__tar.gz → 0.28.0__tar.gz

{polyxml-0.26.0 → polyxml-0.28.0}/Cargo.lock

@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.26.0"
+version = "0.28.0"
 dependencies = [
  "criterion",
  "heck",
@@ -619,6 +619,7 @@ dependencies = [
  "phf_codegen",
  "pretty_assertions",
  "quick-xml",
+ "regex",
  "serde",
  "serde_json",
  "smallvec",
@@ -628,14 +629,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.26.0"
+version = "0.28.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.26.0"
+version = "0.28.0"
 dependencies = [
  "clap",
  "glob",
@@ -649,7 +650,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.26.0"
+version = "0.28.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -659,7 +660,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.26.0"
+version = "0.28.0"
 dependencies = [
  "lexical-core",
  "polyxml",
@@ -669,7 +670,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-wasm"
-version = "0.26.0"
+version = "0.28.0"
 dependencies = [
  "polyxml",
  "quick-xml",

{polyxml-0.26.0 → polyxml-0.28.0}/Cargo.toml

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

{polyxml-0.26.0 → polyxml-0.28.0}/PKG-INFO

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

{polyxml-0.26.0 → polyxml-0.28.0}/crates/polyxml-core/Cargo.toml

@@ -21,6 +21,7 @@ serde_json = "1.0"
 minijinja = { version = "2.8", features = ["builtins"] }
 heck = "0.5"
 phf_codegen = "0.14.0"
+regex = "1.11"
 
 [dev-dependencies]
 criterion = { version = "0.8", default-features = false, features = ["cargo_bench_support"] }

{polyxml-0.26.0 → polyxml-0.28.0}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -313,7 +313,7 @@ impl CSharpCodegen {
         // Emit Unions (Choices)
         for def in ir.types.values() {
             if let TypeDef::Union(u) = def {
-                self.emit_union(&mut out, u, indent);
+                self.emit_union(&mut out, u, ir, indent);
             }
         }
 
@@ -577,14 +577,14 @@ impl CSharpCodegen {
         }
     }
 
-    fn emit_union(&self, out: &mut String, u: &UnionDef, indent: &str) {
+    fn emit_union(&self, out: &mut String, u: &UnionDef, ir: &SchemaIR, indent: &str) {
         let choice_name = type_ident(&u.qname);
         if let Some(ref doc) = u.documentation {
             self.emit_docstring(out, doc, indent);
         }
 
-        // XmlInclude attributes for polymorphism
-        if self.options.emit_xml_attributes {
+        // XmlInclude attributes for element-choice polymorphism.
+        if self.options.emit_xml_attributes && !u.is_lexical() {
             for branch in &u.branches {
                 let variant_name = to_csharp_type_name(&branch.variant_name);
                 writeln!(
@@ -632,10 +632,10 @@ impl CSharpCodegen {
             }
 
             let mut branch_attrs = Vec::new();
-            if self.options.emit_xml_attributes {
+            if self.options.emit_xml_attributes && !u.is_lexical() {
                 branch_attrs.push(format!("XmlElement(\"{}\")", branch.xml_name));
             }
-            if self.options.emit_json_attributes {
+            if self.options.emit_json_attributes && !u.is_lexical() {
                 branch_attrs.push(format!("JsonPropertyName(\"{}\")", branch.xml_name));
             }
             let xml_attr = if branch_attrs.is_empty() {
@@ -679,9 +679,129 @@ impl CSharpCodegen {
             writeln!(out).unwrap();
         }
 
+        if u.is_lexical() {
+            self.emit_lexical_union_helpers(out, u, ir, indent);
+        }
         writeln!(out, "{}}}\n", indent).unwrap();
     }
 
+    fn emit_lexical_union_helpers(
+        &self,
+        out: &mut String,
+        u: &UnionDef,
+        ir: &SchemaIR,
+        indent: &str,
+    ) {
+        let name = type_ident(&u.qname);
+        let _ = writeln!(
+            out,
+            "{}    public static {} Parse(string text)",
+            indent, name
+        );
+        let _ = writeln!(out, "{}    {{", indent);
+        let _ = writeln!(out, "{}        var value = text.Trim();", indent);
+        for (idx, branch) in u.branches.iter().enumerate() {
+            let variant = to_csharp_type_name(&branch.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) {
+                    for item in &def.variants {
+                        let item_name = to_csharp_variant_name(&item.name);
+                        let _ = writeln!(
+                            out,
+                            "{}        if (value == {:?}) return new {}({}.{});",
+                            indent, item.value, variant, mapped, item_name
+                        );
+                    }
+                    continue;
+                }
+            }
+            let simple = match &branch.type_ref {
+                TypeRef::Named(qname) => ir.types.get(qname).and_then(|def| match def {
+                    TypeDef::Simple(s) => Some(s.as_ref()),
+                    _ => None,
+                }),
+                _ => None,
+            };
+            let base = super::primitive_base(&branch.type_ref, ir);
+            let base_name = self.context.map_type_ref(base);
+            let wrap = if simple.is_some() {
+                format!("new {}(candidate{})", mapped, idx)
+            } else {
+                format!("candidate{}", idx)
+            };
+            if base_name == "string" {
+                if let Some(simple) = simple.filter(|s| !s.facets.patterns.is_empty()) {
+                    let checks = simple
+                        .facets
+                        .patterns
+                        .iter()
+                        .map(|pattern| {
+                            format!("Regex.IsMatch(value, {:?})", format!(r"\A(?:{pattern})\z"))
+                        })
+                        .collect::<Vec<_>>()
+                        .join(" && ");
+                    let _ = writeln!(
+                        out,
+                        "{}        if ({}) {{ var candidate{} = value; return new {}({}); }}",
+                        indent, checks, idx, variant, wrap
+                    );
+                } else {
+                    let _ = writeln!(
+                        out,
+                        "{}        {{ var candidate{} = value; return new {}({}); }}",
+                        indent, idx, variant, wrap
+                    );
+                }
+            } else if base_name == "bool" {
+                let _ = writeln!(out, "{}        if (value == \"true\" || value == \"1\") {{ var candidate{} = true; return new {}({}); }}", indent, idx, variant, wrap);
+                let _ = writeln!(out, "{}        if (value == \"false\" || value == \"0\") {{ var candidate{} = false; return new {}({}); }}", indent, idx, variant, wrap);
+            } else if base_name == "DateOnly" {
+                let _ = writeln!(out, "{}        if (DateOnly.TryParseExact(value, \"yyyy-MM-dd\", System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None, out var candidate{})) return new {}({});", indent, idx, variant, wrap);
+            } else {
+                let _ = writeln!(
+                    out,
+                    "{}        if ({}.TryParse(value, out var candidate{})) return new {}({});",
+                    indent, base_name, idx, variant, wrap
+                );
+            }
+        }
+        let _ = writeln!(
+            out,
+            "{}        throw new FormatException(\"No {} union member accepts the value\");",
+            indent, name
+        );
+        let _ = writeln!(out, "{}    }}", indent);
+        let _ = writeln!(
+            out,
+            "{}    public string ToXmlString() => this switch",
+            indent
+        );
+        let _ = writeln!(out, "{}    {{", indent);
+        for branch in &u.branches {
+            let variant = to_csharp_type_name(&branch.variant_name);
+            let value = if matches!(
+                super::primitive_base(&branch.type_ref, ir),
+                TypeRef::Primitive(PrimitiveType::Date)
+            ) {
+                "item.Value.ToString(\"yyyy-MM-dd\", System.Globalization.CultureInfo.InvariantCulture)".to_string()
+            } else {
+                match &branch.type_ref {
+                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(),
+            }
+            };
+            let _ = writeln!(out, "{}        {} item => {},", indent, variant, value);
+        }
+        let _ = writeln!(
+            out,
+            "{}        _ => throw new InvalidOperationException()",
+            indent
+        );
+        let _ = writeln!(out, "{}    }};", indent);
+    }
+
     fn emit_struct(&self, out: &mut String, s: &StructDef, ir: &SchemaIR, indent: &str) {
         let struct_name = type_ident(&s.qname);
         if let Some(ref doc) = s.documentation {
@@ -732,6 +852,55 @@ impl CSharpCodegen {
             .map(|f| self.unique_property_name(&f.name, &mut seen_props, Some(&struct_name)))
             .collect();
 
+        let has_lexical_union = 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_lexical()))
+        });
+
+        if self.options.use_records && has_lexical_union {
+            writeln!(
+                out,
+                "{}public record {}{}\n{}{{",
+                indent, struct_name, implements_str, indent
+            )
+            .unwrap();
+            for (f, name) in s.fields.iter().zip(&prop_names) {
+                let ty = self.map_field_type(f, ir);
+                if let TypeRef::Named(q) = &f.type_ref {
+                    if matches!(ir.types.get(q), Some(TypeDef::Union(u)) if u.is_lexical()) {
+                        let _ = writeln!(out, "{}    [XmlIgnore]", indent);
+                        if self.options.emit_json_attributes {
+                            let _ =
+                                writeln!(out, "{}    [JsonPropertyName({:?})]", indent, f.xml_name);
+                        }
+                        let _ = writeln!(
+                            out,
+                            "{}    public {} {} {{ get; set; }} = default!;",
+                            indent, ty, name
+                        );
+                        let _ = writeln!(out, "{}    [XmlElement({:?})]", indent, f.xml_name);
+                        if self.options.emit_json_attributes {
+                            let _ = writeln!(out, "{}    [JsonIgnore]", indent);
+                        }
+                        let _ = writeln!(out, "{}    public string? {}Xml {{ get => {}?.ToXmlString(); set => {} = value is null ? default! : {}.Parse(value); }}", indent, name, name, name, type_ident(q));
+                        continue;
+                    }
+                }
+                let attrs = self
+                    .build_field_attributes(f, ir)
+                    .replace("[property: ", "[");
+                let _ = writeln!(
+                    out,
+                    "{}    {}public {} {} {{ get; set; }} = default!;",
+                    indent, attrs, ty, name
+                );
+            }
+            if self.options.emit_validation {
+                self.emit_struct_validator(out, s, &prop_names, indent);
+            }
+            writeln!(out, "{}}}\n", indent).unwrap();
+            return;
+        }
+
         if !self.options.use_records {
             writeln!(
                 out,
@@ -742,6 +911,28 @@ impl CSharpCodegen {
             writeln!(out, "{}    public {}() {{ }}", indent, struct_name).unwrap();
             for (f, name) in s.fields.iter().zip(&prop_names) {
                 let ty = self.map_field_type(f, ir);
+                if let TypeRef::Named(q) = &f.type_ref {
+                    if self.options.emit_xml_attributes
+                        && matches!(ir.types.get(q), Some(TypeDef::Union(u)) if u.is_lexical())
+                    {
+                        let _ = writeln!(out, "{}    [XmlIgnore]", indent);
+                        if self.options.emit_json_attributes {
+                            let _ =
+                                writeln!(out, "{}    [JsonPropertyName({:?})]", indent, f.xml_name);
+                        }
+                        let _ = writeln!(
+                            out,
+                            "{}    public {} {} {{ get; set; }} = default!;",
+                            indent, ty, name
+                        );
+                        let _ = writeln!(out, "{}    [XmlElement({:?})]", indent, f.xml_name);
+                        if self.options.emit_json_attributes {
+                            let _ = writeln!(out, "{}    [JsonIgnore]", indent);
+                        }
+                        let _ = writeln!(out, "{}    public string? {}Xml {{ get => {}?.ToXmlString(); set => {} = value is null ? default! : {}.Parse(value); }}", indent, name, name, name, type_ident(q));
+                        continue;
+                    }
+                }
                 let attrs = self
                     .build_field_attributes(f, ir)
                     .replace("[property: ", "[");

{polyxml-0.26.0 → polyxml-0.28.0}/crates/polyxml-core/src/codegen/go/mod.rs

@@ -255,15 +255,22 @@ impl GoCodegen {
         set_type_name_map(build_type_name_map(ir, to_go_type_name));
         let mut body = String::new();
         let mut has_time = false;
-        let has_patterns = self.options.validate_facets
-            && ir.types.values().any(|t| match t {
-                TypeDef::Simple(s) => !s.facets.patterns.is_empty(),
-                TypeDef::Struct(s) => s
-                    .fields
-                    .iter()
-                    .any(|f| f.facets.as_ref().is_some_and(|f| !f.patterns.is_empty())),
-                _ => false,
-            });
+        let lexical_patterns = ir.types.values().any(|def| match def {
+            TypeDef::Union(u) if u.is_lexical() => u.branches.iter().any(|branch| {
+                matches!(&branch.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Simple(s)) if !s.facets.patterns.is_empty()))
+            }),
+            _ => false,
+        });
+        let has_patterns = lexical_patterns
+            || (self.options.validate_facets
+                && ir.types.values().any(|t| match t {
+                    TypeDef::Simple(s) => !s.facets.patterns.is_empty(),
+                    TypeDef::Struct(s) => s
+                        .fields
+                        .iter()
+                        .any(|f| f.facets.as_ref().is_some_and(|f| !f.patterns.is_empty())),
+                    _ => false,
+                }));
         let mut has_fmt = has_patterns;
         let mut has_io = false;
         let mut has_xml = self.options.emit_xml_tags;
@@ -288,12 +295,22 @@ impl GoCodegen {
                         has_fmt = true;
                     }
                 }
-                TypeDef::Union(_) => {
-                    if self.options.validate_choice_exclusivity {
+                TypeDef::Union(u) => {
+                    if u.branches
+                        .iter()
+                        .any(|branch| self.references_time(&branch.type_ref))
+                    {
+                        has_time = true;
+                    }
+                    if self.options.validate_choice_exclusivity && !u.is_lexical() {
                         has_fmt = true;
                         has_io = true;
                         has_xml = true;
                     }
+                    if u.is_lexical() {
+                        has_fmt = true;
+                        has_xml = true;
+                    }
                 }
                 TypeDef::Simple(st) => {
                     if self.references_time(&st.base_type) {
@@ -344,6 +361,14 @@ impl GoCodegen {
         if has_patterns {
             imports.push("\"regexp\"");
         }
+        if ir
+            .types
+            .values()
+            .any(|def| matches!(def, TypeDef::Union(u) if u.is_lexical()))
+        {
+            imports.push("\"strconv\"");
+            imports.push("\"strings\"");
+        }
         if has_time {
             imports.push("\"time\"");
         }
@@ -399,7 +424,7 @@ impl GoCodegen {
         // Emit choices (unions)
         for type_def in ir.types.values() {
             if let TypeDef::Union(u) = type_def {
-                self.emit_union(out, u);
+                self.emit_union(out, u, ir);
             }
         }
 
@@ -509,7 +534,11 @@ impl GoCodegen {
         writeln!(out, "}}\n").unwrap();
     }
 
-    fn emit_union(&self, out: &mut String, u: &UnionDef) {
+    fn emit_union(&self, out: &mut String, u: &UnionDef, ir: &SchemaIR) {
+        if u.is_lexical() {
+            self.emit_lexical_union(out, u, ir);
+            return;
+        }
         let choice_name = type_ident(&u.qname);
         if let Some(ref doc) = u.documentation {
             for line in doc.lines() {
@@ -689,6 +718,153 @@ impl GoCodegen {
         }
     }
 
+    fn emit_lexical_union(&self, out: &mut String, u: &UnionDef, ir: &SchemaIR) {
+        let name = type_ident(&u.qname);
+        let mut seen = HashSet::new();
+        let fields = u
+            .branches
+            .iter()
+            .map(|b| self.unique_field_name(&b.variant_name, &mut seen))
+            .collect::<Vec<_>>();
+        let _ = writeln!(out, "type {} struct {{", name);
+        for (branch, field) in u.branches.iter().zip(&fields) {
+            let _ = writeln!(
+                out,
+                "    {} *{} `json:{:?}`",
+                field,
+                self.context.map_type_ref(&branch.type_ref),
+                format!("{},omitempty", field)
+            );
+        }
+        out.push_str("}\n\n");
+        let _ = writeln!(out, "func (c {}) Selected() string {{", name);
+        for field in &fields {
+            let _ = writeln!(out, "    if c.{} != nil {{ return {:?} }}", field, field);
+        }
+        out.push_str("    return \"\"\n}\n\n");
+        let _ = writeln!(
+            out,
+            "func (c *{}) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {{",
+            name
+        );
+        out.push_str("    var raw string\n    if err := d.DecodeElement(&raw, &start); err != nil { return err }\n    value := strings.TrimSpace(raw)\n    *c = ");
+        let _ = writeln!(out, "{}{{}}", name);
+        for (branch, field) in u.branches.iter().zip(&fields) {
+            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) {
+                    let comparisons = def
+                        .variants
+                        .iter()
+                        .map(|v| format!("value == {:?}", v.value))
+                        .collect::<Vec<_>>()
+                        .join(" || ");
+                    let _ = writeln!(
+                        out,
+                        "    if {} {{ v := {}(value); c.{} = &v; return nil }}",
+                        comparisons, mapped, field
+                    );
+                    continue;
+                }
+            }
+            let base = super::primitive_base(&branch.type_ref, ir);
+            let numeric = match base {
+                TypeRef::Primitive(
+                    PrimitiveType::Int
+                    | PrimitiveType::Integer
+                    | PrimitiveType::Long
+                    | PrimitiveType::Short
+                    | PrimitiveType::Byte,
+                ) => Some("signed"),
+                TypeRef::Primitive(
+                    PrimitiveType::UnsignedInt
+                    | PrimitiveType::UnsignedLong
+                    | PrimitiveType::UnsignedShort
+                    | PrimitiveType::UnsignedByte
+                    | PrimitiveType::PositiveInteger
+                    | PrimitiveType::NonNegativeInteger,
+                ) => Some("unsigned"),
+                TypeRef::Primitive(
+                    PrimitiveType::Float | PrimitiveType::Double | PrimitiveType::Decimal,
+                ) => Some("float"),
+                _ => None,
+            };
+            if matches!(base, TypeRef::Primitive(PrimitiveType::Date)) {
+                let _ = writeln!(out, "    if parsed, err := time.Parse(\"2006-01-02\", value); err == nil {{ v := {}(parsed); c.{} = &v; return nil }}", mapped, field);
+            } else if let Some(kind) = numeric {
+                let parse = match kind {
+                    "signed" => "strconv.ParseInt(value, 10, 64)",
+                    "unsigned" => "strconv.ParseUint(value, 10, 64)",
+                    _ => "strconv.ParseFloat(value, 64)",
+                };
+                let _ = writeln!(out, "    if parsed, err := {}; err == nil {{ v := {}(parsed); c.{} = &v; return nil }}", parse, mapped, field);
+            } else if matches!(base, TypeRef::Primitive(PrimitiveType::Boolean)) {
+                let _ = writeln!(out, "    if parsed, err := strconv.ParseBool(value); err == nil {{ v := {}(parsed); c.{} = &v; return nil }}", mapped, field);
+            } else {
+                let simple = match &branch.type_ref {
+                    TypeRef::Named(qname) => ir.types.get(qname).and_then(|def| match def {
+                        TypeDef::Simple(s) => Some(s.as_ref()),
+                        _ => None,
+                    }),
+                    _ => None,
+                };
+                if let Some(simple) = simple.filter(|s| !s.facets.patterns.is_empty()) {
+                    let checks = simple
+                        .facets
+                        .patterns
+                        .iter()
+                        .map(|pattern| {
+                            format!(
+                                "regexp.MustCompile({:?}).MatchString(value)",
+                                format!("^(?:{pattern})$")
+                            )
+                        })
+                        .collect::<Vec<_>>()
+                        .join(" && ");
+                    let _ = writeln!(
+                        out,
+                        "    if {} {{ v := {}(value); c.{} = &v; return nil }}",
+                        checks, mapped, field
+                    );
+                } else {
+                    let _ = writeln!(
+                        out,
+                        "    {{ v := {}(value); c.{} = &v; return nil }}",
+                        mapped, field
+                    );
+                }
+            }
+        }
+        let _ = writeln!(
+            out,
+            "    return fmt.Errorf(\"invalid lexical value for {}: %q\", value)",
+            name
+        );
+        out.push_str("}\n\n");
+        let _ = writeln!(
+            out,
+            "func (c {}) MarshalXML(e *xml.Encoder, start xml.StartElement) error {{",
+            name
+        );
+        out.push_str("    count := 0\n    var value string\n");
+        for (branch, field) in u.branches.iter().zip(&fields) {
+            let expr = if matches!(
+                super::primitive_base(&branch.type_ref, ir),
+                TypeRef::Primitive(PrimitiveType::Date)
+            ) {
+                format!("c.{}.Format(\"2006-01-02\")", field)
+            } else {
+                format!("fmt.Sprint(*c.{})", field)
+            };
+            let _ = writeln!(
+                out,
+                "    if c.{} != nil {{ count++; value = {} }}",
+                field, expr
+            );
+        }
+        out.push_str("    if count != 1 { return fmt.Errorf(\"lexical union requires exactly one member\") }\n    return e.EncodeElement(value, start)\n}\n\n");
+    }
+
     fn emit_struct(&self, out: &mut String, s: &StructDef, ir: &SchemaIR) {
         let struct_name = type_ident(&s.qname);
         if let Some(ref doc) = s.documentation {

{polyxml-0.26.0 → polyxml-0.28.0}/crates/polyxml-core/src/codegen/java/codec.rs

@@ -40,10 +40,9 @@ impl JavaCodegen {
                         check_type(&f.type_ref, ir)?;
                         if matches!(f.kind, FieldKind::Attribute | FieldKind::Text) {
                             if let TypeRef::Named(q) = &f.type_ref {
-                                if matches!(
-                                    ir.types.get(q),
-                                    Some(TypeDef::Struct(_) | TypeDef::Union(_))
-                                ) {
+                                if matches!(ir.types.get(q), Some(TypeDef::Struct(_)))
+                                    || matches!(ir.types.get(q), Some(TypeDef::Union(u)) if !u.is_lexical())
+                                {
                                     return Err(format!(
                                         "non-scalar XML text/attribute {}.{}",
                                         name, f.name
@@ -176,13 +175,23 @@ impl JavaCodegen {
                 );
             }
             TypeDef::Union(u) => {
-                let _=writeln!(out,"            {name} result = null;\n            while (reader.hasNext()) {{\n                int event = reader.next();\n                if (event == XMLStreamConstants.END_ELEMENT) return result;\n                if (event != XMLStreamConstants.START_ELEMENT) continue;");
-                for (i, b) in u.branches.iter().enumerate() {
-                    let expr = self.read_value(&b.type_ref, ir);
-                    let variant = to_java_type_name(&b.variant_name);
-                    let _=writeln!(out,"                {}if (reader.getLocalName().equals({:?})) result = new {name}.{variant}({expr});",if i==0 {""}else{"else "},b.xml_name);
+                if u.is_lexical() {
+                    out.push_str("            String text = reader.getElementText();\n");
+                    for b in &u.branches {
+                        let expr = self.parse_scalar(&b.type_ref, "text", ir);
+                        let variant = to_java_type_name(&b.variant_name);
+                        let _ = writeln!(out, "            try {{ return new {name}.{variant}({expr}); }} catch (RuntimeException ignored) {{ }}");
+                    }
+                    let _ = writeln!(out, "            throw new XMLStreamException(\"No {} union member accepts: \" + text);", name);
+                } else {
+                    let _=writeln!(out,"            {name} result = null;\n            while (reader.hasNext()) {{\n                int event = reader.next();\n                if (event == XMLStreamConstants.END_ELEMENT) return result;\n                if (event != XMLStreamConstants.START_ELEMENT) continue;");
+                    for (i, b) in u.branches.iter().enumerate() {
+                        let expr = self.read_value(&b.type_ref, ir);
+                        let variant = to_java_type_name(&b.variant_name);
+                        let _=writeln!(out,"                {}if (reader.getLocalName().equals({:?})) result = new {name}.{variant}({expr});",if i==0 {""}else{"else "},b.xml_name);
+                    }
+                    out.push_str("                else skip(reader);\n            }\n            return result;\n");
                 }
-                out.push_str("                else skip(reader);\n            }\n            return result;\n");
             }
         }
         out.push_str("        } catch (IllegalArgumentException | java.time.DateTimeException ex) { throw new XMLStreamException(\"Invalid XML value\", reader.getLocation(), ex); }\n    }\n");
@@ -230,15 +239,20 @@ impl JavaCodegen {
                     } else {
                         "branch.getValue()"
                     };
-                    self.emit_write_value(
-                        &mut out,
-                        &b.type_ref,
-                        access,
-                        &b.xml_name,
-                        u.qname.namespace.as_deref().unwrap_or(""),
-                        ir,
-                        "            ",
-                    );
+                    if u.is_lexical() {
+                        let text = self.format_scalar(&b.type_ref, access, ir);
+                        let _ = writeln!(out, "            writer.writeCharacters({text});");
+                    } else {
+                        self.emit_write_value(
+                            &mut out,
+                            &b.type_ref,
+                            access,
+                            &b.xml_name,
+                            u.qname.namespace.as_deref().unwrap_or(""),
+                            ir,
+                            "            ",
+                        );
+                    }
                     out.push_str("        }\n");
                 }
             }