fix(ast): estree compat AssignmentTargetPropertyIdentifier

crates/oxc_ast/src/ast/js.rs

@@ -884,9 +884,16 @@ pub enum AssignmentTargetProperty<'a> {
 #[ast(visit)]
 #[derive(Debug)]
 #[generate_derive(CloneIn, GetSpan, GetSpanMut, ContentEq, ESTree)]
+#[estree(
+    rename = "Property",
+    add_fields(kind = "\"init\"", method = false, shorthand = true, computed = false),
+    add_ts = "kind: \"init\"; method: false; shorthand: false; computed: false"
+)]
 pub struct AssignmentTargetPropertyIdentifier<'a> {
     pub span: Span,
+    #[estree(rename = "key")]
     pub binding: IdentifierReference<'a>,
+    #[estree(rename = "value", via = crate::serialize::AssignmentTargetPropertyIdentifierValue(self), ts_type = "IdentifierReference | AssignmentTargetWithDefault")]
     pub init: Option<Expression<'a>>,
 }
 

crates/oxc_ast/src/generated/derive_estree.rs

@@ -709,11 +709,18 @@ impl Serialize for AssignmentTargetProperty<'_> {
 impl Serialize for AssignmentTargetPropertyIdentifier<'_> {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         let mut map = serializer.serialize_map(None)?;
-        map.serialize_entry("type", "AssignmentTargetPropertyIdentifier")?;
+        map.serialize_entry("type", "Property")?;
         map.serialize_entry("start", &self.span.start)?;
         map.serialize_entry("end", &self.span.end)?;
-        map.serialize_entry("binding", &self.binding)?;
-        map.serialize_entry("init", &self.init)?;
+        map.serialize_entry("key", &self.binding)?;
+        map.serialize_entry(
+            "value",
+            &crate::serialize::AssignmentTargetPropertyIdentifierValue(self),
+        )?;
+        map.serialize_entry("kind", &"init")?;
+        map.serialize_entry("method", &false)?;
+        map.serialize_entry("shorthand", &true)?;
+        map.serialize_entry("computed", &false)?;
         map.end()
     }
 }

crates/oxc_ast/src/serialize.rs

@@ -307,3 +307,33 @@ impl Serialize for ArrowFunctionExpressionBody<'_> {
         }
     }
 }
+
+pub struct AssignmentTargetPropertyIdentifierValue<'a>(
+    pub &'a AssignmentTargetPropertyIdentifier<'a>,
+);
+
+impl Serialize for AssignmentTargetPropertyIdentifierValue<'_> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        if let Some(init) = &self.0.init {
+            AssignmentTargetPropertyIdentifierValueAssignmentPattern {
+                span: self.0.span,
+                left: &self.0.binding,
+                right: init,
+            }
+            .serialize(serializer)
+        } else {
+            self.0.binding.serialize(serializer)
+        }
+    }
+}
+
+/// wrapper to serialize same as `AssignmentTargetWithDefault`
+/// but without extra enum/Box for `AssignmentTargetWithDefault.binding`
+#[derive(Serialize)]
+#[serde(tag = "type", rename = "AssignmentPattern")]
+pub struct AssignmentTargetPropertyIdentifierValueAssignmentPattern<'a> {
+    #[serde(flatten)]
+    pub span: Span,
+    pub left: &'a IdentifierReference<'a>,
+    pub right: &'a Expression<'a>,
+}

npm/oxc-types/types.d.ts

@@ -268,9 +268,13 @@ export interface AssignmentTargetWithDefault extends Span {
 export type AssignmentTargetProperty = AssignmentTargetPropertyIdentifier | AssignmentTargetPropertyProperty;
 
 export interface AssignmentTargetPropertyIdentifier extends Span {
-  type: 'AssignmentTargetPropertyIdentifier';
-  binding: IdentifierReference;
-  init: Expression | null;
+  type: 'Property';
+  key: IdentifierReference;
+  value: IdentifierReference | AssignmentTargetWithDefault;
+  kind: 'init';
+  method: false;
+  shorthand: false;
+  computed: false;
 }
 
 export interface AssignmentTargetPropertyProperty extends Span {

tasks/ast_tools/src/derives/estree.rs

@@ -4,7 +4,7 @@ use std::borrow::Cow;
 
 use proc_macro2::TokenStream;
 use quote::quote;
-use syn::{parse_str, Expr, Type};
+use syn::{parse_str, Expr};
 
 use crate::{
     schema::{Def, EnumDef, FieldDef, Schema, StructDef, TypeDef, VariantDef, Visibility},
@@ -186,9 +186,9 @@ fn parse_estree_attr(location: AttrLocation, part: AttrPart) -> Result<()> {
 /// Generate body of `serialize` method for a struct.
 fn generate_body_for_struct(struct_def: &StructDef, schema: &Schema) -> TokenStream {
     if let Some(via_str) = struct_def.estree.via.as_deref() {
-        let via_ty = parse_str::<Type>(via_str).unwrap();
+        let via_expr = parse_str::<Expr>(via_str).unwrap();
         return quote! {
-            #via_ty::from(self).serialize(serializer)
+            #via_expr.serialize(serializer)
         };
     }