mirror of
https://github.com/oxc-project/oxc.git
synced 2026-11-04 10:29:58 +00:00
refactor(ast): shorten generated code for numbers (#8864)
Generated output included `0usize`, `1usize` etc where just `0`, `1` is sufficient. Shorten the generated code to aid readability.
This commit is contained in:
overlookmotel committed
1 parent
4b4d5436e1
commit
abfe5bfe53
9 files changed
+3284
-3303
No files matched your search
File diff suppressed because it is too large.
Load diff
@@ -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"),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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",
|
||||
),
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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",
|
||||
),
|
||||
}
|
||||
@@ -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",
|
||||
),
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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",
|
||||
),
|
||||
}
|
||||
@@ -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"),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -70,16 +70,16 @@ impl Serialize for BoundaryAssertionKind {
|
||||
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
|
||||
match *self {
|
||||
BoundaryAssertionKind::Start => {
|
||||
serializer.serialize_unit_variant("BoundaryAssertionKind", 0u32, "start")
|
||||
serializer.serialize_unit_variant("BoundaryAssertionKind", 0, "start")
|
||||
}
|
||||
BoundaryAssertionKind::End => {
|
||||
serializer.serialize_unit_variant("BoundaryAssertionKind", 1u32, "end")
|
||||
serializer.serialize_unit_variant("BoundaryAssertionKind", 1, "end")
|
||||
}
|
||||
BoundaryAssertionKind::Boundary => {
|
||||
serializer.serialize_unit_variant("BoundaryAssertionKind", 2u32, "boundary")
|
||||
serializer.serialize_unit_variant("BoundaryAssertionKind", 2, "boundary")
|
||||
}
|
||||
BoundaryAssertionKind::NegativeBoundary => {
|
||||
serializer.serialize_unit_variant("BoundaryAssertionKind", 3u32, "negativeBoundary")
|
||||
serializer.serialize_unit_variant("BoundaryAssertionKind", 3, "negativeBoundary")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -100,19 +100,17 @@ impl Serialize for LookAroundAssertionKind {
|
||||
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
|
||||
match *self {
|
||||
LookAroundAssertionKind::Lookahead => {
|
||||
serializer.serialize_unit_variant("LookAroundAssertionKind", 0u32, "lookahead")
|
||||
serializer.serialize_unit_variant("LookAroundAssertionKind", 0, "lookahead")
|
||||
}
|
||||
LookAroundAssertionKind::NegativeLookahead => {
|
||||
serializer.serialize_unit_variant("LookAroundAssertionKind", 1, "negativeLookahead")
|
||||
}
|
||||
LookAroundAssertionKind::NegativeLookahead => serializer.serialize_unit_variant(
|
||||
"LookAroundAssertionKind",
|
||||
1u32,
|
||||
"negativeLookahead",
|
||||
),
|
||||
LookAroundAssertionKind::Lookbehind => {
|
||||
serializer.serialize_unit_variant("LookAroundAssertionKind", 2u32, "lookbehind")
|
||||
serializer.serialize_unit_variant("LookAroundAssertionKind", 2, "lookbehind")
|
||||
}
|
||||
LookAroundAssertionKind::NegativeLookbehind => serializer.serialize_unit_variant(
|
||||
"LookAroundAssertionKind",
|
||||
3u32,
|
||||
3,
|
||||
"negativeLookbehind",
|
||||
),
|
||||
}
|
||||
@@ -147,32 +145,32 @@ impl Serialize for CharacterKind {
|
||||
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
|
||||
match *self {
|
||||
CharacterKind::ControlLetter => {
|
||||
serializer.serialize_unit_variant("CharacterKind", 0u32, "controlLetter")
|
||||
serializer.serialize_unit_variant("CharacterKind", 0, "controlLetter")
|
||||
}
|
||||
CharacterKind::HexadecimalEscape => {
|
||||
serializer.serialize_unit_variant("CharacterKind", 1u32, "hexadecimalEscape")
|
||||
serializer.serialize_unit_variant("CharacterKind", 1, "hexadecimalEscape")
|
||||
}
|
||||
CharacterKind::Identifier => {
|
||||
serializer.serialize_unit_variant("CharacterKind", 2u32, "identifier")
|
||||
serializer.serialize_unit_variant("CharacterKind", 2, "identifier")
|
||||
}
|
||||
CharacterKind::Null => serializer.serialize_unit_variant("CharacterKind", 3u32, "null"),
|
||||
CharacterKind::Null => serializer.serialize_unit_variant("CharacterKind", 3, "null"),
|
||||
CharacterKind::Octal1 => {
|
||||
serializer.serialize_unit_variant("CharacterKind", 4u32, "octal1")
|
||||
serializer.serialize_unit_variant("CharacterKind", 4, "octal1")
|
||||
}
|
||||
CharacterKind::Octal2 => {
|
||||
serializer.serialize_unit_variant("CharacterKind", 5u32, "octal2")
|
||||
serializer.serialize_unit_variant("CharacterKind", 5, "octal2")
|
||||
}
|
||||
CharacterKind::Octal3 => {
|
||||
serializer.serialize_unit_variant("CharacterKind", 6u32, "octal3")
|
||||
serializer.serialize_unit_variant("CharacterKind", 6, "octal3")
|
||||
}
|
||||
CharacterKind::SingleEscape => {
|
||||
serializer.serialize_unit_variant("CharacterKind", 7u32, "singleEscape")
|
||||
serializer.serialize_unit_variant("CharacterKind", 7, "singleEscape")
|
||||
}
|
||||
CharacterKind::Symbol => {
|
||||
serializer.serialize_unit_variant("CharacterKind", 8u32, "symbol")
|
||||
serializer.serialize_unit_variant("CharacterKind", 8, "symbol")
|
||||
}
|
||||
CharacterKind::UnicodeEscape => {
|
||||
serializer.serialize_unit_variant("CharacterKind", 9u32, "unicodeEscape")
|
||||
serializer.serialize_unit_variant("CharacterKind", 9, "unicodeEscape")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -192,22 +190,22 @@ impl Serialize for CharacterClassEscapeKind {
|
||||
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
|
||||
match *self {
|
||||
CharacterClassEscapeKind::D => {
|
||||
serializer.serialize_unit_variant("CharacterClassEscapeKind", 0u32, "d")
|
||||
serializer.serialize_unit_variant("CharacterClassEscapeKind", 0, "d")
|
||||
}
|
||||
CharacterClassEscapeKind::NegativeD => {
|
||||
serializer.serialize_unit_variant("CharacterClassEscapeKind", 1u32, "negativeD")
|
||||
serializer.serialize_unit_variant("CharacterClassEscapeKind", 1, "negativeD")
|
||||
}
|
||||
CharacterClassEscapeKind::S => {
|
||||
serializer.serialize_unit_variant("CharacterClassEscapeKind", 2u32, "s")
|
||||
serializer.serialize_unit_variant("CharacterClassEscapeKind", 2, "s")
|
||||
}
|
||||
CharacterClassEscapeKind::NegativeS => {
|
||||
serializer.serialize_unit_variant("CharacterClassEscapeKind", 3u32, "negativeS")
|
||||
serializer.serialize_unit_variant("CharacterClassEscapeKind", 3, "negativeS")
|
||||
}
|
||||
CharacterClassEscapeKind::W => {
|
||||
serializer.serialize_unit_variant("CharacterClassEscapeKind", 4u32, "w")
|
||||
serializer.serialize_unit_variant("CharacterClassEscapeKind", 4, "w")
|
||||
}
|
||||
CharacterClassEscapeKind::NegativeW => {
|
||||
serializer.serialize_unit_variant("CharacterClassEscapeKind", 5u32, "negativeW")
|
||||
serializer.serialize_unit_variant("CharacterClassEscapeKind", 5, "negativeW")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -252,15 +250,13 @@ impl Serialize for CharacterClassContentsKind {
|
||||
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
|
||||
match *self {
|
||||
CharacterClassContentsKind::Union => {
|
||||
serializer.serialize_unit_variant("CharacterClassContentsKind", 0u32, "union")
|
||||
serializer.serialize_unit_variant("CharacterClassContentsKind", 0, "union")
|
||||
}
|
||||
CharacterClassContentsKind::Intersection => {
|
||||
serializer.serialize_unit_variant("CharacterClassContentsKind", 1, "intersection")
|
||||
}
|
||||
CharacterClassContentsKind::Intersection => serializer.serialize_unit_variant(
|
||||
"CharacterClassContentsKind",
|
||||
1u32,
|
||||
"intersection",
|
||||
),
|
||||
CharacterClassContentsKind::Subtraction => {
|
||||
serializer.serialize_unit_variant("CharacterClassContentsKind", 2u32, "subtraction")
|
||||
serializer.serialize_unit_variant("CharacterClassContentsKind", 2, "subtraction")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -30,14 +30,10 @@ impl Serialize for SourceType {
|
||||
impl Serialize for Language {
|
||||
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
|
||||
match *self {
|
||||
Language::JavaScript => {
|
||||
serializer.serialize_unit_variant("Language", 0u32, "javascript")
|
||||
}
|
||||
Language::TypeScript => {
|
||||
serializer.serialize_unit_variant("Language", 1u32, "typescript")
|
||||
}
|
||||
Language::JavaScript => serializer.serialize_unit_variant("Language", 0, "javascript"),
|
||||
Language::TypeScript => serializer.serialize_unit_variant("Language", 1, "typescript"),
|
||||
Language::TypeScriptDefinition => {
|
||||
serializer.serialize_unit_variant("Language", 2u32, "typescriptDefinition")
|
||||
serializer.serialize_unit_variant("Language", 2, "typescriptDefinition")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -46,10 +42,10 @@ impl Serialize for Language {
|
||||
impl Serialize for ModuleKind {
|
||||
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
|
||||
match *self {
|
||||
ModuleKind::Script => serializer.serialize_unit_variant("ModuleKind", 0u32, "script"),
|
||||
ModuleKind::Module => serializer.serialize_unit_variant("ModuleKind", 1u32, "module"),
|
||||
ModuleKind::Script => serializer.serialize_unit_variant("ModuleKind", 0, "script"),
|
||||
ModuleKind::Module => serializer.serialize_unit_variant("ModuleKind", 1, "module"),
|
||||
ModuleKind::Unambiguous => {
|
||||
serializer.serialize_unit_variant("ModuleKind", 2u32, "unambiguous")
|
||||
serializer.serialize_unit_variant("ModuleKind", 2, "unambiguous")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -59,11 +55,9 @@ impl Serialize for LanguageVariant {
|
||||
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
|
||||
match *self {
|
||||
LanguageVariant::Standard => {
|
||||
serializer.serialize_unit_variant("LanguageVariant", 0u32, "standard")
|
||||
}
|
||||
LanguageVariant::Jsx => {
|
||||
serializer.serialize_unit_variant("LanguageVariant", 1u32, "jsx")
|
||||
serializer.serialize_unit_variant("LanguageVariant", 0, "standard")
|
||||
}
|
||||
LanguageVariant::Jsx => serializer.serialize_unit_variant("LanguageVariant", 1, "jsx"),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -11,52 +11,52 @@ impl Serialize for AssignmentOperator {
|
||||
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
|
||||
match *self {
|
||||
AssignmentOperator::Assign => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 0u32, "=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 0, "=")
|
||||
}
|
||||
AssignmentOperator::Addition => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 1u32, "+=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 1, "+=")
|
||||
}
|
||||
AssignmentOperator::Subtraction => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 2u32, "-=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 2, "-=")
|
||||
}
|
||||
AssignmentOperator::Multiplication => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 3u32, "*=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 3, "*=")
|
||||
}
|
||||
AssignmentOperator::Division => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 4u32, "/=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 4, "/=")
|
||||
}
|
||||
AssignmentOperator::Remainder => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 5u32, "%=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 5, "%=")
|
||||
}
|
||||
AssignmentOperator::Exponential => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 6u32, "**=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 6, "**=")
|
||||
}
|
||||
AssignmentOperator::ShiftLeft => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 7u32, "<<=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 7, "<<=")
|
||||
}
|
||||
AssignmentOperator::ShiftRight => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 8u32, ">>=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 8, ">>=")
|
||||
}
|
||||
AssignmentOperator::ShiftRightZeroFill => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 9u32, ">>>=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 9, ">>>=")
|
||||
}
|
||||
AssignmentOperator::BitwiseOR => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 10u32, "|=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 10, "|=")
|
||||
}
|
||||
AssignmentOperator::BitwiseXOR => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 11u32, "^=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 11, "^=")
|
||||
}
|
||||
AssignmentOperator::BitwiseAnd => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 12u32, "&=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 12, "&=")
|
||||
}
|
||||
AssignmentOperator::LogicalOr => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 13u32, "||=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 13, "||=")
|
||||
}
|
||||
AssignmentOperator::LogicalAnd => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 14u32, "&&=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 14, "&&=")
|
||||
}
|
||||
AssignmentOperator::LogicalNullish => {
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 15u32, "??=")
|
||||
serializer.serialize_unit_variant("AssignmentOperator", 15, "??=")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -66,68 +66,64 @@ impl Serialize for BinaryOperator {
|
||||
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
|
||||
match *self {
|
||||
BinaryOperator::Equality => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 0u32, "==")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 0, "==")
|
||||
}
|
||||
BinaryOperator::Inequality => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 1u32, "!=")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 1, "!=")
|
||||
}
|
||||
BinaryOperator::StrictEquality => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 2u32, "===")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 2, "===")
|
||||
}
|
||||
BinaryOperator::StrictInequality => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 3u32, "!==")
|
||||
}
|
||||
BinaryOperator::LessThan => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 4u32, "<")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 3, "!==")
|
||||
}
|
||||
BinaryOperator::LessThan => serializer.serialize_unit_variant("BinaryOperator", 4, "<"),
|
||||
BinaryOperator::LessEqualThan => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 5u32, "<=")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 5, "<=")
|
||||
}
|
||||
BinaryOperator::GreaterThan => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 6u32, ">")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 6, ">")
|
||||
}
|
||||
BinaryOperator::GreaterEqualThan => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 7u32, ">=")
|
||||
}
|
||||
BinaryOperator::Addition => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 8u32, "+")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 7, ">=")
|
||||
}
|
||||
BinaryOperator::Addition => serializer.serialize_unit_variant("BinaryOperator", 8, "+"),
|
||||
BinaryOperator::Subtraction => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 9u32, "-")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 9, "-")
|
||||
}
|
||||
BinaryOperator::Multiplication => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 10u32, "*")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 10, "*")
|
||||
}
|
||||
BinaryOperator::Division => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 11u32, "/")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 11, "/")
|
||||
}
|
||||
BinaryOperator::Remainder => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 12u32, "%")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 12, "%")
|
||||
}
|
||||
BinaryOperator::Exponential => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 13u32, "**")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 13, "**")
|
||||
}
|
||||
BinaryOperator::ShiftLeft => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 14u32, "<<")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 14, "<<")
|
||||
}
|
||||
BinaryOperator::ShiftRight => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 15u32, ">>")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 15, ">>")
|
||||
}
|
||||
BinaryOperator::ShiftRightZeroFill => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 16u32, ">>>")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 16, ">>>")
|
||||
}
|
||||
BinaryOperator::BitwiseOR => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 17u32, "|")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 17, "|")
|
||||
}
|
||||
BinaryOperator::BitwiseXOR => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 18u32, "^")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 18, "^")
|
||||
}
|
||||
BinaryOperator::BitwiseAnd => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 19u32, "&")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 19, "&")
|
||||
}
|
||||
BinaryOperator::In => serializer.serialize_unit_variant("BinaryOperator", 20u32, "in"),
|
||||
BinaryOperator::In => serializer.serialize_unit_variant("BinaryOperator", 20, "in"),
|
||||
BinaryOperator::Instanceof => {
|
||||
serializer.serialize_unit_variant("BinaryOperator", 21u32, "instanceof")
|
||||
serializer.serialize_unit_variant("BinaryOperator", 21, "instanceof")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -136,12 +132,10 @@ impl Serialize for BinaryOperator {
|
||||
impl Serialize for LogicalOperator {
|
||||
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
|
||||
match *self {
|
||||
LogicalOperator::Or => serializer.serialize_unit_variant("LogicalOperator", 0u32, "||"),
|
||||
LogicalOperator::And => {
|
||||
serializer.serialize_unit_variant("LogicalOperator", 1u32, "&&")
|
||||
}
|
||||
LogicalOperator::Or => serializer.serialize_unit_variant("LogicalOperator", 0, "||"),
|
||||
LogicalOperator::And => serializer.serialize_unit_variant("LogicalOperator", 1, "&&"),
|
||||
LogicalOperator::Coalesce => {
|
||||
serializer.serialize_unit_variant("LogicalOperator", 2u32, "??")
|
||||
serializer.serialize_unit_variant("LogicalOperator", 2, "??")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -150,24 +144,18 @@ impl Serialize for LogicalOperator {
|
||||
impl Serialize for UnaryOperator {
|
||||
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
|
||||
match *self {
|
||||
UnaryOperator::UnaryPlus => {
|
||||
serializer.serialize_unit_variant("UnaryOperator", 0u32, "+")
|
||||
}
|
||||
UnaryOperator::UnaryPlus => serializer.serialize_unit_variant("UnaryOperator", 0, "+"),
|
||||
UnaryOperator::UnaryNegation => {
|
||||
serializer.serialize_unit_variant("UnaryOperator", 1u32, "-")
|
||||
}
|
||||
UnaryOperator::LogicalNot => {
|
||||
serializer.serialize_unit_variant("UnaryOperator", 2u32, "!")
|
||||
}
|
||||
UnaryOperator::BitwiseNot => {
|
||||
serializer.serialize_unit_variant("UnaryOperator", 3u32, "~")
|
||||
serializer.serialize_unit_variant("UnaryOperator", 1, "-")
|
||||
}
|
||||
UnaryOperator::LogicalNot => serializer.serialize_unit_variant("UnaryOperator", 2, "!"),
|
||||
UnaryOperator::BitwiseNot => serializer.serialize_unit_variant("UnaryOperator", 3, "~"),
|
||||
UnaryOperator::Typeof => {
|
||||
serializer.serialize_unit_variant("UnaryOperator", 4u32, "typeof")
|
||||
serializer.serialize_unit_variant("UnaryOperator", 4, "typeof")
|
||||
}
|
||||
UnaryOperator::Void => serializer.serialize_unit_variant("UnaryOperator", 5u32, "void"),
|
||||
UnaryOperator::Void => serializer.serialize_unit_variant("UnaryOperator", 5, "void"),
|
||||
UnaryOperator::Delete => {
|
||||
serializer.serialize_unit_variant("UnaryOperator", 6u32, "delete")
|
||||
serializer.serialize_unit_variant("UnaryOperator", 6, "delete")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -177,10 +165,10 @@ impl Serialize for UpdateOperator {
|
||||
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
|
||||
match *self {
|
||||
UpdateOperator::Increment => {
|
||||
serializer.serialize_unit_variant("UpdateOperator", 0u32, "++")
|
||||
serializer.serialize_unit_variant("UpdateOperator", 0, "++")
|
||||
}
|
||||
UpdateOperator::Decrement => {
|
||||
serializer.serialize_unit_variant("UpdateOperator", 1u32, "--")
|
||||
serializer.serialize_unit_variant("UpdateOperator", 1, "--")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,6 +8,7 @@ use syn::{parse_str, Type};
|
||||
|
||||
use crate::{
|
||||
schema::{Def, EnumDef, FieldDef, Schema, StructDef, TypeDef, VariantDef},
|
||||
utils::number_lit,
|
||||
Result,
|
||||
};
|
||||
|
||||
@@ -211,8 +212,7 @@ fn generate_body_for_enum(enum_def: &EnumDef, schema: &Schema) -> TokenStream {
|
||||
let enum_name = enum_def.name();
|
||||
let match_branches = enum_def.all_variants(schema).map(|variant| {
|
||||
let variant_ident = variant.ident();
|
||||
// TODO: Don't print numbers as `0u32` - just `0` is fine
|
||||
let discriminant = u32::from(variant.discriminant);
|
||||
let discriminant = number_lit(variant.discriminant);
|
||||
let value = get_fieldless_variant_value(enum_def, variant);
|
||||
|
||||
quote! {
|
||||
|
||||
@@ -16,6 +16,7 @@ use crate::{
|
||||
extensions::layout::{Layout, Niche, Offset, PlatformLayout},
|
||||
Def, Discriminant, EnumDef, PrimitiveDef, Schema, StructDef, TypeDef, TypeId, Visibility,
|
||||
},
|
||||
utils::number_lit,
|
||||
Codegen, Generator, AST_CRATE_PATH,
|
||||
};
|
||||
|
||||
@@ -409,8 +410,7 @@ fn generate_layout_assertions_for_struct(struct_def: &StructDef) -> (TokenStream
|
||||
|
||||
let field_ident = field.ident();
|
||||
let offset =
|
||||
if is_64 { field.offset.offset_64 } else { field.offset.offset_32 } as usize;
|
||||
// TODO: Don't print numbers as `4usize` - just `4` would be fine
|
||||
number_lit(if is_64 { field.offset.offset_64 } else { field.offset.offset_32 });
|
||||
Some(quote! {
|
||||
assert!(offset_of!(#struct_ident, #field_ident) == #offset);
|
||||
})
|
||||
@@ -438,9 +438,8 @@ fn generate_layout_assertions_for_enum(enum_def: &EnumDef) -> (TokenStream, Toke
|
||||
|
||||
/// Generate size and alignment assertions for a type.
|
||||
fn generate_size_align_assertions(layout: &PlatformLayout, ident: &Ident) -> TokenStream {
|
||||
let size = layout.size as usize;
|
||||
let align = layout.align as usize;
|
||||
// TODO: Don't print numbers as `4usize` - just `4` would be fine
|
||||
let size = number_lit(layout.size);
|
||||
let align = number_lit(layout.align);
|
||||
quote! {
|
||||
///@@line_break
|
||||
assert!(size_of::<#ident>() == #size);
|
||||
|
||||
@@ -8,13 +8,12 @@
|
||||
//!
|
||||
//! Variants of `AstKind` and `AstType` are not created for types listed in `BLACK_LIST` below.
|
||||
|
||||
use proc_macro2::Span;
|
||||
use quote::{format_ident, quote};
|
||||
use syn::LitInt;
|
||||
|
||||
use crate::{
|
||||
output::{output_path, Output},
|
||||
schema::{Def, Schema, TypeDef},
|
||||
utils::number_lit,
|
||||
Codegen, Generator, AST_CRATE_PATH,
|
||||
};
|
||||
|
||||
@@ -130,7 +129,7 @@ impl Generator for AstKindGenerator {
|
||||
let mut span_match_arms = quote!();
|
||||
let mut as_methods = quote!();
|
||||
|
||||
let mut next_index = 0usize;
|
||||
let mut next_index = 0u16;
|
||||
for type_def in &schema.types {
|
||||
let has_kind = match type_def {
|
||||
TypeDef::Struct(struct_def) => struct_def.kind.has_kind,
|
||||
@@ -144,8 +143,8 @@ impl Generator for AstKindGenerator {
|
||||
let type_ident = type_def.ident();
|
||||
let type_ty = type_def.ty(schema);
|
||||
|
||||
let index = u8::try_from(next_index).unwrap();
|
||||
let index = LitInt::new(&index.to_string(), Span::call_site());
|
||||
assert!(u8::try_from(next_index).is_ok());
|
||||
let index = number_lit(next_index);
|
||||
type_variants.extend(quote!( #type_ident = #index, ));
|
||||
kind_variants.extend(quote!( #type_ident(&'a #type_ty) = AstType::#type_ident as u8, ));
|
||||
|
||||
|
||||
@@ -50,3 +50,12 @@ pub fn create_ident_tokens(name: &str) -> TokenStream {
|
||||
quote!(#ident)
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert integer to [`LitInt`].
|
||||
///
|
||||
/// This prints without a `usize` postfix. i.e. `123` not `123usize`.
|
||||
///
|
||||
/// [`LitInt`]: struct@LitInt
|
||||
pub fn number_lit<N: Into<u64>>(n: N) -> LitInt {
|
||||
LitInt::new(&n.into().to_string(), Span::call_site())
|
||||
}
|
||||
Reference in new issue
Block a user