Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

59.8 KB
Raw Blame
use syn::spanned::Spanned;
use syn::{Error, Expr, ExprLit, Field, Lit, LitInt, LitStr, Path, Token};

pub(crate) type ReceiverAttr = Path;

#[derive(Clone)]
pub(crate) enum ObjectRole {
    Instance(Path),
    Plain,
    Fragment,
}

impl ObjectRole {
    pub(crate) fn interface(&self) -> Option<&Path> {
        match self {
            Self::Instance(interface) => Some(interface),
            Self::Plain | Self::Fragment => None,
        }
    }
}

fn resolve_interface_receiver(
    receiver: &mut Option<ReceiverAttr>,
    interface: Option<&Path>,
    shorthand: Option<proc_macro2::Span>,
) -> Result<(), Error> {
    if let Some(span) = shorthand {
        if receiver.is_some() {
            return Err(Error::new(span, "receiver can only be specified once"));
        }
        let interface = interface.ok_or_else(|| {
            Error::new(span, "receiver shorthand requires an interface descriptor")
        })?;
        *receiver = Some(syn::parse_quote!(#interface::is_instance));
    }
    Ok(())
}

#[derive(Clone)]
pub(crate) enum ConstructorAttr {
    Illegal,
    Callback(Path),
}

#[derive(Clone)]
pub(crate) enum ValueInitAttr {
    Null,
    Object,
    NullObject,
    Array,
    Undefined,
    True,
    False,
    Zero,
    EmptyString,
    String(LitStr),
}

#[derive(Clone)]
pub(crate) enum ConstructorDefaultAttr {
    Default,
    Expr(Box<Expr>),
}

#[derive(Clone, Copy, Default)]
pub(crate) enum RenameRule {
    None,
    #[default]
    CamelCase,
}

#[derive(Default)]
pub(crate) struct ObjectAttrs {
    pub(crate) receiver: Option<ReceiverAttr>,
    pub(crate) receiver_access_check: bool,
    pub(crate) role: Option<ObjectRole>,
    pub(crate) prototype: Option<Expr>,
    pub(crate) own_to_string_tag: Option<Expr>,
    pub(crate) fallback_to_string_tag: Option<Expr>,
    pub(crate) readonly_to_string_tag: bool,
    pub(crate) scope_lifetime: Option<syn::Lifetime>,
    pub(crate) require_prototype: bool,
    pub(crate) rename_all: RenameRule,
    pub(crate) default_data_properties: bool,
    pub(crate) default_enumerable: bool,
    pub(crate) no_dynamic_constructor: bool,
}

#[derive(Default)]
pub(crate) struct FunctionTemplateAttrs {
    pub(crate) interface: Option<Path>,
    pub(crate) receiver: Option<ReceiverAttr>,
    pub(crate) receiver_access_check: bool,
    pub(crate) name: Option<LitStr>,
    pub(crate) constructor: Option<ConstructorAttr>,
    pub(crate) constructor_length: Option<i32>,
    pub(crate) intrinsic_prototype_parent: Option<Expr>,
    pub(crate) prototype_to_string_tag: Option<LitStr>,
    pub(crate) readonly_prototype: bool,
    pub(crate) rename_all: RenameRule,
    pub(crate) default_enumerable: bool,
}

/// A field has exactly one installation role. Alias and intrinsic payloads
/// belong to that role instead of being optional flags alongside other kinds.
#[derive(Clone, Default)]
pub(crate) enum FieldKind {
    #[default]
    Input,
    Method,
    StaticMethod,
    Constant,
    AccessorProperty,
    NativeDataProperty,
    IntrinsicDataProperty(Box<Expr>),
    DataProperty,
    Alias(LitStr),
    Hidden,
    Slot,
    Prototype,
    ToStringTag,
}

#[derive(Clone, Copy, Default, PartialEq)]
pub(crate) enum ReceiverAccessCheck {
    #[default]
    None,
    All,
    Getter,
    Setter,
}

impl ReceiverAccessCheck {
    fn parse(value: Expr) -> Result<Self, Error> {
        let policy = match &value {
            Expr::Lit(ExprLit {
                lit: Lit::Bool(value),
                ..
            }) => Some(if value.value { Self::All } else { Self::None }),
            Expr::Lit(ExprLit {
                lit: Lit::Str(value),
                ..
            }) => match value.value().as_str() {
                "getter" => Some(Self::Getter),
                "setter" => Some(Self::Setter),
                _ => None,
            },
            _ => None,
        };
        policy.ok_or_else(|| {
            Error::new_spanned(
                value,
                "receiver_access_check expects true, false, \"getter\", or \"setter\"",
            )
        })
    }

    pub(crate) fn checks_getter(self) -> bool {
        matches!(self, Self::All | Self::Getter)
    }

    pub(crate) fn checks_setter(self) -> bool {
        matches!(self, Self::All | Self::Setter)
    }
}

#[derive(Clone, Copy, Default)]
pub(crate) struct FieldDefaults<'a> {
    pub(crate) receiver: Option<&'a ReceiverAttr>,
    pub(crate) receiver_access_check: bool,
    pub(crate) data_properties: bool,
    pub(crate) enumerable: bool,
}

#[derive(Clone, Default)]
pub(crate) struct FieldAttrs {
    pub(crate) receiver: Option<ReceiverAttr>,
    pub(crate) receiver_access_check: Option<ReceiverAccessCheck>,
    pub(crate) returns_promise: bool,
    pub(crate) kind: FieldKind,
    pub(crate) enumerable: bool,
    pub(crate) readonly: bool,
    pub(crate) dont_delete: bool,
    pub(crate) name: Option<Expr>,
    pub(crate) symbol: Option<LitStr>,
    pub(crate) function_name: Option<LitStr>,
    pub(crate) length: Option<i32>,
    pub(crate) callback: Option<Path>,
    pub(crate) getter: Option<Path>,
    pub(crate) getter_value: Option<Expr>,
    pub(crate) setter: Option<Path>,
    pub(crate) data: Option<Expr>,
    pub(crate) setter_data: Option<Expr>,
    pub(crate) value: Option<Expr>,
    pub(crate) init: Option<ValueInitAttr>,
    pub(crate) constructor_default: Option<ConstructorDefaultAttr>,
}

impl FieldAttrs {
    pub(crate) fn inherit_receiver(
        &mut self,
        receiver: Option<&ReceiverAttr>,
    ) -> Result<(), Error> {
        if matches!(self.kind, FieldKind::Method | FieldKind::AccessorProperty) {
            self.receiver = self.receiver.take().or_else(|| receiver.cloned());
        }
        if (self.receiver.is_some() || self.returns_promise)
            && let Some(getter_value) = &self.getter_value
        {
            return Err(Error::new(
                getter_value.span(),
                "receiver and returns_promise require a Rust callback, not getter_value",
            ));
        }
        Ok(())
    }

    pub(crate) fn has_installation_kind(&self) -> bool {
        !matches!(self.kind, FieldKind::Input)
    }

    fn set_kind(&mut self, kind: FieldKind, span: proc_macro2::Span) -> Result<(), Error> {
        if self.has_installation_kind() {
            // Repeating a flag remains harmless; payload-bearing kinds must
            // appear once so later attributes cannot silently replace values.
            if std::mem::discriminant(&self.kind) != std::mem::discriminant(&kind) {
                return Err(Error::new(
                    span,
                    "field can only declare one installation kind",
                ));
            }
            match kind {
                FieldKind::Alias(_) => {
                    return Err(Error::new(span, "field alias can only be specified once"));
                }
                FieldKind::IntrinsicDataProperty(_) => {
                    return Err(Error::new(
                        span,
                        "field intrinsic_data_property can only be specified once",
                    ));
                }
                _ => {}
            }
        }
        self.kind = kind;
        Ok(())
    }

    pub(crate) fn has_installation_attribute(&self) -> bool {
        self.receiver.is_some()
            || self.receiver_access_check.is_some()
            || self.returns_promise
            || self.enumerable
            || self.readonly
            || self.dont_delete
            || matches!(self.kind, FieldKind::Alias(_))
            || self.name.is_some()
            || self.symbol.is_some()
            || self.function_name.is_some()
            || self.length.is_some()
            || self.callback.is_some()
            || self.getter.is_some()
            || self.getter_value.is_some()
            || self.setter.is_some()
            || self.data.is_some()
            || self.setter_data.is_some()
            || self.value.is_some()
            || self.init.is_some()
    }
}

pub(crate) fn parse_object_attrs(attrs: &[syn::Attribute]) -> Result<ObjectAttrs, Error> {
    let mut parsed = ObjectAttrs::default();
    let mut interface_receiver = None;
    for attr in attrs.iter().filter(|attr| attr.path().is_ident("webapi")) {
        attr.parse_nested_meta(|meta| {
            if meta.path.is_ident("receiver_access_check") {
                parsed.receiver_access_check = true;
                return Ok(());
            }
            if meta.path.is_ident("receiver") {
                if meta.input.peek(Token![=]) {
                    parsed.receiver = Some(meta.value()?.parse()?);
                } else {
                    interface_receiver = Some(meta.path.span());
                }
                return Ok(());
            }
            if meta.path.is_ident("interface")
                || meta.path.is_ident("plain")
                || meta.path.is_ident("fragment")
            {
                if parsed.role.is_some() {
                    return Err(meta.error("choose one object role: interface, plain, or fragment"));
                }
                parsed.role = Some(if meta.path.is_ident("interface") {
                    ObjectRole::Instance(meta.value()?.parse()?)
                } else if meta.path.is_ident("plain") {
                    ObjectRole::Plain
                } else {
                    ObjectRole::Fragment
                });
                return Ok(());
            }
            if meta.path.is_ident("prototype") {
                parsed.prototype = Some(meta.value()?.parse()?);
                return Ok(());
            }
            if meta.path.is_ident("own_to_string_tag") {
                parsed.own_to_string_tag = Some(meta.value()?.parse()?);
                return Ok(());
            }
            if meta.path.is_ident("fallback_to_string_tag") {
                parsed.fallback_to_string_tag = Some(meta.value()?.parse()?);
                return Ok(());
            }
            if meta.path.is_ident("readonly_to_string_tag") {
                parsed.readonly_to_string_tag = true;
                return Ok(());
            }
            if meta.path.is_ident("scope_lifetime") {
                parsed.scope_lifetime = Some(meta.value()?.parse()?);
                return Ok(());
            }
            if meta.path.is_ident("require_prototype") {
                parsed.require_prototype = true;
                return Ok(());
            }
            if meta.path.is_ident("rename_all") {
                let value: LitStr = meta.value()?.parse()?;
                parsed.rename_all = parse_rename_rule(&value)?;
                return Ok(());
            }
            if meta.path.is_ident("data_properties") {
                parsed.default_data_properties = true;
                return Ok(());
            }
            if meta.path.is_ident("enumerable") {
                parsed.default_enumerable = true;
                return Ok(());
            }
            if meta.path.is_ident("no_dynamic_constructor") {
                parsed.no_dynamic_constructor = true;
                return Ok(());
            }
            Err(meta.error("unsupported #[webapi(...)] object attribute"))
        })?;
    }
    resolve_interface_receiver(
        &mut parsed.receiver,
        parsed.role.as_ref().and_then(ObjectRole::interface),
        interface_receiver,
    )?;
    Ok(parsed)
}

pub(crate) fn parse_function_template_attrs(
    attrs: &[syn::Attribute],
) -> Result<FunctionTemplateAttrs, Error> {
    let mut parsed = FunctionTemplateAttrs::default();
    let mut interface_receiver = None;
    for attr in attrs.iter().filter(|attr| attr.path().is_ident("webapi")) {
        attr.parse_nested_meta(|meta| {
            if meta.path.is_ident("receiver_access_check") {
                parsed.receiver_access_check = true;
                return Ok(());
            }
            if meta.path.is_ident("receiver") {
                if meta.input.peek(Token![=]) {
                    parsed.receiver = Some(meta.value()?.parse()?);
                } else {
                    interface_receiver = Some(meta.path.span());
                }
                return Ok(());
            }
            if meta.path.is_ident("interface") {
                parsed.interface = Some(meta.value()?.parse()?);
                return Ok(());
            }
            if meta.path.is_ident("name") {
                parsed.name = Some(meta.value()?.parse()?);
                return Ok(());
            }
            if meta.path.is_ident("constructor") {
                let value: LitStr = meta.value()?.parse()?;
                parsed.constructor = Some(match value.value().as_str() {
                    "illegal" => ConstructorAttr::Illegal,
                    _ => return Err(Error::new(value.span(), "unsupported constructor kind")),
                });
                return Ok(());
            }
            if meta.path.is_ident("constructor_callback") {
                parsed.constructor = Some(ConstructorAttr::Callback(meta.value()?.parse()?));
                return Ok(());
            }
            if meta.path.is_ident("constructor_length") {
                let length: LitInt = meta.value()?.parse()?;
                parsed.constructor_length = Some(length.base10_parse()?);
                return Ok(());
            }
            if meta.path.is_ident("intrinsic_prototype_parent") {
                parsed
                    .intrinsic_prototype_parent
                    .replace(meta.value()?.parse()?)
                    .is_none()
                    .then_some(())
                    .ok_or_else(|| {
                        meta.error(
                            "function template intrinsic_prototype_parent can only be specified once",
                        )
                    })?;
                return Ok(());
            }
            if meta.path.is_ident("prototype_to_string_tag") {
                parsed
                    .prototype_to_string_tag
                    .replace(meta.value()?.parse()?)
                    .is_none()
                    .then_some(())
                    .ok_or_else(|| {
                        meta.error(
                            "function template prototype_to_string_tag can only be specified once",
                        )
                    })?;
                return Ok(());
            }
            if meta.path.is_ident("readonly_prototype") {
                parsed.readonly_prototype = true;
                return Ok(());
            }
            if meta.path.is_ident("rename_all") {
                let value: LitStr = meta.value()?.parse()?;
                parsed.rename_all = parse_rename_rule(&value)?;
                return Ok(());
            }
            if meta.path.is_ident("enumerable") {
                parsed.default_enumerable = true;
                return Ok(());
            }
            Err(meta.error("unsupported #[webapi(...)] function template attribute"))
        })?;
    }
    resolve_interface_receiver(
        &mut parsed.receiver,
        parsed.interface.as_ref(),
        interface_receiver,
    )?;
    Ok(parsed)
}

fn parse_rename_rule(value: &LitStr) -> Result<RenameRule, Error> {
    match value.value().as_str() {
        "none" => Ok(RenameRule::None),
        _ => Err(Error::new(
            value.span(),
            "unsupported rename_all rule; field names are camelCase by default, use rename_all = \"none\" only for explicit Rust spelling",
        )),
    }
}

#[cfg(test)]
pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
    parse_field_attrs_with_defaults(field, FieldDefaults::default())
}

pub(crate) fn parse_field_attrs_with_defaults(
    field: &Field,
    defaults: FieldDefaults<'_>,
) -> Result<FieldAttrs, Error> {
    let mut parsed = FieldAttrs::default();
    for attr in field
        .attrs
        .iter()
        .filter(|attr| attr.path().is_ident("webapi"))
    {
        attr.parse_nested_meta(|meta| {
            if meta.path.is_ident("receiver_access_check") {
                let policy = if meta.input.peek(Token![=]) {
                    ReceiverAccessCheck::parse(meta.value()?.parse()?)?
                } else {
                    ReceiverAccessCheck::All
                };
                if parsed.receiver_access_check.replace(policy).is_some() {
                    return Err(
                        meta.error("field receiver_access_check can only be specified once")
                    );
                }
                return Ok(());
            }
            if meta.path.is_ident("receiver") {
                if parsed.receiver.replace(meta.value()?.parse()?).is_some() {
                    return Err(meta.error("field receiver can only be specified once"));
                }
                return Ok(());
            }
            if meta.path.is_ident("returns_promise") {
                parsed.returns_promise = true;
                return Ok(());
            }
            if meta.path.is_ident("method") {
                parsed.set_kind(FieldKind::Method, meta.path.span())?;
                if meta.input.peek(Token![=]) {
                    set_field_name(&mut parsed.name, meta.value()?.parse()?, meta.path.span())?;
                }
                return Ok(());
            }
            if meta.path.is_ident("static_method") {
                parsed.set_kind(FieldKind::StaticMethod, meta.path.span())?;
                if meta.input.peek(Token![=]) {
                    set_field_name(&mut parsed.name, meta.value()?.parse()?, meta.path.span())?;
                }
                return Ok(());
            }
            if meta.path.is_ident("constant") {
                parsed.set_kind(FieldKind::Constant, meta.path.span())?;
                if meta.input.peek(Token![=]) {
                    set_field_name(&mut parsed.name, meta.value()?.parse()?, meta.path.span())?;
                }
                return Ok(());
            }
            if meta.path.is_ident("accessor_property") {
                parsed.set_kind(FieldKind::AccessorProperty, meta.path.span())?;
                if meta.input.peek(Token![=]) {
                    set_field_name(&mut parsed.name, meta.value()?.parse()?, meta.path.span())?;
                }
                return Ok(());
            }
            if meta.path.is_ident("native_data_property") {
                parsed.set_kind(FieldKind::NativeDataProperty, meta.path.span())?;
                if meta.input.peek(Token![=]) {
                    set_field_name(&mut parsed.name, meta.value()?.parse()?, meta.path.span())?;
                }
                return Ok(());
            }
            if meta.path.is_ident("intrinsic_data_property") {
                parsed.set_kind(
                    FieldKind::IntrinsicDataProperty(meta.value()?.parse()?),
                    meta.path.span(),
                )?;
                return Ok(());
            }
            if meta.path.is_ident("data_property") {
                parsed.set_kind(FieldKind::DataProperty, meta.path.span())?;
                if meta.input.peek(Token![=]) {
                    set_field_name(&mut parsed.name, meta.value()?.parse()?, meta.path.span())?;
                }
                return Ok(());
            }
            if meta.path.is_ident("alias") {
                parsed.set_kind(FieldKind::Alias(meta.value()?.parse()?), meta.path.span())?;
                return Ok(());
            }
            if meta.path.is_ident("enumerable") {
                parsed.enumerable = true;
                return Ok(());
            }
            if meta.path.is_ident("hidden") {
                parsed.set_kind(FieldKind::Hidden, meta.path.span())?;
                if meta.input.peek(Token![=]) {
                    set_field_name(&mut parsed.name, meta.value()?.parse()?, meta.path.span())?;
                }
                return Ok(());
            }
            if meta.path.is_ident("slot") {
                parsed.set_kind(FieldKind::Slot, meta.path.span())?;
                if meta.input.peek(Token![=]) {
                    set_field_name(&mut parsed.name, meta.value()?.parse()?, meta.path.span())?;
                }
                return Ok(());
            }
            if meta.path.is_ident("prototype") {
                if meta.input.peek(Token![=]) {
                    return Err(meta.error("field prototype uses #[webapi(prototype)]"));
                }
                parsed.set_kind(FieldKind::Prototype, meta.path.span())?;
                return Ok(());
            }
            if meta.path.is_ident("to_string_tag") {
                if meta.input.peek(Token![=]) {
                    return Err(meta.error("field to_string_tag uses #[webapi(to_string_tag)]"));
                }
                parsed.set_kind(FieldKind::ToStringTag, meta.path.span())?;
                return Ok(());
            }
            if meta.path.is_ident("readonly") {
                parsed.readonly = true;
                return Ok(());
            }
            if meta.path.is_ident("dont_delete") {
                parsed.dont_delete = true;
                return Ok(());
            }
            if meta.path.is_ident("name") {
                set_field_name(&mut parsed.name, meta.value()?.parse()?, meta.path.span())?;
                return Ok(());
            }
            if meta.path.is_ident("symbol") {
                if parsed.symbol.replace(meta.value()?.parse()?).is_some() {
                    return Err(meta.error("field symbol can only be specified once"));
                }
                return Ok(());
            }
            if meta.path.is_ident("function_name") {
                if parsed
                    .function_name
                    .replace(meta.value()?.parse()?)
                    .is_some()
                {
                    return Err(meta.error("field function_name can only be specified once"));
                }
                return Ok(());
            }
            if meta.path.is_ident("length") {
                let length: LitInt = meta.value()?.parse()?;
                parsed.length = Some(length.base10_parse()?);
                return Ok(());
            }
            if meta.path.is_ident("callback") {
                parsed.callback = Some(meta.value()?.parse()?);
                return Ok(());
            }
            if meta.path.is_ident("getter") {
                if parsed.getter.replace(meta.value()?.parse()?).is_some() {
                    return Err(meta.error("field getter can only be specified once"));
                }
                return Ok(());
            }
            if meta.path.is_ident("getter_value") {
                if parsed
                    .getter_value
                    .replace(meta.value()?.parse()?)
                    .is_some()
                {
                    return Err(meta.error("field getter_value can only be specified once"));
                }
                return Ok(());
            }
            if meta.path.is_ident("setter") {
                if parsed.setter.replace(meta.value()?.parse()?).is_some() {
                    return Err(meta.error("field setter can only be specified once"));
                }
                return Ok(());
            }
            if meta.path.is_ident("data") {
                if parsed.data.replace(meta.value()?.parse()?).is_some() {
                    return Err(meta.error("field data can only be specified once"));
                }
                return Ok(());
            }
            if meta.path.is_ident("setter_data") {
                if parsed.setter_data.replace(meta.value()?.parse()?).is_some() {
                    return Err(meta.error("field setter_data can only be specified once"));
                }
                return Ok(());
            }
            if meta.path.is_ident("value") {
                parsed.value = Some(meta.value()?.parse()?);
                return Ok(());
            }
            if meta.path.is_ident("init") {
                let value: Expr = meta.value()?.parse()?;
                parsed.init = Some(parse_value_init(value)?);
                return Ok(());
            }
            if meta.path.is_ident("constructor_default") {
                let default = if meta.input.peek(Token![=]) {
                    ConstructorDefaultAttr::Expr(Box::new(meta.value()?.parse()?))
                } else {
                    ConstructorDefaultAttr::Default
                };
                if parsed.constructor_default.replace(default).is_some() {
                    return Err(meta.error("field constructor_default can only be specified once"));
                }
                return Ok(());
            }
            Err(meta.error("unsupported #[webapi(...)] field attribute"))
        })?;
    }

    if defaults.data_properties && !parsed.has_installation_kind() {
        parsed.kind = FieldKind::DataProperty;
    }
    if defaults.enumerable
        && parsed.symbol.is_none()
        && matches!(
            parsed.kind,
            FieldKind::DataProperty
                | FieldKind::Method
                | FieldKind::StaticMethod
                | FieldKind::AccessorProperty
                | FieldKind::NativeDataProperty
                | FieldKind::IntrinsicDataProperty(_)
                | FieldKind::Alias(_)
        )
    {
        parsed.enumerable = true;
    }
    if parsed.receiver.is_some()
        && !matches!(parsed.kind, FieldKind::Method | FieldKind::AccessorProperty)
    {
        return Err(Error::new(
            field.span(),
            "receiver is only supported on instance methods and accessor_property fields",
        ));
    }
    if parsed.returns_promise
        && !matches!(
            parsed.kind,
            FieldKind::Method | FieldKind::StaticMethod | FieldKind::AccessorProperty
        )
    {
        return Err(Error::new(
            field.span(),
            "returns_promise is only supported on methods and accessor_property getters",
        ));
    }
    parsed.inherit_receiver(defaults.receiver)?;
    if parsed.receiver_access_check.is_some()
        && (!matches!(parsed.kind, FieldKind::Method | FieldKind::AccessorProperty)
            || parsed.getter_value.is_some())
    {
        return Err(Error::new(
            field.span(),
            "receiver_access_check requires a method or native accessor callback",
        ));
    }
    if parsed.receiver_access_check.is_none()
        && defaults.receiver_access_check
        && matches!(parsed.kind, FieldKind::Method | FieldKind::AccessorProperty)
        && parsed.getter_value.is_none()
    {
        parsed.receiver_access_check = Some(ReceiverAccessCheck::All);
    }
    if matches!(parsed.kind, FieldKind::Method)
        && matches!(
            parsed.receiver_access_check,
            Some(ReceiverAccessCheck::Getter | ReceiverAccessCheck::Setter)
        )
    {
        return Err(Error::new(
            field.span(),
            "method receiver_access_check expects true or false",
        ));
    }

    if parsed.value.is_some() && parsed.init.is_some() {
        return Err(Error::new(
            field.span(),
            "field can only define one of #[webapi(value = expr)] or #[webapi(init = \"...\")]",
        ));
    }
    if parsed.data.is_some()
        && !matches!(parsed.kind, FieldKind::Method | FieldKind::StaticMethod)
        && !matches!(
            parsed.kind,
            FieldKind::AccessorProperty | FieldKind::NativeDataProperty
        )
    {
        return Err(Error::new(
            field.span(),
            "field data can only be specified for #[webapi(method)], #[webapi(static_method)], #[webapi(accessor_property)], or #[webapi(native_data_property)] fields",
        ));
    }
    if parsed.setter_data.is_some() && !matches!(parsed.kind, FieldKind::AccessorProperty) {
        return Err(Error::new(
            field.span(),
            "field setter_data can only be specified for #[webapi(accessor_property)] fields",
        ));
    }
    if parsed.setter_data.is_some() && parsed.setter.is_none() {
        return Err(Error::new(
            field.span(),
            "field setter_data requires #[webapi(setter = path)]",
        ));
    }
    if let Some(function_name) = parsed.function_name.as_ref() {
        if !matches!(parsed.kind, FieldKind::Method | FieldKind::StaticMethod) {
            return Err(Error::new(
                field.span(),
                "field function_name can only be specified for #[webapi(method)] or #[webapi(static_method)] fields",
            ));
        }
        if function_name.value().is_empty() {
            return Err(Error::new(
                function_name.span(),
                "field function_name cannot be empty",
            ));
        }
    }
    if parsed.symbol.is_some() {
        if parsed.name.is_some() {
            return Err(Error::new(
                field.span(),
                "field can only specify one of #[webapi(name = ...)] or #[webapi(symbol = ...)]",
            ));
        }
        if !matches!(parsed.kind, FieldKind::Method | FieldKind::StaticMethod)
            && !matches!(
                parsed.kind,
                FieldKind::AccessorProperty | FieldKind::NativeDataProperty
            )
            && !matches!(
                parsed.kind,
                FieldKind::IntrinsicDataProperty(_) | FieldKind::Alias(_)
            )
        {
            return Err(Error::new(
                field.span(),
                "field symbol can only be specified for #[webapi(method)], #[webapi(static_method)], #[webapi(accessor_property)], #[webapi(native_data_property)], #[webapi(intrinsic_data_property = ...)], or #[webapi(alias = ...)] fields",
            ));
        }
    }
    if parsed.getter.is_some()
        && !matches!(
            parsed.kind,
            FieldKind::AccessorProperty | FieldKind::NativeDataProperty
        )
    {
        return Err(Error::new(
            field.span(),
            "field getter can only be specified for #[webapi(accessor_property)] or #[webapi(native_data_property)] fields",
        ));
    }
    if parsed.setter.is_some()
        && !matches!(
            parsed.kind,
            FieldKind::AccessorProperty | FieldKind::NativeDataProperty
        )
    {
        return Err(Error::new(
            field.span(),
            "field setter can only be specified for #[webapi(accessor_property)] or #[webapi(native_data_property)] fields",
        ));
    }
    let accessor_kind = match parsed.kind {
        FieldKind::AccessorProperty => Some("accessor_property"),
        FieldKind::NativeDataProperty => Some("native_data_property"),
        _ => None,
    };
    if let Some(kind) = accessor_kind {
        if parsed.readonly {
            return Err(Error::new(
                field.span(),
                format!(
                    "`{kind}` fields have no writable attribute; omit #[webapi(setter)] instead of using readonly"
                ),
            ));
        }
        if parsed.callback.is_some() {
            return Err(Error::new(
                field.span(),
                format!(
                    "`{kind}` fields use #[webapi(getter = path)] and optional #[webapi(setter = path)] instead of callback"
                ),
            ));
        }
        if parsed.length.is_some() || parsed.value.is_some() || parsed.init.is_some() {
            return Err(Error::new(
                field.span(),
                format!("`{kind}` fields cannot use length, value, or init attributes"),
            ));
        }
    }
    if matches!(parsed.kind, FieldKind::IntrinsicDataProperty(_))
        && (parsed.function_name.is_some()
            || parsed.length.is_some()
            || parsed.callback.is_some()
            || parsed.getter.is_some()
            || parsed.getter_value.is_some()
            || parsed.setter.is_some()
            || parsed.data.is_some()
            || parsed.setter_data.is_some()
            || parsed.value.is_some()
            || parsed.init.is_some())
    {
        return Err(Error::new(
            field.span(),
            "`intrinsic_data_property` fields can only use name, symbol, enumerable, readonly, or dont_delete attributes",
        ));
    }
    if (matches!(parsed.kind, FieldKind::Method | FieldKind::StaticMethod))
        && (parsed.getter.is_some()
            || parsed.setter.is_some()
            || parsed.value.is_some()
            || parsed.init.is_some())
    {
        return Err(Error::new(
            field.span(),
            "method fields cannot use getter, setter, value, or init attributes",
        ));
    }
    if matches!(parsed.kind, FieldKind::Constant)
        && (parsed.symbol.is_some()
            || parsed.function_name.is_some()
            || parsed.length.is_some()
            || parsed.callback.is_some()
            || parsed.getter.is_some()
            || parsed.setter.is_some()
            || parsed.data.is_some()
            || parsed.setter_data.is_some()
            || parsed.init.is_some()
            || parsed.readonly
            || parsed.dont_delete)
    {
        return Err(Error::new(
            field.span(),
            "constant fields can only use name, value, and optional enumerable attributes",
        ));
    }
    if matches!(parsed.kind, FieldKind::Constant) && parsed.value.is_none() {
        return Err(Error::new(
            field.span(),
            "constant field requires #[webapi(value = expr)]",
        ));
    }
    if matches!(parsed.kind, FieldKind::Alias(_))
        && (parsed.callback.is_some()
            || parsed.function_name.is_some()
            || parsed.length.is_some()
            || parsed.getter.is_some()
            || parsed.setter.is_some()
            || parsed.data.is_some()
            || parsed.setter_data.is_some()
            || parsed.value.is_some()
            || parsed.init.is_some())
    {
        return Err(Error::new(
            field.span(),
            "alias fields cannot use callback, length, getter, setter, data, value, or init attributes",
        ));
    }
    if matches!(parsed.kind, FieldKind::DataProperty)
        && (parsed.callback.is_some()
            || parsed.length.is_some()
            || parsed.getter.is_some()
            || parsed.setter.is_some())
    {
        return Err(Error::new(
            field.span(),
            "`data_property` fields cannot use callback, length, getter, or setter attributes",
        ));
    }
    if matches!(parsed.kind, FieldKind::Hidden)
        && (parsed.callback.is_some()
            || parsed.length.is_some()
            || parsed.getter.is_some()
            || parsed.setter.is_some()
            || parsed.setter_data.is_some()
            || parsed.enumerable)
    {
        return Err(Error::new(
            field.span(),
            "hidden fields cannot use callback, length, getter, setter, or enumerable attributes",
        ));
    }
    if matches!(parsed.kind, FieldKind::Slot)
        && (parsed.callback.is_some()
            || parsed.length.is_some()
            || parsed.getter.is_some()
            || parsed.setter.is_some()
            || parsed.setter_data.is_some()
            || parsed.enumerable
            || parsed.readonly
            || parsed.dont_delete)
    {
        return Err(Error::new(
            field.span(),
            "slot fields cannot use callback, length, getter, setter, enumerable, readonly, or dont_delete attributes",
        ));
    }
    if matches!(parsed.kind, FieldKind::Prototype)
        && (parsed.name.is_some()
            || parsed.symbol.is_some()
            || parsed.function_name.is_some()
            || parsed.length.is_some()
            || parsed.callback.is_some()
            || parsed.getter.is_some()
            || parsed.setter.is_some()
            || parsed.data.is_some()
            || parsed.setter_data.is_some()
            || parsed.enumerable
            || parsed.readonly
            || parsed.dont_delete)
    {
        return Err(Error::new(
            field.span(),
            "prototype fields can only use value, init, or optional field state",
        ));
    }
    if matches!(parsed.kind, FieldKind::ToStringTag)
        && (parsed.name.is_some()
            || parsed.symbol.is_some()
            || parsed.function_name.is_some()
            || parsed.length.is_some()
            || parsed.callback.is_some()
            || parsed.getter.is_some()
            || parsed.setter.is_some()
            || parsed.data.is_some()
            || parsed.setter_data.is_some()
            || parsed.enumerable)
    {
        return Err(Error::new(
            field.span(),
            "to_string_tag fields can only use value, init, readonly, dont_delete, or optional field state",
        ));
    }

    Ok(parsed)
}

fn parse_value_init(value: Expr) -> Result<ValueInitAttr, Error> {
    match value {
        Expr::Call(call) if expr_path_is_ident(call.func.as_ref(), "string") => {
            let span = call.span();
            let mut args = call.args.into_iter();
            let Some(arg) = args.next() else {
                return Err(Error::new(span, "string initializer requires one literal"));
            };
            if args.next().is_some() {
                return Err(Error::new(span, "string initializer requires one literal"));
            }
            match arg {
                Expr::Lit(ExprLit {
                    lit: Lit::Str(value),
                    ..
                }) => Ok(ValueInitAttr::String(value)),
                other => Err(Error::new(
                    other.span(),
                    "string initializer requires a string literal",
                )),
            }
        }
        Expr::Lit(ExprLit {
            lit: Lit::Str(value),
            ..
        }) => match value.value().as_str() {
            "null" => Ok(ValueInitAttr::Null),
            "object" => Ok(ValueInitAttr::Object),
            "null_object" => Ok(ValueInitAttr::NullObject),
            "array" => Ok(ValueInitAttr::Array),
            "undefined" => Ok(ValueInitAttr::Undefined),
            "true" => Ok(ValueInitAttr::True),
            "false" => Ok(ValueInitAttr::False),
            "zero" => Ok(ValueInitAttr::Zero),
            "empty_string" | "" => Ok(ValueInitAttr::EmptyString),
            _ => Err(Error::new(value.span(), "unsupported value initializer")),
        },
        Expr::Lit(ExprLit {
            lit: Lit::Bool(value),
            ..
        }) => Ok(if value.value {
            ValueInitAttr::True
        } else {
            ValueInitAttr::False
        }),
        Expr::Lit(ExprLit {
            lit: Lit::Int(value),
            ..
        }) if value.base10_digits() == "0" => Ok(ValueInitAttr::Zero),
        Expr::Lit(ExprLit {
            lit: Lit::Float(value),
            ..
        }) if value.base10_parse::<f64>().ok() == Some(0.0) => Ok(ValueInitAttr::Zero),
        _ => Err(Error::new(value.span(), "unsupported value initializer")),
    }
}

fn expr_path_is_ident(expr: &Expr, ident: &str) -> bool {
    matches!(expr, Expr::Path(path) if path.path.is_ident(ident))
}

fn set_field_name(
    target: &mut Option<Expr>,
    name: Expr,
    span: proc_macro2::Span,
) -> Result<(), Error> {
    if target.replace(name).is_some() {
        return Err(Error::new(span, "field name can only be specified once"));
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::{
        FieldDefaults, FieldKind, RenameRule, ValueInitAttr, parse_field_attrs,
        parse_field_attrs_with_defaults, parse_function_template_attrs, parse_object_attrs,
    };
    use syn::Field;
    use syn::parse::Parser;

    #[test]
    fn object_roles_are_exclusive() {
        let cases: [Vec<syn::Attribute>; 3] = [
            syn::parse_quote!(#[webapi(plain, fragment)]),
            syn::parse_quote!(#[webapi(interface = Event, plain)]),
            syn::parse_quote!(#[webapi(fragment, interface = Event)]),
        ];
        for attrs in cases {
            let error = parse_object_attrs(&attrs).err().expect("conflicting roles");
            assert_eq!(
                error.to_string(),
                "choose one object role: interface, plain, or fragment"
            );
        }
    }

    #[test]
    fn receiver_shorthand_requires_and_uses_the_declared_interface() {
        let attrs: Vec<syn::Attribute> =
            syn::parse_quote!(#[webapi(interface = interfaces::Event, receiver)]);
        let parsed = parse_object_attrs(&attrs).expect("native instance receiver");
        let receiver = parsed.receiver.expect("resolved receiver");
        assert_eq!(
            quote::quote!(#receiver).to_string(),
            "interfaces :: Event :: is_instance"
        );
        let attrs: Vec<syn::Attribute> = syn::parse_quote!(#[webapi(plain, receiver)]);
        assert!(parse_object_attrs(&attrs).is_err());
    }

    #[test]
    fn installation_kinds_conflict_even_across_separate_attributes() {
        let fields: [Field; 3] = [
            syn::parse_quote!(#[webapi(method)] #[webapi(slot)] value: ()),
            syn::parse_quote!(#[webapi(alias = "values", method)] value: ()),
            syn::parse_quote!(#[webapi(intrinsic_data_property = v8::Intrinsic::ArrayProtoValues, data_property)] value: ()),
        ];
        for field in fields {
            let error = parse_field_attrs(&field).err().expect("conflicting kinds");
            assert_eq!(
                error.to_string(),
                "field can only declare one installation kind"
            );
        }
    }

    #[test]
    fn inherited_defaults_respect_member_roles() {
        let receiver = syn::parse_quote!(is_example);
        let defaults = FieldDefaults {
            receiver: Some(&receiver),
            data_properties: true,
            enumerable: true,
            ..FieldDefaults::default()
        };
        let fields: [Field; 5] = [
            syn::parse_quote!(value: u32),
            syn::parse_quote!(#[webapi(method, callback = call)] call: ()),
            syn::parse_quote!(#[webapi(method, symbol = "iterator", callback = call)] iterator: ()),
            syn::parse_quote!(#[webapi(slot)] state: u32),
            syn::parse_quote!(#[webapi(native_data_property, getter = get)] native: ()),
        ];
        let attrs: Vec<_> = fields
            .iter()
            .map(|field| parse_field_attrs_with_defaults(field, defaults).expect("defaults"))
            .collect();
        assert!(matches!(attrs[0].kind, FieldKind::DataProperty));
        assert!(attrs[0].enumerable && attrs[0].receiver.is_none());
        assert!(attrs[1].enumerable && attrs[1].receiver.is_some());
        assert!(!attrs[2].enumerable && attrs[2].receiver.is_some());
        assert!(!attrs[3].enumerable && attrs[3].receiver.is_none());
        assert!(attrs[4].enumerable && attrs[4].receiver.is_none());
    }

    #[test]
    fn implicit_data_properties_are_validated_like_explicit_ones() {
        let field = syn::parse_quote!(#[webapi(length = 1)] value: u32);
        let error = parse_field_attrs_with_defaults(
            &field,
            FieldDefaults {
                data_properties: true,
                ..FieldDefaults::default()
            },
        )
        .err()
        .expect("length is not data");
        assert_eq!(
            error.to_string(),
            "`data_property` fields cannot use callback, length, getter, or setter attributes"
        );
    }

    #[test]
    fn object_enumerable_default_can_be_used_without_default_data_properties() {
        let attrs: Vec<syn::Attribute> = syn::parse_quote! {
            #[webapi(plain, enumerable)]
        };
        let attrs = parse_object_attrs(&attrs)
            .expect("enumerable default should parse without data properties");
        assert!(attrs.default_enumerable);
        assert!(!attrs.default_data_properties);
    }

    #[test]
    fn object_data_properties_default_is_parsed() {
        let attrs: Vec<syn::Attribute> = syn::parse_quote! {
            #[webapi(plain, data_properties)]
        };
        let attrs = parse_object_attrs(&attrs).expect("data-properties default should parse");
        assert!(attrs.default_data_properties);
    }

    #[test]
    fn rename_all_none_is_the_only_explicit_rename_rule() {
        let attrs: Vec<syn::Attribute> = syn::parse_quote! {
            #[webapi(plain, rename_all = "none")]
        };
        let attrs = parse_object_attrs(&attrs).expect("rename_all none should parse");
        assert!(matches!(attrs.rename_all, RenameRule::None));

        let attrs: Vec<syn::Attribute> = syn::parse_quote! {
            #[webapi(plain, rename_all = "camelCase")]
        };
        let error = match parse_object_attrs(&attrs) {
            Ok(_) => panic!("explicit camelCase rename_all should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "unsupported rename_all rule; field names are camelCase by default, use rename_all = \"none\" only for explicit Rust spelling"
        );
    }

    #[test]
    fn readonly_accessor_properties_are_rejected() {
        for kind in ["accessor_property", "native_data_property"] {
            let field: Field = syn::Field::parse_named
                .parse_str(&format!(
                    "#[webapi({kind}, readonly, getter = sample_getter)] value: ()"
                ))
                .expect("parse field");
            let error = parse_field_attrs(&field)
                .err()
                .expect("invalid writable attribute");
            assert_eq!(
                error.to_string(),
                format!(
                    "`{kind}` fields have no writable attribute; omit #[webapi(setter)] instead of using readonly"
                )
            );
        }
    }

    #[test]
    fn accessor_property_setter_data_attribute_is_parsed() {
        let field = syn::parse_quote! {
            #[webapi(accessor_property, getter = sample_getter, setter = sample_setter, data = getter_data, setter_data = setter_data)]
            value: ()
        };
        let attrs = parse_field_attrs(&field).expect("setter_data accessor property should parse");
        assert!(matches!(attrs.kind, FieldKind::AccessorProperty));
        assert!(attrs.data.is_some());
        assert!(attrs.setter_data.is_some());
    }

    #[test]
    fn literal_init_attributes_are_parsed() {
        let field = syn::parse_quote! {
            #[webapi(data_property, init = true)]
            value: ()
        };
        let attrs = parse_field_attrs(&field).expect("literal true init should parse");
        assert!(matches!(attrs.init, Some(ValueInitAttr::True)));

        let field = syn::parse_quote! {
            #[webapi(data_property, init = false)]
            value: ()
        };
        let attrs = parse_field_attrs(&field).expect("literal false init should parse");
        assert!(matches!(attrs.init, Some(ValueInitAttr::False)));

        let field = syn::parse_quote! {
            #[webapi(data_property, init = 0)]
            value: ()
        };
        let attrs = parse_field_attrs(&field).expect("literal zero init should parse");
        assert!(matches!(attrs.init, Some(ValueInitAttr::Zero)));

        let field = syn::parse_quote! {
            #[webapi(data_property, init = "")]
            value: ()
        };
        let attrs = parse_field_attrs(&field).expect("empty string init should parse");
        assert!(matches!(attrs.init, Some(ValueInitAttr::EmptyString)));

        let field = syn::parse_quote! {
            #[webapi(data_property, init = string("none"))]
            value: ()
        };
        let attrs = parse_field_attrs(&field).expect("literal string init should parse");
        assert!(
            matches!(attrs.init, Some(ValueInitAttr::String(value)) if value.value() == "none")
        );
    }

    #[test]
    fn setter_data_without_setter_is_rejected() {
        let field = syn::parse_quote! {
            #[webapi(accessor_property, getter = sample_getter, setter_data = setter_data)]
            value: ()
        };
        let error = match parse_field_attrs(&field) {
            Ok(_) => panic!("setter_data without setter should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "field setter_data requires #[webapi(setter = path)]"
        );
    }

    #[test]
    fn symbol_name_conflict_is_rejected() {
        let field = syn::parse_quote! {
            #[webapi(method, name = "named", symbol = "iterator", callback = sample_callback)]
            value: ()
        };
        let error = match parse_field_attrs(&field) {
            Ok(_) => panic!("name + symbol should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "field can only specify one of #[webapi(name = ...)] or #[webapi(symbol = ...)]"
        );
    }

    #[test]
    fn symbol_on_non_callback_field_is_rejected() {
        let field = syn::parse_quote! {
            #[webapi(data_property, symbol = "iterator")]
            value: ()
        };
        let error = match parse_field_attrs(&field) {
            Ok(_) => panic!("symbol on a data_property field should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "field symbol can only be specified for #[webapi(method)], #[webapi(static_method)], #[webapi(accessor_property)], #[webapi(native_data_property)], #[webapi(intrinsic_data_property = ...)], or #[webapi(alias = ...)] fields"
        );
    }

    #[test]
    fn removed_function_accessor_attribute_is_rejected() {
        let field = syn::parse_quote! {
            #[webapi(function_accessor, getter = sample_getter)]
            value: ()
        };
        let error = match parse_field_attrs(&field) {
            Ok(_) => panic!("removed function_accessor spelling should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "unsupported #[webapi(...)] field attribute"
        );
    }

    #[test]
    fn removed_property_attribute_spellings_are_rejected() {
        let fields: [Field; 3] = [
            syn::parse_quote! {
                #[webapi(property)]
                value: ()
            },
            syn::parse_quote! {
                #[webapi(accessor, getter = sample_getter)]
                value: ()
            },
            syn::parse_quote! {
                #[webapi(native_accessor, getter = sample_getter)]
                value: ()
            },
        ];

        for field in fields {
            let error = match parse_field_attrs(&field) {
                Ok(_) => panic!("removed property spelling should be rejected"),
                Err(error) => error,
            };
            assert_eq!(
                error.to_string(),
                "unsupported #[webapi(...)] field attribute"
            );
        }
    }

    #[test]
    fn removed_object_properties_spelling_is_rejected() {
        let attrs: Vec<syn::Attribute> = syn::parse_quote! {
            #[webapi(plain, properties)]
        };
        let error = match parse_object_attrs(&attrs) {
            Ok(_) => panic!("removed object properties spelling should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "unsupported #[webapi(...)] object attribute"
        );
    }

    #[test]
    fn native_data_property_attribute_is_parsed() {
        let field = syn::parse_quote! {
            #[webapi(native_data_property = "value", enumerable, getter = sample_getter, setter = sample_setter)]
            value: ()
        };
        let attrs = parse_field_attrs(&field).expect("native data property should parse");
        assert!(matches!(attrs.kind, FieldKind::NativeDataProperty));
        assert!(attrs.enumerable);
        assert!(attrs.getter.is_some());
        assert!(attrs.setter.is_some());
    }

    #[test]
    fn intrinsic_data_property_attribute_is_parsed() {
        let field = syn::parse_quote! {
            #[webapi(
                intrinsic_data_property = v8::Intrinsic::ArrayProtoValues,
                symbol = "iterator",
                readonly,
                dont_delete
            )]
            iterator: ()
        };
        let attrs = parse_field_attrs(&field).expect("intrinsic data property should parse");
        assert!(matches!(attrs.kind, FieldKind::IntrinsicDataProperty(_)));
        assert_eq!(
            attrs
                .symbol
                .as_ref()
                .map(|symbol| symbol.value())
                .as_deref(),
            Some("iterator")
        );
        assert!(attrs.readonly);
        assert!(attrs.dont_delete);
    }

    #[test]
    fn intrinsic_data_property_callback_attributes_are_rejected() {
        let field = syn::parse_quote! {
            #[webapi(
                intrinsic_data_property = v8::Intrinsic::ArrayProtoValues,
                callback = sample_callback
            )]
            values: ()
        };
        let error = match parse_field_attrs(&field) {
            Ok(_) => panic!("callback on intrinsic data property should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "`intrinsic_data_property` fields can only use name, symbol, enumerable, readonly, or dont_delete attributes"
        );
    }

    #[test]
    fn intrinsic_prototype_parent_attribute_is_parsed() {
        let attrs: Vec<syn::Attribute> = syn::parse_quote! {
            #[webapi(
                name = "ErrorLike",
                intrinsic_prototype_parent = v8::Intrinsic::ErrorPrototype
            )]
        };
        let attrs =
            parse_function_template_attrs(&attrs).expect("intrinsic prototype parent should parse");
        assert!(attrs.intrinsic_prototype_parent.is_some());
    }

    #[test]
    fn iterator_prototype_shape_attributes_are_parsed() {
        let attrs: Vec<syn::Attribute> = syn::parse_quote! {
            #[webapi(
                name = "Example Iterator",
                intrinsic_prototype_parent = v8::Intrinsic::IteratorPrototype,
                prototype_to_string_tag = "Example Iterator",
                readonly_prototype
            )]
        };
        let attrs =
            parse_function_template_attrs(&attrs).expect("iterator prototype shape should parse");
        assert_eq!(
            attrs
                .prototype_to_string_tag
                .as_ref()
                .map(|tag| tag.value())
                .as_deref(),
            Some("Example Iterator")
        );
        assert!(attrs.readonly_prototype);
    }

    #[test]
    fn method_descriptor_attributes_are_allowed() {
        let field = syn::parse_quote! {
            #[webapi(method, callback = sample_callback, readonly, dont_delete)]
            value: ()
        };
        let attrs = parse_field_attrs(&field).expect("method descriptor attrs should parse");
        assert!(matches!(attrs.kind, FieldKind::Method));
        assert!(attrs.readonly);
        assert!(attrs.dont_delete);
    }

    #[test]
    fn method_function_name_attribute_is_allowed() {
        let field = syn::parse_quote! {
            #[webapi(method, symbol = "iterator", function_name = "values", callback = sample_callback)]
            value: ()
        };
        let attrs = parse_field_attrs(&field).expect("method function_name attr should parse");
        assert_eq!(
            attrs.function_name.as_ref().map(|name| name.value()),
            Some("values".to_string())
        );
    }

    #[test]
    fn function_name_on_non_method_field_is_rejected() {
        let field = syn::parse_quote! {
            #[webapi(accessor_property, function_name = "value", getter = sample_getter)]
            value: ()
        };
        let error = match parse_field_attrs(&field) {
            Ok(_) => panic!("function_name on accessor_property should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "field function_name can only be specified for #[webapi(method)] or #[webapi(static_method)] fields"
        );
    }

    #[test]
    fn native_data_property_callback_attribute_is_rejected() {
        let field = syn::parse_quote! {
            #[webapi(native_data_property, callback = sample_callback)]
            value: ()
        };
        let error = match parse_field_attrs(&field) {
            Ok(_) => panic!("callback on native_data_property should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "`native_data_property` fields use #[webapi(getter = path)] and optional #[webapi(setter = path)] instead of callback"
        );
    }

    #[test]
    fn constant_without_value_is_rejected() {
        let field = syn::parse_quote! {
            #[webapi(constant = "READY")]
            ready: ()
        };
        let error = match parse_field_attrs(&field) {
            Ok(_) => panic!("constant without a value should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "constant field requires #[webapi(value = expr)]"
        );
    }

    #[test]
    fn constant_callback_attributes_are_rejected() {
        let field = syn::parse_quote! {
            #[webapi(constant = "READY", value = 4u32, callback = sample_callback)]
            ready: ()
        };
        let error = match parse_field_attrs(&field) {
            Ok(_) => panic!("constant callback should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "constant fields can only use name, value, and optional enumerable attributes"
        );
    }

    #[test]
    fn data_property_callback_attributes_are_rejected() {
        let field = syn::parse_quote! {
            #[webapi(data_property, callback = sample_callback)]
            value: ()
        };
        let error = match parse_field_attrs(&field) {
            Ok(_) => panic!("callback on data_property should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "`data_property` fields cannot use callback, length, getter, or setter attributes"
        );
    }

    #[test]
    fn hidden_enumerable_attribute_is_rejected() {
        let field = syn::parse_quote! {
            #[webapi(hidden, enumerable)]
            value: ()
        };
        let error = match parse_field_attrs(&field) {
            Ok(_) => panic!("enumerable hidden field should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "hidden fields cannot use callback, length, getter, setter, or enumerable attributes"
        );
    }

    #[test]
    fn slot_descriptor_attributes_are_rejected() {
        let field = syn::parse_quote! {
            #[webapi(slot, readonly)]
            value: ()
        };
        let error = match parse_field_attrs(&field) {
            Ok(_) => panic!("readonly slot should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "slot fields cannot use callback, length, getter, setter, enumerable, readonly, or dont_delete attributes"
        );
    }

    #[test]
    fn prototype_installation_attributes_are_rejected() {
        let field = syn::parse_quote! {
            #[webapi(prototype, name = "ignored")]
            value: ()
        };
        let error = match parse_field_attrs(&field) {
            Ok(_) => panic!("name on prototype field should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "prototype fields can only use value, init, or optional field state"
        );
    }

    #[test]
    fn to_string_tag_descriptor_attributes_are_allowed() {
        let field = syn::parse_quote! {
            #[webapi(to_string_tag, readonly, dont_delete, value = "Sample")]
            value: ()
        };
        let attrs = parse_field_attrs(&field).expect("toStringTag attrs should parse");
        assert!(matches!(attrs.kind, FieldKind::ToStringTag));
        assert!(attrs.readonly);
        assert!(attrs.dont_delete);
    }

    #[test]
    fn to_string_tag_enumerable_attribute_is_rejected() {
        let field = syn::parse_quote! {
            #[webapi(to_string_tag, enumerable, value = "Sample")]
            value: ()
        };
        let error = match parse_field_attrs(&field) {
            Ok(_) => panic!("enumerable toStringTag should be rejected"),
            Err(error) => error,
        };
        assert_eq!(
            error.to_string(),
            "to_string_tag fields can only use value, init, readonly, dont_delete, or optional field state"
        );
    }
}