Make macros accept idents where atom is a valid atom

This means that local_name!(html) will work as well
as local_name!("html")

Signed-off-by: Nico Burns <[email protected]>

Author: nicoburns

string-cache-codegen/lib.rs

@@ -68,6 +68,7 @@
 
 #![recursion_limit = "128"]
 
+use proc_macro2::{Ident, Literal, TokenStream};
 use quote::quote;
 use std::collections::BTreeSet;
 use std::fs::File;
@@ -185,8 +186,7 @@ impl AtomType {
     /// Write generated code to destination [`Vec<u8>`] and return it as [`String`]
     ///
     /// Used mostly for testing or displaying a value.
-    pub fn write_to_string(&mut self, mut destination: Vec<u8>) -> io::Result<String>
-    {
+    pub fn write_to_string(&mut self, mut destination: Vec<u8>) -> io::Result<String> {
         destination.write_all(
             self.to_tokens()
                 .to_string()
@@ -223,6 +223,27 @@ impl AtomType {
         let empty_string_index = atoms.iter().position(|s| s.is_empty()).unwrap() as u32;
         let indices = 0..atoms.len() as u32;
 
+        let atom_idents: Vec<Ident> = atoms
+            .iter()
+            .filter(|atom| {
+                atom.chars()
+                    .next()
+                    .is_some_and(|c| c.is_alphabetic() || c == '_')
+            })
+            .filter(|atom| atom.chars().all(|c| c.is_alphanumeric() || c == '_'))
+            .map(|atom| new_term(atom))
+            .collect();
+        let inline_str_idents: Vec<Ident> = inline_strs
+            .iter()
+            .filter(|atom| {
+                atom.chars()
+                    .next()
+                    .is_some_and(|c| c.is_alphabetic() || c == '_')
+            })
+            .filter(|s| s.chars().all(|c| c.is_alphanumeric() || c == '_'))
+            .map(|s| new_term(s))
+            .collect();
+
         let hashes: Vec<u32> = atoms
             .iter()
             .map(|string| {
@@ -249,8 +270,9 @@ impl AtomType {
             Some(ref doc) => quote!(#[doc = #doc]),
             None => quote!(),
         };
-        let new_term =
-            |string: &str| proc_macro2::Ident::new(string, proc_macro2::Span::call_site());
+        fn new_term(string: &str) -> Ident {
+            Ident::new(string, proc_macro2::Span::call_site())
+        }
         let static_set_name = new_term(&format!("{}StaticSet", type_name));
         let type_name = new_term(type_name);
         let macro_name = new_term(&*self.macro_name);
@@ -323,6 +345,12 @@ impl AtomType {
                 #(
                     (#inline_strs) => { #module::#inline_const_names };
                 )*
+                #(
+                    (#atom_idents) => { #module::#const_names };
+                )*
+                #(
+                    (#inline_str_idents) => { #module::#inline_const_names };
+                )*
             }
         }
     }
@@ -340,11 +368,13 @@ impl AtomType {
 fn test_iteration_order() {
     let x1 = crate::AtomType::new("foo::Atom", "foo_atom!")
         .atoms(&["x", "xlink", "svg", "test"])
-        .write_to_string(Vec::new()).expect("write to string cache x1");
+        .write_to_string(Vec::new())
+        .expect("write to string cache x1");
 
     let x2 = crate::AtomType::new("foo::Atom", "foo_atom!")
         .atoms(&["x", "xlink", "svg", "test"])
-        .write_to_string(Vec::new()).expect("write to string cache x2");
+        .write_to_string(Vec::new())
+        .expect("write to string cache x2");
 
     assert_eq!(x1, x2);
 }