Simplify ident and mangling handling.

Author: Dirbaio

java-spaghetti-gen/src/emit/classes.rs

@@ -9,7 +9,7 @@ use super::fields::Field;
 use super::known_docs_url::KnownDocsUrl;
 use super::methods::Method;
 use crate::emit::Context;
-use crate::identifiers::{FieldMangling, RustIdentifier};
+use crate::identifiers::{FieldMangling, rust_ident};
 use crate::parser_util::{Id, IdPart, JavaClass};
 
 #[derive(Debug, Default)]
@@ -33,18 +33,6 @@ pub(crate) struct Class {
     pub java: JavaClass,
 }
 
-fn rust_id(id: &str) -> Result<String, anyhow::Error> {
-    Ok(match RustIdentifier::from_str(id) {
-        RustIdentifier::Identifier(id) => id,
-        RustIdentifier::KeywordRawSafe(id) => id,
-        RustIdentifier::KeywordUnderscorePostfix(id) => id,
-        RustIdentifier::NonIdentifier(id) => io_data_err!(
-            "Unable to add_class(): java identifier {:?} has no rust equivalent (yet?)",
-            id
-        )?,
-    })
-}
-
 impl Class {
     pub(crate) fn mod_for(class: Id) -> Result<String, anyhow::Error> {
         let mut buf = String::new();
@@ -54,7 +42,7 @@ impl Class {
                     if !buf.is_empty() {
                         buf.push_str("::");
                     }
-                    buf.push_str(&rust_id(id)?);
+                    buf.push_str(&rust_ident(id)?);
                 }
                 IdPart::ContainingClass(_) => {}
                 IdPart::LeafClass(_) => {}
@@ -68,8 +56,8 @@ impl Class {
         for component in class.iter() {
             match component {
                 IdPart::Namespace(_) => {}
-                IdPart::ContainingClass(id) => write!(&mut buf, "{}_", rust_id(id)?)?,
-                IdPart::LeafClass(id) => write!(&mut buf, "{}", rust_id(id)?)?,
+                IdPart::ContainingClass(id) => write!(&mut buf, "{}_", rust_ident(id)?)?,
+                IdPart::LeafClass(id) => write!(&mut buf, "{}", rust_ident(id)?)?,
             }
         }
         Ok(buf)

java-spaghetti-gen/src/emit/fields.rs

@@ -8,13 +8,13 @@ use super::cstring;
 use super::known_docs_url::KnownDocsUrl;
 use crate::config::ClassConfig;
 use crate::emit::Context;
-use crate::identifiers::{FieldMangling, IdentifierManglingError, mangle_field};
+use crate::identifiers::{FieldMangling, mangle_field};
 use crate::parser_util::{Id, JavaClass, JavaField};
 
 pub struct Field<'a> {
     pub class: &'a JavaClass,
     pub java: JavaField<'a>,
-    pub rust_names: Result<FieldMangling<'a>, IdentifierManglingError>,
+    pub rust_names: Result<FieldMangling<'a>, anyhow::Error>,
 }
 
 impl<'a> Field<'a> {

…/src/identifiers/field_mangling_style.rs …ti-gen/src/identifiers/field_mangling.rsjava-spaghetti-gen/src/identifiers/field_mangling_style.rs renamed to java-spaghetti-gen/src/identifiers/field_mangling.rs java-spaghetti-gen/src/identifiers/field_mangling_style.rs renamed to java-spaghetti-gen/src/identifiers/field_mangling.rs

@@ -1,20 +1,20 @@
-use crate::identifiers::{IdentifierManglingError, javaify_identifier};
+use crate::identifiers::rust_ident;
 use crate::parser_util::JavaField;
 
 pub enum FieldMangling<'a> {
     ConstValue(String, cafebabe::constant_pool::LiteralConstant<'a>),
     GetSet(String, String),
 }
 
-pub fn mangle_field<'a>(field: JavaField<'a>) -> Result<FieldMangling<'a>, IdentifierManglingError> {
+pub fn mangle_field<'a>(field: JavaField<'a>) -> Result<FieldMangling<'a>, anyhow::Error> {
     let field_name = field.name();
     if let Some(value) = field.constant().as_ref() {
-        let name = javaify_identifier(field_name)?;
+        let name = rust_ident(field_name)?;
         Ok(FieldMangling::ConstValue(name, value.clone()))
     } else {
         Ok(FieldMangling::GetSet(
-            javaify_identifier(field_name)?,
-            javaify_identifier(&format!("set_{field_name}"))?,
+            rust_ident(field_name)?,
+            rust_ident(&format!("set_{field_name}"))?,
         ))
     }
 }

…src/identifiers/method_mangling_style.rs …i-gen/src/identifiers/method_mangling.rsjava-spaghetti-gen/src/identifiers/method_mangling_style.rs renamed to java-spaghetti-gen/src/identifiers/method_mangling.rs java-spaghetti-gen/src/identifiers/method_mangling_style.rs renamed to java-spaghetti-gen/src/identifiers/method_mangling.rs

@@ -1,7 +1,8 @@
+use anyhow::bail;
 use cafebabe::descriptors::{FieldType, MethodDescriptor};
 use serde_derive::Deserialize;
 
-use super::rust_identifier::{IdentifierManglingError, javaify_identifier};
+use super::rust_identifier::rust_ident;
 use crate::parser_util::{Id, IdPart};
 
 #[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, Hash)]
@@ -123,20 +124,20 @@ fn mangle_method_name_test() {
 }
 
 impl MethodManglingStyle {
-    pub fn mangle(&self, name: &str, descriptor: &MethodDescriptor) -> Result<String, IdentifierManglingError> {
+    pub fn mangle(&self, name: &str, descriptor: &MethodDescriptor) -> Result<String, anyhow::Error> {
         let name = match name {
             "" => {
-                return Err(IdentifierManglingError::EmptyString);
+                bail!("empty string")
             }
             "<init>" => "new",
             "<clinit>" => {
-                return Err(IdentifierManglingError::NotApplicable("Static type ctor"));
+                bail!("not applicable: Static type ctor")
             }
             name => name,
         };
 
         let long_sig = match self {
-            MethodManglingStyle::Java => return javaify_identifier(name),
+            MethodManglingStyle::Java => return rust_ident(name),
             MethodManglingStyle::JavaShortSignature => false,
             MethodManglingStyle::JavaLongSignature => true,
         };
@@ -189,6 +190,6 @@ impl MethodManglingStyle {
             }
         }
 
-        javaify_identifier(&buffer)
+        rust_ident(&buffer)
     }
 }

java-spaghetti-gen/src/identifiers/mod.rs

@@ -1,9 +1,9 @@
 //! JNI and Rust identifier parsing and categorizing utilities
 
-mod field_mangling_style;
-mod method_mangling_style;
+mod field_mangling;
+mod method_mangling;
 mod rust_identifier;
 
-pub use field_mangling_style::*;
-pub use method_mangling_style::*;
+pub use field_mangling::*;
+pub use method_mangling::*;
 pub use rust_identifier::*;