Similar simpleTypes cause compilation error

[Qix-]

Working with an external XSD right now, and it has these simpleTypes defined:

  <xs:simpleType name="String..1">
    <xs:restriction base="xs:string">
      <xs:maxLength value="1"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="String1">
    <xs:restriction base="xs:string">
      <xs:length value="1"/>
    </xs:restriction>
  </xs:simpleType>

Looks like xsd-parser is stripping out non-alphanumeric characters here and arriving at String1 for each one, causing a compilation error:

3 | ... } pub type String1Type = :: std :: string :: String ; pub type String20Type = :: std :: string :: String ; pub type String3Type = :: std :: string :: String ; pub type String35Type = :: std :: string :: String ; pub type String6Type = :: std :: string :: String ; pub type String60Type = :: std :: string :: String ; pub type String1Type = :: std :: string :: String ; pu...
  |       --------------------------------------------------- previous definition of the type `String1Type` here                                                                                                                                                                                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `String1Type` redefined here

Is there a way to augment how it generates these? Even if it's ugly, we're treating these generated bindings more like a -sys crate that we'll build higher level abstractions over, I just need it to actually be correct/compilable.

[Qix-]

Even with a custom with_naming there's no apparent way to get access to the original name:

	fn format_type_ident(&self, name: &xsd_parser::Name, display_name: Option<&str>) -> xsd_parser::Ident2 {
		eprintln!("Formatting type ident: {:?} (display name: {:?})", name, display_name);
		self.0.format_type_ident(name, display_name)
	}

  Formatting type ident: Generated("String1Type") (display name: None)
  Formatting type ident: Generated("String20Type") (display name: None)
  Formatting type ident: Generated("String3Type") (display name: None)
  Formatting type ident: Generated("String35Type") (display name: None)
  Formatting type ident: Generated("String6Type") (display name: None)
  Formatting type ident: Generated("String60Type") (display name: None)
  Formatting type ident: Generated("String1Type") (display name: None)

[Bergmann89]

Hey @Qix-,

checkout the Naming::unify method. This is the method that gets passed the original name and generates a unified version of it to be able to compare it to each other. The default implementation uses PascalCase here. If you return the passed string as is, the name passed to format_type_ident should be also the original one.

[Qix-]

Having a heck of a time with this, unfortunately. Here's the naming implementation I'm using. I'm getting two errors:

1. The naming still doesn't seem to result in unique names; still getting error[E0428]: the name 'String1Type' is defined multiple times
2. Built-in keywords are not being emitted as raw identifiers; with this I'm getting errors such as error: expected identifier, found keyword 'type'

#[derive(Debug)]
struct MessyNaming(Naming);

impl xsd_parser::traits::Naming for MessyNaming {
	fn clone_boxed(&self) -> Box<dyn xsd_parser::traits::Naming> {
		Box::new(MessyNaming(self.0.clone()))
	}

	fn builder(&self) -> Box<dyn xsd_parser::traits::NameBuilder> {
		self.0.builder()
	}

	fn unify(&self, s: &str) -> String {
		let mut ns = s.chars().map(|c| if c.is_alphanumeric() { c } else { '_' })
			.fold(String::new(), |mut acc, c| {
				if c != '_' || !acc.ends_with('_') {
					acc.push(c);
				}
				acc
			});

		if ns.chars().next().map_or(false, char::is_numeric) {
			ns.insert(0, '_');
		}

		ns
	}

	fn make_type_name(&self, postfixes: &[String], ty: &xsd_parser::config::MetaType, ident: &xsd_parser::TypeIdent) -> xsd_parser::Name {
        if let MetaTypeVariant::Reference(ti) = &ty.variant {
            if ident.name.is_generated() && ti.type_.name.is_named() {
                let s = self.format_type_name(ti.type_.name.as_str());

                if ti.max_occurs > MaxOccurs::Bounded(1) {
                    return Name::new_generated(format!("{s}List"));
                } else if ti.min_occurs == 0 {
                    return Name::new_generated(format!("{s}Opt"));
                }
            }
        }

        let postfix = postfixes
            .get(ident.type_ as usize)
            .map_or("", |s| s.as_str());

        let s = self.format_type_name(ident.name.as_str());

        if s.ends_with(postfix) {
            ident.name.clone()
        } else {
            Name::new_generated(format!("{s}{postfix}"))
        }
	}

	fn make_unknown_variant(&self, id: usize) -> xsd_parser::Ident2 {
		self.0.make_unknown_variant(id)
	}

	fn format_module_name(&self, s: &str) -> String {
		self.unify(s)
	}

	fn format_type_ident(&self, name: &xsd_parser::Name, display_name: Option<&str>) -> xsd_parser::Ident2 {
		self.0.format_type_ident(name, display_name)
	}

	fn format_type_name(&self, s: &str) -> String {
		self.unify(s)
	}

	fn format_field_name(&self, s: &str) -> String {
		self.unify(s)
	}

	fn format_variant_name(&self, s: &str) -> String {
		self.unify(s)
	}

	fn format_constant_name(&self, s: &str) -> String {
		self.unify(s)
	}
}

Any advice would be appreciated!

[Bergmann89]

Hey @Qix-,

I've added a working example in #260. Feel free to have a look. The main problem in you code above is, that you create the builder using the default naming instance. The builder itself gets the naming instance passed, to use it's unify method, so it still uses the default unify in your case.

[Qix-]

Thank you @Bergmann89 - looks like that worked :) I appreciate the help!