fix(macro): identifier-related bugs #536

Author: kakserpom

crates/macros/src/class.rs

@@ -5,7 +5,7 @@ use quote::{TokenStreamExt, quote};
 use syn::{Attribute, Expr, Fields, ItemStruct};
 
 use crate::helpers::get_docs;
-use crate::parsing::{PhpRename, RenameRule};
+use crate::parsing::{PhpNameContext, PhpRename, RenameRule, ident_to_php_name, validate_php_name};
 use crate::prelude::*;
 
 #[derive(FromAttributes, Debug, Default)]
@@ -44,7 +44,10 @@ impl ToTokens for ClassEntryAttribute {
 pub fn parser(mut input: ItemStruct) -> Result<TokenStream> {
     let attr = StructAttributes::from_attributes(&input.attrs)?;
     let ident = &input.ident;
-    let name = attr.rename.rename(ident.to_string(), RenameRule::Pascal);
+    let name = attr
+        .rename
+        .rename(ident_to_php_name(ident), RenameRule::Pascal);
+    validate_php_name(&name, PhpNameContext::Class, ident.span())?;
     let docs = get_docs(&attr.attrs)?;
     input.attrs.retain(|attr| !attr.path().is_ident("php"));
 
@@ -94,7 +97,17 @@ fn parse_fields<'a>(fields: impl Iterator<Item = &'a mut syn::Field>) -> Result<
             let docs = get_docs(&attr.attrs)?;
             field.attrs.retain(|attr| !attr.path().is_ident("php"));
 
-            result.push(Property { ident, attr, docs });
+            let name = attr
+                .rename
+                .rename(ident_to_php_name(ident), RenameRule::Camel);
+            validate_php_name(&name, PhpNameContext::Property, ident.span())?;
+
+            result.push(Property {
+                ident,
+                name,
+                attr,
+                docs,
+            });
         }
     }
 
@@ -104,18 +117,11 @@ fn parse_fields<'a>(fields: impl Iterator<Item = &'a mut syn::Field>) -> Result<
 #[derive(Debug)]
 struct Property<'a> {
     pub ident: &'a syn::Ident,
+    pub name: String,
     pub attr: PropAttributes,
     pub docs: Vec<String>,
 }
 
-impl Property<'_> {
-    pub fn name(&self) -> String {
-        self.attr
-            .rename
-            .rename(self.ident.to_string(), RenameRule::Camel)
-    }
-}
-
 /// Generates an implementation of `RegisteredClass` for struct `ident`.
 #[allow(clippy::too_many_arguments)]
 fn generate_registered_class_impl(
@@ -131,7 +137,7 @@ fn generate_registered_class_impl(
     let modifier = modifier.option_tokens();
 
     let fields = fields.iter().map(|prop| {
-        let name = prop.name();
+        let name = &prop.name;
         let ident = prop.ident;
         let flags = prop
             .attr

crates/macros/src/constant.rs

@@ -4,7 +4,7 @@ use quote::{format_ident, quote};
 use syn::ItemConst;
 
 use crate::helpers::get_docs;
-use crate::parsing::{PhpRename, RenameRule};
+use crate::parsing::{PhpNameContext, PhpRename, RenameRule, ident_to_php_name, validate_php_name};
 use crate::prelude::*;
 
 const INTERNAL_CONST_DOC_PREFIX: &str = "_internal_const_docs_";
@@ -25,7 +25,8 @@ pub fn parser(mut item: ItemConst) -> Result<TokenStream> {
 
     let name = attr
         .rename
-        .rename(item.ident.to_string(), RenameRule::ScreamingSnake);
+        .rename(ident_to_php_name(&item.ident), RenameRule::ScreamingSnake);
+    validate_php_name(&name, PhpNameContext::Constant, item.ident.span())?;
     let name_ident = format_ident!("{INTERNAL_CONST_NAME_PREFIX}{}", item.ident);
 
     let docs = get_docs(&attr.attrs)?;

crates/macros/src/enum_.rs

@@ -8,7 +8,9 @@ use syn::{Fields, Ident, ItemEnum, Lit};
 
 use crate::{
     helpers::get_docs,
-    parsing::{PhpRename, RenameRule, Visibility},
+    parsing::{
+        PhpNameContext, PhpRename, RenameRule, Visibility, ident_to_php_name, validate_php_name,
+    },
     prelude::*,
 };
 
@@ -81,12 +83,15 @@ pub fn parser(mut input: ItemEnum) -> Result<TokenStream> {
             bail!(variant => "Discriminant must be specified for all enum cases, found: {:?}", variant);
         }
 
+        let case_name = variant_attr.rename.rename(
+            ident_to_php_name(&variant.ident),
+            php_attr.rename_cases.unwrap_or(RenameRule::Pascal),
+        );
+        validate_php_name(&case_name, PhpNameContext::EnumCase, variant.ident.span())?;
+
         cases.push(EnumCase {
             ident: variant.ident.clone(),
-            name: variant_attr.rename.rename(
-                variant.ident.to_string(),
-                php_attr.rename_cases.unwrap_or(RenameRule::Pascal),
-            ),
+            name: case_name,
             attrs: variant_attr,
             discriminant,
             docs,
@@ -108,7 +113,7 @@ pub fn parser(mut input: ItemEnum) -> Result<TokenStream> {
         cases,
         None, // TODO: Implement flags support
         discriminant_type,
-    );
+    )?;
 
     Ok(quote! {
         #[allow(dead_code)]
@@ -136,17 +141,20 @@ impl<'a> Enum<'a> {
         cases: Vec<EnumCase>,
         flags: Option<String>,
         discriminant_type: DiscriminantType,
-    ) -> Self {
-        let name = attrs.rename.rename(ident.to_string(), RenameRule::Pascal);
+    ) -> Result<Self> {
+        let name = attrs
+            .rename
+            .rename(ident_to_php_name(ident), RenameRule::Pascal);
+        validate_php_name(&name, PhpNameContext::Enum, ident.span())?;
 
-        Self {
+        Ok(Self {
             ident,
             name,
             discriminant_type,
             docs,
             cases,
             flags,
-        }
+        })
     }
 
     fn registered_class(&self) -> TokenStream {

crates/macros/src/extern_.rs

@@ -5,6 +5,7 @@ use syn::{
     spanned::Spanned as _, token::Unsafe,
 };
 
+use crate::parsing::ident_to_php_name;
 use crate::prelude::*;
 
 pub fn parser(input: ItemForeignMod) -> Result<TokenStream> {
@@ -27,7 +28,7 @@ fn parse_function(mut func: ForeignItemFn) -> Result<TokenStream> {
 
     let Signature { ident, .. } = &sig;
 
-    let name = ident.to_string();
+    let name = ident_to_php_name(ident);
     let params = sig
         .inputs
         .iter()

crates/macros/src/function.rs

@@ -7,7 +7,9 @@ use syn::spanned::Spanned as _;
 use syn::{Expr, FnArg, GenericArgument, ItemFn, PatType, PathArguments, Type, TypePath};
 
 use crate::helpers::get_docs;
-use crate::parsing::{PhpRename, RenameRule, Visibility};
+use crate::parsing::{
+    PhpNameContext, PhpRename, RenameRule, Visibility, ident_to_php_name, validate_php_name,
+};
 use crate::prelude::*;
 use crate::syn_ext::DropLifetimes;
 
@@ -44,15 +46,11 @@ pub fn parser(mut input: ItemFn) -> Result<TokenStream> {
 
     let docs = get_docs(&php_attr.attrs)?;
 
-    let func = Function::new(
-        &input.sig,
-        php_attr
-            .rename
-            .rename(input.sig.ident.to_string(), RenameRule::Snake),
-        args,
-        php_attr.optional,
-        docs,
-    );
+    let func_name = php_attr
+        .rename
+        .rename(ident_to_php_name(&input.sig.ident), RenameRule::Snake);
+    validate_php_name(&func_name, PhpNameContext::Function, input.sig.ident.span())?;
+    let func = Function::new(&input.sig, func_name, args, php_attr.optional, docs);
     let function_impl = func.php_function_impl();
 
     Ok(quote! {
@@ -625,7 +623,7 @@ impl TypedArg<'_> {
     /// Returns a token stream containing the `Arg` definition to be passed to
     /// `ext-php-rs`.
     fn arg_builder(&self) -> TokenStream {
-        let name = self.name.to_string();
+        let name = ident_to_php_name(self.name);
         let ty = self.clean_ty();
         let null = if self.nullable {
             Some(quote! { .allow_null() })

crates/macros/src/impl_.rs

@@ -8,7 +8,9 @@ use syn::{Expr, Ident, ItemImpl};
 use crate::constant::PhpConstAttribute;
 use crate::function::{Args, CallType, Function, MethodReceiver};
 use crate::helpers::get_docs;
-use crate::parsing::{PhpRename, RenameRule, Visibility};
+use crate::parsing::{
+    PhpNameContext, PhpRename, RenameRule, Visibility, ident_to_php_name, validate_php_name,
+};
 use crate::prelude::*;
 
 /// Method types.
@@ -187,7 +189,8 @@ impl<'a> ParsedImpl<'a> {
                     let attr = PhpConstAttribute::from_attributes(&c.attrs)?;
                     let name = attr
                         .rename
-                        .rename(c.ident.to_string(), self.change_constant_case);
+                        .rename(ident_to_php_name(&c.ident), self.change_constant_case);
+                    validate_php_name(&name, PhpNameContext::Constant, c.ident.span())?;
                     let docs = get_docs(&attr.attrs)?;
                     c.attrs.retain(|attr| !attr.path().is_ident("php"));
 
@@ -199,9 +202,11 @@ impl<'a> ParsedImpl<'a> {
                 }
                 syn::ImplItem::Fn(method) => {
                     let attr = PhpFunctionImplAttribute::from_attributes(&method.attrs)?;
-                    let name = attr
-                        .rename
-                        .rename_method(method.sig.ident.to_string(), self.change_method_case);
+                    let name = attr.rename.rename_method(
+                        ident_to_php_name(&method.sig.ident),
+                        self.change_method_case,
+                    );
+                    validate_php_name(&name, PhpNameContext::Method, method.sig.ident.span())?;
                     let docs = get_docs(&attr.attrs)?;
                     method.attrs.retain(|attr| !attr.path().is_ident("php"));
 

crates/macros/src/interface.rs

@@ -11,7 +11,9 @@ use quote::{ToTokens, format_ident, quote};
 use syn::{Expr, Ident, ItemTrait, Path, TraitItem, TraitItemConst, TraitItemFn};
 
 use crate::impl_::{FnBuilder, MethodModifier};
-use crate::parsing::{PhpRename, RenameRule, Visibility};
+use crate::parsing::{
+    PhpNameContext, PhpRename, RenameRule, Visibility, ident_to_php_name, validate_php_name,
+};
 use crate::prelude::*;
 
 const INTERNAL_INTERFACE_NAME_PREFIX: &str = "PhpInterface";
@@ -196,7 +198,10 @@ impl<'a> Parse<'a, InterfaceData<'a>> for ItemTrait {
     fn parse(&'a mut self) -> Result<InterfaceData<'a>> {
         let attrs = TraitAttributes::from_attributes(&self.attrs)?;
         let ident = &self.ident;
-        let name = attrs.rename.rename(ident.to_string(), RenameRule::Pascal);
+        let name = attrs
+            .rename
+            .rename(ident_to_php_name(ident), RenameRule::Pascal);
+        validate_php_name(&name, PhpNameContext::Interface, ident.span())?;
         let docs = get_docs(&attrs.attrs)?;
         self.attrs.clean_php();
         let interface_name = format_ident!("{INTERNAL_INTERFACE_NAME_PREFIX}{ident}");
@@ -277,16 +282,16 @@ fn parse_trait_item_fn(
         modifiers.insert(MethodModifier::Static);
     }
 
-    let f = Function::new(
-        &fn_item.sig,
-        php_attr.rename.rename(
-            fn_item.sig.ident.to_string(),
-            change_case.unwrap_or(RenameRule::Camel),
-        ),
-        args,
-        php_attr.optional,
-        docs,
+    let method_name = php_attr.rename.rename(
+        ident_to_php_name(&fn_item.sig.ident),
+        change_case.unwrap_or(RenameRule::Camel),
     );
+    validate_php_name(
+        &method_name,
+        PhpNameContext::Method,
+        fn_item.sig.ident.span(),
+    )?;
+    let f = Function::new(&fn_item.sig, method_name, args, php_attr.optional, docs);
 
     if php_attr.constructor.is_present() {
         Ok(MethodKind::Constructor(f))
@@ -336,9 +341,10 @@ fn parse_trait_item_const(
 
     let attr = PhpConstAttribute::from_attributes(&const_item.attrs)?;
     let name = attr.rename.rename(
-        const_item.ident.to_string(),
+        ident_to_php_name(&const_item.ident),
         change_case.unwrap_or(RenameRule::ScreamingSnake),
     );
+    validate_php_name(&name, PhpNameContext::Constant, const_item.ident.span())?;
     let docs = get_docs(&attr.attrs)?;
     const_item.attrs.clean_php();