Skip to content

Commit

Permalink
refactor(ast): shorten generated code for numbers (#8864)
Browse files Browse the repository at this point in the history 
Generated output included `0usize`, `1usize` etc where just `0`, `1` is sufficient. Shorten the generated code to aid readability.
  • Loading branch information
@overlookmotel
overlookmotel committed Feb 4, 2025
1 parent 4b4d543 commit abfe5bf
Show file tree
Hide file tree
Showing 9 changed files with 3,284 additions and 3,303 deletions.
6,248 changes: 3,124 additions & 3,124 deletions crates/oxc_ast/src/generated/assert_layouts.rs
View file

Large diffs are not rendered by default.

108 changes: 52 additions & 56 deletions crates/oxc_ast/src/generated/derive_estree.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -290,9 +290,9 @@ impl Serialize for PropertyKey<'_> {
impl Serialize for PropertyKind {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
PropertyKind::Init => serializer.serialize_unit_variant("PropertyKind", 0u32, "init"),
PropertyKind::Get => serializer.serialize_unit_variant("PropertyKind", 1u32, "get"),
PropertyKind::Set => serializer.serialize_unit_variant("PropertyKind", 2u32, "set"),
PropertyKind::Init => serializer.serialize_unit_variant("PropertyKind", 0, "init"),
PropertyKind::Get => serializer.serialize_unit_variant("PropertyKind", 1, "get"),
PropertyKind::Set => serializer.serialize_unit_variant("PropertyKind", 2, "set"),
}
}
}
Expand Down Expand Up @@ -914,19 +914,19 @@ impl Serialize for VariableDeclarationKind {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
VariableDeclarationKind::Var => {
serializer.serialize_unit_variant("VariableDeclarationKind", 0u32, "var")
serializer.serialize_unit_variant("VariableDeclarationKind", 0, "var")
}
VariableDeclarationKind::Const => {
serializer.serialize_unit_variant("VariableDeclarationKind", 1u32, "const")
serializer.serialize_unit_variant("VariableDeclarationKind", 1, "const")
}
VariableDeclarationKind::Let => {
serializer.serialize_unit_variant("VariableDeclarationKind", 2u32, "let")
serializer.serialize_unit_variant("VariableDeclarationKind", 2, "let")
}
VariableDeclarationKind::Using => {
serializer.serialize_unit_variant("VariableDeclarationKind", 3u32, "using")
serializer.serialize_unit_variant("VariableDeclarationKind", 3, "using")
}
VariableDeclarationKind::AwaitUsing => {
serializer.serialize_unit_variant("VariableDeclarationKind", 4u32, "await using")
serializer.serialize_unit_variant("VariableDeclarationKind", 4, "await using")
}
}
}
Expand Down Expand Up @@ -1335,17 +1335,17 @@ impl Serialize for FunctionType {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
FunctionType::FunctionDeclaration => {
serializer.serialize_unit_variant("FunctionType", 0u32, "FunctionDeclaration")
serializer.serialize_unit_variant("FunctionType", 0, "FunctionDeclaration")
}
FunctionType::FunctionExpression => {
serializer.serialize_unit_variant("FunctionType", 1u32, "FunctionExpression")
serializer.serialize_unit_variant("FunctionType", 1, "FunctionExpression")
}
FunctionType::TSDeclareFunction => {
serializer.serialize_unit_variant("FunctionType", 2u32, "TSDeclareFunction")
serializer.serialize_unit_variant("FunctionType", 2, "TSDeclareFunction")
}
FunctionType::TSEmptyBodyFunctionExpression => serializer.serialize_unit_variant(
"FunctionType",
3u32,
3,
"TSEmptyBodyFunctionExpression",
),
}
Expand All @@ -1370,20 +1370,18 @@ impl Serialize for FormalParameterKind {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
FormalParameterKind::FormalParameter => {
serializer.serialize_unit_variant("FormalParameterKind", 0u32, "FormalParameter")
serializer.serialize_unit_variant("FormalParameterKind", 0, "FormalParameter")
}
FormalParameterKind::UniqueFormalParameters => serializer.serialize_unit_variant(
"FormalParameterKind",
1u32,
1,
"UniqueFormalParameters",
),
FormalParameterKind::ArrowFormalParameters => serializer.serialize_unit_variant(
"FormalParameterKind",
2u32,
"ArrowFormalParameters",
),
FormalParameterKind::ArrowFormalParameters => {
serializer.serialize_unit_variant("FormalParameterKind", 2, "ArrowFormalParameters")
}
FormalParameterKind::Signature => {
serializer.serialize_unit_variant("FormalParameterKind", 3u32, "Signature")
serializer.serialize_unit_variant("FormalParameterKind", 3, "Signature")
}
}
}
Expand Down Expand Up @@ -1448,10 +1446,10 @@ impl Serialize for ClassType {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
ClassType::ClassDeclaration => {
serializer.serialize_unit_variant("ClassType", 0u32, "ClassDeclaration")
serializer.serialize_unit_variant("ClassType", 0, "ClassDeclaration")
}
ClassType::ClassExpression => {
serializer.serialize_unit_variant("ClassType", 1u32, "ClassExpression")
serializer.serialize_unit_variant("ClassType", 1, "ClassExpression")
}
}
}
Expand Down Expand Up @@ -1501,11 +1499,11 @@ impl Serialize for MethodDefinitionType {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
MethodDefinitionType::MethodDefinition => {
serializer.serialize_unit_variant("MethodDefinitionType", 0u32, "MethodDefinition")
serializer.serialize_unit_variant("MethodDefinitionType", 0, "MethodDefinition")
}
MethodDefinitionType::TSAbstractMethodDefinition => serializer.serialize_unit_variant(
"MethodDefinitionType",
1u32,
1,
"TSAbstractMethodDefinition",
),
}
Expand Down Expand Up @@ -1536,15 +1534,13 @@ impl Serialize for PropertyDefinition<'_> {
impl Serialize for PropertyDefinitionType {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
PropertyDefinitionType::PropertyDefinition => serializer.serialize_unit_variant(
"PropertyDefinitionType",
0u32,
"PropertyDefinition",
),
PropertyDefinitionType::PropertyDefinition => {
serializer.serialize_unit_variant("PropertyDefinitionType", 0, "PropertyDefinition")
}
PropertyDefinitionType::TSAbstractPropertyDefinition => serializer
.serialize_unit_variant(
"PropertyDefinitionType",
1u32,
1,
"TSAbstractPropertyDefinition",
),
}
Expand All @@ -1555,16 +1551,16 @@ impl Serialize for MethodDefinitionKind {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
MethodDefinitionKind::Constructor => {
serializer.serialize_unit_variant("MethodDefinitionKind", 0u32, "constructor")
serializer.serialize_unit_variant("MethodDefinitionKind", 0, "constructor")
}
MethodDefinitionKind::Method => {
serializer.serialize_unit_variant("MethodDefinitionKind", 1u32, "method")
serializer.serialize_unit_variant("MethodDefinitionKind", 1, "method")
}
MethodDefinitionKind::Get => {
serializer.serialize_unit_variant("MethodDefinitionKind", 2u32, "get")
serializer.serialize_unit_variant("MethodDefinitionKind", 2, "get")
}
MethodDefinitionKind::Set => {
serializer.serialize_unit_variant("MethodDefinitionKind", 3u32, "set")
serializer.serialize_unit_variant("MethodDefinitionKind", 3, "set")
}
}
}
Expand Down Expand Up @@ -1609,11 +1605,11 @@ impl Serialize for AccessorPropertyType {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
AccessorPropertyType::AccessorProperty => {
serializer.serialize_unit_variant("AccessorPropertyType", 0u32, "AccessorProperty")
serializer.serialize_unit_variant("AccessorPropertyType", 0, "AccessorProperty")
}
AccessorPropertyType::TSAbstractAccessorProperty => serializer.serialize_unit_variant(
"AccessorPropertyType",
1u32,
1,
"TSAbstractAccessorProperty",
),
}
Expand Down Expand Up @@ -1666,8 +1662,8 @@ impl Serialize for ImportDeclaration<'_> {
impl Serialize for ImportPhase {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
ImportPhase::Source => serializer.serialize_unit_variant("ImportPhase", 0u32, "source"),
ImportPhase::Defer => serializer.serialize_unit_variant("ImportPhase", 1u32, "defer"),
ImportPhase::Source => serializer.serialize_unit_variant("ImportPhase", 0, "source"),
ImportPhase::Defer => serializer.serialize_unit_variant("ImportPhase", 1, "defer"),
}
}
}
Expand Down Expand Up @@ -2415,13 +2411,13 @@ impl Serialize for TSTypeOperatorOperator {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
TSTypeOperatorOperator::Keyof => {
serializer.serialize_unit_variant("TSTypeOperatorOperator", 0u32, "keyof")
serializer.serialize_unit_variant("TSTypeOperatorOperator", 0, "keyof")
}
TSTypeOperatorOperator::Unique => {
serializer.serialize_unit_variant("TSTypeOperatorOperator", 1u32, "unique")
serializer.serialize_unit_variant("TSTypeOperatorOperator", 1, "unique")
}
TSTypeOperatorOperator::Readonly => {
serializer.serialize_unit_variant("TSTypeOperatorOperator", 2u32, "readonly")
serializer.serialize_unit_variant("TSTypeOperatorOperator", 2, "readonly")
}
}
}
Expand Down Expand Up @@ -2746,13 +2742,13 @@ impl Serialize for TSAccessibility {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
TSAccessibility::Private => {
serializer.serialize_unit_variant("TSAccessibility", 0u32, "private")
serializer.serialize_unit_variant("TSAccessibility", 0, "private")
}
TSAccessibility::Protected => {
serializer.serialize_unit_variant("TSAccessibility", 1u32, "protected")
serializer.serialize_unit_variant("TSAccessibility", 1, "protected")
}
TSAccessibility::Public => {
serializer.serialize_unit_variant("TSAccessibility", 2u32, "public")
serializer.serialize_unit_variant("TSAccessibility", 2, "public")
}
}
}
Expand Down Expand Up @@ -2851,13 +2847,13 @@ impl Serialize for TSMethodSignatureKind {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
TSMethodSignatureKind::Method => {
serializer.serialize_unit_variant("TSMethodSignatureKind", 0u32, "method")
serializer.serialize_unit_variant("TSMethodSignatureKind", 0, "method")
}
TSMethodSignatureKind::Get => {
serializer.serialize_unit_variant("TSMethodSignatureKind", 1u32, "get")
serializer.serialize_unit_variant("TSMethodSignatureKind", 1, "get")
}
TSMethodSignatureKind::Set => {
serializer.serialize_unit_variant("TSMethodSignatureKind", 2u32, "set")
serializer.serialize_unit_variant("TSMethodSignatureKind", 2, "set")
}
}
}
Expand Down Expand Up @@ -2952,13 +2948,13 @@ impl Serialize for TSModuleDeclarationKind {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
TSModuleDeclarationKind::Global => {
serializer.serialize_unit_variant("TSModuleDeclarationKind", 0u32, "global")
serializer.serialize_unit_variant("TSModuleDeclarationKind", 0, "global")
}
TSModuleDeclarationKind::Module => {
serializer.serialize_unit_variant("TSModuleDeclarationKind", 1u32, "module")
serializer.serialize_unit_variant("TSModuleDeclarationKind", 1, "module")
}
TSModuleDeclarationKind::Namespace => {
serializer.serialize_unit_variant("TSModuleDeclarationKind", 2u32, "namespace")
serializer.serialize_unit_variant("TSModuleDeclarationKind", 2, "namespace")
}
}
}
Expand Down Expand Up @@ -3114,16 +3110,16 @@ impl Serialize for TSMappedTypeModifierOperator {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
TSMappedTypeModifierOperator::True => {
serializer.serialize_unit_variant("TSMappedTypeModifierOperator", 0u32, "true")
serializer.serialize_unit_variant("TSMappedTypeModifierOperator", 0, "true")
}
TSMappedTypeModifierOperator::Plus => {
serializer.serialize_unit_variant("TSMappedTypeModifierOperator", 1u32, "+")
serializer.serialize_unit_variant("TSMappedTypeModifierOperator", 1, "+")
}
TSMappedTypeModifierOperator::Minus => {
serializer.serialize_unit_variant("TSMappedTypeModifierOperator", 2u32, "-")
serializer.serialize_unit_variant("TSMappedTypeModifierOperator", 2, "-")
}
TSMappedTypeModifierOperator::None => {
serializer.serialize_unit_variant("TSMappedTypeModifierOperator", 3u32, "none")
serializer.serialize_unit_variant("TSMappedTypeModifierOperator", 3, "none")
}
}
}
Expand Down Expand Up @@ -3260,10 +3256,10 @@ impl Serialize for ImportOrExportKind {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
ImportOrExportKind::Value => {
serializer.serialize_unit_variant("ImportOrExportKind", 0u32, "value")
serializer.serialize_unit_variant("ImportOrExportKind", 0, "value")
}
ImportOrExportKind::Type => {
serializer.serialize_unit_variant("ImportOrExportKind", 1u32, "type")
serializer.serialize_unit_variant("ImportOrExportKind", 1, "type")
}
}
}
Expand Down
Loading

0 comments on commit abfe5bf

Please sign in to comment.