refactor: Use Self wherever possible

This avoids having to move around the struct/enum name all over the
place.

lua_typed_macro/src/lib.rs

@@ -43,18 +43,16 @@ impl ToTokens for StructField {
 }
 
 struct Struct {
-    name: syn::Ident,
     fields: Vec<StructField>,
 }
 
 impl ToTokens for Struct {
     fn to_tokens(&self, tokens: &mut TokenStream2) {
-        let name = &self.name;
         let fields = &self.fields;
 
         tokens.extend(quote! {
             fn generate_header() -> Option<String> {
-                let type_name = <#name as Typed>::type_name();
+                let type_name = <Self as Typed>::type_name();
                 Some(format!("---@class {type_name}\nlocal {type_name}\n"))
             }
 
@@ -72,17 +70,10 @@ impl ToTokens for Struct {
 }
 
 impl Struct {
-    fn from_data(
-        data: DataStruct,
-        name: syn::Ident,
-        case: Option<convert_case::Case<'static>>,
-    ) -> syn::Result<Self> {
+    fn from_data(data: DataStruct, case: Option<convert_case::Case<'static>>) -> syn::Result<Self> {
         let fields = parse_fields(data.fields, case)?;
 
-        Ok(Self {
-            name: name.to_owned(),
-            fields,
-        })
+        Ok(Self { fields })
     }
 }
 
@@ -108,18 +99,16 @@ impl ToTokens for BasicEnumVariant {
 }
 
 struct BasicEnum {
-    name: syn::Ident,
     variants: Vec<BasicEnumVariant>,
 }
 
 impl ToTokens for BasicEnum {
     fn to_tokens(&self, tokens: &mut TokenStream2) {
-        let name = &self.name;
         let variants = &self.variants;
 
         tokens.extend(quote! {
             fn generate_header() -> Option<String> {
-                Some(format!("---@alias {}\n", <#name as Typed>::type_name()))
+                Some(format!("---@alias {}\n", <Self as Typed>::type_name()))
             }
 
             fn generate_members() -> Option<String> {
@@ -136,11 +125,7 @@ impl ToTokens for BasicEnum {
 }
 
 impl BasicEnum {
-    fn from_data(
-        data: DataEnum,
-        name: syn::Ident,
-        case: Option<convert_case::Case<'static>>,
-    ) -> syn::Result<Self> {
+    fn from_data(data: DataEnum, case: Option<convert_case::Case<'static>>) -> syn::Result<Self> {
         if let Some(err) = data
             .variants
             .iter()
@@ -160,7 +145,6 @@ impl BasicEnum {
         }
 
         Ok(Self {
-            name: name.to_owned(),
             variants: data
                 .variants
                 .into_iter()
@@ -202,14 +186,12 @@ impl From<ExtTaggedEnumVariant> for BasicEnumVariant {
 }
 
 struct ExtTaggedEnum {
-    name: syn::Ident,
     tag: LitStr,
     variants: Vec<ExtTaggedEnumVariant>,
 }
 
 impl ToTokens for ExtTaggedEnum {
     fn to_tokens(&self, tokens: &mut TokenStream2) {
-        let name = &self.name;
         let tag_variants: Vec<BasicEnumVariant> =
             self.variants.iter().cloned().map(Into::into).collect();
         let variants = &self.variants;
@@ -218,7 +200,7 @@ impl ToTokens for ExtTaggedEnum {
 
         tokens.extend(quote! {
             fn generate_header() -> Option<String> {
-                let type_name = <#name as Typed>::type_name();
+                let type_name = <Self as Typed>::type_name();
                 Some(format!("---@class {type_name}\nlocal {type_name}\n"))
             }
 
@@ -243,7 +225,6 @@ impl ToTokens for ExtTaggedEnum {
 impl ExtTaggedEnum {
     fn from_data(
         data: DataEnum,
-        name: syn::Ident,
         tag: LitStr,
         case: Option<convert_case::Case<'static>>,
     ) -> syn::Result<Self> {
@@ -281,11 +262,7 @@ impl ExtTaggedEnum {
             .map(|variant| variant.expect("Should only contain ok results"))
             .collect();
 
-        Ok(Self {
-            name: name.to_owned(),
-            tag,
-            variants,
-        })
+        Ok(Self { tag, variants })
     }
 }
 
@@ -422,15 +399,11 @@ fn typed_inner(ast: DeriveInput) -> syn::Result<TokenStream2> {
     };
 
     let test: TokenStream2 = match ast.data {
-        syn::Data::Struct(data_struct) => {
-            Struct::from_data(data_struct, name.clone(), case)?.into_token_stream()
-        }
+        syn::Data::Struct(data_struct) => Struct::from_data(data_struct, case)?.into_token_stream(),
         syn::Data::Enum(data_enum) if let Some(tag) = tag => {
-            ExtTaggedEnum::from_data(data_enum, name.clone(), tag, case)?.into_token_stream()
-        }
-        syn::Data::Enum(data_enum) => {
-            BasicEnum::from_data(data_enum, name.clone(), case)?.into_token_stream()
+            ExtTaggedEnum::from_data(data_enum, tag, case)?.into_token_stream()
         }
+        syn::Data::Enum(data_enum) => BasicEnum::from_data(data_enum, case)?.into_token_stream(),
         syn::Data::Union(data_union) => {
             return Err(syn::Error::new(
                 data_union.union_token.span,