polyxml 0.20.0__tar.gz → 0.20.1__tar.gz

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

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

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

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

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

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

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

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

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

@@ -8,9 +8,11 @@ use std::fmt::Write as FmtWrite;
 use heck::{AsLowerCamelCase, AsPascalCase};
 use serde::{Deserialize, Serialize};
 
-use crate::codegen::{sanitize_keyword, LanguageContext};
+use crate::codegen::{
+    build_type_name_map, lookup_type_name, sanitize_keyword, set_type_name_map, LanguageContext,
+};
 use crate::ir::{
-    EnumDef, FieldDef, FieldKind, PrimitiveType, RestrictionFacets, SchemaIR, SimpleTypeDef,
+    EnumDef, FieldDef, FieldKind, PrimitiveType, QName, RestrictionFacets, SchemaIR, SimpleTypeDef,
     StructDef, TypeDef, TypeRef, UnionDef,
 };
 
@@ -218,7 +220,7 @@ impl LanguageContext for CSharpLanguageContext {
     fn map_type_ref(&self, type_ref: &TypeRef) -> String {
         match type_ref {
             TypeRef::Primitive(prim) => self.map_primitive(*prim).to_string(),
-            TypeRef::Named(qname) => to_csharp_type_name(&qname.local),
+            TypeRef::Named(qname) => type_ident(qname),
             TypeRef::Boxed(inner) => self.map_type_ref(inner),
             TypeRef::List(inner) => format!("List<{}>", self.map_type_ref(inner)),
         }
@@ -231,6 +233,12 @@ pub struct CSharpCodegen {
     context: CSharpLanguageContext,
 }
 
+/// Emitted C# identifier for a named type, disambiguated across namespaces
+/// for the IR currently being generated (issue #51 item 3).
+fn type_ident(q: &QName) -> String {
+    lookup_type_name(q, || to_csharp_type_name(&q.local))
+}
+
 impl CSharpCodegen {
     /// Creates a new C# code generator with the given configuration options.
     pub fn new(options: CSharpOptions) -> Self {
@@ -242,6 +250,7 @@ impl CSharpCodegen {
 
     /// Emits all types in the given SchemaIR as a single C# compilation unit.
     pub fn generate_module(&self, ir: &SchemaIR) -> String {
+        set_type_name_map(build_type_name_map(ir, to_csharp_type_name));
         let mut out = String::new();
 
         if let Some(ref header) = self.options.custom_header {
@@ -350,7 +359,7 @@ impl CSharpCodegen {
         // Enums
         for def in ir.types.values() {
             if let TypeDef::Enum(e) = def {
-                let name = to_csharp_type_name(&e.qname.local);
+                let name = type_ident(&e.qname);
                 writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
             }
         }
@@ -358,7 +367,7 @@ impl CSharpCodegen {
         // Simple types
         for def in ir.types.values() {
             if let TypeDef::Simple(s) = def {
-                let name = to_csharp_type_name(&s.qname.local);
+                let name = type_ident(&s.qname);
                 writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
             }
         }
@@ -366,7 +375,7 @@ impl CSharpCodegen {
         // Unions
         for def in ir.types.values() {
             if let TypeDef::Union(u) = def {
-                let name = to_csharp_type_name(&u.qname.local);
+                let name = type_ident(&u.qname);
                 writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
             }
         }
@@ -374,7 +383,7 @@ impl CSharpCodegen {
         // Structs
         for def in ir.types.values() {
             if let TypeDef::Struct(s) = def {
-                let name = to_csharp_type_name(&s.qname.local);
+                let name = type_ident(&s.qname);
                 writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
                 writeln!(out, "{}[JsonSerializable(typeof(List<{}>))]", indent, name).unwrap();
             }
@@ -399,7 +408,7 @@ impl CSharpCodegen {
     }
 
     fn emit_enum(&self, out: &mut String, e: &EnumDef, indent: &str) {
-        let enum_name = to_csharp_type_name(&e.qname.local);
+        let enum_name = type_ident(&e.qname);
         if let Some(ref doc) = e.documentation {
             self.emit_docstring(out, doc, indent);
         }
@@ -482,7 +491,7 @@ impl CSharpCodegen {
 
     fn emit_simple(&self, out: &mut String, s: &SimpleTypeDef, indent: &str) {
         if !s.facets.is_empty() || !self.options.use_records {
-            let type_name = to_csharp_type_name(&s.qname.local);
+            let type_name = type_ident(&s.qname);
             let base_type = self.context.map_type_ref(&s.base_type);
 
             if let Some(ref doc) = s.documentation {
@@ -557,7 +566,7 @@ impl CSharpCodegen {
     }
 
     fn emit_union(&self, out: &mut String, u: &UnionDef, indent: &str) {
-        let choice_name = to_csharp_type_name(&u.qname.local);
+        let choice_name = type_ident(&u.qname);
         if let Some(ref doc) = u.documentation {
             self.emit_docstring(out, doc, indent);
         }
@@ -662,7 +671,7 @@ impl CSharpCodegen {
     }
 
     fn emit_struct(&self, out: &mut String, s: &StructDef, ir: &SchemaIR, indent: &str) {
-        let struct_name = to_csharp_type_name(&s.qname.local);
+        let struct_name = type_ident(&s.qname);
         if let Some(ref doc) = s.documentation {
             self.emit_docstring(out, doc, indent);
         }
@@ -690,7 +699,7 @@ impl CSharpCodegen {
         let mut base_clause = Vec::new();
         if let Some(ref base_qname) = s.base_type {
             if matches!(ir.types.get(base_qname), Some(TypeDef::Struct(_))) {
-                let base_name = to_csharp_type_name(&base_qname.local);
+                let base_name = type_ident(base_qname);
                 base_clause.push(base_name);
             }
         }
@@ -816,7 +825,7 @@ impl CSharpCodegen {
     }
 
     fn emit_struct_validator(&self, out: &mut String, s: &StructDef, indent: &str) {
-        let struct_name = to_csharp_type_name(&s.qname.local);
+        let struct_name = type_ident(&s.qname);
         let new_kw = if !self.options.use_records {
             if s.base_type.is_some() {
                 "override "
@@ -940,9 +949,9 @@ impl CSharpCodegen {
             TypeRef::Primitive(p) => self.context.map_primitive(*p).to_string(),
             TypeRef::Named(qn) => {
                 if let Some(TypeDef::Union(u)) = ir.types.get(qn) {
-                    to_csharp_type_name(&u.qname.local)
+                    type_ident(&u.qname)
                 } else {
-                    to_csharp_type_name(&qn.local)
+                    type_ident(qn)
                 }
             }
             TypeRef::Boxed(inner) => self.context.map_type_ref(inner),
@@ -969,7 +978,7 @@ impl CSharpCodegen {
             // If the field is a choice (UnionDef), emit XmlElement("branchXml", typeof(BranchType))
             if let TypeRef::Named(ref qname) = f.type_ref {
                 if let Some(TypeDef::Union(u)) = ir.types.get(qname) {
-                    let choice_name = to_csharp_type_name(&u.qname.local);
+                    let choice_name = type_ident(&u.qname);
                     for branch in &u.branches {
                         let variant_name = to_csharp_type_name(&branch.variant_name);
                         parts.push(format!(

{polyxml-0.20.0 → polyxml-0.20.1}/crates/polyxml-core/src/codegen/go/mod.rs

@@ -3,9 +3,11 @@ use std::fmt::Write as FmtWrite;
 use heck::{AsPascalCase, AsSnakeCase};
 use serde::{Deserialize, Serialize};
 
-use crate::codegen::{sanitize_keyword, LanguageContext};
+use crate::codegen::{
+    build_type_name_map, lookup_type_name, sanitize_keyword, set_type_name_map, LanguageContext,
+};
 use crate::ir::{
-    EnumDef, FieldDef, FieldKind, PrimitiveType, RestrictionFacets, SchemaIR, SimpleTypeDef,
+    EnumDef, FieldDef, FieldKind, PrimitiveType, QName, RestrictionFacets, SchemaIR, SimpleTypeDef,
     StructDef, TypeDef, TypeRef, UnionDef,
 };
 
@@ -124,7 +126,7 @@ impl LanguageContext for GoLanguageContext {
     fn map_type_ref(&self, type_ref: &TypeRef) -> String {
         match type_ref {
             TypeRef::Primitive(prim) => self.map_primitive(*prim).to_string(),
-            TypeRef::Named(qname) => to_go_type_name(&qname.local),
+            TypeRef::Named(qname) => type_ident(qname),
             TypeRef::Boxed(inner) => format!("*{}", self.map_type_ref(inner)),
             TypeRef::List(inner) => format!("[]{}", self.map_type_ref(inner)),
         }
@@ -231,6 +233,12 @@ pub struct GoCodegen {
     context: GoLanguageContext,
 }
 
+/// Emitted Go identifier for a named type, disambiguated across namespaces
+/// for the IR currently being generated (issue #51 item 3).
+fn type_ident(q: &QName) -> String {
+    lookup_type_name(q, || to_go_type_name(&q.local))
+}
+
 impl GoCodegen {
     pub fn new(options: GoOptions) -> Self {
         Self {
@@ -241,6 +249,7 @@ impl GoCodegen {
 
     /// Generate complete Go module content.
     pub fn generate_module(&self, ir: &SchemaIR) -> String {
+        set_type_name_map(build_type_name_map(ir, to_go_type_name));
         let mut body = String::new();
         let mut has_time = false;
         let mut has_fmt = false;
@@ -394,13 +403,13 @@ impl GoCodegen {
             }
         }
 
-        let type_name = to_go_type_name(&simple.qname.local);
+        let type_name = type_ident(&simple.qname);
         let base_type = self.context.map_type_ref(&simple.base_type);
         writeln!(out, "type {} {}\n", type_name, base_type).unwrap();
     }
 
     fn emit_enum(&self, out: &mut String, enum_def: &EnumDef) {
-        let enum_name = to_go_type_name(&enum_def.qname.local);
+        let enum_name = type_ident(&enum_def.qname);
         if let Some(ref doc) = enum_def.documentation {
             for line in doc.lines() {
                 writeln!(out, "// {}", line).unwrap();
@@ -441,7 +450,7 @@ impl GoCodegen {
     }
 
     fn emit_union(&self, out: &mut String, u: &UnionDef) {
-        let choice_name = to_go_type_name(&u.qname.local);
+        let choice_name = type_ident(&u.qname);
         if let Some(ref doc) = u.documentation {
             for line in doc.lines() {
                 writeln!(out, "// {}", line).unwrap();
@@ -587,7 +596,7 @@ impl GoCodegen {
     }
 
     fn emit_struct(&self, out: &mut String, s: &StructDef, ir: &SchemaIR) {
-        let struct_name = to_go_type_name(&s.qname.local);
+        let struct_name = type_ident(&s.qname);
         if let Some(ref doc) = s.documentation {
             for line in doc.lines() {
                 writeln!(out, "// {}", line).unwrap();
@@ -620,12 +629,12 @@ impl GoCodegen {
         let mut simple_content_base: Option<String> = None;
         if let Some(ref base_qname) = s.base_type {
             if matches!(ir.types.get(base_qname), Some(TypeDef::Struct(_))) {
-                let base_name = to_go_type_name(&base_qname.local);
+                let base_name = type_ident(base_qname);
                 writeln!(out, "    {}", base_name).unwrap();
             } else if let Some(prim) = PrimitiveType::from_xsd_name(&base_qname.local) {
                 simple_content_base = Some(self.context.map_primitive(prim).to_string());
             } else if let Some(TypeDef::Simple(st)) = ir.types.get(base_qname) {
-                simple_content_base = Some(to_go_type_name(&st.qname.local));
+                simple_content_base = Some(type_ident(&st.qname));
             }
         }
 
@@ -744,7 +753,7 @@ impl GoCodegen {
     }
 
     fn emit_struct_validator(&self, out: &mut String, s: &StructDef) {
-        let struct_name = to_go_type_name(&s.qname.local);
+        let struct_name = type_ident(&s.qname);
         writeln!(out, "func (s {}) Validate() error {{", struct_name).unwrap();
 
         let mut has_checks = false;

{polyxml-0.20.0 → polyxml-0.20.1}/crates/polyxml-core/src/codegen/java/codec.rs

@@ -20,13 +20,9 @@ impl JavaCodegen {
                 _ => Ok(()),
             }
         }
-        let names: HashSet<_> = ir
-            .types
-            .values()
-            .map(|d| to_java_type_name(&d.qname().local))
-            .collect();
+        let names: HashSet<_> = ir.types.values().map(|d| type_ident(d.qname())).collect();
         for def in ir.types.values() {
-            let name = to_java_type_name(&def.qname().local);
+            let name = type_ident(def.qname());
             if names.contains(&format!("{name}Codec")) {
                 return Err(format!(
                     "direct codec name {name}Codec collides with a schema type"
@@ -70,7 +66,7 @@ impl JavaCodegen {
     }
 
     pub(super) fn generate_codec(&self, def: &TypeDef, ir: &SchemaIR) -> String {
-        let name = to_java_type_name(&def.qname().local);
+        let name = type_ident(def.qname());
         let mut out = String::new();
         self.emit_file_header(&mut out);
         out.push_str("import javax.xml.stream.*;\nimport java.io.*;\n\n");
@@ -224,7 +220,7 @@ impl JavaCodegen {
     }
 
     fn emit_read_struct(&self, out: &mut String, s: &StructDef, ir: &SchemaIR) {
-        let name = to_java_type_name(&s.qname.local);
+        let name = type_ident(&s.qname);
         if s.is_abstract && !self.options.use_records {
             out.push_str("            throw new XMLStreamException(\"Cannot instantiate abstract XML type without a concrete codec\");\n");
             return;
@@ -400,7 +396,7 @@ impl JavaCodegen {
                 self.emit_write_value(out, inner, value, local, ns, ir, indent)
             }
             TypeRef::Named(q) => {
-                let name = to_java_type_name(&q.local);
+                let name = type_ident(q);
                 let _ = writeln!(
                     out,
                     "{indent}{name}Codec.writeXml({value}, writer, {local:?}, {ns:?});"
@@ -415,7 +411,7 @@ impl JavaCodegen {
 
     fn read_value(&self, ty: &TypeRef, ir: &SchemaIR) -> String {
         match ty {
-            TypeRef::Named(q) => format!("{}Codec.readXml(reader)", to_java_type_name(&q.local)),
+            TypeRef::Named(q) => format!("{}Codec.readXml(reader)", type_ident(q)),
             TypeRef::Boxed(t) => self.read_value(t, ir),
             _ => self.parse_scalar(ty, "reader.getElementText()", ir),
         }
@@ -431,11 +427,11 @@ impl JavaCodegen {
             }
             TypeRef::Named(q) => match ir.types.get(q) {
                 Some(TypeDef::Enum(_)) => {
-                    format!("{}.fromValue({raw})", to_java_type_name(&q.local))
+                    format!("{}.fromValue({raw})", type_ident(q))
                 }
                 Some(TypeDef::Simple(s)) => format!(
                     "new {}({})",
-                    to_java_type_name(&q.local),
+                    type_ident(q),
                     self.parse_scalar(&s.base_type, raw, ir)
                 ),
                 _ => "null".into(),

{polyxml-0.20.0 → polyxml-0.20.1}/crates/polyxml-core/src/codegen/java/mod.rs

@@ -7,9 +7,11 @@ use std::fmt::Write as FmtWrite;
 use heck::{AsLowerCamelCase, AsPascalCase, AsShoutySnakeCase};
 use serde::{Deserialize, Serialize};
 
-use crate::codegen::{sanitize_keyword, LanguageContext};
+use crate::codegen::{
+    build_type_name_map, lookup_type_name, sanitize_keyword, set_type_name_map, LanguageContext,
+};
 use crate::ir::{
-    EnumDef, PrimitiveType, RestrictionFacets, SchemaIR, SimpleTypeDef, StructDef, TypeDef,
+    EnumDef, PrimitiveType, QName, RestrictionFacets, SchemaIR, SimpleTypeDef, StructDef, TypeDef,
     TypeRef, UnionDef,
 };
 
@@ -134,7 +136,7 @@ impl LanguageContext for JavaLanguageContext {
     fn map_type_ref(&self, type_ref: &TypeRef) -> String {
         match type_ref {
             TypeRef::Primitive(prim) => self.map_primitive(*prim).to_string(),
-            TypeRef::Named(qname) => to_java_type_name(&qname.local),
+            TypeRef::Named(qname) => type_ident(qname),
             TypeRef::Boxed(inner) | TypeRef::List(inner) => {
                 let inner_str = self.boxed_type(inner);
                 if matches!(type_ref, TypeRef::List(_)) {
@@ -172,7 +174,7 @@ impl JavaLanguageContext {
                 PrimitiveType::Base64Binary | PrimitiveType::HexBinary => "byte[]".to_string(),
                 _ => self.map_primitive(*prim).to_string(),
             },
-            TypeRef::Named(qname) => to_java_type_name(&qname.local),
+            TypeRef::Named(qname) => type_ident(qname),
             TypeRef::Boxed(inner) => self.boxed_type(inner),
             TypeRef::List(inner) => format!("java.util.List<{}>", self.boxed_type(inner)),
         }
@@ -205,6 +207,12 @@ pub fn to_java_type_name(name: &str) -> String {
     sanitize_keyword(&sanitized, "java")
 }
 
+/// Emitted Java identifier for a named type, disambiguated across
+/// namespaces for the IR currently being generated (issue #51 item 3).
+pub(super) fn type_ident(q: &QName) -> String {
+    lookup_type_name(q, || to_java_type_name(&q.local))
+}
+
 /// Convert an XML enumeration variant name to SCREAMING_SNAKE_CASE for Java enum constants.
 pub fn to_java_enum_constant(name: &str) -> String {
     let raw = AsShoutySnakeCase(name).to_string();
@@ -234,6 +242,7 @@ impl JavaCodegen {
 
     /// Generate individual compilation units (`{TypeName}.java`), one for each schema type.
     pub fn generate_files(&self, ir: &SchemaIR) -> Vec<(String, String)> {
+        set_type_name_map(build_type_name_map(ir, to_java_type_name));
         let mut files = Vec::new();
 
         for type_def in ir.types.values() {
@@ -253,6 +262,7 @@ impl JavaCodegen {
 
     /// Generate a single outer class (`{outer_class_name}.java`) enclosing all types as static members.
     pub fn generate_module(&self, ir: &SchemaIR, outer_class_name: &str) -> String {
+        set_type_name_map(build_type_name_map(ir, to_java_type_name));
         let mut out = String::new();
 
         self.emit_file_header(&mut out);
@@ -368,22 +378,22 @@ impl JavaCodegen {
         let mut out = String::new();
         let type_name = match type_def {
             TypeDef::Struct(s) => {
-                let name = to_java_type_name(&s.qname.local);
+                let name = type_ident(&s.qname);
                 self.emit_struct(&mut out, s, &name, indent, ir);
                 name
             }
             TypeDef::Enum(e) => {
-                let name = to_java_type_name(&e.qname.local);
+                let name = type_ident(&e.qname);
                 self.emit_enum(&mut out, e, &name, indent);
                 name
             }
             TypeDef::Union(u) => {
-                let name = to_java_type_name(&u.qname.local);
+                let name = type_ident(&u.qname);
                 self.emit_union(&mut out, u, &name, indent);
                 name
             }
             TypeDef::Simple(s) => {
-                let name = to_java_type_name(&s.qname.local);
+                let name = type_ident(&s.qname);
                 self.emit_simple(&mut out, s, &name, indent);
                 name
             }

{polyxml-0.20.0 → polyxml-0.20.1}/crates/polyxml-core/src/codegen/java/models.rs

@@ -160,7 +160,7 @@ impl JavaCodegen {
             .as_ref()
             .filter(|q| matches!(ir.types.get(q), Some(TypeDef::Struct(_))));
         let extends = base
-            .map(|q| format!(" extends {}", to_java_type_name(&q.local)))
+            .map(|q| format!(" extends {}", type_ident(q)))
             .unwrap_or_default();
         let nested = if indent.is_empty() { "" } else { "static " };
         let abstract_kw = if s.is_abstract { "abstract " } else { "" };
@@ -258,7 +258,7 @@ impl JavaCodegen {
         };
         let extends = base
             .map(|q| {
-                let n = to_java_type_name(&q.local);
+                let n = type_ident(q);
                 format!(" extends {n}.{n}Builder")
             })
             .unwrap_or_default();