refactor(ast_tools): parse attributes more deeply

Author: overlookmotel

tasks/ast_tools/src/generators/mod.rs

@@ -1,6 +1,6 @@
 use crate::{
     output::Output,
-    parse::attr::{attr_positions, AttrLocation, AttrPart, AttrPositions},
+    parse::attr::{attr_positions, AttrLocation, AttrPart, AttrPartListElement, AttrPositions},
     Codegen, Result, Runner, Schema,
 };
 

tasks/ast_tools/src/generators/visit.rs

@@ -4,11 +4,10 @@ use cow_utils::CowUtils;
 use oxc_index::IndexVec;
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote, ToTokens};
-use syn::{parse_str, punctuated::Punctuated, token::Comma, Expr, Ident, Meta};
+use syn::{parse_str, Expr, Ident};
 
 use crate::{
     output::{output_path, Output},
-    parse::convert_expr_to_string,
     schema::{
         extensions::visit::Scope, Def, EnumDef, FieldDef, OptionDef, Schema, StructDef, TypeDef,
         TypeId, VecDef,
@@ -17,7 +16,9 @@ use crate::{
     Codegen, Generator, Result, AST_CRATE_PATH,
 };
 
-use super::{attr_positions, define_generator, AttrLocation, AttrPart, AttrPositions};
+use super::{
+    attr_positions, define_generator, AttrLocation, AttrPart, AttrPartListElement, AttrPositions,
+};
 
 /// Generator for `Visit` and `VisitMut` traits.
 pub struct VisitGenerator;
@@ -72,21 +73,14 @@ fn parse_visit_attr(location: AttrLocation, part: AttrPart) -> Result<()> {
             enum_def.visit.is_visited = true;
         }
         // `#[visit(args(flags = ...))]` on struct field or enum variant
-        (AttrPart::List("args", meta_list), location) => {
-            // Parse args as a list of `x = expr` parts
-            let metas = meta_list
-                .parse_args_with(Punctuated::<Meta, Comma>::parse_terminated)
-                .map_err(|_| ())?;
-            let mut args = vec![];
-            for meta in metas {
-                if let Meta::NameValue(name_value) = meta {
-                    let arg_name = name_value.path.get_ident().ok_or(())?.to_string();
-                    let arg_value = convert_expr_to_string(&name_value.value);
-                    args.push((arg_name, arg_value));
-                } else {
-                    return Err(());
-                }
-            }
+        (AttrPart::List("args", args), location) => {
+            let args = args
+                .into_iter()
+                .map(|list_element| match list_element {
+                    AttrPartListElement::String(name, value) => Ok((name, value)),
+                    _ => Err(()),
+                })
+                .collect::<Result<Vec<(String, String)>>>()?;
             if args.is_empty() {
                 return Err(());
             }

tasks/ast_tools/src/parse/attr.rs

@@ -1,7 +1,6 @@
 use std::fmt::{self, Display};
 
 use bitflags::bitflags;
-use syn::MetaList;
 
 use crate::{
     codegen::{DeriveId, GeneratorId},
@@ -146,5 +145,21 @@ pub enum AttrPart<'p> {
     String(&'p str, String),
     /// List part.
     /// e.g. `#[visit(args(flags = ScopeFlags::Function))]`.
-    List(&'p str, &'p MetaList),
+    List(&'p str, Vec<AttrPartListElement>),
+}
+
+/// An element of an [`AttrPart::List`].
+#[derive(Debug)]
+pub enum AttrPartListElement {
+    /// Named part.
+    /// e.g. `qux` in `#[foo(bar(qux))]`.
+    #[expect(dead_code)]
+    Tag(String),
+    /// String part.
+    /// e.g. `flags = ScopeFlags::Function` in `#[visit(args(flags = ScopeFlags::Function))]`.
+    String(String, String),
+    /// List part.
+    /// e.g. `qux(doof, bing = donk)` in `#[foo(bar(qux(doof, bing = donk)))]`.
+    #[expect(dead_code)]
+    List(String, Vec<AttrPartListElement>),
 }

tasks/ast_tools/src/parse/mod.rs

@@ -65,7 +65,6 @@ mod load;
 mod parse;
 mod skeleton;
 use load::load_file;
-pub use parse::convert_expr_to_string;
 use parse::parse;
 use skeleton::Skeleton;
 

tasks/ast_tools/src/parse/parse.rs

@@ -3,8 +3,8 @@ use quote::ToTokens;
 use rustc_hash::FxHashMap;
 use syn::{
     punctuated::Punctuated, token::Comma, AttrStyle, Attribute, Expr, ExprLit, Field, Fields,
-    GenericArgument, Generics, Ident, ItemEnum, ItemStruct, Lit, Meta, PathArguments, PathSegment,
-    Type, TypePath, TypeReference, Variant, Visibility as SynVisibility,
+    GenericArgument, Generics, Ident, ItemEnum, ItemStruct, Lit, Meta, MetaList, PathArguments,
+    PathSegment, Type, TypePath, TypeReference, Variant, Visibility as SynVisibility,
 };
 
 use crate::{
@@ -17,7 +17,7 @@ use crate::{
 };
 
 use super::{
-    attr::{AttrLocation, AttrPart, AttrPositions, AttrProcessor},
+    attr::{AttrLocation, AttrPart, AttrPartListElement, AttrPositions, AttrProcessor},
     ident_name,
     skeleton::{EnumSkeleton, Skeleton, StructSkeleton},
     Derives, FxIndexMap, FxIndexSet,
@@ -707,23 +707,24 @@ fn process_attr(
                             AttrPart::Tag(&part_name),
                         )?;
                     }
-                    Meta::List(meta_list) => {
-                        let part_name = meta_list.path.get_ident().ok_or(())?.to_string();
+                    Meta::NameValue(name_value) => {
+                        let part_name = name_value.path.get_ident().ok_or(())?.to_string();
+                        let str = convert_expr_to_string(&name_value.value);
                         process_attr_part(
                             processor,
                             attr_name,
                             location.unpack(),
-                            AttrPart::List(&part_name, meta_list),
+                            AttrPart::String(&part_name, str),
                         )?;
                     }
-                    Meta::NameValue(name_value) => {
-                        let part_name = name_value.path.get_ident().ok_or(())?.to_string();
-                        let str = convert_expr_to_string(&name_value.value);
+                    Meta::List(meta_list) => {
+                        let part_name = meta_list.path.get_ident().ok_or(())?.to_string();
+                        let list = parse_attr_part_list(meta_list)?;
                         process_attr_part(
                             processor,
                             attr_name,
                             location.unpack(),
-                            AttrPart::String(&part_name, str),
+                            AttrPart::List(&part_name, list),
                         )?;
                     }
                 };
@@ -734,12 +735,34 @@ fn process_attr(
     }
 }
 
+fn parse_attr_part_list(meta_list: &MetaList) -> Result<Vec<AttrPartListElement>> {
+    let metas =
+        meta_list.parse_args_with(Punctuated::<Meta, Comma>::parse_terminated).map_err(|_| ())?;
+    metas
+        .into_iter()
+        .map(|meta| match meta {
+            Meta::Path(path) => {
+                let part_name = path.get_ident().ok_or(())?.to_string();
+                Ok(AttrPartListElement::Tag(part_name))
+            }
+            Meta::NameValue(name_value) => {
+                let part_name = name_value.path.get_ident().ok_or(())?.to_string();
+                let str = convert_expr_to_string(&name_value.value);
+                Ok(AttrPartListElement::String(part_name, str))
+            }
+            Meta::List(meta_list) => {
+                let part_name = meta_list.path.get_ident().ok_or(())?.to_string();
+                let list = parse_attr_part_list(&meta_list)?;
+                Ok(AttrPartListElement::List(part_name, list))
+            }
+        })
+        .collect()
+}
+
 /// Convert an [`Expr`] to a string.
 ///
 /// If the `Expr` is a string literal, get the value of the string.
 /// Otherwise print the `Expr` as a string.
-///
-/// This function is also used in `Visit` generator.
 pub fn convert_expr_to_string(expr: &Expr) -> String {
     if let Expr::Lit(ExprLit { lit: Lit::Str(s), .. }) = expr {
         s.value()