Skip to content

refactor(ast): generated Serialize impls flatten struct fields #8904

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
graphite-app merged 1 commit into from
Feb 5, 2025
Merged

refactor(ast): generated Serialize impls flatten struct fields #8904

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1,826 changes: 930 additions & 896 deletions crates/oxc_ast/src/generated/derive_estree.rs
View file
Open in desktop

Large diffs are not rendered by default.

115 changes: 64 additions & 51 deletions crates/oxc_regular_expression/src/generated/derive_estree.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,15 +3,18 @@

#![allow(unused_imports, clippy::match_same_arms)]

use serde::{ser::SerializeMap, Serialize, Serializer};
use serde::{__private::ser::FlatMapSerializer, ser::SerializeMap, Serialize, Serializer};

use oxc_estree::ser::AppendTo;

use crate::ast::*;

impl Serialize for Pattern<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "Pattern")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("body", &self.body)?;
map.end()
}
Expand All @@ -21,7 +24,8 @@ impl Serialize for Disjunction<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "Disjunction")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("body", &self.body)?;
map.end()
}
Expand All @@ -31,7 +35,8 @@ impl Serialize for Alternative<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "Alternative")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("body", &self.body)?;
map.end()
}
Expand All @@ -40,18 +45,18 @@ impl Serialize for Alternative<'_> {
impl Serialize for Term<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Term::BoundaryAssertion(it) => Serialize::serialize(it, serializer),
Term::LookAroundAssertion(it) => Serialize::serialize(it, serializer),
Term::Quantifier(it) => Serialize::serialize(it, serializer),
Term::Character(it) => Serialize::serialize(it, serializer),
Term::Dot(it) => Serialize::serialize(it, serializer),
Term::CharacterClassEscape(it) => Serialize::serialize(it, serializer),
Term::UnicodePropertyEscape(it) => Serialize::serialize(it, serializer),
Term::CharacterClass(it) => Serialize::serialize(it, serializer),
Term::CapturingGroup(it) => Serialize::serialize(it, serializer),
Term::IgnoreGroup(it) => Serialize::serialize(it, serializer),
Term::IndexedReference(it) => Serialize::serialize(it, serializer),
Term::NamedReference(it) => Serialize::serialize(it, serializer),
Term::BoundaryAssertion(it) => it.serialize(serializer),
Term::LookAroundAssertion(it) => it.serialize(serializer),
Term::Quantifier(it) => it.serialize(serializer),
Term::Character(it) => it.serialize(serializer),
Term::Dot(it) => it.serialize(serializer),
Term::CharacterClassEscape(it) => it.serialize(serializer),
Term::UnicodePropertyEscape(it) => it.serialize(serializer),
Term::CharacterClass(it) => it.serialize(serializer),
Term::CapturingGroup(it) => it.serialize(serializer),
Term::IgnoreGroup(it) => it.serialize(serializer),
Term::IndexedReference(it) => it.serialize(serializer),
Term::NamedReference(it) => it.serialize(serializer),
}
}
}
Expand All @@ -60,15 +65,16 @@ impl Serialize for BoundaryAssertion {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "BoundaryAssertion")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("kind", &self.kind)?;
map.end()
}
}

impl Serialize for BoundaryAssertionKind {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
match self {
BoundaryAssertionKind::Start => {
serializer.serialize_unit_variant("BoundaryAssertionKind", 0, "start")
}
Expand All @@ -89,7 +95,8 @@ impl Serialize for LookAroundAssertion<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "LookAroundAssertion")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("kind", &self.kind)?;
map.serialize_entry("body", &self.body)?;
map.end()
Expand All @@ -98,7 +105,7 @@ impl Serialize for LookAroundAssertion<'_> {

impl Serialize for LookAroundAssertionKind {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
match self {
LookAroundAssertionKind::Lookahead => {
serializer.serialize_unit_variant("LookAroundAssertionKind", 0, "lookahead")
}
Expand All @@ -121,7 +128,8 @@ impl Serialize for Quantifier<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "Quantifier")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("min", &self.min)?;
map.serialize_entry("max", &self.max)?;
map.serialize_entry("greedy", &self.greedy)?;
Expand All @@ -134,7 +142,8 @@ impl Serialize for Character {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "Character")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("kind", &self.kind)?;
map.serialize_entry("value", &self.value)?;
map.end()
Expand All @@ -143,7 +152,7 @@ impl Serialize for Character {

impl Serialize for CharacterKind {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
match self {
CharacterKind::ControlLetter => {
serializer.serialize_unit_variant("CharacterKind", 0, "controlLetter")
}
Expand Down Expand Up @@ -180,15 +189,16 @@ impl Serialize for CharacterClassEscape {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "CharacterClassEscape")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("kind", &self.kind)?;
map.end()
}
}

impl Serialize for CharacterClassEscapeKind {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
match self {
CharacterClassEscapeKind::D => {
serializer.serialize_unit_variant("CharacterClassEscapeKind", 0, "d")
}
Expand All @@ -215,7 +225,8 @@ impl Serialize for UnicodePropertyEscape<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "UnicodePropertyEscape")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("negative", &self.negative)?;
map.serialize_entry("strings", &self.strings)?;
map.serialize_entry("name", &self.name)?;
Expand All @@ -228,7 +239,8 @@ impl Serialize for Dot {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "Dot")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.end()
}
}
Expand All @@ -237,7 +249,8 @@ impl Serialize for CharacterClass<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "CharacterClass")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("negative", &self.negative)?;
map.serialize_entry("strings", &self.strings)?;
map.serialize_entry("kind", &self.kind)?;
Expand All @@ -248,7 +261,7 @@ impl Serialize for CharacterClass<'_> {

impl Serialize for CharacterClassContentsKind {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
match self {
CharacterClassContentsKind::Union => {
serializer.serialize_unit_variant("CharacterClassContentsKind", 0, "union")
}
Expand All @@ -265,20 +278,12 @@ impl Serialize for CharacterClassContentsKind {
impl Serialize for CharacterClassContents<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
CharacterClassContents::CharacterClassRange(it) => Serialize::serialize(it, serializer),
CharacterClassContents::CharacterClassEscape(it) => {
Serialize::serialize(it, serializer)
}
CharacterClassContents::UnicodePropertyEscape(it) => {
Serialize::serialize(it, serializer)
}
CharacterClassContents::Character(it) => Serialize::serialize(it, serializer),
CharacterClassContents::NestedCharacterClass(it) => {
Serialize::serialize(it, serializer)
}
CharacterClassContents::ClassStringDisjunction(it) => {
Serialize::serialize(it, serializer)
}
CharacterClassContents::CharacterClassRange(it) => it.serialize(serializer),
CharacterClassContents::CharacterClassEscape(it) => it.serialize(serializer),
CharacterClassContents::UnicodePropertyEscape(it) => it.serialize(serializer),
CharacterClassContents::Character(it) => it.serialize(serializer),
CharacterClassContents::NestedCharacterClass(it) => it.serialize(serializer),
CharacterClassContents::ClassStringDisjunction(it) => it.serialize(serializer),
}
}
}
Expand All @@ -287,7 +292,8 @@ impl Serialize for CharacterClassRange {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "CharacterClassRange")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("min", &self.min)?;
map.serialize_entry("max", &self.max)?;
map.end()
Expand All @@ -298,7 +304,8 @@ impl Serialize for ClassStringDisjunction<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "ClassStringDisjunction")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("strings", &self.strings)?;
map.serialize_entry("body", &self.body)?;
map.end()
Expand All @@ -309,7 +316,8 @@ impl Serialize for ClassString<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "ClassString")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("strings", &self.strings)?;
map.serialize_entry("body", &self.body)?;
map.end()
Expand All @@ -320,7 +328,8 @@ impl Serialize for CapturingGroup<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "CapturingGroup")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("name", &self.name)?;
map.serialize_entry("body", &self.body)?;
map.end()
Expand All @@ -331,7 +340,8 @@ impl Serialize for IgnoreGroup<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "IgnoreGroup")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("modifiers", &self.modifiers)?;
map.serialize_entry("body", &self.body)?;
map.end()
Expand All @@ -342,7 +352,8 @@ impl Serialize for Modifiers {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "Modifiers")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("enabling", &self.enabling)?;
map.serialize_entry("disabling", &self.disabling)?;
map.end()
Expand All @@ -364,7 +375,8 @@ impl Serialize for IndexedReference {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "IndexedReference")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("index", &self.index)?;
map.end()
}
Expand All @@ -374,7 +386,8 @@ impl Serialize for NamedReference<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("type", "NamedReference")?;
self.span.serialize(serde::__private::ser::FlatMapSerializer(&mut map))?;
map.serialize_entry("start", &self.span.start)?;
map.serialize_entry("end", &self.span.end)?;
map.serialize_entry("name", &self.name)?;
map.end()
}
Expand Down
10 changes: 6 additions & 4 deletions crates/oxc_span/src/generated/derive_estree.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,9 @@

#![allow(unused_imports, clippy::match_same_arms)]

use serde::{ser::SerializeMap, Serialize, Serializer};
use serde::{__private::ser::FlatMapSerializer, ser::SerializeMap, Serialize, Serializer};

use oxc_estree::ser::AppendTo;

use crate::source_type::*;
use crate::span::*;
Expand All @@ -29,7 +31,7 @@ impl Serialize for SourceType {

impl Serialize for Language {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
match self {
Language::JavaScript => serializer.serialize_unit_variant("Language", 0, "javascript"),
Language::TypeScript => serializer.serialize_unit_variant("Language", 1, "typescript"),
Language::TypeScriptDefinition => {
Expand All @@ -41,7 +43,7 @@ impl Serialize for Language {

impl Serialize for ModuleKind {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
match self {
ModuleKind::Script => serializer.serialize_unit_variant("ModuleKind", 0, "script"),
ModuleKind::Module => serializer.serialize_unit_variant("ModuleKind", 1, "module"),
ModuleKind::Unambiguous => {
Expand All @@ -53,7 +55,7 @@ impl Serialize for ModuleKind {

impl Serialize for LanguageVariant {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
match self {
LanguageVariant::Standard => {
serializer.serialize_unit_variant("LanguageVariant", 0, "standard")
}
Expand Down
14 changes: 8 additions & 6 deletions crates/oxc_syntax/src/generated/derive_estree.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,13 +3,15 @@

#![allow(unused_imports, clippy::match_same_arms)]

use serde::{ser::SerializeMap, Serialize, Serializer};
use serde::{__private::ser::FlatMapSerializer, ser::SerializeMap, Serialize, Serializer};

use oxc_estree::ser::AppendTo;

use crate::operator::*;

impl Serialize for AssignmentOperator {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
match self {
AssignmentOperator::Assign => {
serializer.serialize_unit_variant("AssignmentOperator", 0, "=")
}
Expand Down Expand Up @@ -64,7 +66,7 @@ impl Serialize for AssignmentOperator {

impl Serialize for BinaryOperator {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
match self {
BinaryOperator::Equality => {
serializer.serialize_unit_variant("BinaryOperator", 0, "==")
}
Expand Down Expand Up @@ -131,7 +133,7 @@ impl Serialize for BinaryOperator {

impl Serialize for LogicalOperator {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
match self {
LogicalOperator::Or => serializer.serialize_unit_variant("LogicalOperator", 0, "||"),
LogicalOperator::And => serializer.serialize_unit_variant("LogicalOperator", 1, "&&"),
LogicalOperator::Coalesce => {
Expand All @@ -143,7 +145,7 @@ impl Serialize for LogicalOperator {

impl Serialize for UnaryOperator {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
match self {
UnaryOperator::UnaryPlus => serializer.serialize_unit_variant("UnaryOperator", 0, "+"),
UnaryOperator::UnaryNegation => {
serializer.serialize_unit_variant("UnaryOperator", 1, "-")
Expand All @@ -163,7 +165,7 @@ impl Serialize for UnaryOperator {

impl Serialize for UpdateOperator {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
match self {
UpdateOperator::Increment => {
serializer.serialize_unit_variant("UpdateOperator", 0, "++")
}
Expand Down
Loading