Skip to content

armgit / moli

Public Imported from GitHub
0

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

refactor(webapi): normalize field roles and inherited defaults

ldm0ed3321a3ee72
diff --git a/moli-webapi-declare-derive/src/attrs.rs b/moli-webapi-declare-derive/src/attrs.rs
index 8b74ea6d6..8e458799b 100644
--- a/moli-webapi-declare-derive/src/attrs.rs
+++ b/moli-webapi-declare-derive/src/attrs.rs
@@ -89,23 +89,39 @@ pub(crate) struct FunctionTemplateAttrs {
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)]
+pub(crate) struct FieldDefaults<'a> {
+ pub(crate) receiver: Option<&'a ReceiverAttr>,
+ pub(crate) data_properties: bool,
+ pub(crate) enumerable: bool,
+}
+
#[derive(Clone, Default)]
pub(crate) struct FieldAttrs {
pub(crate) receiver: Option<ReceiverAttr>,
pub(crate) returns_promise: bool,
- pub(crate) method: bool,
- pub(crate) static_method: bool,
- pub(crate) constant: bool,
- pub(crate) accessor_property: bool,
- pub(crate) native_data_property: bool,
- pub(crate) intrinsic_data_property: Option<Expr>,
- pub(crate) data_property: bool,
- pub(crate) alias: Option<LitStr>,
+ pub(crate) kind: FieldKind,
pub(crate) enumerable: bool,
- pub(crate) hidden: bool,
- pub(crate) slot: bool,
- pub(crate) prototype: bool,
- pub(crate) to_string_tag: bool,
pub(crate) readonly: bool,
pub(crate) dont_delete: bool,
pub(crate) name: Option<Expr>,
@@ -128,7 +144,7 @@ impl FieldAttrs {
&mut self,
receiver: Option<&ReceiverAttr>,
) -> Result<(), Error> {
- if self.method || self.accessor_property {
+ 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)
@@ -143,18 +159,34 @@ impl FieldAttrs {
}
pub(crate) fn has_installation_kind(&self) -> bool {
- self.method
- || self.static_method
- || self.constant
- || self.accessor_property
- || self.native_data_property
- || self.intrinsic_data_property.is_some()
- || self.data_property
- || self.alias.is_some()
- || self.hidden
- || self.slot
- || self.prototype
- || self.to_string_tag
+ !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 {
@@ -163,7 +195,7 @@ impl FieldAttrs {
|| self.enumerable
|| self.readonly
|| self.dont_delete
- || self.alias.is_some()
+ || matches!(self.kind, FieldKind::Alias(_))
|| self.name.is_some()
|| self.symbol.is_some()
|| self.function_name.is_some()
@@ -336,7 +368,15 @@ fn parse_rename_rule(value: &LitStr) -> Result<RenameRule, Error> {
}
}
+#[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
@@ -355,63 +395,56 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
return Ok(());
}
if meta.path.is_ident("method") {
- parsed.method = true;
+ 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.static_method = true;
+ 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.constant = true;
+ 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.accessor_property = true;
+ 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.native_data_property = true;
+ 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") {
- if parsed
- .intrinsic_data_property
- .replace(meta.value()?.parse()?)
- .is_some()
- {
- return Err(
- meta.error("field intrinsic_data_property can only be specified once")
- );
- }
+ parsed.set_kind(
+ FieldKind::IntrinsicDataProperty(meta.value()?.parse()?),
+ meta.path.span(),
+ )?;
return Ok(());
}
if meta.path.is_ident("data_property") {
- parsed.data_property = true;
+ 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") {
- if parsed.alias.replace(meta.value()?.parse()?).is_some() {
- return Err(meta.error("field alias can only be specified once"));
- }
+ parsed.set_kind(FieldKind::Alias(meta.value()?.parse()?), meta.path.span())?;
return Ok(());
}
if meta.path.is_ident("enumerable") {
@@ -419,14 +452,14 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
return Ok(());
}
if meta.path.is_ident("hidden") {
- parsed.hidden = true;
+ 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.slot = true;
+ 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())?;
}
@@ -436,14 +469,14 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
if meta.input.peek(Token![=]) {
return Err(meta.error("field prototype uses #[webapi(prototype)]"));
}
- parsed.prototype = true;
+ 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.to_string_tag = true;
+ parsed.set_kind(FieldKind::ToStringTag, meta.path.span())?;
return Ok(());
}
if meta.path.is_ident("readonly") {
@@ -541,47 +574,45 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
})?;
}
- if parsed.receiver.is_some() && !parsed.method && !parsed.accessor_property {
+ 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
- && !parsed.method
- && !parsed.static_method
- && !parsed.accessor_property
+ && !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(None)?;
-
- let kinds = [
- parsed.method,
- parsed.static_method,
- parsed.constant,
- parsed.accessor_property,
- parsed.native_data_property,
- parsed.intrinsic_data_property.is_some(),
- parsed.data_property,
- parsed.alias.is_some(),
- parsed.hidden,
- parsed.slot,
- parsed.prototype,
- parsed.to_string_tag,
- ]
- .into_iter()
- .filter(|enabled| *enabled)
- .count();
- if kinds > 1 {
- return Err(Error::new(
- field.span(),
- "field can only be one of #[webapi(method)], #[webapi(static_method)], #[webapi(constant)], #[webapi(accessor_property)], #[webapi(native_data_property)], #[webapi(intrinsic_data_property = ...)], #[webapi(data_property)], #[webapi(alias = ...)], #[webapi(hidden)], #[webapi(slot)], #[webapi(prototype)], or #[webapi(to_string_tag)]",
- ));
- }
+ parsed.inherit_receiver(defaults.receiver)?;
+
if parsed.value.is_some() && parsed.init.is_some() {
return Err(Error::new(
field.span(),
@@ -589,17 +620,18 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
));
}
if parsed.data.is_some()
- && !parsed.method
- && !parsed.static_method
- && !parsed.accessor_property
- && !parsed.native_data_property
+ && !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() && !parsed.accessor_property {
+ 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",
@@ -612,7 +644,7 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
));
}
if let Some(function_name) = parsed.function_name.as_ref() {
- if !parsed.method && !parsed.static_method {
+ 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",
@@ -632,12 +664,15 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
"field can only specify one of #[webapi(name = ...)] or #[webapi(symbol = ...)]",
));
}
- if !parsed.method
- && !parsed.static_method
- && !parsed.accessor_property
- && !parsed.native_data_property
- && parsed.intrinsic_data_property.is_none()
- && parsed.alias.is_none()
+ 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(),
@@ -645,25 +680,35 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
));
}
}
- if parsed.getter.is_some() && !parsed.accessor_property && !parsed.native_data_property {
+ 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() && !parsed.accessor_property && !parsed.native_data_property {
+ 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",
));
}
- if parsed.accessor_property && parsed.callback.is_some() {
+ if matches!(parsed.kind, FieldKind::AccessorProperty) && parsed.callback.is_some() {
return Err(Error::new(
field.span(),
"`accessor_property` fields use #[webapi(getter = path)] and optional #[webapi(setter = path)] instead of callback",
));
}
- if parsed.accessor_property
+ if matches!(parsed.kind, FieldKind::AccessorProperty)
&& (parsed.length.is_some() || parsed.value.is_some() || parsed.init.is_some())
{
return Err(Error::new(
@@ -671,13 +716,13 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
"`accessor_property` fields cannot use length, value, or init attributes",
));
}
- if parsed.native_data_property && parsed.callback.is_some() {
+ if matches!(parsed.kind, FieldKind::NativeDataProperty) && parsed.callback.is_some() {
return Err(Error::new(
field.span(),
"`native_data_property` fields use #[webapi(getter = path)] and optional #[webapi(setter = path)] instead of callback",
));
}
- if parsed.native_data_property
+ if matches!(parsed.kind, FieldKind::NativeDataProperty)
&& (parsed.length.is_some() || parsed.value.is_some() || parsed.init.is_some())
{
return Err(Error::new(
@@ -685,7 +730,7 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
"`native_data_property` fields cannot use length, value, or init attributes",
));
}
- if parsed.intrinsic_data_property.is_some()
+ if matches!(parsed.kind, FieldKind::IntrinsicDataProperty(_))
&& (parsed.function_name.is_some()
|| parsed.length.is_some()
|| parsed.callback.is_some()
@@ -702,7 +747,7 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
"`intrinsic_data_property` fields can only use name, symbol, enumerable, readonly, or dont_delete attributes",
));
}
- if (parsed.method || parsed.static_method)
+ if (matches!(parsed.kind, FieldKind::Method | FieldKind::StaticMethod))
&& (parsed.getter.is_some()
|| parsed.setter.is_some()
|| parsed.value.is_some()
@@ -713,7 +758,7 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
"method fields cannot use getter, setter, value, or init attributes",
));
}
- if parsed.constant
+ if matches!(parsed.kind, FieldKind::Constant)
&& (parsed.symbol.is_some()
|| parsed.function_name.is_some()
|| parsed.length.is_some()
@@ -731,13 +776,13 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
"constant fields can only use name, value, and optional enumerable attributes",
));
}
- if parsed.constant && parsed.value.is_none() {
+ if matches!(parsed.kind, FieldKind::Constant) && parsed.value.is_none() {
return Err(Error::new(
field.span(),
"constant field requires #[webapi(value = expr)]",
));
}
- if parsed.alias.is_some()
+ if matches!(parsed.kind, FieldKind::Alias(_))
&& (parsed.callback.is_some()
|| parsed.function_name.is_some()
|| parsed.length.is_some()
@@ -753,7 +798,7 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
"alias fields cannot use callback, length, getter, setter, data, value, or init attributes",
));
}
- if parsed.data_property
+ if matches!(parsed.kind, FieldKind::DataProperty)
&& (parsed.callback.is_some()
|| parsed.length.is_some()
|| parsed.getter.is_some()
@@ -764,7 +809,7 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
"`data_property` fields cannot use callback, length, getter, or setter attributes",
));
}
- if parsed.hidden
+ if matches!(parsed.kind, FieldKind::Hidden)
&& (parsed.callback.is_some()
|| parsed.length.is_some()
|| parsed.getter.is_some()
@@ -777,7 +822,7 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
"hidden fields cannot use callback, length, getter, setter, or enumerable attributes",
));
}
- if parsed.slot
+ if matches!(parsed.kind, FieldKind::Slot)
&& (parsed.callback.is_some()
|| parsed.length.is_some()
|| parsed.getter.is_some()
@@ -792,7 +837,7 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
"slot fields cannot use callback, length, getter, setter, enumerable, readonly, or dont_delete attributes",
));
}
- if parsed.prototype
+ if matches!(parsed.kind, FieldKind::Prototype)
&& (parsed.name.is_some()
|| parsed.symbol.is_some()
|| parsed.function_name.is_some()
@@ -811,7 +856,7 @@ pub(crate) fn parse_field_attrs(field: &Field) -> Result<FieldAttrs, Error> {
"prototype fields can only use value, init, or optional field state",
));
}
- if parsed.to_string_tag
+ if matches!(parsed.kind, FieldKind::ToStringTag)
&& (parsed.name.is_some()
|| parsed.symbol.is_some()
|| parsed.function_name.is_some()
@@ -907,11 +952,72 @@ fn set_field_name(
#[cfg(test)]
mod tests {
use super::{
- RenameRule, ValueInitAttr, parse_field_attrs, parse_function_template_attrs,
- parse_object_attrs,
+ FieldDefaults, FieldKind, RenameRule, ValueInitAttr, parse_field_attrs,
+ parse_field_attrs_with_defaults, parse_function_template_attrs, parse_object_attrs,
};
use syn::Field;
+ #[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!("Example");
+ let defaults = FieldDefaults {
+ receiver: Some(&receiver),
+ data_properties: true,
+ enumerable: true,
+ };
+ 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! {
@@ -960,7 +1066,7 @@ mod tests {
value: ()
};
let attrs = parse_field_attrs(&field).expect("readonly accessor property should parse");
- assert!(attrs.accessor_property);
+ assert!(matches!(attrs.kind, FieldKind::AccessorProperty));
assert!(attrs.readonly);
}
@@ -971,7 +1077,7 @@ mod tests {
value: ()
};
let attrs = parse_field_attrs(&field).expect("setter_data accessor property should parse");
- assert!(attrs.accessor_property);
+ assert!(matches!(attrs.kind, FieldKind::AccessorProperty));
assert!(attrs.data.is_some());
assert!(attrs.setter_data.is_some());
}
@@ -1131,7 +1237,7 @@ mod tests {
value: ()
};
let attrs = parse_field_attrs(&field).expect("native data property should parse");
- assert!(attrs.native_data_property);
+ assert!(matches!(attrs.kind, FieldKind::NativeDataProperty));
assert!(attrs.enumerable);
assert!(attrs.getter.is_some());
assert!(attrs.setter.is_some());
@@ -1149,7 +1255,7 @@ mod tests {
iterator: ()
};
let attrs = parse_field_attrs(&field).expect("intrinsic data property should parse");
- assert!(attrs.intrinsic_data_property.is_some());
+ assert!(matches!(attrs.kind, FieldKind::IntrinsicDataProperty(_)));
assert_eq!(
attrs
.symbol
@@ -1224,7 +1330,7 @@ mod tests {
value: ()
};
let attrs = parse_field_attrs(&field).expect("method descriptor attrs should parse");
- assert!(attrs.method);
+ assert!(matches!(attrs.kind, FieldKind::Method));
assert!(attrs.readonly);
assert!(attrs.dont_delete);
}
@@ -1377,7 +1483,7 @@ mod tests {
value: ()
};
let attrs = parse_field_attrs(&field).expect("toStringTag attrs should parse");
- assert!(attrs.to_string_tag);
+ assert!(matches!(attrs.kind, FieldKind::ToStringTag));
assert!(attrs.readonly);
assert!(attrs.dont_delete);
}
diff --git a/moli-webapi-declare-derive/src/expand.rs b/moli-webapi-declare-derive/src/expand.rs
index 81be91a16..52586c3d8 100644
--- a/moli-webapi-declare-derive/src/expand.rs
+++ b/moli-webapi-declare-derive/src/expand.rs
@@ -5,10 +5,26 @@ use syn::spanned::Spanned;
use syn::{Data, DeriveInput, Error, Field, Fields, GenericParam, Ident, Lit, LitStr, Type};
use crate::attrs::{
- ConstructorAttr, ConstructorDefaultAttr, FunctionTemplateAttrs, ObjectAttrs, RenameRule,
- ValueInitAttr, parse_field_attrs, parse_function_template_attrs, parse_object_attrs,
+ ConstructorAttr, ConstructorDefaultAttr, FieldAttrs, FieldDefaults, FieldKind,
+ FunctionTemplateAttrs, ObjectAttrs, RenameRule, ValueInitAttr, parse_field_attrs_with_defaults,
+ parse_function_template_attrs, parse_object_attrs,
};
+struct DeclaredField {
+ field: Field,
+ attrs: FieldAttrs,
+}
+
+fn declared_fields(data: &Data, defaults: FieldDefaults<'_>) -> Result<Vec<DeclaredField>, Error> {
+ named_fields(data)?
+ .into_iter()
+ .map(|field| {
+ let attrs = parse_field_attrs_with_defaults(&field, defaults)?;
+ Ok(DeclaredField { field, attrs })
+ })
+ .collect()
+}
+
struct WebApiFieldKey {
display_name: proc_macro2::TokenStream,
display_name_literal: Option<LitStr>,
@@ -76,8 +92,15 @@ pub(crate) fn expand_webapi_function_template(
);
}
});
- let fields = named_fields(&input.data)?;
- let declaration_field_reads = fields.iter().filter_map(|field| {
+ let fields = declared_fields(
+ &input.data,
+ FieldDefaults {
+ receiver: attrs.receiver.as_ref(),
+ enumerable: attrs.default_enumerable,
+ ..FieldDefaults::default()
+ },
+ )?;
+ let declaration_field_reads = fields.iter().filter_map(|DeclaredField { field, .. }| {
field.ident.as_ref().map(|ident| {
quote! {
let _ = &self.#ident;
@@ -209,7 +232,14 @@ pub(crate) fn expand_webapi_object(input: DeriveInput) -> Result<proc_macro2::To
}
}
};
- let fields = named_fields(&input.data)?;
+ let fields = declared_fields(
+ &input.data,
+ FieldDefaults {
+ receiver: attrs.receiver.as_ref(),
+ data_properties: attrs.default_data_properties,
+ enumerable: attrs.default_enumerable,
+ },
+ )?;
let generated_constructor = expand_object_generated_constructor(&fields, &attrs, &struct_name)?;
let inferred_scope_lifetime = attrs
.scope_lifetime
@@ -404,7 +434,7 @@ pub(crate) fn expand_webapi_object(input: DeriveInput) -> Result<proc_macro2::To
}
fn expand_object_generated_constructor(
- fields: &[Field],
+ fields: &[DeclaredField],
attrs: &ObjectAttrs,
struct_name: &Ident,
) -> Result<proc_macro2::TokenStream, Error> {
@@ -413,15 +443,18 @@ fn expand_object_generated_constructor(
}
let mut parameters = Vec::new();
let mut initializers = Vec::new();
- for field in fields {
+ for DeclaredField {
+ field,
+ attrs: field_attrs,
+ } in fields
+ {
let ident = field
.ident
.as_ref()
.ok_or_else(|| Error::new(field.span(), "WebApiObject field requires a name"))?;
- let field_attrs = parse_field_attrs(field)?;
if type_is_unit(&field.ty) {
initializers.push(quote!(#ident: ()));
- } else if let Some(default) = field_attrs.constructor_default {
+ } else if let Some(default) = &field_attrs.constructor_default {
let default = match default {
ConstructorDefaultAttr::Default => quote!(::std::default::Default::default()),
ConstructorDefaultAttr::Expr(expr) => quote!(#expr),
@@ -449,54 +482,41 @@ struct FunctionTemplateFieldExpansions {
}
fn expand_function_template_fields(
- fields: &[Field],
+ fields: &[DeclaredField],
template_attrs: &FunctionTemplateAttrs,
template_name: &LitStr,
) -> Result<FunctionTemplateFieldExpansions, Error> {
let mut template_methods = Vec::new();
let mut prototype_methods = Vec::new();
let mut method_bindings = HashMap::new();
- for (index, field) in fields.iter().enumerate() {
- let mut attrs = parse_field_attrs(field)?;
- attrs.inherit_receiver(template_attrs.receiver.as_ref())?;
- if template_attrs.default_enumerable
- && attrs.symbol.is_none()
- && (attrs.method
- || attrs.static_method
- || attrs.accessor_property
- || attrs.native_data_property
- || attrs.intrinsic_data_property.is_some()
- || attrs.alias.is_some())
- {
- attrs.enumerable = true;
- }
- if attrs.constant {
+ for (index, DeclaredField { field, attrs }) in fields.iter().enumerate() {
+ if matches!(attrs.kind, FieldKind::Constant) {
template_methods.push(expand_function_template_constant_field(
field,
- &attrs,
+ attrs,
template_attrs.rename_all,
quote!(template),
)?);
prototype_methods.push(expand_function_template_constant_field(
field,
- &attrs,
+ attrs,
template_attrs.rename_all,
quote!(prototype),
)?);
continue;
}
- if attrs.static_method {
+ if matches!(attrs.kind, FieldKind::StaticMethod) {
let binding = format_ident!("__webapi_template_static_method_{index}");
template_methods.push(expand_function_template_static_method_field(
field,
- &attrs,
+ attrs,
template_attrs.rename_all,
template_name,
binding,
)?);
continue;
}
- if attrs.method {
+ if matches!(attrs.kind, FieldKind::Method) {
let binding = format_ident!("__webapi_template_method_{index}");
if attrs.symbol.is_none()
&& let Some(name) = webapi_field_name_literal(
@@ -509,42 +529,42 @@ fn expand_function_template_fields(
}
prototype_methods.push(expand_function_template_method_field(
field,
- &attrs,
+ attrs,
template_attrs.rename_all,
template_name,
binding,
)?);
continue;
}
- if attrs.accessor_property {
+ if matches!(attrs.kind, FieldKind::AccessorProperty) {
prototype_methods.push(expand_function_template_accessor_property_field(
field,
- &attrs,
+ attrs,
template_attrs.rename_all,
template_name,
)?);
continue;
}
- if attrs.native_data_property {
+ if matches!(attrs.kind, FieldKind::NativeDataProperty) {
prototype_methods.push(expand_function_template_native_data_property_field(
field,
- &attrs,
+ attrs,
template_attrs.rename_all,
)?);
continue;
}
- if attrs.intrinsic_data_property.is_some() {
+ if matches!(attrs.kind, FieldKind::IntrinsicDataProperty(_)) {
prototype_methods.push(expand_function_template_intrinsic_data_property_field(
field,
- &attrs,
+ attrs,
template_attrs.rename_all,
)?);
continue;
}
- if attrs.alias.is_some() {
+ if matches!(attrs.kind, FieldKind::Alias(_)) {
prototype_methods.push(expand_function_template_alias_field(
field,
- &attrs,
+ attrs,
template_attrs.rename_all,
&method_bindings,
)?);
@@ -901,7 +921,7 @@ fn expand_function_template_intrinsic_data_property_field(
let key = webapi_field_key(field, attrs, rename_all)?;
let name = key.display_name;
let property_key = key.property_key;
- let Some(intrinsic) = attrs.intrinsic_data_property.as_ref() else {
+ let FieldKind::IntrinsicDataProperty(intrinsic) = &attrs.kind else {
return Err(Error::new(
field.span(),
"function template intrinsic data property requires an intrinsic value",
@@ -943,7 +963,7 @@ fn expand_function_template_alias_field(
"function template alias fields cannot define callbacks, function metadata, data, or values",
));
}
- let Some(source_name) = attrs.alias.as_ref() else {
+ let FieldKind::Alias(source_name) = &attrs.kind else {
return Err(Error::new(
field.span(),
"function template alias field requires a source name",
@@ -989,46 +1009,10 @@ fn single_lifetime_param(generics: &syn::Generics) -> Option<syn::Lifetime> {
}
fn expand_object_field(
- field: &Field,
+ declaration: &DeclaredField,
object_attrs: &ObjectAttrs,
) -> Option<Result<proc_macro2::TokenStream, Error>> {
- let mut attrs = match parse_field_attrs(field) {
- Ok(attrs) => attrs,
- Err(error) => return Some(Err(error)),
- };
- if let Err(error) = attrs.inherit_receiver(object_attrs.receiver.as_ref()) {
- return Some(Err(error));
- }
- // Struct-level `#[webapi(data_properties)]` is the only mode where an unannotated
- // field becomes part of the JavaScript surface by default. Without it,
- // unannotated fields are declaration-only inputs that can still be consumed
- // by other attributes, for example `#[webapi(method, data = self.cache)]`.
- if object_attrs.default_data_properties
- && !attrs.method
- && !attrs.static_method
- && !attrs.constant
- && !attrs.accessor_property
- && !attrs.native_data_property
- && attrs.intrinsic_data_property.is_none()
- && !attrs.data_property
- && attrs.alias.is_none()
- && !attrs.hidden
- && !attrs.slot
- && !attrs.prototype
- && !attrs.to_string_tag
- {
- attrs.data_property = true;
- }
- if object_attrs.default_enumerable
- && attrs.symbol.is_none()
- && (attrs.data_property
- || attrs.method
- || attrs.accessor_property
- || attrs.native_data_property
- || attrs.alias.is_some())
- {
- attrs.enumerable = true;
- }
+ let DeclaredField { field, attrs } = declaration;
if !attrs.has_installation_kind() {
if attrs.has_installation_attribute() {
return Some(Err(Error::new(
@@ -1038,24 +1022,24 @@ fn expand_object_field(
}
return None;
}
- if attrs.static_method {
+ if matches!(attrs.kind, FieldKind::StaticMethod) {
return Some(Err(Error::new(
field.span(),
"object fields with #[webapi(...)] attributes cannot declare #[webapi(static_method)]",
)));
}
- if attrs.intrinsic_data_property.is_some() {
+ if matches!(attrs.kind, FieldKind::IntrinsicDataProperty(_)) {
return Some(Err(Error::new(
field.span(),
"`intrinsic_data_property` is only supported by WebApiFunctionTemplate",
)));
}
- if attrs.constant {
+ if matches!(attrs.kind, FieldKind::Constant) {
let name = match webapi_field_name(field, attrs.name.as_ref(), object_attrs.rename_all) {
Ok(name) => name,
Err(error) => return Some(Err(error)),
};
- let value = match expand_object_field_value(field, &attrs, false) {
+ let value = match expand_object_field_value(field, attrs, false) {
Ok(value) => value,
Err(error) => return Some(Err(error)),
};
@@ -1069,39 +1053,39 @@ fn expand_object_field(
)?;
}));
}
- if attrs.method {
+ if matches!(attrs.kind, FieldKind::Method) {
return Some(expand_object_method_field(
field,
- &attrs,
+ attrs,
object_attrs.rename_all,
));
}
- if attrs.accessor_property {
+ if matches!(attrs.kind, FieldKind::AccessorProperty) {
return Some(expand_accessor_property_field(
field,
- &attrs,
+ attrs,
object_attrs.rename_all,
quote!(object),
));
}
- if attrs.native_data_property {
+ if matches!(attrs.kind, FieldKind::NativeDataProperty) {
return Some(expand_native_data_property_field(
field,
- &attrs,
+ attrs,
object_attrs.rename_all,
));
}
- if attrs.alias.is_some() {
- return Some(expand_alias_field(field, &attrs, object_attrs.rename_all));
+ if matches!(attrs.kind, FieldKind::Alias(_)) {
+ return Some(expand_alias_field(field, attrs, object_attrs.rename_all));
}
- if attrs.prototype || attrs.to_string_tag {
+ if matches!(attrs.kind, FieldKind::Prototype | FieldKind::ToStringTag) {
let field_is_option = type_is_option(&field.ty);
let optional = field_is_option && attrs.value.is_none() && attrs.init.is_none();
- let value = match expand_object_field_value(field, &attrs, optional) {
+ let value = match expand_object_field_value(field, attrs, optional) {
Ok(value) => value,
Err(error) => return Some(Err(error)),
};
- let bind_value = if attrs.prototype {
+ let bind_value = if matches!(attrs.kind, FieldKind::Prototype) {
quote! {
::moli_webapi_declare::set_declared_prototype(
scope,
@@ -1110,7 +1094,7 @@ fn expand_object_field(
)?;
}
} else {
- let attributes = to_string_tag_property_attributes(&attrs);
+ let attributes = to_string_tag_property_attributes(attrs);
quote! {
::moli_webapi_declare::define_declared_to_string_tag_with_attributes(
scope,
@@ -1136,10 +1120,13 @@ fn expand_object_field(
// object. This allows declarations to carry Rust/V8 values used only while
// generating methods or metadata. Keeping the skip here prevents accidental
// own-data-property exposure on web-facing wrappers.
- if !attrs.data_property && !attrs.hidden && !attrs.slot {
+ if !matches!(
+ attrs.kind,
+ FieldKind::DataProperty | FieldKind::Hidden | FieldKind::Slot
+ ) {
return None;
}
- let rename_all = if attrs.hidden || attrs.slot {
+ let rename_all = if matches!(attrs.kind, FieldKind::Hidden | FieldKind::Slot) {
RenameRule::None
} else {
object_attrs.rename_all
@@ -1150,11 +1137,11 @@ fn expand_object_field(
};
let field_is_option = type_is_option(&field.ty);
let optional = field_is_option && attrs.value.is_none() && attrs.init.is_none();
- let value = match expand_object_field_value(field, &attrs, optional) {
+ let value = match expand_object_field_value(field, attrs, optional) {
Ok(value) => value,
Err(error) => return Some(Err(error)),
};
- let define_value = if attrs.slot {
+ let define_value = if matches!(attrs.kind, FieldKind::Slot) {
quote! {
::moli_webapi_declare::define_declared_private_slot(
scope,
@@ -1163,7 +1150,7 @@ fn expand_object_field(
__webapi_value_ref,
)?;
}
- } else if attrs.hidden {
+ } else if matches!(attrs.kind, FieldKind::Hidden) {
let writable = syn::LitBool::new(!attrs.readonly, proc_macro2::Span::call_site());
let configurable = syn::LitBool::new(!attrs.dont_delete, proc_macro2::Span::call_site());
quote! {
@@ -1229,13 +1216,13 @@ fn expand_object_field(
}
}));
}
- if attrs.hidden {
+ if matches!(attrs.kind, FieldKind::Hidden) {
return Some(Ok(quote! {
#value
#define_value
}));
}
- if attrs.slot {
+ if matches!(attrs.kind, FieldKind::Slot) {
return Some(Ok(quote! {
#value
::moli_webapi_declare::define_declared_private_slot(
@@ -1468,7 +1455,7 @@ fn expand_alias_field(
let key = webapi_field_key(field, attrs, rename_all)?;
let name = key.display_name;
let property_key = key.property_key;
- let Some(source_name) = attrs.alias.as_ref() else {
+ let FieldKind::Alias(source_name) = &attrs.kind else {
return Err(Error::new(
field.span(),
"alias field requires a source name",
@@ -2050,7 +2037,12 @@ fn expand_object_field_value(
}
});
}
- if attrs.data_property || attrs.hidden || attrs.slot || attrs.prototype || attrs.to_string_tag {
+ if matches!(attrs.kind, FieldKind::DataProperty | FieldKind::Hidden)
+ || matches!(
+ attrs.kind,
+ FieldKind::Slot | FieldKind::Prototype | FieldKind::ToStringTag
+ )
+ {
let Some(ident) = field.ident.as_ref() else {
return Err(Error::new(field.span(), "object field requires a name"));
};