From 88cad6fc59c5af7db129182469395c50099dadf4 Mon Sep 17 00:00:00 2001 From: Boshen Date: Thu, 20 Feb 2025 00:10:01 +0800 Subject: [PATCH] refactor(oxc): apply `clippy::use_self` --- Cargo.toml | 1 + crates/oxc_allocator/src/clone_in.rs | 4 +- crates/oxc_allocator/src/string.rs | 12 +- crates/oxc_ast/src/ast_impl/js.rs | 6 +- crates/oxc_ast/src/ast_impl/ts.rs | 8 +- .../oxc_ast/src/generated/derive_clone_in.rs | 2 +- crates/oxc_ast/src/generated/derive_estree.rs | 1233 ++++++++--------- crates/oxc_cfg/src/block.rs | 2 +- crates/oxc_ecmascript/src/to_int_32.rs | 4 +- crates/oxc_ecmascript/src/to_numeric.rs | 14 +- .../oxc_language_server/src/capabilities.rs | 2 +- crates/oxc_language_server/src/commands.rs | 6 +- .../oxc_linter/src/config/config_builder.rs | 2 +- crates/oxc_linter/src/config/env.rs | 2 +- crates/oxc_linter/src/config/globals.rs | 12 +- crates/oxc_linter/src/config/plugins.rs | 68 +- crates/oxc_linter/src/config/settings/next.rs | 2 +- crates/oxc_linter/src/fixer/fix.rs | 6 +- crates/oxc_linter/src/module_record.rs | 2 +- crates/oxc_linter/src/options/filter.rs | 8 +- crates/oxc_linter/src/rule.rs | 2 +- .../oxc_linter/src/rules/eslint/func_names.rs | 6 +- .../oxc_linter/src/rules/eslint/func_style.rs | 4 +- crates/oxc_linter/src/rules/eslint/new_cap.rs | 2 +- .../src/rules/eslint/no_magic_numbers.rs | 2 +- .../src/rules/eslint/no_restricted_imports.rs | 4 +- .../no_unused_vars/fixers/fix_symbol.rs | 16 +- .../src/rules/eslint/no_unused_vars/mod.rs | 2 +- .../src/rules/eslint/no_unused_vars/symbol.rs | 4 +- .../src/rules/eslint/sort_imports.rs | 18 +- .../oxc_linter/src/rules/import/no_cycle.rs | 2 +- .../src/rules/jest/consistent_test_it.rs | 10 +- .../src/rules/oxc/no_barrel_file.rs | 2 +- crates/oxc_linter/src/table.rs | 2 +- crates/oxc_linter/src/tester.rs | 4 +- .../src/utils/jest/parse_jest_fn.rs | 2 +- crates/oxc_mangler/src/lib.rs | 2 +- crates/oxc_parser/src/cursor.rs | 4 +- .../src/generated/derive_clone_in.rs | 2 +- .../src/generated/derive_estree.rs | 110 +- .../string_literal_parser/parser_impl.rs | 2 +- crates/oxc_semantic/src/dot.rs | 2 +- crates/oxc_semantic/src/jsdoc/parser/jsdoc.rs | 2 +- .../src/jsdoc/parser/jsdoc_tag.rs | 2 +- crates/oxc_semantic/src/stats.rs | 2 +- crates/oxc_semantic/tests/conformance/mod.rs | 12 +- crates/oxc_span/src/atom.rs | 4 +- crates/oxc_span/src/compact_str.rs | 4 +- .../oxc_span/src/generated/derive_estree.rs | 8 +- crates/oxc_span/src/span.rs | 6 +- .../src/generated/derive_clone_in.rs | 2 +- .../oxc_syntax/src/generated/derive_estree.rs | 172 +-- crates/oxc_syntax/src/node.rs | 2 +- crates/oxc_transformer/src/es2017/mod.rs | 2 +- .../oxc_transformer/src/options/babel/mod.rs | 2 +- .../src/options/browserslist_query.rs | 4 +- crates/oxc_transformer/src/options/engine.rs | 2 +- crates/oxc_transformer/src/options/env.rs | 2 +- .../src/plugins/inject_global_variables.rs | 12 +- napi/minify/src/options.rs | 8 +- napi/transform/src/transformer.rs | 22 +- tasks/ast_tools/src/derives/clone_in.rs | 2 +- tasks/ast_tools/src/derives/estree.rs | 6 +- tasks/ast_tools/src/parse/attr.rs | 2 +- tasks/ast_tools/src/schema/defs/type.rs | 84 +- tasks/transform_checker/src/lib.rs | 2 +- 66 files changed, 914 insertions(+), 1052 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index a5fcc7a3197c2..d874906ccc267 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -76,6 +76,7 @@ iter_on_single_items = "warn" unused_peekable = "warn" too_long_first_doc_paragraph = "warn" suspicious_operation_groupings = "warn" +use_self = "warn" # cargo cargo = { level = "warn", priority = -1 } multiple_crate_versions = "allow" diff --git a/crates/oxc_allocator/src/clone_in.rs b/crates/oxc_allocator/src/clone_in.rs index bc21ed2501a21..ee5779163b355 100644 --- a/crates/oxc_allocator/src/clone_in.rs +++ b/crates/oxc_allocator/src/clone_in.rs @@ -67,10 +67,10 @@ where } impl<'alloc, T: Copy> CloneIn<'alloc> for Cell { - type Cloned = Cell; + type Cloned = Self; fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned { - Cell::new(self.get()) + Self::new(self.get()) } } diff --git a/crates/oxc_allocator/src/string.rs b/crates/oxc_allocator/src/string.rs index f6684af5dcecd..4b36bf7486860 100644 --- a/crates/oxc_allocator/src/string.rs +++ b/crates/oxc_allocator/src/string.rs @@ -44,7 +44,7 @@ impl<'alloc> String<'alloc> { /// /// [`with_capacity_in`]: String::with_capacity_in #[inline(always)] - pub fn new_in(allocator: &'alloc Allocator) -> String<'alloc> { + pub fn new_in(allocator: &'alloc Allocator) -> Self { Self(ManuallyDrop::new(BumpaloString::new_in(allocator.bump()))) } @@ -63,7 +63,7 @@ impl<'alloc> String<'alloc> { /// [`capacity`]: String::capacity /// [`new_in`]: String::new_in #[inline(always)] - pub fn with_capacity_in(capacity: usize, allocator: &'alloc Allocator) -> String<'alloc> { + pub fn with_capacity_in(capacity: usize, allocator: &'alloc Allocator) -> Self { Self(ManuallyDrop::new(BumpaloString::with_capacity_in(capacity, allocator.bump()))) } @@ -79,7 +79,7 @@ impl<'alloc> String<'alloc> { /// assert_eq!(s, "hello"); /// ``` #[inline(always)] - pub fn from_str_in(s: &str, allocator: &'alloc Allocator) -> String<'alloc> { + pub fn from_str_in(s: &str, allocator: &'alloc Allocator) -> Self { Self(ManuallyDrop::new(BumpaloString::from_str_in(s, allocator.bump()))) } @@ -87,7 +87,7 @@ impl<'alloc> String<'alloc> { /// /// # Errors /// Returns [`Err`] if the `Vec` does not comprise a valid UTF-8 string. - pub fn from_utf8(bytes: Vec<'alloc, u8>) -> Result, Utf8Error> { + pub fn from_utf8(bytes: Vec<'alloc, u8>) -> Result { // Check vec comprises a valid UTF-8 string. from_utf8(&bytes)?; // SAFETY: We just checked it's a valid UTF-8 string @@ -105,7 +105,7 @@ impl<'alloc> String<'alloc> { // `#[inline(always)]` because this is a no-op at runtime #[expect(clippy::missing_safety_doc, clippy::unnecessary_safety_comment)] #[inline(always)] - pub unsafe fn from_utf8_unchecked(bytes: Vec<'alloc, u8>) -> String<'alloc> { + pub unsafe fn from_utf8_unchecked(bytes: Vec<'alloc, u8>) -> Self { // Cannot use `bumpalo::String::from_utf8_unchecked` because it takes a `bumpalo::collections::Vec`, // and our inner `Vec` type is `allocator_api2::vec::Vec`. // SAFETY: Conversion is safe because both types store data in arena in same way. @@ -156,7 +156,7 @@ impl<'alloc> String<'alloc> { length: usize, capacity: usize, allocator: &'alloc Allocator, - ) -> String<'alloc> { + ) -> Self { // SAFETY: Safety conditions of this method are the same as `BumpaloString`'s method let inner = BumpaloString::from_raw_parts_in(buf, length, capacity, allocator.bump()); Self(ManuallyDrop::new(inner)) diff --git a/crates/oxc_ast/src/ast_impl/js.rs b/crates/oxc_ast/src/ast_impl/js.rs index 5ecd777cc1427..e81a899ed4f5a 100644 --- a/crates/oxc_ast/src/ast_impl/js.rs +++ b/crates/oxc_ast/src/ast_impl/js.rs @@ -202,7 +202,7 @@ impl<'a> Expression<'a> { /// /// For getting a reference to the expression inside, use [`Expression::get_inner_expression`]. #[must_use] - pub fn into_inner_expression(self) -> Expression<'a> { + pub fn into_inner_expression(self) -> Self { let mut expr = self; loop { expr = match expr { @@ -225,7 +225,7 @@ impl<'a> Expression<'a> { /// /// For taking ownership of the expression inside, use [`Expression::into_inner_expression`]. /// For getting a mutable reference to the expression inside, use [`Expression::get_inner_expression_mut`]. - pub fn get_inner_expression(&self) -> &Expression<'a> { + pub fn get_inner_expression(&self) -> &Self { let mut expr = self; loop { expr = match expr { @@ -248,7 +248,7 @@ impl<'a> Expression<'a> { /// /// For taking ownership of the expression inside, use [`Expression::into_inner_expression`]. /// For getting an immutable reference to the expression inside, use [`Expression::get_inner_expression`]. - pub fn get_inner_expression_mut(&mut self) -> &mut Expression<'a> { + pub fn get_inner_expression_mut(&mut self) -> &mut Self { let mut expr = self; loop { expr = match expr { diff --git a/crates/oxc_ast/src/ast_impl/ts.rs b/crates/oxc_ast/src/ast_impl/ts.rs index af97bced35f54..358734e916471 100644 --- a/crates/oxc_ast/src/ast_impl/ts.rs +++ b/crates/oxc_ast/src/ast_impl/ts.rs @@ -174,7 +174,7 @@ impl TSModuleDeclaration<'_> { impl TSModuleDeclarationKind { /// Returns `true` for `declare global { ... }` pub fn is_global(self) -> bool { - matches!(self, TSModuleDeclarationKind::Global) + matches!(self, Self::Global) } /// Declaration keyword as a string, identical to how it would appear in the @@ -304,9 +304,9 @@ impl TSTypeOperatorOperator { /// Get the operator string as it would appear in the source code. pub fn to_str(self) -> &'static str { match self { - TSTypeOperatorOperator::Keyof => "keyof", - TSTypeOperatorOperator::Readonly => "readonly", - TSTypeOperatorOperator::Unique => "unique", + Self::Keyof => "keyof", + Self::Readonly => "readonly", + Self::Unique => "unique", } } } diff --git a/crates/oxc_ast/src/generated/derive_clone_in.rs b/crates/oxc_ast/src/generated/derive_clone_in.rs index 6faaae0bd28db..9a2987598f713 100644 --- a/crates/oxc_ast/src/generated/derive_clone_in.rs +++ b/crates/oxc_ast/src/generated/derive_clone_in.rs @@ -1,7 +1,7 @@ // Auto-generated code, DO NOT EDIT DIRECTLY! // To edit this generated file you have to edit `tasks/ast_tools/src/derives/clone_in.rs` -#![allow(clippy::default_trait_access)] +#![allow(clippy::default_trait_access, clippy::use_self)] use oxc_allocator::{Allocator, CloneIn}; diff --git a/crates/oxc_ast/src/generated/derive_estree.rs b/crates/oxc_ast/src/generated/derive_estree.rs index ccc4529b774db..540aa0d86c9b3 100644 --- a/crates/oxc_ast/src/generated/derive_estree.rs +++ b/crates/oxc_ast/src/generated/derive_estree.rs @@ -31,48 +31,48 @@ impl Serialize for Program<'_> { impl Serialize for Expression<'_> { fn serialize(&self, serializer: S) -> Result { match self { - Expression::BooleanLiteral(it) => it.serialize(serializer), - Expression::NullLiteral(it) => it.serialize(serializer), - Expression::NumericLiteral(it) => it.serialize(serializer), - Expression::BigIntLiteral(it) => it.serialize(serializer), - Expression::RegExpLiteral(it) => it.serialize(serializer), - Expression::StringLiteral(it) => it.serialize(serializer), - Expression::TemplateLiteral(it) => it.serialize(serializer), - Expression::Identifier(it) => it.serialize(serializer), - Expression::MetaProperty(it) => it.serialize(serializer), - Expression::Super(it) => it.serialize(serializer), - Expression::ArrayExpression(it) => it.serialize(serializer), - Expression::ArrowFunctionExpression(it) => it.serialize(serializer), - Expression::AssignmentExpression(it) => it.serialize(serializer), - Expression::AwaitExpression(it) => it.serialize(serializer), - Expression::BinaryExpression(it) => it.serialize(serializer), - Expression::CallExpression(it) => it.serialize(serializer), - Expression::ChainExpression(it) => it.serialize(serializer), - Expression::ClassExpression(it) => it.serialize(serializer), - Expression::ConditionalExpression(it) => it.serialize(serializer), - Expression::FunctionExpression(it) => it.serialize(serializer), - Expression::ImportExpression(it) => it.serialize(serializer), - Expression::LogicalExpression(it) => it.serialize(serializer), - Expression::NewExpression(it) => it.serialize(serializer), - Expression::ObjectExpression(it) => it.serialize(serializer), - Expression::ParenthesizedExpression(it) => it.serialize(serializer), - Expression::SequenceExpression(it) => it.serialize(serializer), - Expression::TaggedTemplateExpression(it) => it.serialize(serializer), - Expression::ThisExpression(it) => it.serialize(serializer), - Expression::UnaryExpression(it) => it.serialize(serializer), - Expression::UpdateExpression(it) => it.serialize(serializer), - Expression::YieldExpression(it) => it.serialize(serializer), - Expression::PrivateInExpression(it) => it.serialize(serializer), - Expression::JSXElement(it) => it.serialize(serializer), - Expression::JSXFragment(it) => it.serialize(serializer), - Expression::TSAsExpression(it) => it.serialize(serializer), - Expression::TSSatisfiesExpression(it) => it.serialize(serializer), - Expression::TSTypeAssertion(it) => it.serialize(serializer), - Expression::TSNonNullExpression(it) => it.serialize(serializer), - Expression::TSInstantiationExpression(it) => it.serialize(serializer), - Expression::ComputedMemberExpression(it) => it.serialize(serializer), - Expression::StaticMemberExpression(it) => it.serialize(serializer), - Expression::PrivateFieldExpression(it) => it.serialize(serializer), + Self::BooleanLiteral(it) => it.serialize(serializer), + Self::NullLiteral(it) => it.serialize(serializer), + Self::NumericLiteral(it) => it.serialize(serializer), + Self::BigIntLiteral(it) => it.serialize(serializer), + Self::RegExpLiteral(it) => it.serialize(serializer), + Self::StringLiteral(it) => it.serialize(serializer), + Self::TemplateLiteral(it) => it.serialize(serializer), + Self::Identifier(it) => it.serialize(serializer), + Self::MetaProperty(it) => it.serialize(serializer), + Self::Super(it) => it.serialize(serializer), + Self::ArrayExpression(it) => it.serialize(serializer), + Self::ArrowFunctionExpression(it) => it.serialize(serializer), + Self::AssignmentExpression(it) => it.serialize(serializer), + Self::AwaitExpression(it) => it.serialize(serializer), + Self::BinaryExpression(it) => it.serialize(serializer), + Self::CallExpression(it) => it.serialize(serializer), + Self::ChainExpression(it) => it.serialize(serializer), + Self::ClassExpression(it) => it.serialize(serializer), + Self::ConditionalExpression(it) => it.serialize(serializer), + Self::FunctionExpression(it) => it.serialize(serializer), + Self::ImportExpression(it) => it.serialize(serializer), + Self::LogicalExpression(it) => it.serialize(serializer), + Self::NewExpression(it) => it.serialize(serializer), + Self::ObjectExpression(it) => it.serialize(serializer), + Self::ParenthesizedExpression(it) => it.serialize(serializer), + Self::SequenceExpression(it) => it.serialize(serializer), + Self::TaggedTemplateExpression(it) => it.serialize(serializer), + Self::ThisExpression(it) => it.serialize(serializer), + Self::UnaryExpression(it) => it.serialize(serializer), + Self::UpdateExpression(it) => it.serialize(serializer), + Self::YieldExpression(it) => it.serialize(serializer), + Self::PrivateInExpression(it) => it.serialize(serializer), + Self::JSXElement(it) => it.serialize(serializer), + Self::JSXFragment(it) => it.serialize(serializer), + Self::TSAsExpression(it) => it.serialize(serializer), + Self::TSSatisfiesExpression(it) => it.serialize(serializer), + Self::TSTypeAssertion(it) => it.serialize(serializer), + Self::TSNonNullExpression(it) => it.serialize(serializer), + Self::TSInstantiationExpression(it) => it.serialize(serializer), + Self::ComputedMemberExpression(it) => it.serialize(serializer), + Self::StaticMemberExpression(it) => it.serialize(serializer), + Self::PrivateFieldExpression(it) => it.serialize(serializer), } } } @@ -145,50 +145,50 @@ impl Serialize for ArrayExpression<'_> { impl Serialize for ArrayExpressionElement<'_> { fn serialize(&self, serializer: S) -> Result { match self { - ArrayExpressionElement::SpreadElement(it) => it.serialize(serializer), - ArrayExpressionElement::Elision(it) => it.serialize(serializer), - ArrayExpressionElement::BooleanLiteral(it) => it.serialize(serializer), - ArrayExpressionElement::NullLiteral(it) => it.serialize(serializer), - ArrayExpressionElement::NumericLiteral(it) => it.serialize(serializer), - ArrayExpressionElement::BigIntLiteral(it) => it.serialize(serializer), - ArrayExpressionElement::RegExpLiteral(it) => it.serialize(serializer), - ArrayExpressionElement::StringLiteral(it) => it.serialize(serializer), - ArrayExpressionElement::TemplateLiteral(it) => it.serialize(serializer), - ArrayExpressionElement::Identifier(it) => it.serialize(serializer), - ArrayExpressionElement::MetaProperty(it) => it.serialize(serializer), - ArrayExpressionElement::Super(it) => it.serialize(serializer), - ArrayExpressionElement::ArrayExpression(it) => it.serialize(serializer), - ArrayExpressionElement::ArrowFunctionExpression(it) => it.serialize(serializer), - ArrayExpressionElement::AssignmentExpression(it) => it.serialize(serializer), - ArrayExpressionElement::AwaitExpression(it) => it.serialize(serializer), - ArrayExpressionElement::BinaryExpression(it) => it.serialize(serializer), - ArrayExpressionElement::CallExpression(it) => it.serialize(serializer), - ArrayExpressionElement::ChainExpression(it) => it.serialize(serializer), - ArrayExpressionElement::ClassExpression(it) => it.serialize(serializer), - ArrayExpressionElement::ConditionalExpression(it) => it.serialize(serializer), - ArrayExpressionElement::FunctionExpression(it) => it.serialize(serializer), - ArrayExpressionElement::ImportExpression(it) => it.serialize(serializer), - ArrayExpressionElement::LogicalExpression(it) => it.serialize(serializer), - ArrayExpressionElement::NewExpression(it) => it.serialize(serializer), - ArrayExpressionElement::ObjectExpression(it) => it.serialize(serializer), - ArrayExpressionElement::ParenthesizedExpression(it) => it.serialize(serializer), - ArrayExpressionElement::SequenceExpression(it) => it.serialize(serializer), - ArrayExpressionElement::TaggedTemplateExpression(it) => it.serialize(serializer), - ArrayExpressionElement::ThisExpression(it) => it.serialize(serializer), - ArrayExpressionElement::UnaryExpression(it) => it.serialize(serializer), - ArrayExpressionElement::UpdateExpression(it) => it.serialize(serializer), - ArrayExpressionElement::YieldExpression(it) => it.serialize(serializer), - ArrayExpressionElement::PrivateInExpression(it) => it.serialize(serializer), - ArrayExpressionElement::JSXElement(it) => it.serialize(serializer), - ArrayExpressionElement::JSXFragment(it) => it.serialize(serializer), - ArrayExpressionElement::TSAsExpression(it) => it.serialize(serializer), - ArrayExpressionElement::TSSatisfiesExpression(it) => it.serialize(serializer), - ArrayExpressionElement::TSTypeAssertion(it) => it.serialize(serializer), - ArrayExpressionElement::TSNonNullExpression(it) => it.serialize(serializer), - ArrayExpressionElement::TSInstantiationExpression(it) => it.serialize(serializer), - ArrayExpressionElement::ComputedMemberExpression(it) => it.serialize(serializer), - ArrayExpressionElement::StaticMemberExpression(it) => it.serialize(serializer), - ArrayExpressionElement::PrivateFieldExpression(it) => it.serialize(serializer), + Self::SpreadElement(it) => it.serialize(serializer), + Self::Elision(it) => it.serialize(serializer), + Self::BooleanLiteral(it) => it.serialize(serializer), + Self::NullLiteral(it) => it.serialize(serializer), + Self::NumericLiteral(it) => it.serialize(serializer), + Self::BigIntLiteral(it) => it.serialize(serializer), + Self::RegExpLiteral(it) => it.serialize(serializer), + Self::StringLiteral(it) => it.serialize(serializer), + Self::TemplateLiteral(it) => it.serialize(serializer), + Self::Identifier(it) => it.serialize(serializer), + Self::MetaProperty(it) => it.serialize(serializer), + Self::Super(it) => it.serialize(serializer), + Self::ArrayExpression(it) => it.serialize(serializer), + Self::ArrowFunctionExpression(it) => it.serialize(serializer), + Self::AssignmentExpression(it) => it.serialize(serializer), + Self::AwaitExpression(it) => it.serialize(serializer), + Self::BinaryExpression(it) => it.serialize(serializer), + Self::CallExpression(it) => it.serialize(serializer), + Self::ChainExpression(it) => it.serialize(serializer), + Self::ClassExpression(it) => it.serialize(serializer), + Self::ConditionalExpression(it) => it.serialize(serializer), + Self::FunctionExpression(it) => it.serialize(serializer), + Self::ImportExpression(it) => it.serialize(serializer), + Self::LogicalExpression(it) => it.serialize(serializer), + Self::NewExpression(it) => it.serialize(serializer), + Self::ObjectExpression(it) => it.serialize(serializer), + Self::ParenthesizedExpression(it) => it.serialize(serializer), + Self::SequenceExpression(it) => it.serialize(serializer), + Self::TaggedTemplateExpression(it) => it.serialize(serializer), + Self::ThisExpression(it) => it.serialize(serializer), + Self::UnaryExpression(it) => it.serialize(serializer), + Self::UpdateExpression(it) => it.serialize(serializer), + Self::YieldExpression(it) => it.serialize(serializer), + Self::PrivateInExpression(it) => it.serialize(serializer), + Self::JSXElement(it) => it.serialize(serializer), + Self::JSXFragment(it) => it.serialize(serializer), + Self::TSAsExpression(it) => it.serialize(serializer), + Self::TSSatisfiesExpression(it) => it.serialize(serializer), + Self::TSTypeAssertion(it) => it.serialize(serializer), + Self::TSNonNullExpression(it) => it.serialize(serializer), + Self::TSInstantiationExpression(it) => it.serialize(serializer), + Self::ComputedMemberExpression(it) => it.serialize(serializer), + Self::StaticMemberExpression(it) => it.serialize(serializer), + Self::PrivateFieldExpression(it) => it.serialize(serializer), } } } @@ -207,8 +207,8 @@ impl Serialize for ObjectExpression<'_> { impl Serialize for ObjectPropertyKind<'_> { fn serialize(&self, serializer: S) -> Result { match self { - ObjectPropertyKind::ObjectProperty(it) => it.serialize(serializer), - ObjectPropertyKind::SpreadProperty(it) => it.serialize(serializer), + Self::ObjectProperty(it) => it.serialize(serializer), + Self::SpreadProperty(it) => it.serialize(serializer), } } } @@ -216,50 +216,50 @@ impl Serialize for ObjectPropertyKind<'_> { impl Serialize for PropertyKey<'_> { fn serialize(&self, serializer: S) -> Result { match self { - PropertyKey::StaticIdentifier(it) => it.serialize(serializer), - PropertyKey::PrivateIdentifier(it) => it.serialize(serializer), - PropertyKey::BooleanLiteral(it) => it.serialize(serializer), - PropertyKey::NullLiteral(it) => it.serialize(serializer), - PropertyKey::NumericLiteral(it) => it.serialize(serializer), - PropertyKey::BigIntLiteral(it) => it.serialize(serializer), - PropertyKey::RegExpLiteral(it) => it.serialize(serializer), - PropertyKey::StringLiteral(it) => it.serialize(serializer), - PropertyKey::TemplateLiteral(it) => it.serialize(serializer), - PropertyKey::Identifier(it) => it.serialize(serializer), - PropertyKey::MetaProperty(it) => it.serialize(serializer), - PropertyKey::Super(it) => it.serialize(serializer), - PropertyKey::ArrayExpression(it) => it.serialize(serializer), - PropertyKey::ArrowFunctionExpression(it) => it.serialize(serializer), - PropertyKey::AssignmentExpression(it) => it.serialize(serializer), - PropertyKey::AwaitExpression(it) => it.serialize(serializer), - PropertyKey::BinaryExpression(it) => it.serialize(serializer), - PropertyKey::CallExpression(it) => it.serialize(serializer), - PropertyKey::ChainExpression(it) => it.serialize(serializer), - PropertyKey::ClassExpression(it) => it.serialize(serializer), - PropertyKey::ConditionalExpression(it) => it.serialize(serializer), - PropertyKey::FunctionExpression(it) => it.serialize(serializer), - PropertyKey::ImportExpression(it) => it.serialize(serializer), - PropertyKey::LogicalExpression(it) => it.serialize(serializer), - PropertyKey::NewExpression(it) => it.serialize(serializer), - PropertyKey::ObjectExpression(it) => it.serialize(serializer), - PropertyKey::ParenthesizedExpression(it) => it.serialize(serializer), - PropertyKey::SequenceExpression(it) => it.serialize(serializer), - PropertyKey::TaggedTemplateExpression(it) => it.serialize(serializer), - PropertyKey::ThisExpression(it) => it.serialize(serializer), - PropertyKey::UnaryExpression(it) => it.serialize(serializer), - PropertyKey::UpdateExpression(it) => it.serialize(serializer), - PropertyKey::YieldExpression(it) => it.serialize(serializer), - PropertyKey::PrivateInExpression(it) => it.serialize(serializer), - PropertyKey::JSXElement(it) => it.serialize(serializer), - PropertyKey::JSXFragment(it) => it.serialize(serializer), - PropertyKey::TSAsExpression(it) => it.serialize(serializer), - PropertyKey::TSSatisfiesExpression(it) => it.serialize(serializer), - PropertyKey::TSTypeAssertion(it) => it.serialize(serializer), - PropertyKey::TSNonNullExpression(it) => it.serialize(serializer), - PropertyKey::TSInstantiationExpression(it) => it.serialize(serializer), - PropertyKey::ComputedMemberExpression(it) => it.serialize(serializer), - PropertyKey::StaticMemberExpression(it) => it.serialize(serializer), - PropertyKey::PrivateFieldExpression(it) => it.serialize(serializer), + Self::StaticIdentifier(it) => it.serialize(serializer), + Self::PrivateIdentifier(it) => it.serialize(serializer), + Self::BooleanLiteral(it) => it.serialize(serializer), + Self::NullLiteral(it) => it.serialize(serializer), + Self::NumericLiteral(it) => it.serialize(serializer), + Self::BigIntLiteral(it) => it.serialize(serializer), + Self::RegExpLiteral(it) => it.serialize(serializer), + Self::StringLiteral(it) => it.serialize(serializer), + Self::TemplateLiteral(it) => it.serialize(serializer), + Self::Identifier(it) => it.serialize(serializer), + Self::MetaProperty(it) => it.serialize(serializer), + Self::Super(it) => it.serialize(serializer), + Self::ArrayExpression(it) => it.serialize(serializer), + Self::ArrowFunctionExpression(it) => it.serialize(serializer), + Self::AssignmentExpression(it) => it.serialize(serializer), + Self::AwaitExpression(it) => it.serialize(serializer), + Self::BinaryExpression(it) => it.serialize(serializer), + Self::CallExpression(it) => it.serialize(serializer), + Self::ChainExpression(it) => it.serialize(serializer), + Self::ClassExpression(it) => it.serialize(serializer), + Self::ConditionalExpression(it) => it.serialize(serializer), + Self::FunctionExpression(it) => it.serialize(serializer), + Self::ImportExpression(it) => it.serialize(serializer), + Self::LogicalExpression(it) => it.serialize(serializer), + Self::NewExpression(it) => it.serialize(serializer), + Self::ObjectExpression(it) => it.serialize(serializer), + Self::ParenthesizedExpression(it) => it.serialize(serializer), + Self::SequenceExpression(it) => it.serialize(serializer), + Self::TaggedTemplateExpression(it) => it.serialize(serializer), + Self::ThisExpression(it) => it.serialize(serializer), + Self::UnaryExpression(it) => it.serialize(serializer), + Self::UpdateExpression(it) => it.serialize(serializer), + Self::YieldExpression(it) => it.serialize(serializer), + Self::PrivateInExpression(it) => it.serialize(serializer), + Self::JSXElement(it) => it.serialize(serializer), + Self::JSXFragment(it) => it.serialize(serializer), + Self::TSAsExpression(it) => it.serialize(serializer), + Self::TSSatisfiesExpression(it) => it.serialize(serializer), + Self::TSTypeAssertion(it) => it.serialize(serializer), + Self::TSNonNullExpression(it) => it.serialize(serializer), + Self::TSInstantiationExpression(it) => it.serialize(serializer), + Self::ComputedMemberExpression(it) => it.serialize(serializer), + Self::StaticMemberExpression(it) => it.serialize(serializer), + Self::PrivateFieldExpression(it) => it.serialize(serializer), } } } @@ -267,9 +267,9 @@ impl Serialize for PropertyKey<'_> { impl Serialize for PropertyKind { fn serialize(&self, serializer: S) -> Result { match self { - 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"), + Self::Init => serializer.serialize_unit_variant("PropertyKind", 0, "init"), + Self::Get => serializer.serialize_unit_variant("PropertyKind", 1, "get"), + Self::Set => serializer.serialize_unit_variant("PropertyKind", 2, "set"), } } } @@ -323,9 +323,9 @@ impl Serialize for TemplateElementValue<'_> { impl Serialize for MemberExpression<'_> { fn serialize(&self, serializer: S) -> Result { match self { - MemberExpression::ComputedMemberExpression(it) => it.serialize(serializer), - MemberExpression::StaticMemberExpression(it) => it.serialize(serializer), - MemberExpression::PrivateFieldExpression(it) => it.serialize(serializer), + Self::ComputedMemberExpression(it) => it.serialize(serializer), + Self::StaticMemberExpression(it) => it.serialize(serializer), + Self::PrivateFieldExpression(it) => it.serialize(serializer), } } } @@ -425,49 +425,49 @@ impl Serialize for SpreadElement<'_> { impl Serialize for Argument<'_> { fn serialize(&self, serializer: S) -> Result { match self { - Argument::SpreadElement(it) => it.serialize(serializer), - Argument::BooleanLiteral(it) => it.serialize(serializer), - Argument::NullLiteral(it) => it.serialize(serializer), - Argument::NumericLiteral(it) => it.serialize(serializer), - Argument::BigIntLiteral(it) => it.serialize(serializer), - Argument::RegExpLiteral(it) => it.serialize(serializer), - Argument::StringLiteral(it) => it.serialize(serializer), - Argument::TemplateLiteral(it) => it.serialize(serializer), - Argument::Identifier(it) => it.serialize(serializer), - Argument::MetaProperty(it) => it.serialize(serializer), - Argument::Super(it) => it.serialize(serializer), - Argument::ArrayExpression(it) => it.serialize(serializer), - Argument::ArrowFunctionExpression(it) => it.serialize(serializer), - Argument::AssignmentExpression(it) => it.serialize(serializer), - Argument::AwaitExpression(it) => it.serialize(serializer), - Argument::BinaryExpression(it) => it.serialize(serializer), - Argument::CallExpression(it) => it.serialize(serializer), - Argument::ChainExpression(it) => it.serialize(serializer), - Argument::ClassExpression(it) => it.serialize(serializer), - Argument::ConditionalExpression(it) => it.serialize(serializer), - Argument::FunctionExpression(it) => it.serialize(serializer), - Argument::ImportExpression(it) => it.serialize(serializer), - Argument::LogicalExpression(it) => it.serialize(serializer), - Argument::NewExpression(it) => it.serialize(serializer), - Argument::ObjectExpression(it) => it.serialize(serializer), - Argument::ParenthesizedExpression(it) => it.serialize(serializer), - Argument::SequenceExpression(it) => it.serialize(serializer), - Argument::TaggedTemplateExpression(it) => it.serialize(serializer), - Argument::ThisExpression(it) => it.serialize(serializer), - Argument::UnaryExpression(it) => it.serialize(serializer), - Argument::UpdateExpression(it) => it.serialize(serializer), - Argument::YieldExpression(it) => it.serialize(serializer), - Argument::PrivateInExpression(it) => it.serialize(serializer), - Argument::JSXElement(it) => it.serialize(serializer), - Argument::JSXFragment(it) => it.serialize(serializer), - Argument::TSAsExpression(it) => it.serialize(serializer), - Argument::TSSatisfiesExpression(it) => it.serialize(serializer), - Argument::TSTypeAssertion(it) => it.serialize(serializer), - Argument::TSNonNullExpression(it) => it.serialize(serializer), - Argument::TSInstantiationExpression(it) => it.serialize(serializer), - Argument::ComputedMemberExpression(it) => it.serialize(serializer), - Argument::StaticMemberExpression(it) => it.serialize(serializer), - Argument::PrivateFieldExpression(it) => it.serialize(serializer), + Self::SpreadElement(it) => it.serialize(serializer), + Self::BooleanLiteral(it) => it.serialize(serializer), + Self::NullLiteral(it) => it.serialize(serializer), + Self::NumericLiteral(it) => it.serialize(serializer), + Self::BigIntLiteral(it) => it.serialize(serializer), + Self::RegExpLiteral(it) => it.serialize(serializer), + Self::StringLiteral(it) => it.serialize(serializer), + Self::TemplateLiteral(it) => it.serialize(serializer), + Self::Identifier(it) => it.serialize(serializer), + Self::MetaProperty(it) => it.serialize(serializer), + Self::Super(it) => it.serialize(serializer), + Self::ArrayExpression(it) => it.serialize(serializer), + Self::ArrowFunctionExpression(it) => it.serialize(serializer), + Self::AssignmentExpression(it) => it.serialize(serializer), + Self::AwaitExpression(it) => it.serialize(serializer), + Self::BinaryExpression(it) => it.serialize(serializer), + Self::CallExpression(it) => it.serialize(serializer), + Self::ChainExpression(it) => it.serialize(serializer), + Self::ClassExpression(it) => it.serialize(serializer), + Self::ConditionalExpression(it) => it.serialize(serializer), + Self::FunctionExpression(it) => it.serialize(serializer), + Self::ImportExpression(it) => it.serialize(serializer), + Self::LogicalExpression(it) => it.serialize(serializer), + Self::NewExpression(it) => it.serialize(serializer), + Self::ObjectExpression(it) => it.serialize(serializer), + Self::ParenthesizedExpression(it) => it.serialize(serializer), + Self::SequenceExpression(it) => it.serialize(serializer), + Self::TaggedTemplateExpression(it) => it.serialize(serializer), + Self::ThisExpression(it) => it.serialize(serializer), + Self::UnaryExpression(it) => it.serialize(serializer), + Self::UpdateExpression(it) => it.serialize(serializer), + Self::YieldExpression(it) => it.serialize(serializer), + Self::PrivateInExpression(it) => it.serialize(serializer), + Self::JSXElement(it) => it.serialize(serializer), + Self::JSXFragment(it) => it.serialize(serializer), + Self::TSAsExpression(it) => it.serialize(serializer), + Self::TSSatisfiesExpression(it) => it.serialize(serializer), + Self::TSTypeAssertion(it) => it.serialize(serializer), + Self::TSNonNullExpression(it) => it.serialize(serializer), + Self::TSInstantiationExpression(it) => it.serialize(serializer), + Self::ComputedMemberExpression(it) => it.serialize(serializer), + Self::StaticMemberExpression(it) => it.serialize(serializer), + Self::PrivateFieldExpression(it) => it.serialize(serializer), } } } @@ -566,17 +566,17 @@ impl Serialize for AssignmentExpression<'_> { impl Serialize for AssignmentTarget<'_> { fn serialize(&self, serializer: S) -> Result { match self { - AssignmentTarget::AssignmentTargetIdentifier(it) => it.serialize(serializer), - AssignmentTarget::TSAsExpression(it) => it.serialize(serializer), - AssignmentTarget::TSSatisfiesExpression(it) => it.serialize(serializer), - AssignmentTarget::TSNonNullExpression(it) => it.serialize(serializer), - AssignmentTarget::TSTypeAssertion(it) => it.serialize(serializer), - AssignmentTarget::TSInstantiationExpression(it) => it.serialize(serializer), - AssignmentTarget::ComputedMemberExpression(it) => it.serialize(serializer), - AssignmentTarget::StaticMemberExpression(it) => it.serialize(serializer), - AssignmentTarget::PrivateFieldExpression(it) => it.serialize(serializer), - AssignmentTarget::ArrayAssignmentTarget(it) => it.serialize(serializer), - AssignmentTarget::ObjectAssignmentTarget(it) => it.serialize(serializer), + Self::AssignmentTargetIdentifier(it) => it.serialize(serializer), + Self::TSAsExpression(it) => it.serialize(serializer), + Self::TSSatisfiesExpression(it) => it.serialize(serializer), + Self::TSNonNullExpression(it) => it.serialize(serializer), + Self::TSTypeAssertion(it) => it.serialize(serializer), + Self::TSInstantiationExpression(it) => it.serialize(serializer), + Self::ComputedMemberExpression(it) => it.serialize(serializer), + Self::StaticMemberExpression(it) => it.serialize(serializer), + Self::PrivateFieldExpression(it) => it.serialize(serializer), + Self::ArrayAssignmentTarget(it) => it.serialize(serializer), + Self::ObjectAssignmentTarget(it) => it.serialize(serializer), } } } @@ -584,15 +584,15 @@ impl Serialize for AssignmentTarget<'_> { impl Serialize for SimpleAssignmentTarget<'_> { fn serialize(&self, serializer: S) -> Result { match self { - SimpleAssignmentTarget::AssignmentTargetIdentifier(it) => it.serialize(serializer), - SimpleAssignmentTarget::TSAsExpression(it) => it.serialize(serializer), - SimpleAssignmentTarget::TSSatisfiesExpression(it) => it.serialize(serializer), - SimpleAssignmentTarget::TSNonNullExpression(it) => it.serialize(serializer), - SimpleAssignmentTarget::TSTypeAssertion(it) => it.serialize(serializer), - SimpleAssignmentTarget::TSInstantiationExpression(it) => it.serialize(serializer), - SimpleAssignmentTarget::ComputedMemberExpression(it) => it.serialize(serializer), - SimpleAssignmentTarget::StaticMemberExpression(it) => it.serialize(serializer), - SimpleAssignmentTarget::PrivateFieldExpression(it) => it.serialize(serializer), + Self::AssignmentTargetIdentifier(it) => it.serialize(serializer), + Self::TSAsExpression(it) => it.serialize(serializer), + Self::TSSatisfiesExpression(it) => it.serialize(serializer), + Self::TSNonNullExpression(it) => it.serialize(serializer), + Self::TSTypeAssertion(it) => it.serialize(serializer), + Self::TSInstantiationExpression(it) => it.serialize(serializer), + Self::ComputedMemberExpression(it) => it.serialize(serializer), + Self::StaticMemberExpression(it) => it.serialize(serializer), + Self::PrivateFieldExpression(it) => it.serialize(serializer), } } } @@ -600,8 +600,8 @@ impl Serialize for SimpleAssignmentTarget<'_> { impl Serialize for AssignmentTargetPattern<'_> { fn serialize(&self, serializer: S) -> Result { match self { - AssignmentTargetPattern::ArrayAssignmentTarget(it) => it.serialize(serializer), - AssignmentTargetPattern::ObjectAssignmentTarget(it) => it.serialize(serializer), + Self::ArrayAssignmentTarget(it) => it.serialize(serializer), + Self::ObjectAssignmentTarget(it) => it.serialize(serializer), } } } @@ -645,22 +645,18 @@ impl Serialize for AssignmentTargetRest<'_> { impl Serialize for AssignmentTargetMaybeDefault<'_> { fn serialize(&self, serializer: S) -> Result { match self { - AssignmentTargetMaybeDefault::AssignmentTargetWithDefault(it) => { - it.serialize(serializer) - } - AssignmentTargetMaybeDefault::AssignmentTargetIdentifier(it) => { - it.serialize(serializer) - } - AssignmentTargetMaybeDefault::TSAsExpression(it) => it.serialize(serializer), - AssignmentTargetMaybeDefault::TSSatisfiesExpression(it) => it.serialize(serializer), - AssignmentTargetMaybeDefault::TSNonNullExpression(it) => it.serialize(serializer), - AssignmentTargetMaybeDefault::TSTypeAssertion(it) => it.serialize(serializer), - AssignmentTargetMaybeDefault::TSInstantiationExpression(it) => it.serialize(serializer), - AssignmentTargetMaybeDefault::ComputedMemberExpression(it) => it.serialize(serializer), - AssignmentTargetMaybeDefault::StaticMemberExpression(it) => it.serialize(serializer), - AssignmentTargetMaybeDefault::PrivateFieldExpression(it) => it.serialize(serializer), - AssignmentTargetMaybeDefault::ArrayAssignmentTarget(it) => it.serialize(serializer), - AssignmentTargetMaybeDefault::ObjectAssignmentTarget(it) => it.serialize(serializer), + Self::AssignmentTargetWithDefault(it) => it.serialize(serializer), + Self::AssignmentTargetIdentifier(it) => it.serialize(serializer), + Self::TSAsExpression(it) => it.serialize(serializer), + Self::TSSatisfiesExpression(it) => it.serialize(serializer), + Self::TSNonNullExpression(it) => it.serialize(serializer), + Self::TSTypeAssertion(it) => it.serialize(serializer), + Self::TSInstantiationExpression(it) => it.serialize(serializer), + Self::ComputedMemberExpression(it) => it.serialize(serializer), + Self::StaticMemberExpression(it) => it.serialize(serializer), + Self::PrivateFieldExpression(it) => it.serialize(serializer), + Self::ArrayAssignmentTarget(it) => it.serialize(serializer), + Self::ObjectAssignmentTarget(it) => it.serialize(serializer), } } } @@ -680,12 +676,8 @@ impl Serialize for AssignmentTargetWithDefault<'_> { impl Serialize for AssignmentTargetProperty<'_> { fn serialize(&self, serializer: S) -> Result { match self { - AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(it) => { - it.serialize(serializer) - } - AssignmentTargetProperty::AssignmentTargetPropertyProperty(it) => { - it.serialize(serializer) - } + Self::AssignmentTargetPropertyIdentifier(it) => it.serialize(serializer), + Self::AssignmentTargetPropertyProperty(it) => it.serialize(serializer), } } } @@ -771,11 +763,11 @@ impl Serialize for ChainExpression<'_> { impl Serialize for ChainElement<'_> { fn serialize(&self, serializer: S) -> Result { match self { - ChainElement::CallExpression(it) => it.serialize(serializer), - ChainElement::TSNonNullExpression(it) => it.serialize(serializer), - ChainElement::ComputedMemberExpression(it) => it.serialize(serializer), - ChainElement::StaticMemberExpression(it) => it.serialize(serializer), - ChainElement::PrivateFieldExpression(it) => it.serialize(serializer), + Self::CallExpression(it) => it.serialize(serializer), + Self::TSNonNullExpression(it) => it.serialize(serializer), + Self::ComputedMemberExpression(it) => it.serialize(serializer), + Self::StaticMemberExpression(it) => it.serialize(serializer), + Self::PrivateFieldExpression(it) => it.serialize(serializer), } } } @@ -794,38 +786,38 @@ impl Serialize for ParenthesizedExpression<'_> { impl Serialize for Statement<'_> { fn serialize(&self, serializer: S) -> Result { match self { - Statement::BlockStatement(it) => it.serialize(serializer), - Statement::BreakStatement(it) => it.serialize(serializer), - Statement::ContinueStatement(it) => it.serialize(serializer), - Statement::DebuggerStatement(it) => it.serialize(serializer), - Statement::DoWhileStatement(it) => it.serialize(serializer), - Statement::EmptyStatement(it) => it.serialize(serializer), - Statement::ExpressionStatement(it) => it.serialize(serializer), - Statement::ForInStatement(it) => it.serialize(serializer), - Statement::ForOfStatement(it) => it.serialize(serializer), - Statement::ForStatement(it) => it.serialize(serializer), - Statement::IfStatement(it) => it.serialize(serializer), - Statement::LabeledStatement(it) => it.serialize(serializer), - Statement::ReturnStatement(it) => it.serialize(serializer), - Statement::SwitchStatement(it) => it.serialize(serializer), - Statement::ThrowStatement(it) => it.serialize(serializer), - Statement::TryStatement(it) => it.serialize(serializer), - Statement::WhileStatement(it) => it.serialize(serializer), - Statement::WithStatement(it) => it.serialize(serializer), - Statement::VariableDeclaration(it) => it.serialize(serializer), - Statement::FunctionDeclaration(it) => it.serialize(serializer), - Statement::ClassDeclaration(it) => it.serialize(serializer), - Statement::TSTypeAliasDeclaration(it) => it.serialize(serializer), - Statement::TSInterfaceDeclaration(it) => it.serialize(serializer), - Statement::TSEnumDeclaration(it) => it.serialize(serializer), - Statement::TSModuleDeclaration(it) => it.serialize(serializer), - Statement::TSImportEqualsDeclaration(it) => it.serialize(serializer), - Statement::ImportDeclaration(it) => it.serialize(serializer), - Statement::ExportAllDeclaration(it) => it.serialize(serializer), - Statement::ExportDefaultDeclaration(it) => it.serialize(serializer), - Statement::ExportNamedDeclaration(it) => it.serialize(serializer), - Statement::TSExportAssignment(it) => it.serialize(serializer), - Statement::TSNamespaceExportDeclaration(it) => it.serialize(serializer), + Self::BlockStatement(it) => it.serialize(serializer), + Self::BreakStatement(it) => it.serialize(serializer), + Self::ContinueStatement(it) => it.serialize(serializer), + Self::DebuggerStatement(it) => it.serialize(serializer), + Self::DoWhileStatement(it) => it.serialize(serializer), + Self::EmptyStatement(it) => it.serialize(serializer), + Self::ExpressionStatement(it) => it.serialize(serializer), + Self::ForInStatement(it) => it.serialize(serializer), + Self::ForOfStatement(it) => it.serialize(serializer), + Self::ForStatement(it) => it.serialize(serializer), + Self::IfStatement(it) => it.serialize(serializer), + Self::LabeledStatement(it) => it.serialize(serializer), + Self::ReturnStatement(it) => it.serialize(serializer), + Self::SwitchStatement(it) => it.serialize(serializer), + Self::ThrowStatement(it) => it.serialize(serializer), + Self::TryStatement(it) => it.serialize(serializer), + Self::WhileStatement(it) => it.serialize(serializer), + Self::WithStatement(it) => it.serialize(serializer), + Self::VariableDeclaration(it) => it.serialize(serializer), + Self::FunctionDeclaration(it) => it.serialize(serializer), + Self::ClassDeclaration(it) => it.serialize(serializer), + Self::TSTypeAliasDeclaration(it) => it.serialize(serializer), + Self::TSInterfaceDeclaration(it) => it.serialize(serializer), + Self::TSEnumDeclaration(it) => it.serialize(serializer), + Self::TSModuleDeclaration(it) => it.serialize(serializer), + Self::TSImportEqualsDeclaration(it) => it.serialize(serializer), + Self::ImportDeclaration(it) => it.serialize(serializer), + Self::ExportAllDeclaration(it) => it.serialize(serializer), + Self::ExportDefaultDeclaration(it) => it.serialize(serializer), + Self::ExportNamedDeclaration(it) => it.serialize(serializer), + Self::TSExportAssignment(it) => it.serialize(serializer), + Self::TSNamespaceExportDeclaration(it) => it.serialize(serializer), } } } @@ -867,14 +859,14 @@ impl Serialize for BlockStatement<'_> { impl Serialize for Declaration<'_> { fn serialize(&self, serializer: S) -> Result { match self { - Declaration::VariableDeclaration(it) => it.serialize(serializer), - Declaration::FunctionDeclaration(it) => it.serialize(serializer), - Declaration::ClassDeclaration(it) => it.serialize(serializer), - Declaration::TSTypeAliasDeclaration(it) => it.serialize(serializer), - Declaration::TSInterfaceDeclaration(it) => it.serialize(serializer), - Declaration::TSEnumDeclaration(it) => it.serialize(serializer), - Declaration::TSModuleDeclaration(it) => it.serialize(serializer), - Declaration::TSImportEqualsDeclaration(it) => it.serialize(serializer), + Self::VariableDeclaration(it) => it.serialize(serializer), + Self::FunctionDeclaration(it) => it.serialize(serializer), + Self::ClassDeclaration(it) => it.serialize(serializer), + Self::TSTypeAliasDeclaration(it) => it.serialize(serializer), + Self::TSInterfaceDeclaration(it) => it.serialize(serializer), + Self::TSEnumDeclaration(it) => it.serialize(serializer), + Self::TSModuleDeclaration(it) => it.serialize(serializer), + Self::TSImportEqualsDeclaration(it) => it.serialize(serializer), } } } @@ -895,19 +887,11 @@ impl Serialize for VariableDeclaration<'_> { impl Serialize for VariableDeclarationKind { fn serialize(&self, serializer: S) -> Result { match self { - VariableDeclarationKind::Var => { - serializer.serialize_unit_variant("VariableDeclarationKind", 0, "var") - } - VariableDeclarationKind::Const => { - serializer.serialize_unit_variant("VariableDeclarationKind", 1, "const") - } - VariableDeclarationKind::Let => { - serializer.serialize_unit_variant("VariableDeclarationKind", 2, "let") - } - VariableDeclarationKind::Using => { - serializer.serialize_unit_variant("VariableDeclarationKind", 3, "using") - } - VariableDeclarationKind::AwaitUsing => { + Self::Var => serializer.serialize_unit_variant("VariableDeclarationKind", 0, "var"), + Self::Const => serializer.serialize_unit_variant("VariableDeclarationKind", 1, "const"), + Self::Let => serializer.serialize_unit_variant("VariableDeclarationKind", 2, "let"), + Self::Using => serializer.serialize_unit_variant("VariableDeclarationKind", 3, "using"), + Self::AwaitUsing => { serializer.serialize_unit_variant("VariableDeclarationKind", 4, "await using") } } @@ -1002,49 +986,49 @@ impl Serialize for ForStatement<'_> { impl Serialize for ForStatementInit<'_> { fn serialize(&self, serializer: S) -> Result { match self { - ForStatementInit::VariableDeclaration(it) => it.serialize(serializer), - ForStatementInit::BooleanLiteral(it) => it.serialize(serializer), - ForStatementInit::NullLiteral(it) => it.serialize(serializer), - ForStatementInit::NumericLiteral(it) => it.serialize(serializer), - ForStatementInit::BigIntLiteral(it) => it.serialize(serializer), - ForStatementInit::RegExpLiteral(it) => it.serialize(serializer), - ForStatementInit::StringLiteral(it) => it.serialize(serializer), - ForStatementInit::TemplateLiteral(it) => it.serialize(serializer), - ForStatementInit::Identifier(it) => it.serialize(serializer), - ForStatementInit::MetaProperty(it) => it.serialize(serializer), - ForStatementInit::Super(it) => it.serialize(serializer), - ForStatementInit::ArrayExpression(it) => it.serialize(serializer), - ForStatementInit::ArrowFunctionExpression(it) => it.serialize(serializer), - ForStatementInit::AssignmentExpression(it) => it.serialize(serializer), - ForStatementInit::AwaitExpression(it) => it.serialize(serializer), - ForStatementInit::BinaryExpression(it) => it.serialize(serializer), - ForStatementInit::CallExpression(it) => it.serialize(serializer), - ForStatementInit::ChainExpression(it) => it.serialize(serializer), - ForStatementInit::ClassExpression(it) => it.serialize(serializer), - ForStatementInit::ConditionalExpression(it) => it.serialize(serializer), - ForStatementInit::FunctionExpression(it) => it.serialize(serializer), - ForStatementInit::ImportExpression(it) => it.serialize(serializer), - ForStatementInit::LogicalExpression(it) => it.serialize(serializer), - ForStatementInit::NewExpression(it) => it.serialize(serializer), - ForStatementInit::ObjectExpression(it) => it.serialize(serializer), - ForStatementInit::ParenthesizedExpression(it) => it.serialize(serializer), - ForStatementInit::SequenceExpression(it) => it.serialize(serializer), - ForStatementInit::TaggedTemplateExpression(it) => it.serialize(serializer), - ForStatementInit::ThisExpression(it) => it.serialize(serializer), - ForStatementInit::UnaryExpression(it) => it.serialize(serializer), - ForStatementInit::UpdateExpression(it) => it.serialize(serializer), - ForStatementInit::YieldExpression(it) => it.serialize(serializer), - ForStatementInit::PrivateInExpression(it) => it.serialize(serializer), - ForStatementInit::JSXElement(it) => it.serialize(serializer), - ForStatementInit::JSXFragment(it) => it.serialize(serializer), - ForStatementInit::TSAsExpression(it) => it.serialize(serializer), - ForStatementInit::TSSatisfiesExpression(it) => it.serialize(serializer), - ForStatementInit::TSTypeAssertion(it) => it.serialize(serializer), - ForStatementInit::TSNonNullExpression(it) => it.serialize(serializer), - ForStatementInit::TSInstantiationExpression(it) => it.serialize(serializer), - ForStatementInit::ComputedMemberExpression(it) => it.serialize(serializer), - ForStatementInit::StaticMemberExpression(it) => it.serialize(serializer), - ForStatementInit::PrivateFieldExpression(it) => it.serialize(serializer), + Self::VariableDeclaration(it) => it.serialize(serializer), + Self::BooleanLiteral(it) => it.serialize(serializer), + Self::NullLiteral(it) => it.serialize(serializer), + Self::NumericLiteral(it) => it.serialize(serializer), + Self::BigIntLiteral(it) => it.serialize(serializer), + Self::RegExpLiteral(it) => it.serialize(serializer), + Self::StringLiteral(it) => it.serialize(serializer), + Self::TemplateLiteral(it) => it.serialize(serializer), + Self::Identifier(it) => it.serialize(serializer), + Self::MetaProperty(it) => it.serialize(serializer), + Self::Super(it) => it.serialize(serializer), + Self::ArrayExpression(it) => it.serialize(serializer), + Self::ArrowFunctionExpression(it) => it.serialize(serializer), + Self::AssignmentExpression(it) => it.serialize(serializer), + Self::AwaitExpression(it) => it.serialize(serializer), + Self::BinaryExpression(it) => it.serialize(serializer), + Self::CallExpression(it) => it.serialize(serializer), + Self::ChainExpression(it) => it.serialize(serializer), + Self::ClassExpression(it) => it.serialize(serializer), + Self::ConditionalExpression(it) => it.serialize(serializer), + Self::FunctionExpression(it) => it.serialize(serializer), + Self::ImportExpression(it) => it.serialize(serializer), + Self::LogicalExpression(it) => it.serialize(serializer), + Self::NewExpression(it) => it.serialize(serializer), + Self::ObjectExpression(it) => it.serialize(serializer), + Self::ParenthesizedExpression(it) => it.serialize(serializer), + Self::SequenceExpression(it) => it.serialize(serializer), + Self::TaggedTemplateExpression(it) => it.serialize(serializer), + Self::ThisExpression(it) => it.serialize(serializer), + Self::UnaryExpression(it) => it.serialize(serializer), + Self::UpdateExpression(it) => it.serialize(serializer), + Self::YieldExpression(it) => it.serialize(serializer), + Self::PrivateInExpression(it) => it.serialize(serializer), + Self::JSXElement(it) => it.serialize(serializer), + Self::JSXFragment(it) => it.serialize(serializer), + Self::TSAsExpression(it) => it.serialize(serializer), + Self::TSSatisfiesExpression(it) => it.serialize(serializer), + Self::TSTypeAssertion(it) => it.serialize(serializer), + Self::TSNonNullExpression(it) => it.serialize(serializer), + Self::TSInstantiationExpression(it) => it.serialize(serializer), + Self::ComputedMemberExpression(it) => it.serialize(serializer), + Self::StaticMemberExpression(it) => it.serialize(serializer), + Self::PrivateFieldExpression(it) => it.serialize(serializer), } } } @@ -1065,18 +1049,18 @@ impl Serialize for ForInStatement<'_> { impl Serialize for ForStatementLeft<'_> { fn serialize(&self, serializer: S) -> Result { match self { - ForStatementLeft::VariableDeclaration(it) => it.serialize(serializer), - ForStatementLeft::AssignmentTargetIdentifier(it) => it.serialize(serializer), - ForStatementLeft::TSAsExpression(it) => it.serialize(serializer), - ForStatementLeft::TSSatisfiesExpression(it) => it.serialize(serializer), - ForStatementLeft::TSNonNullExpression(it) => it.serialize(serializer), - ForStatementLeft::TSTypeAssertion(it) => it.serialize(serializer), - ForStatementLeft::TSInstantiationExpression(it) => it.serialize(serializer), - ForStatementLeft::ComputedMemberExpression(it) => it.serialize(serializer), - ForStatementLeft::StaticMemberExpression(it) => it.serialize(serializer), - ForStatementLeft::PrivateFieldExpression(it) => it.serialize(serializer), - ForStatementLeft::ArrayAssignmentTarget(it) => it.serialize(serializer), - ForStatementLeft::ObjectAssignmentTarget(it) => it.serialize(serializer), + Self::VariableDeclaration(it) => it.serialize(serializer), + Self::AssignmentTargetIdentifier(it) => it.serialize(serializer), + Self::TSAsExpression(it) => it.serialize(serializer), + Self::TSSatisfiesExpression(it) => it.serialize(serializer), + Self::TSNonNullExpression(it) => it.serialize(serializer), + Self::TSTypeAssertion(it) => it.serialize(serializer), + Self::TSInstantiationExpression(it) => it.serialize(serializer), + Self::ComputedMemberExpression(it) => it.serialize(serializer), + Self::StaticMemberExpression(it) => it.serialize(serializer), + Self::PrivateFieldExpression(it) => it.serialize(serializer), + Self::ArrayAssignmentTarget(it) => it.serialize(serializer), + Self::ObjectAssignmentTarget(it) => it.serialize(serializer), } } } @@ -1245,10 +1229,10 @@ impl Serialize for BindingPattern<'_> { impl Serialize for BindingPatternKind<'_> { fn serialize(&self, serializer: S) -> Result { match self { - BindingPatternKind::BindingIdentifier(it) => it.serialize(serializer), - BindingPatternKind::ObjectPattern(it) => it.serialize(serializer), - BindingPatternKind::ArrayPattern(it) => it.serialize(serializer), - BindingPatternKind::AssignmentPattern(it) => it.serialize(serializer), + Self::BindingIdentifier(it) => it.serialize(serializer), + Self::ObjectPattern(it) => it.serialize(serializer), + Self::ArrayPattern(it) => it.serialize(serializer), + Self::AssignmentPattern(it) => it.serialize(serializer), } } } @@ -1324,16 +1308,16 @@ impl Serialize for Function<'_> { impl Serialize for FunctionType { fn serialize(&self, serializer: S) -> Result { match self { - FunctionType::FunctionDeclaration => { + Self::FunctionDeclaration => { serializer.serialize_unit_variant("FunctionType", 0, "FunctionDeclaration") } - FunctionType::FunctionExpression => { + Self::FunctionExpression => { serializer.serialize_unit_variant("FunctionType", 1, "FunctionExpression") } - FunctionType::TSDeclareFunction => { + Self::TSDeclareFunction => { serializer.serialize_unit_variant("FunctionType", 2, "TSDeclareFunction") } - FunctionType::TSEmptyBodyFunctionExpression => serializer.serialize_unit_variant( + Self::TSEmptyBodyFunctionExpression => serializer.serialize_unit_variant( "FunctionType", 3, "TSEmptyBodyFunctionExpression", @@ -1359,18 +1343,18 @@ impl Serialize for FormalParameter<'_> { impl Serialize for FormalParameterKind { fn serialize(&self, serializer: S) -> Result { match self { - FormalParameterKind::FormalParameter => { + Self::FormalParameter => { serializer.serialize_unit_variant("FormalParameterKind", 0, "FormalParameter") } - FormalParameterKind::UniqueFormalParameters => serializer.serialize_unit_variant( + Self::UniqueFormalParameters => serializer.serialize_unit_variant( "FormalParameterKind", 1, "UniqueFormalParameters", ), - FormalParameterKind::ArrowFormalParameters => { + Self::ArrowFormalParameters => { serializer.serialize_unit_variant("FormalParameterKind", 2, "ArrowFormalParameters") } - FormalParameterKind::Signature => { + Self::Signature => { serializer.serialize_unit_variant("FormalParameterKind", 3, "Signature") } } @@ -1443,10 +1427,10 @@ impl Serialize for Class<'_> { impl Serialize for ClassType { fn serialize(&self, serializer: S) -> Result { match self { - ClassType::ClassDeclaration => { + Self::ClassDeclaration => { serializer.serialize_unit_variant("ClassType", 0, "ClassDeclaration") } - ClassType::ClassExpression => { + Self::ClassExpression => { serializer.serialize_unit_variant("ClassType", 1, "ClassExpression") } } @@ -1467,11 +1451,11 @@ impl Serialize for ClassBody<'_> { impl Serialize for ClassElement<'_> { fn serialize(&self, serializer: S) -> Result { match self { - ClassElement::StaticBlock(it) => it.serialize(serializer), - ClassElement::MethodDefinition(it) => it.serialize(serializer), - ClassElement::PropertyDefinition(it) => it.serialize(serializer), - ClassElement::AccessorProperty(it) => it.serialize(serializer), - ClassElement::TSIndexSignature(it) => it.serialize(serializer), + Self::StaticBlock(it) => it.serialize(serializer), + Self::MethodDefinition(it) => it.serialize(serializer), + Self::PropertyDefinition(it) => it.serialize(serializer), + Self::AccessorProperty(it) => it.serialize(serializer), + Self::TSIndexSignature(it) => it.serialize(serializer), } } } @@ -1498,10 +1482,10 @@ impl Serialize for MethodDefinition<'_> { impl Serialize for MethodDefinitionType { fn serialize(&self, serializer: S) -> Result { match self { - MethodDefinitionType::MethodDefinition => { + Self::MethodDefinition => { serializer.serialize_unit_variant("MethodDefinitionType", 0, "MethodDefinition") } - MethodDefinitionType::TSAbstractMethodDefinition => serializer.serialize_unit_variant( + Self::TSAbstractMethodDefinition => serializer.serialize_unit_variant( "MethodDefinitionType", 1, "TSAbstractMethodDefinition", @@ -1535,15 +1519,14 @@ impl Serialize for PropertyDefinition<'_> { impl Serialize for PropertyDefinitionType { fn serialize(&self, serializer: S) -> Result { match self { - PropertyDefinitionType::PropertyDefinition => { + Self::PropertyDefinition => { serializer.serialize_unit_variant("PropertyDefinitionType", 0, "PropertyDefinition") } - PropertyDefinitionType::TSAbstractPropertyDefinition => serializer - .serialize_unit_variant( - "PropertyDefinitionType", - 1, - "TSAbstractPropertyDefinition", - ), + Self::TSAbstractPropertyDefinition => serializer.serialize_unit_variant( + "PropertyDefinitionType", + 1, + "TSAbstractPropertyDefinition", + ), } } } @@ -1551,18 +1534,12 @@ impl Serialize for PropertyDefinitionType { impl Serialize for MethodDefinitionKind { fn serialize(&self, serializer: S) -> Result { match self { - MethodDefinitionKind::Constructor => { + Self::Constructor => { serializer.serialize_unit_variant("MethodDefinitionKind", 0, "constructor") } - MethodDefinitionKind::Method => { - serializer.serialize_unit_variant("MethodDefinitionKind", 1, "method") - } - MethodDefinitionKind::Get => { - serializer.serialize_unit_variant("MethodDefinitionKind", 2, "get") - } - MethodDefinitionKind::Set => { - serializer.serialize_unit_variant("MethodDefinitionKind", 3, "set") - } + Self::Method => serializer.serialize_unit_variant("MethodDefinitionKind", 1, "method"), + Self::Get => serializer.serialize_unit_variant("MethodDefinitionKind", 2, "get"), + Self::Set => serializer.serialize_unit_variant("MethodDefinitionKind", 3, "set"), } } } @@ -1592,12 +1569,12 @@ impl Serialize for StaticBlock<'_> { impl Serialize for ModuleDeclaration<'_> { fn serialize(&self, serializer: S) -> Result { match self { - ModuleDeclaration::ImportDeclaration(it) => it.serialize(serializer), - ModuleDeclaration::ExportAllDeclaration(it) => it.serialize(serializer), - ModuleDeclaration::ExportDefaultDeclaration(it) => it.serialize(serializer), - ModuleDeclaration::ExportNamedDeclaration(it) => it.serialize(serializer), - ModuleDeclaration::TSExportAssignment(it) => it.serialize(serializer), - ModuleDeclaration::TSNamespaceExportDeclaration(it) => it.serialize(serializer), + Self::ImportDeclaration(it) => it.serialize(serializer), + Self::ExportAllDeclaration(it) => it.serialize(serializer), + Self::ExportDefaultDeclaration(it) => it.serialize(serializer), + Self::ExportNamedDeclaration(it) => it.serialize(serializer), + Self::TSExportAssignment(it) => it.serialize(serializer), + Self::TSNamespaceExportDeclaration(it) => it.serialize(serializer), } } } @@ -1605,10 +1582,10 @@ impl Serialize for ModuleDeclaration<'_> { impl Serialize for AccessorPropertyType { fn serialize(&self, serializer: S) -> Result { match self { - AccessorPropertyType::AccessorProperty => { + Self::AccessorProperty => { serializer.serialize_unit_variant("AccessorPropertyType", 0, "AccessorProperty") } - AccessorPropertyType::TSAbstractAccessorProperty => serializer.serialize_unit_variant( + Self::TSAbstractAccessorProperty => serializer.serialize_unit_variant( "AccessorPropertyType", 1, "TSAbstractAccessorProperty", @@ -1671,8 +1648,8 @@ impl Serialize for ImportDeclaration<'_> { impl Serialize for ImportPhase { fn serialize(&self, serializer: S) -> Result { match self { - ImportPhase::Source => serializer.serialize_unit_variant("ImportPhase", 0, "source"), - ImportPhase::Defer => serializer.serialize_unit_variant("ImportPhase", 1, "defer"), + Self::Source => serializer.serialize_unit_variant("ImportPhase", 0, "source"), + Self::Defer => serializer.serialize_unit_variant("ImportPhase", 1, "defer"), } } } @@ -1680,9 +1657,9 @@ impl Serialize for ImportPhase { impl Serialize for ImportDeclarationSpecifier<'_> { fn serialize(&self, serializer: S) -> Result { match self { - ImportDeclarationSpecifier::ImportSpecifier(it) => it.serialize(serializer), - ImportDeclarationSpecifier::ImportDefaultSpecifier(it) => it.serialize(serializer), - ImportDeclarationSpecifier::ImportNamespaceSpecifier(it) => it.serialize(serializer), + Self::ImportSpecifier(it) => it.serialize(serializer), + Self::ImportDefaultSpecifier(it) => it.serialize(serializer), + Self::ImportNamespaceSpecifier(it) => it.serialize(serializer), } } } @@ -1749,8 +1726,8 @@ impl Serialize for ImportAttribute<'_> { impl Serialize for ImportAttributeKey<'_> { fn serialize(&self, serializer: S) -> Result { match self { - ImportAttributeKey::Identifier(it) => it.serialize(serializer), - ImportAttributeKey::StringLiteral(it) => it.serialize(serializer), + Self::Identifier(it) => it.serialize(serializer), + Self::StringLiteral(it) => it.serialize(serializer), } } } @@ -1818,51 +1795,51 @@ impl Serialize for ExportSpecifier<'_> { impl Serialize for ExportDefaultDeclarationKind<'_> { fn serialize(&self, serializer: S) -> Result { match self { - ExportDefaultDeclarationKind::FunctionDeclaration(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::ClassDeclaration(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::TSInterfaceDeclaration(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::BooleanLiteral(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::NullLiteral(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::NumericLiteral(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::BigIntLiteral(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::RegExpLiteral(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::StringLiteral(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::TemplateLiteral(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::Identifier(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::MetaProperty(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::Super(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::ArrayExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::ArrowFunctionExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::AssignmentExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::AwaitExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::BinaryExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::CallExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::ChainExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::ClassExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::ConditionalExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::FunctionExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::ImportExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::LogicalExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::NewExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::ObjectExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::ParenthesizedExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::SequenceExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::TaggedTemplateExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::ThisExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::UnaryExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::UpdateExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::YieldExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::PrivateInExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::JSXElement(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::JSXFragment(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::TSAsExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::TSSatisfiesExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::TSTypeAssertion(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::TSNonNullExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::TSInstantiationExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::ComputedMemberExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::StaticMemberExpression(it) => it.serialize(serializer), - ExportDefaultDeclarationKind::PrivateFieldExpression(it) => it.serialize(serializer), + Self::FunctionDeclaration(it) => it.serialize(serializer), + Self::ClassDeclaration(it) => it.serialize(serializer), + Self::TSInterfaceDeclaration(it) => it.serialize(serializer), + Self::BooleanLiteral(it) => it.serialize(serializer), + Self::NullLiteral(it) => it.serialize(serializer), + Self::NumericLiteral(it) => it.serialize(serializer), + Self::BigIntLiteral(it) => it.serialize(serializer), + Self::RegExpLiteral(it) => it.serialize(serializer), + Self::StringLiteral(it) => it.serialize(serializer), + Self::TemplateLiteral(it) => it.serialize(serializer), + Self::Identifier(it) => it.serialize(serializer), + Self::MetaProperty(it) => it.serialize(serializer), + Self::Super(it) => it.serialize(serializer), + Self::ArrayExpression(it) => it.serialize(serializer), + Self::ArrowFunctionExpression(it) => it.serialize(serializer), + Self::AssignmentExpression(it) => it.serialize(serializer), + Self::AwaitExpression(it) => it.serialize(serializer), + Self::BinaryExpression(it) => it.serialize(serializer), + Self::CallExpression(it) => it.serialize(serializer), + Self::ChainExpression(it) => it.serialize(serializer), + Self::ClassExpression(it) => it.serialize(serializer), + Self::ConditionalExpression(it) => it.serialize(serializer), + Self::FunctionExpression(it) => it.serialize(serializer), + Self::ImportExpression(it) => it.serialize(serializer), + Self::LogicalExpression(it) => it.serialize(serializer), + Self::NewExpression(it) => it.serialize(serializer), + Self::ObjectExpression(it) => it.serialize(serializer), + Self::ParenthesizedExpression(it) => it.serialize(serializer), + Self::SequenceExpression(it) => it.serialize(serializer), + Self::TaggedTemplateExpression(it) => it.serialize(serializer), + Self::ThisExpression(it) => it.serialize(serializer), + Self::UnaryExpression(it) => it.serialize(serializer), + Self::UpdateExpression(it) => it.serialize(serializer), + Self::YieldExpression(it) => it.serialize(serializer), + Self::PrivateInExpression(it) => it.serialize(serializer), + Self::JSXElement(it) => it.serialize(serializer), + Self::JSXFragment(it) => it.serialize(serializer), + Self::TSAsExpression(it) => it.serialize(serializer), + Self::TSSatisfiesExpression(it) => it.serialize(serializer), + Self::TSTypeAssertion(it) => it.serialize(serializer), + Self::TSNonNullExpression(it) => it.serialize(serializer), + Self::TSInstantiationExpression(it) => it.serialize(serializer), + Self::ComputedMemberExpression(it) => it.serialize(serializer), + Self::StaticMemberExpression(it) => it.serialize(serializer), + Self::PrivateFieldExpression(it) => it.serialize(serializer), } } } @@ -1870,9 +1847,9 @@ impl Serialize for ExportDefaultDeclarationKind<'_> { impl Serialize for ModuleExportName<'_> { fn serialize(&self, serializer: S) -> Result { match self { - ModuleExportName::IdentifierName(it) => it.serialize(serializer), - ModuleExportName::IdentifierReference(it) => it.serialize(serializer), - ModuleExportName::StringLiteral(it) => it.serialize(serializer), + Self::IdentifierName(it) => it.serialize(serializer), + Self::IdentifierReference(it) => it.serialize(serializer), + Self::StringLiteral(it) => it.serialize(serializer), } } } @@ -2069,49 +2046,49 @@ impl Serialize for JSXExpressionContainer<'_> { impl Serialize for JSXExpression<'_> { fn serialize(&self, serializer: S) -> Result { match self { - JSXExpression::EmptyExpression(it) => it.serialize(serializer), - JSXExpression::BooleanLiteral(it) => it.serialize(serializer), - JSXExpression::NullLiteral(it) => it.serialize(serializer), - JSXExpression::NumericLiteral(it) => it.serialize(serializer), - JSXExpression::BigIntLiteral(it) => it.serialize(serializer), - JSXExpression::RegExpLiteral(it) => it.serialize(serializer), - JSXExpression::StringLiteral(it) => it.serialize(serializer), - JSXExpression::TemplateLiteral(it) => it.serialize(serializer), - JSXExpression::Identifier(it) => it.serialize(serializer), - JSXExpression::MetaProperty(it) => it.serialize(serializer), - JSXExpression::Super(it) => it.serialize(serializer), - JSXExpression::ArrayExpression(it) => it.serialize(serializer), - JSXExpression::ArrowFunctionExpression(it) => it.serialize(serializer), - JSXExpression::AssignmentExpression(it) => it.serialize(serializer), - JSXExpression::AwaitExpression(it) => it.serialize(serializer), - JSXExpression::BinaryExpression(it) => it.serialize(serializer), - JSXExpression::CallExpression(it) => it.serialize(serializer), - JSXExpression::ChainExpression(it) => it.serialize(serializer), - JSXExpression::ClassExpression(it) => it.serialize(serializer), - JSXExpression::ConditionalExpression(it) => it.serialize(serializer), - JSXExpression::FunctionExpression(it) => it.serialize(serializer), - JSXExpression::ImportExpression(it) => it.serialize(serializer), - JSXExpression::LogicalExpression(it) => it.serialize(serializer), - JSXExpression::NewExpression(it) => it.serialize(serializer), - JSXExpression::ObjectExpression(it) => it.serialize(serializer), - JSXExpression::ParenthesizedExpression(it) => it.serialize(serializer), - JSXExpression::SequenceExpression(it) => it.serialize(serializer), - JSXExpression::TaggedTemplateExpression(it) => it.serialize(serializer), - JSXExpression::ThisExpression(it) => it.serialize(serializer), - JSXExpression::UnaryExpression(it) => it.serialize(serializer), - JSXExpression::UpdateExpression(it) => it.serialize(serializer), - JSXExpression::YieldExpression(it) => it.serialize(serializer), - JSXExpression::PrivateInExpression(it) => it.serialize(serializer), - JSXExpression::JSXElement(it) => it.serialize(serializer), - JSXExpression::JSXFragment(it) => it.serialize(serializer), - JSXExpression::TSAsExpression(it) => it.serialize(serializer), - JSXExpression::TSSatisfiesExpression(it) => it.serialize(serializer), - JSXExpression::TSTypeAssertion(it) => it.serialize(serializer), - JSXExpression::TSNonNullExpression(it) => it.serialize(serializer), - JSXExpression::TSInstantiationExpression(it) => it.serialize(serializer), - JSXExpression::ComputedMemberExpression(it) => it.serialize(serializer), - JSXExpression::StaticMemberExpression(it) => it.serialize(serializer), - JSXExpression::PrivateFieldExpression(it) => it.serialize(serializer), + Self::EmptyExpression(it) => it.serialize(serializer), + Self::BooleanLiteral(it) => it.serialize(serializer), + Self::NullLiteral(it) => it.serialize(serializer), + Self::NumericLiteral(it) => it.serialize(serializer), + Self::BigIntLiteral(it) => it.serialize(serializer), + Self::RegExpLiteral(it) => it.serialize(serializer), + Self::StringLiteral(it) => it.serialize(serializer), + Self::TemplateLiteral(it) => it.serialize(serializer), + Self::Identifier(it) => it.serialize(serializer), + Self::MetaProperty(it) => it.serialize(serializer), + Self::Super(it) => it.serialize(serializer), + Self::ArrayExpression(it) => it.serialize(serializer), + Self::ArrowFunctionExpression(it) => it.serialize(serializer), + Self::AssignmentExpression(it) => it.serialize(serializer), + Self::AwaitExpression(it) => it.serialize(serializer), + Self::BinaryExpression(it) => it.serialize(serializer), + Self::CallExpression(it) => it.serialize(serializer), + Self::ChainExpression(it) => it.serialize(serializer), + Self::ClassExpression(it) => it.serialize(serializer), + Self::ConditionalExpression(it) => it.serialize(serializer), + Self::FunctionExpression(it) => it.serialize(serializer), + Self::ImportExpression(it) => it.serialize(serializer), + Self::LogicalExpression(it) => it.serialize(serializer), + Self::NewExpression(it) => it.serialize(serializer), + Self::ObjectExpression(it) => it.serialize(serializer), + Self::ParenthesizedExpression(it) => it.serialize(serializer), + Self::SequenceExpression(it) => it.serialize(serializer), + Self::TaggedTemplateExpression(it) => it.serialize(serializer), + Self::ThisExpression(it) => it.serialize(serializer), + Self::UnaryExpression(it) => it.serialize(serializer), + Self::UpdateExpression(it) => it.serialize(serializer), + Self::YieldExpression(it) => it.serialize(serializer), + Self::PrivateInExpression(it) => it.serialize(serializer), + Self::JSXElement(it) => it.serialize(serializer), + Self::JSXFragment(it) => it.serialize(serializer), + Self::TSAsExpression(it) => it.serialize(serializer), + Self::TSSatisfiesExpression(it) => it.serialize(serializer), + Self::TSTypeAssertion(it) => it.serialize(serializer), + Self::TSNonNullExpression(it) => it.serialize(serializer), + Self::TSInstantiationExpression(it) => it.serialize(serializer), + Self::ComputedMemberExpression(it) => it.serialize(serializer), + Self::StaticMemberExpression(it) => it.serialize(serializer), + Self::PrivateFieldExpression(it) => it.serialize(serializer), } } } @@ -2129,8 +2106,8 @@ impl Serialize for JSXEmptyExpression { impl Serialize for JSXAttributeItem<'_> { fn serialize(&self, serializer: S) -> Result { match self { - JSXAttributeItem::Attribute(it) => it.serialize(serializer), - JSXAttributeItem::SpreadAttribute(it) => it.serialize(serializer), + Self::Attribute(it) => it.serialize(serializer), + Self::SpreadAttribute(it) => it.serialize(serializer), } } } @@ -2161,8 +2138,8 @@ impl Serialize for JSXSpreadAttribute<'_> { impl Serialize for JSXAttributeName<'_> { fn serialize(&self, serializer: S) -> Result { match self { - JSXAttributeName::Identifier(it) => it.serialize(serializer), - JSXAttributeName::NamespacedName(it) => it.serialize(serializer), + Self::Identifier(it) => it.serialize(serializer), + Self::NamespacedName(it) => it.serialize(serializer), } } } @@ -2170,10 +2147,10 @@ impl Serialize for JSXAttributeName<'_> { impl Serialize for JSXAttributeValue<'_> { fn serialize(&self, serializer: S) -> Result { match self { - JSXAttributeValue::StringLiteral(it) => it.serialize(serializer), - JSXAttributeValue::ExpressionContainer(it) => it.serialize(serializer), - JSXAttributeValue::Element(it) => it.serialize(serializer), - JSXAttributeValue::Fragment(it) => it.serialize(serializer), + Self::StringLiteral(it) => it.serialize(serializer), + Self::ExpressionContainer(it) => it.serialize(serializer), + Self::Element(it) => it.serialize(serializer), + Self::Fragment(it) => it.serialize(serializer), } } } @@ -2192,11 +2169,11 @@ impl Serialize for JSXIdentifier<'_> { impl Serialize for JSXChild<'_> { fn serialize(&self, serializer: S) -> Result { match self { - JSXChild::Text(it) => it.serialize(serializer), - JSXChild::Element(it) => it.serialize(serializer), - JSXChild::Fragment(it) => it.serialize(serializer), - JSXChild::ExpressionContainer(it) => it.serialize(serializer), - JSXChild::Spread(it) => it.serialize(serializer), + Self::Text(it) => it.serialize(serializer), + Self::Element(it) => it.serialize(serializer), + Self::Fragment(it) => it.serialize(serializer), + Self::ExpressionContainer(it) => it.serialize(serializer), + Self::Spread(it) => it.serialize(serializer), } } } @@ -2263,8 +2240,8 @@ impl Serialize for TSEnumMember<'_> { impl Serialize for TSEnumMemberName<'_> { fn serialize(&self, serializer: S) -> Result { match self { - TSEnumMemberName::Identifier(it) => it.serialize(serializer), - TSEnumMemberName::String(it) => it.serialize(serializer), + Self::Identifier(it) => it.serialize(serializer), + Self::String(it) => it.serialize(serializer), } } } @@ -2294,12 +2271,12 @@ impl Serialize for TSLiteralType<'_> { impl Serialize for TSLiteral<'_> { fn serialize(&self, serializer: S) -> Result { match self { - TSLiteral::BooleanLiteral(it) => it.serialize(serializer), - TSLiteral::NumericLiteral(it) => it.serialize(serializer), - TSLiteral::BigIntLiteral(it) => it.serialize(serializer), - TSLiteral::StringLiteral(it) => it.serialize(serializer), - TSLiteral::TemplateLiteral(it) => it.serialize(serializer), - TSLiteral::UnaryExpression(it) => it.serialize(serializer), + Self::BooleanLiteral(it) => it.serialize(serializer), + Self::NumericLiteral(it) => it.serialize(serializer), + Self::BigIntLiteral(it) => it.serialize(serializer), + Self::StringLiteral(it) => it.serialize(serializer), + Self::TemplateLiteral(it) => it.serialize(serializer), + Self::UnaryExpression(it) => it.serialize(serializer), } } } @@ -2307,43 +2284,43 @@ impl Serialize for TSLiteral<'_> { impl Serialize for TSType<'_> { fn serialize(&self, serializer: S) -> Result { match self { - TSType::TSAnyKeyword(it) => it.serialize(serializer), - TSType::TSBigIntKeyword(it) => it.serialize(serializer), - TSType::TSBooleanKeyword(it) => it.serialize(serializer), - TSType::TSIntrinsicKeyword(it) => it.serialize(serializer), - TSType::TSNeverKeyword(it) => it.serialize(serializer), - TSType::TSNullKeyword(it) => it.serialize(serializer), - TSType::TSNumberKeyword(it) => it.serialize(serializer), - TSType::TSObjectKeyword(it) => it.serialize(serializer), - TSType::TSStringKeyword(it) => it.serialize(serializer), - TSType::TSSymbolKeyword(it) => it.serialize(serializer), - TSType::TSUndefinedKeyword(it) => it.serialize(serializer), - TSType::TSUnknownKeyword(it) => it.serialize(serializer), - TSType::TSVoidKeyword(it) => it.serialize(serializer), - TSType::TSArrayType(it) => it.serialize(serializer), - TSType::TSConditionalType(it) => it.serialize(serializer), - TSType::TSConstructorType(it) => it.serialize(serializer), - TSType::TSFunctionType(it) => it.serialize(serializer), - TSType::TSImportType(it) => it.serialize(serializer), - TSType::TSIndexedAccessType(it) => it.serialize(serializer), - TSType::TSInferType(it) => it.serialize(serializer), - TSType::TSIntersectionType(it) => it.serialize(serializer), - TSType::TSLiteralType(it) => it.serialize(serializer), - TSType::TSMappedType(it) => it.serialize(serializer), - TSType::TSNamedTupleMember(it) => it.serialize(serializer), - TSType::TSTemplateLiteralType(it) => it.serialize(serializer), - TSType::TSThisType(it) => it.serialize(serializer), - TSType::TSTupleType(it) => it.serialize(serializer), - TSType::TSTypeLiteral(it) => it.serialize(serializer), - TSType::TSTypeOperatorType(it) => it.serialize(serializer), - TSType::TSTypePredicate(it) => it.serialize(serializer), - TSType::TSTypeQuery(it) => it.serialize(serializer), - TSType::TSTypeReference(it) => it.serialize(serializer), - TSType::TSUnionType(it) => it.serialize(serializer), - TSType::TSParenthesizedType(it) => it.serialize(serializer), - TSType::JSDocNullableType(it) => it.serialize(serializer), - TSType::JSDocNonNullableType(it) => it.serialize(serializer), - TSType::JSDocUnknownType(it) => it.serialize(serializer), + Self::TSAnyKeyword(it) => it.serialize(serializer), + Self::TSBigIntKeyword(it) => it.serialize(serializer), + Self::TSBooleanKeyword(it) => it.serialize(serializer), + Self::TSIntrinsicKeyword(it) => it.serialize(serializer), + Self::TSNeverKeyword(it) => it.serialize(serializer), + Self::TSNullKeyword(it) => it.serialize(serializer), + Self::TSNumberKeyword(it) => it.serialize(serializer), + Self::TSObjectKeyword(it) => it.serialize(serializer), + Self::TSStringKeyword(it) => it.serialize(serializer), + Self::TSSymbolKeyword(it) => it.serialize(serializer), + Self::TSUndefinedKeyword(it) => it.serialize(serializer), + Self::TSUnknownKeyword(it) => it.serialize(serializer), + Self::TSVoidKeyword(it) => it.serialize(serializer), + Self::TSArrayType(it) => it.serialize(serializer), + Self::TSConditionalType(it) => it.serialize(serializer), + Self::TSConstructorType(it) => it.serialize(serializer), + Self::TSFunctionType(it) => it.serialize(serializer), + Self::TSImportType(it) => it.serialize(serializer), + Self::TSIndexedAccessType(it) => it.serialize(serializer), + Self::TSInferType(it) => it.serialize(serializer), + Self::TSIntersectionType(it) => it.serialize(serializer), + Self::TSLiteralType(it) => it.serialize(serializer), + Self::TSMappedType(it) => it.serialize(serializer), + Self::TSNamedTupleMember(it) => it.serialize(serializer), + Self::TSTemplateLiteralType(it) => it.serialize(serializer), + Self::TSThisType(it) => it.serialize(serializer), + Self::TSTupleType(it) => it.serialize(serializer), + Self::TSTypeLiteral(it) => it.serialize(serializer), + Self::TSTypeOperatorType(it) => it.serialize(serializer), + Self::TSTypePredicate(it) => it.serialize(serializer), + Self::TSTypeQuery(it) => it.serialize(serializer), + Self::TSTypeReference(it) => it.serialize(serializer), + Self::TSUnionType(it) => it.serialize(serializer), + Self::TSParenthesizedType(it) => it.serialize(serializer), + Self::JSDocNullableType(it) => it.serialize(serializer), + Self::JSDocNonNullableType(it) => it.serialize(serializer), + Self::JSDocUnknownType(it) => it.serialize(serializer), } } } @@ -2410,13 +2387,11 @@ impl Serialize for TSTypeOperator<'_> { impl Serialize for TSTypeOperatorOperator { fn serialize(&self, serializer: S) -> Result { match self { - TSTypeOperatorOperator::Keyof => { - serializer.serialize_unit_variant("TSTypeOperatorOperator", 0, "keyof") - } - TSTypeOperatorOperator::Unique => { + Self::Keyof => serializer.serialize_unit_variant("TSTypeOperatorOperator", 0, "keyof"), + Self::Unique => { serializer.serialize_unit_variant("TSTypeOperatorOperator", 1, "unique") } - TSTypeOperatorOperator::Readonly => { + Self::Readonly => { serializer.serialize_unit_variant("TSTypeOperatorOperator", 2, "readonly") } } @@ -2495,45 +2470,45 @@ impl Serialize for TSRestType<'_> { impl Serialize for TSTupleElement<'_> { fn serialize(&self, serializer: S) -> Result { match self { - TSTupleElement::TSOptionalType(it) => it.serialize(serializer), - TSTupleElement::TSRestType(it) => it.serialize(serializer), - TSTupleElement::TSAnyKeyword(it) => it.serialize(serializer), - TSTupleElement::TSBigIntKeyword(it) => it.serialize(serializer), - TSTupleElement::TSBooleanKeyword(it) => it.serialize(serializer), - TSTupleElement::TSIntrinsicKeyword(it) => it.serialize(serializer), - TSTupleElement::TSNeverKeyword(it) => it.serialize(serializer), - TSTupleElement::TSNullKeyword(it) => it.serialize(serializer), - TSTupleElement::TSNumberKeyword(it) => it.serialize(serializer), - TSTupleElement::TSObjectKeyword(it) => it.serialize(serializer), - TSTupleElement::TSStringKeyword(it) => it.serialize(serializer), - TSTupleElement::TSSymbolKeyword(it) => it.serialize(serializer), - TSTupleElement::TSUndefinedKeyword(it) => it.serialize(serializer), - TSTupleElement::TSUnknownKeyword(it) => it.serialize(serializer), - TSTupleElement::TSVoidKeyword(it) => it.serialize(serializer), - TSTupleElement::TSArrayType(it) => it.serialize(serializer), - TSTupleElement::TSConditionalType(it) => it.serialize(serializer), - TSTupleElement::TSConstructorType(it) => it.serialize(serializer), - TSTupleElement::TSFunctionType(it) => it.serialize(serializer), - TSTupleElement::TSImportType(it) => it.serialize(serializer), - TSTupleElement::TSIndexedAccessType(it) => it.serialize(serializer), - TSTupleElement::TSInferType(it) => it.serialize(serializer), - TSTupleElement::TSIntersectionType(it) => it.serialize(serializer), - TSTupleElement::TSLiteralType(it) => it.serialize(serializer), - TSTupleElement::TSMappedType(it) => it.serialize(serializer), - TSTupleElement::TSNamedTupleMember(it) => it.serialize(serializer), - TSTupleElement::TSTemplateLiteralType(it) => it.serialize(serializer), - TSTupleElement::TSThisType(it) => it.serialize(serializer), - TSTupleElement::TSTupleType(it) => it.serialize(serializer), - TSTupleElement::TSTypeLiteral(it) => it.serialize(serializer), - TSTupleElement::TSTypeOperatorType(it) => it.serialize(serializer), - TSTupleElement::TSTypePredicate(it) => it.serialize(serializer), - TSTupleElement::TSTypeQuery(it) => it.serialize(serializer), - TSTupleElement::TSTypeReference(it) => it.serialize(serializer), - TSTupleElement::TSUnionType(it) => it.serialize(serializer), - TSTupleElement::TSParenthesizedType(it) => it.serialize(serializer), - TSTupleElement::JSDocNullableType(it) => it.serialize(serializer), - TSTupleElement::JSDocNonNullableType(it) => it.serialize(serializer), - TSTupleElement::JSDocUnknownType(it) => it.serialize(serializer), + Self::TSOptionalType(it) => it.serialize(serializer), + Self::TSRestType(it) => it.serialize(serializer), + Self::TSAnyKeyword(it) => it.serialize(serializer), + Self::TSBigIntKeyword(it) => it.serialize(serializer), + Self::TSBooleanKeyword(it) => it.serialize(serializer), + Self::TSIntrinsicKeyword(it) => it.serialize(serializer), + Self::TSNeverKeyword(it) => it.serialize(serializer), + Self::TSNullKeyword(it) => it.serialize(serializer), + Self::TSNumberKeyword(it) => it.serialize(serializer), + Self::TSObjectKeyword(it) => it.serialize(serializer), + Self::TSStringKeyword(it) => it.serialize(serializer), + Self::TSSymbolKeyword(it) => it.serialize(serializer), + Self::TSUndefinedKeyword(it) => it.serialize(serializer), + Self::TSUnknownKeyword(it) => it.serialize(serializer), + Self::TSVoidKeyword(it) => it.serialize(serializer), + Self::TSArrayType(it) => it.serialize(serializer), + Self::TSConditionalType(it) => it.serialize(serializer), + Self::TSConstructorType(it) => it.serialize(serializer), + Self::TSFunctionType(it) => it.serialize(serializer), + Self::TSImportType(it) => it.serialize(serializer), + Self::TSIndexedAccessType(it) => it.serialize(serializer), + Self::TSInferType(it) => it.serialize(serializer), + Self::TSIntersectionType(it) => it.serialize(serializer), + Self::TSLiteralType(it) => it.serialize(serializer), + Self::TSMappedType(it) => it.serialize(serializer), + Self::TSNamedTupleMember(it) => it.serialize(serializer), + Self::TSTemplateLiteralType(it) => it.serialize(serializer), + Self::TSThisType(it) => it.serialize(serializer), + Self::TSTupleType(it) => it.serialize(serializer), + Self::TSTypeLiteral(it) => it.serialize(serializer), + Self::TSTypeOperatorType(it) => it.serialize(serializer), + Self::TSTypePredicate(it) => it.serialize(serializer), + Self::TSTypeQuery(it) => it.serialize(serializer), + Self::TSTypeReference(it) => it.serialize(serializer), + Self::TSUnionType(it) => it.serialize(serializer), + Self::TSParenthesizedType(it) => it.serialize(serializer), + Self::JSDocNullableType(it) => it.serialize(serializer), + Self::JSDocNonNullableType(it) => it.serialize(serializer), + Self::JSDocUnknownType(it) => it.serialize(serializer), } } } @@ -2693,8 +2668,8 @@ impl Serialize for TSTypeReference<'_> { impl Serialize for TSTypeName<'_> { fn serialize(&self, serializer: S) -> Result { match self { - TSTypeName::IdentifierReference(it) => it.serialize(serializer), - TSTypeName::QualifiedName(it) => it.serialize(serializer), + Self::IdentifierReference(it) => it.serialize(serializer), + Self::QualifiedName(it) => it.serialize(serializer), } } } @@ -2766,15 +2741,9 @@ impl Serialize for TSTypeAliasDeclaration<'_> { impl Serialize for TSAccessibility { fn serialize(&self, serializer: S) -> Result { match self { - TSAccessibility::Private => { - serializer.serialize_unit_variant("TSAccessibility", 0, "private") - } - TSAccessibility::Protected => { - serializer.serialize_unit_variant("TSAccessibility", 1, "protected") - } - TSAccessibility::Public => { - serializer.serialize_unit_variant("TSAccessibility", 2, "public") - } + Self::Private => serializer.serialize_unit_variant("TSAccessibility", 0, "private"), + Self::Protected => serializer.serialize_unit_variant("TSAccessibility", 1, "protected"), + Self::Public => serializer.serialize_unit_variant("TSAccessibility", 2, "public"), } } } @@ -2835,11 +2804,11 @@ impl Serialize for TSPropertySignature<'_> { impl Serialize for TSSignature<'_> { fn serialize(&self, serializer: S) -> Result { match self { - TSSignature::TSIndexSignature(it) => it.serialize(serializer), - TSSignature::TSPropertySignature(it) => it.serialize(serializer), - TSSignature::TSCallSignatureDeclaration(it) => it.serialize(serializer), - TSSignature::TSConstructSignatureDeclaration(it) => it.serialize(serializer), - TSSignature::TSMethodSignature(it) => it.serialize(serializer), + Self::TSIndexSignature(it) => it.serialize(serializer), + Self::TSPropertySignature(it) => it.serialize(serializer), + Self::TSCallSignatureDeclaration(it) => it.serialize(serializer), + Self::TSConstructSignatureDeclaration(it) => it.serialize(serializer), + Self::TSMethodSignature(it) => it.serialize(serializer), } } } @@ -2875,15 +2844,9 @@ impl Serialize for TSCallSignatureDeclaration<'_> { impl Serialize for TSMethodSignatureKind { fn serialize(&self, serializer: S) -> Result { match self { - TSMethodSignatureKind::Method => { - serializer.serialize_unit_variant("TSMethodSignatureKind", 0, "method") - } - TSMethodSignatureKind::Get => { - serializer.serialize_unit_variant("TSMethodSignatureKind", 1, "get") - } - TSMethodSignatureKind::Set => { - serializer.serialize_unit_variant("TSMethodSignatureKind", 2, "set") - } + Self::Method => serializer.serialize_unit_variant("TSMethodSignatureKind", 0, "method"), + Self::Get => serializer.serialize_unit_variant("TSMethodSignatureKind", 1, "get"), + Self::Set => serializer.serialize_unit_variant("TSMethodSignatureKind", 2, "set"), } } } @@ -2959,8 +2922,8 @@ impl Serialize for TSTypePredicate<'_> { impl Serialize for TSTypePredicateName<'_> { fn serialize(&self, serializer: S) -> Result { match self { - TSTypePredicateName::Identifier(it) => it.serialize(serializer), - TSTypePredicateName::This(it) => it.serialize(serializer), + Self::Identifier(it) => it.serialize(serializer), + Self::This(it) => it.serialize(serializer), } } } @@ -2982,13 +2945,13 @@ impl Serialize for TSModuleDeclaration<'_> { impl Serialize for TSModuleDeclarationKind { fn serialize(&self, serializer: S) -> Result { match self { - TSModuleDeclarationKind::Global => { + Self::Global => { serializer.serialize_unit_variant("TSModuleDeclarationKind", 0, "global") } - TSModuleDeclarationKind::Module => { + Self::Module => { serializer.serialize_unit_variant("TSModuleDeclarationKind", 1, "module") } - TSModuleDeclarationKind::Namespace => { + Self::Namespace => { serializer.serialize_unit_variant("TSModuleDeclarationKind", 2, "namespace") } } @@ -2998,8 +2961,8 @@ impl Serialize for TSModuleDeclarationKind { impl Serialize for TSModuleDeclarationName<'_> { fn serialize(&self, serializer: S) -> Result { match self { - TSModuleDeclarationName::Identifier(it) => it.serialize(serializer), - TSModuleDeclarationName::StringLiteral(it) => it.serialize(serializer), + Self::Identifier(it) => it.serialize(serializer), + Self::StringLiteral(it) => it.serialize(serializer), } } } @@ -3007,8 +2970,8 @@ impl Serialize for TSModuleDeclarationName<'_> { impl Serialize for TSModuleDeclarationBody<'_> { fn serialize(&self, serializer: S) -> Result { match self { - TSModuleDeclarationBody::TSModuleDeclaration(it) => it.serialize(serializer), - TSModuleDeclarationBody::TSModuleBlock(it) => it.serialize(serializer), + Self::TSModuleDeclaration(it) => it.serialize(serializer), + Self::TSModuleBlock(it) => it.serialize(serializer), } } } @@ -3064,9 +3027,9 @@ impl Serialize for TSTypeQuery<'_> { impl Serialize for TSTypeQueryExprName<'_> { fn serialize(&self, serializer: S) -> Result { match self { - TSTypeQueryExprName::TSImportType(it) => it.serialize(serializer), - TSTypeQueryExprName::IdentifierReference(it) => it.serialize(serializer), - TSTypeQueryExprName::QualifiedName(it) => it.serialize(serializer), + Self::TSImportType(it) => it.serialize(serializer), + Self::IdentifierReference(it) => it.serialize(serializer), + Self::QualifiedName(it) => it.serialize(serializer), } } } @@ -3113,8 +3076,8 @@ impl Serialize for TSImportAttribute<'_> { impl Serialize for TSImportAttributeName<'_> { fn serialize(&self, serializer: S) -> Result { match self { - TSImportAttributeName::Identifier(it) => it.serialize(serializer), - TSImportAttributeName::StringLiteral(it) => it.serialize(serializer), + Self::Identifier(it) => it.serialize(serializer), + Self::StringLiteral(it) => it.serialize(serializer), } } } @@ -3165,16 +3128,14 @@ impl Serialize for TSMappedType<'_> { impl Serialize for TSMappedTypeModifierOperator { fn serialize(&self, serializer: S) -> Result { match self { - TSMappedTypeModifierOperator::True => { + Self::True => { serializer.serialize_unit_variant("TSMappedTypeModifierOperator", 0, "true") } - TSMappedTypeModifierOperator::Plus => { - serializer.serialize_unit_variant("TSMappedTypeModifierOperator", 1, "+") - } - TSMappedTypeModifierOperator::Minus => { + Self::Plus => serializer.serialize_unit_variant("TSMappedTypeModifierOperator", 1, "+"), + Self::Minus => { serializer.serialize_unit_variant("TSMappedTypeModifierOperator", 2, "-") } - TSMappedTypeModifierOperator::None => { + Self::None => { serializer.serialize_unit_variant("TSMappedTypeModifierOperator", 3, "none") } } @@ -3245,9 +3206,9 @@ impl Serialize for TSImportEqualsDeclaration<'_> { impl Serialize for TSModuleReference<'_> { fn serialize(&self, serializer: S) -> Result { match self { - TSModuleReference::ExternalModuleReference(it) => it.serialize(serializer), - TSModuleReference::IdentifierReference(it) => it.serialize(serializer), - TSModuleReference::QualifiedName(it) => it.serialize(serializer), + Self::ExternalModuleReference(it) => it.serialize(serializer), + Self::IdentifierReference(it) => it.serialize(serializer), + Self::QualifiedName(it) => it.serialize(serializer), } } } @@ -3322,12 +3283,8 @@ impl Serialize for TSInstantiationExpression<'_> { impl Serialize for ImportOrExportKind { fn serialize(&self, serializer: S) -> Result { match self { - ImportOrExportKind::Value => { - serializer.serialize_unit_variant("ImportOrExportKind", 0, "value") - } - ImportOrExportKind::Type => { - serializer.serialize_unit_variant("ImportOrExportKind", 1, "type") - } + Self::Value => serializer.serialize_unit_variant("ImportOrExportKind", 0, "value"), + Self::Type => serializer.serialize_unit_variant("ImportOrExportKind", 1, "type"), } } } diff --git a/crates/oxc_cfg/src/block.rs b/crates/oxc_cfg/src/block.rs index b80a84304f82d..3ee2f3f5bb032 100644 --- a/crates/oxc_cfg/src/block.rs +++ b/crates/oxc_cfg/src/block.rs @@ -8,7 +8,7 @@ pub struct BasicBlock { impl BasicBlock { pub(crate) fn new() -> Self { - BasicBlock { instructions: Vec::new(), unreachable: false } + Self { instructions: Vec::new(), unreachable: false } } pub fn instructions(&self) -> &Vec { diff --git a/crates/oxc_ecmascript/src/to_int_32.rs b/crates/oxc_ecmascript/src/to_int_32.rs index 0a55b6c9a438c..6d4e02d0b61a3 100644 --- a/crates/oxc_ecmascript/src/to_int_32.rs +++ b/crates/oxc_ecmascript/src/to_int_32.rs @@ -61,9 +61,9 @@ impl ToInt32 for f64 { return 0; } - if number.is_finite() && number <= f64::from(i32::MAX) && number >= f64::from(i32::MIN) { + if number.is_finite() && number <= Self::from(i32::MAX) && number >= Self::from(i32::MIN) { let i = number as i32; - if f64::from(i) == number { + if Self::from(i) == number { return i; } } diff --git a/crates/oxc_ecmascript/src/to_numeric.rs b/crates/oxc_ecmascript/src/to_numeric.rs index 9452a4b196df1..7215f5419566b 100644 --- a/crates/oxc_ecmascript/src/to_numeric.rs +++ b/crates/oxc_ecmascript/src/to_numeric.rs @@ -39,15 +39,15 @@ impl ToNumeric<'_> for ToPrimitiveResult { fn to_numeric(&self, _is_global_reference: &impl IsGlobalReference) -> ToNumericResult { match self { // Symbol throws an error when passed to ToNumber in step 3 - ToPrimitiveResult::Symbol | ToPrimitiveResult::Undetermined => { + Self::Symbol | Self::Undetermined => { ToNumericResult::Undetermined } - ToPrimitiveResult::BigInt => ToNumericResult::BigInt, - ToPrimitiveResult::Boolean - | ToPrimitiveResult::Null - | ToPrimitiveResult::Number - | ToPrimitiveResult::String - | ToPrimitiveResult::Undefined => ToNumericResult::Number, + Self::BigInt => ToNumericResult::BigInt, + Self::Boolean + | Self::Null + | Self::Number + | Self::String + | Self::Undefined => ToNumericResult::Number, } } } diff --git a/crates/oxc_language_server/src/capabilities.rs b/crates/oxc_language_server/src/capabilities.rs index f4df66c9e9271..5a9cf3fc00d13 100644 --- a/crates/oxc_language_server/src/capabilities.rs +++ b/crates/oxc_language_server/src/capabilities.rs @@ -71,7 +71,7 @@ impl From for ServerCapabilities { } else { None }, - ..ServerCapabilities::default() + ..Self::default() } } } diff --git a/crates/oxc_language_server/src/commands.rs b/crates/oxc_language_server/src/commands.rs index 63b9029104528..13cb464e77c02 100644 --- a/crates/oxc_language_server/src/commands.rs +++ b/crates/oxc_language_server/src/commands.rs @@ -29,12 +29,12 @@ pub enum WorkspaceCommands { impl WorkspaceCommands { pub fn command_id(&self) -> String { match self { - WorkspaceCommands::FixAll(c) => c.command_id(), + Self::FixAll(c) => c.command_id(), } } pub fn available(&self, cap: Capabilities) -> bool { match self { - WorkspaceCommands::FixAll(c) => c.available(cap), + Self::FixAll(c) => c.available(cap), } } pub async fn execute( @@ -43,7 +43,7 @@ impl WorkspaceCommands { args: Vec, ) -> jsonrpc::Result> { match self { - WorkspaceCommands::FixAll(c) => { + Self::FixAll(c) => { let arg: Result< ::CommandArgs<'_>, serde_json::Error, diff --git a/crates/oxc_linter/src/config/config_builder.rs b/crates/oxc_linter/src/config/config_builder.rs index cb07edff4f9c0..44febccf5af5b 100644 --- a/crates/oxc_linter/src/config/config_builder.rs +++ b/crates/oxc_linter/src/config/config_builder.rs @@ -314,7 +314,7 @@ pub enum ConfigBuilderError { impl std::fmt::Display for ConfigBuilderError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - ConfigBuilderError::UnknownRules { rules } => { + Self::UnknownRules { rules } => { write!(f, "unknown rules: ")?; for rule in rules { write!(f, "{}", rule.full_name())?; diff --git a/crates/oxc_linter/src/config/env.rs b/crates/oxc_linter/src/config/env.rs index cab011440a433..73ef710d62c43 100644 --- a/crates/oxc_linter/src/config/env.rs +++ b/crates/oxc_linter/src/config/env.rs @@ -44,7 +44,7 @@ impl OxlintEnv { self.0.iter().filter_map(|(k, v)| (*v).then_some(k.as_str())) } - pub(crate) fn override_envs(&self, envs_to_override: &mut OxlintEnv) { + pub(crate) fn override_envs(&self, envs_to_override: &mut Self) { for (env, supported) in self.0.clone() { envs_to_override.0.insert(env, supported); } diff --git a/crates/oxc_linter/src/config/globals.rs b/crates/oxc_linter/src/config/globals.rs index 0aaf0ed2dea87..3e16dc3db4fa7 100644 --- a/crates/oxc_linter/src/config/globals.rs +++ b/crates/oxc_linter/src/config/globals.rs @@ -50,7 +50,7 @@ impl OxlintGlobals { self.0.get(name).is_some_and(|value| *value != GlobalValue::Off) } - pub(crate) fn override_globals(&self, globals_to_override: &mut OxlintGlobals) { + pub(crate) fn override_globals(&self, globals_to_override: &mut Self) { for (env, supported) in self.0.clone() { globals_to_override.0.insert(env, supported); } @@ -88,9 +88,9 @@ impl From for GlobalValue { #[inline] fn from(value: bool) -> Self { if value { - GlobalValue::Writeable + Self::Writeable } else { - GlobalValue::Readonly + Self::Readonly } } } @@ -100,9 +100,9 @@ impl TryFrom<&str> for GlobalValue { fn try_from(value: &str) -> Result { match value { - "readonly" | "readable" => Ok(GlobalValue::Readonly), - "writable" | "writeable" => Ok(GlobalValue::Writeable), - "off" => Ok(GlobalValue::Off), + "readonly" | "readable" => Ok(Self::Readonly), + "writable" | "writeable" => Ok(Self::Writeable), + "off" => Ok(Self::Off), _ => Err("Invalid global value"), } } diff --git a/crates/oxc_linter/src/config/plugins.rs b/crates/oxc_linter/src/config/plugins.rs index e6ad6bf39c144..a363bd33dea6d 100644 --- a/crates/oxc_linter/src/config/plugins.rs +++ b/crates/oxc_linter/src/config/plugins.rs @@ -43,26 +43,26 @@ bitflags! { impl Default for LintPlugins { #[inline] fn default() -> Self { - LintPlugins::REACT | LintPlugins::UNICORN | LintPlugins::TYPESCRIPT | LintPlugins::OXC + Self::REACT | Self::UNICORN | Self::TYPESCRIPT | Self::OXC } } impl From for LintPlugins { fn from(options: LintPluginOptions) -> Self { - let mut plugins = LintPlugins::empty(); - plugins.set(LintPlugins::REACT, options.react); - plugins.set(LintPlugins::UNICORN, options.unicorn); - plugins.set(LintPlugins::TYPESCRIPT, options.typescript); - plugins.set(LintPlugins::OXC, options.oxc); - plugins.set(LintPlugins::IMPORT, options.import); - plugins.set(LintPlugins::JSDOC, options.jsdoc); - plugins.set(LintPlugins::JEST, options.jest); - plugins.set(LintPlugins::VITEST, options.vitest); - plugins.set(LintPlugins::JSX_A11Y, options.jsx_a11y); - plugins.set(LintPlugins::NEXTJS, options.nextjs); - plugins.set(LintPlugins::REACT_PERF, options.react_perf); - plugins.set(LintPlugins::PROMISE, options.promise); - plugins.set(LintPlugins::NODE, options.node); + let mut plugins = Self::empty(); + plugins.set(Self::REACT, options.react); + plugins.set(Self::UNICORN, options.unicorn); + plugins.set(Self::TYPESCRIPT, options.typescript); + plugins.set(Self::OXC, options.oxc); + plugins.set(Self::IMPORT, options.import); + plugins.set(Self::JSDOC, options.jsdoc); + plugins.set(Self::JEST, options.jest); + plugins.set(Self::VITEST, options.vitest); + plugins.set(Self::JSX_A11Y, options.jsx_a11y); + plugins.set(Self::NEXTJS, options.nextjs); + plugins.set(Self::REACT_PERF, options.react_perf); + plugins.set(Self::PROMISE, options.promise); + plugins.set(Self::NODE, options.node); plugins } } @@ -71,51 +71,51 @@ impl LintPlugins { /// Returns `true` if the Vitest plugin is enabled. #[inline] pub fn has_vitest(self) -> bool { - self.contains(LintPlugins::VITEST) + self.contains(Self::VITEST) } /// Returns `true` if the Jest plugin is enabled. #[inline] pub fn has_jest(self) -> bool { - self.contains(LintPlugins::JEST) + self.contains(Self::JEST) } /// Returns `true` if Jest or Vitest plugins are enabled. #[inline] pub fn has_test(self) -> bool { - self.intersects(LintPlugins::JEST.union(LintPlugins::VITEST)) + self.intersects(Self::JEST.union(Self::VITEST)) } /// Returns `true` if the import plugin is enabled. #[inline] pub fn has_import(self) -> bool { - self.contains(LintPlugins::IMPORT) + self.contains(Self::IMPORT) } } impl From<&str> for LintPlugins { fn from(value: &str) -> Self { match value { - "react" | "react-hooks" | "react_hooks" => LintPlugins::REACT, - "unicorn" => LintPlugins::UNICORN, + "react" | "react-hooks" | "react_hooks" => Self::REACT, + "unicorn" => Self::UNICORN, "typescript" | "typescript-eslint" | "typescript_eslint" | "@typescript-eslint" => { - LintPlugins::TYPESCRIPT + Self::TYPESCRIPT } // deepscan for backwards compatibility. Those rules have been moved into oxc - "oxc" | "deepscan" => LintPlugins::OXC, + "oxc" | "deepscan" => Self::OXC, // import-x has the same rules but better performance - "import" | "import-x" => LintPlugins::IMPORT, - "jsdoc" => LintPlugins::JSDOC, - "jest" => LintPlugins::JEST, - "vitest" => LintPlugins::VITEST, - "jsx-a11y" | "jsx_a11y" => LintPlugins::JSX_A11Y, - "nextjs" => LintPlugins::NEXTJS, - "react-perf" | "react_perf" => LintPlugins::REACT_PERF, - "promise" => LintPlugins::PROMISE, - "node" => LintPlugins::NODE, + "import" | "import-x" => Self::IMPORT, + "jsdoc" => Self::JSDOC, + "jest" => Self::JEST, + "vitest" => Self::VITEST, + "jsx-a11y" | "jsx_a11y" => Self::JSX_A11Y, + "nextjs" => Self::NEXTJS, + "react-perf" | "react_perf" => Self::REACT_PERF, + "promise" => Self::PROMISE, + "node" => Self::NODE, // "eslint" is not really a plugin, so it's 'empty'. This has the added benefit of // making it the default value. - _ => LintPlugins::empty(), + _ => Self::empty(), } } } @@ -145,7 +145,7 @@ impl> FromIterator for LintPlugins { fn from_iter>(iter: T) -> Self { iter.into_iter() .map(|plugin| plugin.as_ref().into()) - .fold(LintPlugins::empty(), LintPlugins::union) + .fold(Self::empty(), Self::union) } } diff --git a/crates/oxc_linter/src/config/settings/next.rs b/crates/oxc_linter/src/config/settings/next.rs index 52e00d05b848c..dce4742569653 100644 --- a/crates/oxc_linter/src/config/settings/next.rs +++ b/crates/oxc_linter/src/config/settings/next.rs @@ -48,7 +48,7 @@ enum OneOrMany { impl Default for OneOrMany { fn default() -> Self { - OneOrMany::Many(Vec::new()) + Self::Many(Vec::new()) } } diff --git a/crates/oxc_linter/src/fixer/fix.rs b/crates/oxc_linter/src/fixer/fix.rs index 1090ffb212786..63e12e8b2bdc3 100644 --- a/crates/oxc_linter/src/fixer/fix.rs +++ b/crates/oxc_linter/src/fixer/fix.rs @@ -339,7 +339,7 @@ impl<'a> From>> for CompositeFix<'a> { } } -impl<'a> From>> for CompositeFix<'a> { +impl From> for CompositeFix<'_> { fn from(fixes: Vec) -> Self { fixes.into_iter().reduce(Self::concat).unwrap_or_default() } @@ -358,7 +358,7 @@ impl GetSpan for CompositeFix<'_> { } impl<'a> CompositeFix<'a> { - pub fn push(&mut self, fix: CompositeFix<'a>) { + pub fn push(&mut self, fix: Self) { match self { Self::None => *self = fix, Self::Single(fix1) => match fix { @@ -383,7 +383,7 @@ impl<'a> CompositeFix<'a> { #[cold] #[must_use] - pub fn concat(self, fix: CompositeFix<'a>) -> Self { + pub fn concat(self, fix: Self) -> Self { match (self, fix) { (Self::None, f) | (f, Self::None) => f, (Self::Single(fix1), Self::Single(fix2)) => Self::Multiple(vec![fix1, fix2]), diff --git a/crates/oxc_linter/src/module_record.rs b/crates/oxc_linter/src/module_record.rs index 5918b7b17b9a1..f6afecd49d9ce 100644 --- a/crates/oxc_linter/src/module_record.rs +++ b/crates/oxc_linter/src/module_record.rs @@ -499,7 +499,7 @@ impl ModuleRecord { .filter_map(|export_entry| export_entry.export_name.default_export_span()), ) .next(), - ..ModuleRecord::default() + ..Self::default() } } diff --git a/crates/oxc_linter/src/options/filter.rs b/crates/oxc_linter/src/options/filter.rs index 80c8fc08ddb9a..c577c8cba2cec 100644 --- a/crates/oxc_linter/src/options/filter.rs +++ b/crates/oxc_linter/src/options/filter.rs @@ -141,11 +141,11 @@ impl LintFilterKind { (LintPlugins::from(plugin), Cow::Owned(rule.to_string())) } }; - Ok(LintFilterKind::Rule(plugin, rule)) + Ok(Self::Rule(plugin, rule)) } else { match RuleCategory::try_from(filter.as_ref()) { - Ok(category) => Ok(LintFilterKind::Category(category)), - Err(()) => Ok(LintFilterKind::Generic(filter)), + Ok(category) => Ok(Self::Category(category)), + Err(()) => Ok(Self::Generic(filter)), } } } @@ -181,7 +181,7 @@ impl TryFrom> for LintFilterKind { impl From for LintFilterKind { #[inline] fn from(category: RuleCategory) -> Self { - LintFilterKind::Category(category) + Self::Category(category) } } diff --git a/crates/oxc_linter/src/rule.rs b/crates/oxc_linter/src/rule.rs index 49e895662034c..8c820ac5b400e 100644 --- a/crates/oxc_linter/src/rule.rs +++ b/crates/oxc_linter/src/rule.rs @@ -192,7 +192,7 @@ impl RuleFixMeta { ); kind } - RuleFixMeta::None | RuleFixMeta::FixPending => FixKind::None, + Self::None | Self::FixPending => FixKind::None, } } diff --git a/crates/oxc_linter/src/rules/eslint/func_names.rs b/crates/oxc_linter/src/rules/eslint/func_names.rs index 7ff69515855da..dd0f5d3c4873f 100644 --- a/crates/oxc_linter/src/rules/eslint/func_names.rs +++ b/crates/oxc_linter/src/rules/eslint/func_names.rs @@ -61,9 +61,9 @@ impl TryFrom<&serde_json::Value> for FuncNamesConfig { raw.as_str().map_or_else( || Err(OxcDiagnostic::warn("Expecting string for eslint/func-names configuration")), |v| match v { - "always" => Ok(FuncNamesConfig::Always), - "as-needed" => Ok(FuncNamesConfig::AsNeeded), - "never" => Ok(FuncNamesConfig::Never), + "always" => Ok(Self::Always), + "as-needed" => Ok(Self::AsNeeded), + "never" => Ok(Self::Never), _ => Err(OxcDiagnostic::warn( "Expecting always, as-needed or never for eslint/func-names configuration", )), diff --git a/crates/oxc_linter/src/rules/eslint/func_style.rs b/crates/oxc_linter/src/rules/eslint/func_style.rs index 5430ff5ae0858..c5174eda59daa 100644 --- a/crates/oxc_linter/src/rules/eslint/func_style.rs +++ b/crates/oxc_linter/src/rules/eslint/func_style.rs @@ -32,8 +32,8 @@ impl Style { pub fn as_str(&self) -> &str { match self { - Style::Expression => "expression", - Style::Declaration => "declaration", + Self::Expression => "expression", + Self::Declaration => "declaration", } } } diff --git a/crates/oxc_linter/src/rules/eslint/new_cap.rs b/crates/oxc_linter/src/rules/eslint/new_cap.rs index b97e70afe5772..979ec9bc305c9 100644 --- a/crates/oxc_linter/src/rules/eslint/new_cap.rs +++ b/crates/oxc_linter/src/rules/eslint/new_cap.rs @@ -449,7 +449,7 @@ declare_oxc_lint!( impl Rule for NewCap { fn from_configuration(value: serde_json::Value) -> Self { - NewCap::from(&value) + Self::from(&value) } fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) { match node.kind() { diff --git a/crates/oxc_linter/src/rules/eslint/no_magic_numbers.rs b/crates/oxc_linter/src/rules/eslint/no_magic_numbers.rs index 552ac4660799a..371ddbbef76d0 100644 --- a/crates/oxc_linter/src/rules/eslint/no_magic_numbers.rs +++ b/crates/oxc_linter/src/rules/eslint/no_magic_numbers.rs @@ -60,7 +60,7 @@ impl TryFrom<&serde_json::Value> for NoMagicNumbersConfig { fn try_from(raw: &serde_json::Value) -> Result { if raw.is_null() { - return Ok(NoMagicNumbersConfig::default()); + return Ok(Self::default()); } raw.get(0).map_or_else( diff --git a/crates/oxc_linter/src/rules/eslint/no_restricted_imports.rs b/crates/oxc_linter/src/rules/eslint/no_restricted_imports.rs index 1603bfaf6fd90..d1abbd149d728 100644 --- a/crates/oxc_linter/src/rules/eslint/no_restricted_imports.rs +++ b/crates/oxc_linter/src/rules/eslint/no_restricted_imports.rs @@ -194,14 +194,14 @@ impl std::ops::Deref for SerdeRegexWrapper { } impl<'de> Deserialize<'de> for SerdeRegexWrapper { - fn deserialize(d: D) -> Result, D::Error> + fn deserialize(d: D) -> Result where D: Deserializer<'de>, { let s = >::deserialize(d)?; match s.parse() { - Ok(regex) => Ok(SerdeRegexWrapper(regex)), + Ok(regex) => Ok(Self(regex)), Err(err) => Err(D::Error::custom(err)), } } diff --git a/crates/oxc_linter/src/rules/eslint/no_unused_vars/fixers/fix_symbol.rs b/crates/oxc_linter/src/rules/eslint/no_unused_vars/fixers/fix_symbol.rs index f21ede19d690b..a54303bb13cd9 100644 --- a/crates/oxc_linter/src/rules/eslint/no_unused_vars/fixers/fix_symbol.rs +++ b/crates/oxc_linter/src/rules/eslint/no_unused_vars/fixers/fix_symbol.rs @@ -4,7 +4,7 @@ use oxc_span::{CompactStr, GetSpan, Span}; use super::Symbol; use crate::fixer::{Fix, RuleFix, RuleFixer}; -impl<'s, 'a> Symbol<'s, 'a> { +impl<'a> Symbol<'_, 'a> { /// Delete a single declarator from a [`VariableDeclaration`] list with more /// than one declarator. pub(super) fn delete_from_list( @@ -15,7 +15,7 @@ impl<'s, 'a> Symbol<'s, 'a> { ) -> RuleFix<'a> where T: GetSpan, - Symbol<'s, 'a>: PartialEq, + Self: PartialEq, { let Some(own_position) = list.iter().position(|el| self == el) else { // Happens when the symbol is in a destructuring pattern. @@ -182,23 +182,23 @@ impl BindingInfo { #[inline] const fn single_or_missing(found: bool) -> Self { if found { - BindingInfo::SingleDestructure + Self::SingleDestructure } else { - BindingInfo::NotFound + Self::NotFound } } fn multi_or_missing(found: Option<(Span, bool)>, is_object: bool) -> Self { match found { - Some((span, is_last)) => BindingInfo::MultiDestructure(span.span(), is_object, is_last), - None => BindingInfo::NotFound, + Some((span, is_last)) => Self::MultiDestructure(span.span(), is_object, is_last), + None => Self::NotFound, } } fn multi_or_single(found: Option<(Span, bool)>, is_object: bool) -> Self { match found { - Some((span, is_last)) => BindingInfo::MultiDestructure(span.span(), is_object, is_last), - None => BindingInfo::SingleDestructure, + Some((span, is_last)) => Self::MultiDestructure(span.span(), is_object, is_last), + None => Self::SingleDestructure, } } } diff --git a/crates/oxc_linter/src/rules/eslint/no_unused_vars/mod.rs b/crates/oxc_linter/src/rules/eslint/no_unused_vars/mod.rs index 6c1aab88ba4b3..16e34663c9d84 100644 --- a/crates/oxc_linter/src/rules/eslint/no_unused_vars/mod.rs +++ b/crates/oxc_linter/src/rules/eslint/no_unused_vars/mod.rs @@ -306,7 +306,7 @@ impl NoUnusedVars { ctx.diagnostic(diagnostic::param(symbol, &self.args_ignore_pattern)); } AstKind::BindingRestElement(_) => { - if NoUnusedVars::is_allowed_binding_rest_element(symbol) { + if Self::is_allowed_binding_rest_element(symbol) { return; } ctx.diagnostic(diagnostic::declared(symbol, &self.vars_ignore_pattern)); diff --git a/crates/oxc_linter/src/rules/eslint/no_unused_vars/symbol.rs b/crates/oxc_linter/src/rules/eslint/no_unused_vars/symbol.rs index 231fa1baaad9f..33c39c1447676 100644 --- a/crates/oxc_linter/src/rules/eslint/no_unused_vars/symbol.rs +++ b/crates/oxc_linter/src/rules/eslint/no_unused_vars/symbol.rs @@ -283,9 +283,9 @@ impl<'a> PartialEq> for Symbol<'_, 'a> { } } -impl<'s, 'a, T> PartialEq<&T> for Symbol<'s, 'a> +impl PartialEq<&T> for Symbol<'_, '_> where - Symbol<'s, 'a>: PartialEq, + Self: PartialEq, { fn eq(&self, other: &&T) -> bool { self == *other diff --git a/crates/oxc_linter/src/rules/eslint/sort_imports.rs b/crates/oxc_linter/src/rules/eslint/sort_imports.rs index 78e08c31207b2..d1da206339a9e 100644 --- a/crates/oxc_linter/src/rules/eslint/sort_imports.rs +++ b/crates/oxc_linter/src/rules/eslint/sort_imports.rs @@ -361,7 +361,7 @@ struct MemberSyntaxSortOrder(Vec); impl Default for MemberSyntaxSortOrder { fn default() -> Self { - MemberSyntaxSortOrder(vec![ + Self(vec![ ImportKind::None, ImportKind::All, ImportKind::Multiple, @@ -426,10 +426,10 @@ impl FromStr for ImportKind { fn from_str(s: &str) -> Result { match s { - "none" => Ok(ImportKind::None), - "all" => Ok(ImportKind::All), - "multiple" => Ok(ImportKind::Multiple), - "single" => Ok(ImportKind::Single), + "none" => Ok(Self::None), + "all" => Ok(Self::All), + "multiple" => Ok(Self::Multiple), + "single" => Ok(Self::Single), _ => Err("Invalid import kind"), } } @@ -438,10 +438,10 @@ impl FromStr for ImportKind { impl Display for ImportKind { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - ImportKind::None => write!(f, "None"), - ImportKind::All => write!(f, "All"), - ImportKind::Multiple => write!(f, "Multiple"), - ImportKind::Single => write!(f, "Single"), + Self::None => write!(f, "None"), + Self::All => write!(f, "All"), + Self::Multiple => write!(f, "Multiple"), + Self::Single => write!(f, "Single"), } } } diff --git a/crates/oxc_linter/src/rules/import/no_cycle.rs b/crates/oxc_linter/src/rules/import/no_cycle.rs index 75da8164fdc17..060bb8a19c37b 100644 --- a/crates/oxc_linter/src/rules/import/no_cycle.rs +++ b/crates/oxc_linter/src/rules/import/no_cycle.rs @@ -93,7 +93,7 @@ declare_oxc_lint!( impl Rule for NoCycle { fn from_configuration(value: serde_json::Value) -> Self { let obj = value.get(0); - let default = NoCycle::default(); + let default = Self::default(); Self { max_depth: obj .and_then(|v| v.get("maxDepth")) diff --git a/crates/oxc_linter/src/rules/jest/consistent_test_it.rs b/crates/oxc_linter/src/rules/jest/consistent_test_it.rs index 1e5cecaca7c0f..29e67bb0e8194 100644 --- a/crates/oxc_linter/src/rules/jest/consistent_test_it.rs +++ b/crates/oxc_linter/src/rules/jest/consistent_test_it.rs @@ -59,11 +59,11 @@ impl std::str::FromStr for TestCaseName { fn from_str(s: &str) -> Result { match s { - "fit" => Ok(TestCaseName::Fit), - "it" => Ok(TestCaseName::IT), - "test" => Ok(TestCaseName::Test), - "xit" => Ok(TestCaseName::Xit), - "xtest" => Ok(TestCaseName::Xtest), + "fit" => Ok(Self::Fit), + "it" => Ok(Self::IT), + "test" => Ok(Self::Test), + "xit" => Ok(Self::Xit), + "xtest" => Ok(Self::Xtest), _ => Err("Unknown Test case name"), } } diff --git a/crates/oxc_linter/src/rules/oxc/no_barrel_file.rs b/crates/oxc_linter/src/rules/oxc/no_barrel_file.rs index 1a962a42ecfc5..fab2a036a9ce3 100644 --- a/crates/oxc_linter/src/rules/oxc/no_barrel_file.rs +++ b/crates/oxc_linter/src/rules/oxc/no_barrel_file.rs @@ -66,7 +66,7 @@ impl Rule for NoBarrelFile { .get(0) .and_then(|config| config.get("threshold")) .and_then(serde_json::Value::as_u64) - .map_or(NoBarrelFile::default().threshold, |n| n as usize), + .map_or(Self::default().threshold, |n| n as usize), } } diff --git a/crates/oxc_linter/src/table.rs b/crates/oxc_linter/src/table.rs index 91d22831c82c9..8c86ca4a7045f 100644 --- a/crates/oxc_linter/src/table.rs +++ b/crates/oxc_linter/src/table.rs @@ -85,7 +85,7 @@ impl RuleTable { }) .collect::>(); - RuleTable { total, sections, turned_on_by_default_count: 123 } + Self { total, sections, turned_on_by_default_count: 123 } } } diff --git a/crates/oxc_linter/src/tester.rs b/crates/oxc_linter/src/tester.rs index 515588bec374a..6a399127d9b34 100644 --- a/crates/oxc_linter/src/tester.rs +++ b/crates/oxc_linter/src/tester.rs @@ -98,8 +98,8 @@ impl From for ExpectFixKind { impl From for FixKind { fn from(expected_kind: ExpectFixKind) -> Self { match expected_kind { - ExpectFixKind::None => FixKind::None, - ExpectFixKind::Any => FixKind::All, + ExpectFixKind::None => Self::None, + ExpectFixKind::Any => Self::All, ExpectFixKind::Specific(kind) => kind, } } diff --git a/crates/oxc_linter/src/utils/jest/parse_jest_fn.rs b/crates/oxc_linter/src/utils/jest/parse_jest_fn.rs index e5f9fc06842c6..d65f6376be043 100644 --- a/crates/oxc_linter/src/utils/jest/parse_jest_fn.rs +++ b/crates/oxc_linter/src/utils/jest/parse_jest_fn.rs @@ -454,7 +454,7 @@ pub enum MemberExpressionElement<'a> { impl<'a> MemberExpressionElement<'a> { pub fn from_member_expr( member_expr: &'a MemberExpression<'a>, - ) -> Option<(Span, MemberExpressionElement<'a>)> { + ) -> Option<(Span, Self)> { let (span, _) = member_expr.static_property_info()?; match member_expr { MemberExpression::ComputedMemberExpression(expr) => { diff --git a/crates/oxc_mangler/src/lib.rs b/crates/oxc_mangler/src/lib.rs index 251d8aa44ed93..9a620bea38469 100644 --- a/crates/oxc_mangler/src/lib.rs +++ b/crates/oxc_mangler/src/lib.rs @@ -198,7 +198,7 @@ impl Mangler { } let (exported_names, exported_symbols) = if self.options.top_level { - Mangler::collect_exported_symbols(program) + Self::collect_exported_symbols(program) } else { Default::default() }; diff --git a/crates/oxc_parser/src/cursor.rs b/crates/oxc_parser/src/cursor.rs index 66d5bf0de31d4..173db6214876e 100644 --- a/crates/oxc_parser/src/cursor.rs +++ b/crates/oxc_parser/src/cursor.rs @@ -295,7 +295,7 @@ impl<'a> ParserImpl<'a> { /// # Errors pub(crate) fn try_parse( &mut self, - func: impl FnOnce(&mut ParserImpl<'a>) -> Result, + func: impl FnOnce(&mut Self) -> Result, ) -> Option { let checkpoint = self.checkpoint(); let ctx = self.ctx; @@ -309,7 +309,7 @@ impl<'a> ParserImpl<'a> { } } - pub(crate) fn lookahead(&mut self, predicate: impl Fn(&mut ParserImpl<'a>) -> U) -> U { + pub(crate) fn lookahead(&mut self, predicate: impl Fn(&mut Self) -> U) -> U { let checkpoint = self.checkpoint(); let answer = predicate(self); self.rewind(checkpoint); diff --git a/crates/oxc_regular_expression/src/generated/derive_clone_in.rs b/crates/oxc_regular_expression/src/generated/derive_clone_in.rs index 62f9e4ef10fde..7c070f526b203 100644 --- a/crates/oxc_regular_expression/src/generated/derive_clone_in.rs +++ b/crates/oxc_regular_expression/src/generated/derive_clone_in.rs @@ -1,7 +1,7 @@ // Auto-generated code, DO NOT EDIT DIRECTLY! // To edit this generated file you have to edit `tasks/ast_tools/src/derives/clone_in.rs` -#![allow(clippy::default_trait_access)] +#![allow(clippy::default_trait_access, clippy::use_self)] use oxc_allocator::{Allocator, CloneIn}; diff --git a/crates/oxc_regular_expression/src/generated/derive_estree.rs b/crates/oxc_regular_expression/src/generated/derive_estree.rs index 03ba5a4deeec4..60b182fa23983 100644 --- a/crates/oxc_regular_expression/src/generated/derive_estree.rs +++ b/crates/oxc_regular_expression/src/generated/derive_estree.rs @@ -45,18 +45,18 @@ impl Serialize for Alternative<'_> { impl Serialize for Term<'_> { fn serialize(&self, serializer: S) -> Result { match self { - 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), + Self::BoundaryAssertion(it) => it.serialize(serializer), + Self::LookAroundAssertion(it) => it.serialize(serializer), + Self::Quantifier(it) => it.serialize(serializer), + Self::Character(it) => it.serialize(serializer), + Self::Dot(it) => it.serialize(serializer), + Self::CharacterClassEscape(it) => it.serialize(serializer), + Self::UnicodePropertyEscape(it) => it.serialize(serializer), + Self::CharacterClass(it) => it.serialize(serializer), + Self::CapturingGroup(it) => it.serialize(serializer), + Self::IgnoreGroup(it) => it.serialize(serializer), + Self::IndexedReference(it) => it.serialize(serializer), + Self::NamedReference(it) => it.serialize(serializer), } } } @@ -75,16 +75,12 @@ impl Serialize for BoundaryAssertion { impl Serialize for BoundaryAssertionKind { fn serialize(&self, serializer: S) -> Result { match self { - BoundaryAssertionKind::Start => { - serializer.serialize_unit_variant("BoundaryAssertionKind", 0, "start") - } - BoundaryAssertionKind::End => { - serializer.serialize_unit_variant("BoundaryAssertionKind", 1, "end") - } - BoundaryAssertionKind::Boundary => { + Self::Start => serializer.serialize_unit_variant("BoundaryAssertionKind", 0, "start"), + Self::End => serializer.serialize_unit_variant("BoundaryAssertionKind", 1, "end"), + Self::Boundary => { serializer.serialize_unit_variant("BoundaryAssertionKind", 2, "boundary") } - BoundaryAssertionKind::NegativeBoundary => { + Self::NegativeBoundary => { serializer.serialize_unit_variant("BoundaryAssertionKind", 3, "negativeBoundary") } } @@ -106,16 +102,16 @@ impl Serialize for LookAroundAssertion<'_> { impl Serialize for LookAroundAssertionKind { fn serialize(&self, serializer: S) -> Result { match self { - LookAroundAssertionKind::Lookahead => { + Self::Lookahead => { serializer.serialize_unit_variant("LookAroundAssertionKind", 0, "lookahead") } - LookAroundAssertionKind::NegativeLookahead => { + Self::NegativeLookahead => { serializer.serialize_unit_variant("LookAroundAssertionKind", 1, "negativeLookahead") } - LookAroundAssertionKind::Lookbehind => { + Self::Lookbehind => { serializer.serialize_unit_variant("LookAroundAssertionKind", 2, "lookbehind") } - LookAroundAssertionKind::NegativeLookbehind => serializer.serialize_unit_variant( + Self::NegativeLookbehind => serializer.serialize_unit_variant( "LookAroundAssertionKind", 3, "negativeLookbehind", @@ -153,32 +149,22 @@ impl Serialize for Character { impl Serialize for CharacterKind { fn serialize(&self, serializer: S) -> Result { match self { - CharacterKind::ControlLetter => { + Self::ControlLetter => { serializer.serialize_unit_variant("CharacterKind", 0, "controlLetter") } - CharacterKind::HexadecimalEscape => { + Self::HexadecimalEscape => { serializer.serialize_unit_variant("CharacterKind", 1, "hexadecimalEscape") } - CharacterKind::Identifier => { - serializer.serialize_unit_variant("CharacterKind", 2, "identifier") - } - CharacterKind::Null => serializer.serialize_unit_variant("CharacterKind", 3, "null"), - CharacterKind::Octal1 => { - serializer.serialize_unit_variant("CharacterKind", 4, "octal1") - } - CharacterKind::Octal2 => { - serializer.serialize_unit_variant("CharacterKind", 5, "octal2") - } - CharacterKind::Octal3 => { - serializer.serialize_unit_variant("CharacterKind", 6, "octal3") - } - CharacterKind::SingleEscape => { + Self::Identifier => serializer.serialize_unit_variant("CharacterKind", 2, "identifier"), + Self::Null => serializer.serialize_unit_variant("CharacterKind", 3, "null"), + Self::Octal1 => serializer.serialize_unit_variant("CharacterKind", 4, "octal1"), + Self::Octal2 => serializer.serialize_unit_variant("CharacterKind", 5, "octal2"), + Self::Octal3 => serializer.serialize_unit_variant("CharacterKind", 6, "octal3"), + Self::SingleEscape => { serializer.serialize_unit_variant("CharacterKind", 7, "singleEscape") } - CharacterKind::Symbol => { - serializer.serialize_unit_variant("CharacterKind", 8, "symbol") - } - CharacterKind::UnicodeEscape => { + Self::Symbol => serializer.serialize_unit_variant("CharacterKind", 8, "symbol"), + Self::UnicodeEscape => { serializer.serialize_unit_variant("CharacterKind", 9, "unicodeEscape") } } @@ -199,22 +185,16 @@ impl Serialize for CharacterClassEscape { impl Serialize for CharacterClassEscapeKind { fn serialize(&self, serializer: S) -> Result { match self { - CharacterClassEscapeKind::D => { - serializer.serialize_unit_variant("CharacterClassEscapeKind", 0, "d") - } - CharacterClassEscapeKind::NegativeD => { + Self::D => serializer.serialize_unit_variant("CharacterClassEscapeKind", 0, "d"), + Self::NegativeD => { serializer.serialize_unit_variant("CharacterClassEscapeKind", 1, "negativeD") } - CharacterClassEscapeKind::S => { - serializer.serialize_unit_variant("CharacterClassEscapeKind", 2, "s") - } - CharacterClassEscapeKind::NegativeS => { + Self::S => serializer.serialize_unit_variant("CharacterClassEscapeKind", 2, "s"), + Self::NegativeS => { serializer.serialize_unit_variant("CharacterClassEscapeKind", 3, "negativeS") } - CharacterClassEscapeKind::W => { - serializer.serialize_unit_variant("CharacterClassEscapeKind", 4, "w") - } - CharacterClassEscapeKind::NegativeW => { + Self::W => serializer.serialize_unit_variant("CharacterClassEscapeKind", 4, "w"), + Self::NegativeW => { serializer.serialize_unit_variant("CharacterClassEscapeKind", 5, "negativeW") } } @@ -262,13 +242,13 @@ impl Serialize for CharacterClass<'_> { impl Serialize for CharacterClassContentsKind { fn serialize(&self, serializer: S) -> Result { match self { - CharacterClassContentsKind::Union => { + Self::Union => { serializer.serialize_unit_variant("CharacterClassContentsKind", 0, "union") } - CharacterClassContentsKind::Intersection => { + Self::Intersection => { serializer.serialize_unit_variant("CharacterClassContentsKind", 1, "intersection") } - CharacterClassContentsKind::Subtraction => { + Self::Subtraction => { serializer.serialize_unit_variant("CharacterClassContentsKind", 2, "subtraction") } } @@ -278,12 +258,12 @@ impl Serialize for CharacterClassContentsKind { impl Serialize for CharacterClassContents<'_> { fn serialize(&self, serializer: S) -> Result { match self { - 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), + Self::CharacterClassRange(it) => it.serialize(serializer), + Self::CharacterClassEscape(it) => it.serialize(serializer), + Self::UnicodePropertyEscape(it) => it.serialize(serializer), + Self::Character(it) => it.serialize(serializer), + Self::NestedCharacterClass(it) => it.serialize(serializer), + Self::ClassStringDisjunction(it) => it.serialize(serializer), } } } diff --git a/crates/oxc_regular_expression/src/parser/reader/string_literal_parser/parser_impl.rs b/crates/oxc_regular_expression/src/parser/reader/string_literal_parser/parser_impl.rs index 94e104cd3d609..e174d9c398bd3 100644 --- a/crates/oxc_regular_expression/src/parser/reader/string_literal_parser/parser_impl.rs +++ b/crates/oxc_regular_expression/src/parser/reader/string_literal_parser/parser_impl.rs @@ -128,7 +128,7 @@ impl Parser { ) -> Result> { let mut body = vec![]; while let Some(code_point) = self.parse_string_character(single_or_double_quote)? { - Parser::handle_code_point( + Self::handle_code_point( &mut body, code_point, self.options.span_offset, diff --git a/crates/oxc_semantic/src/dot.rs b/crates/oxc_semantic/src/dot.rs index 5d25edb1e7467..4dd219212f5bb 100644 --- a/crates/oxc_semantic/src/dot.rs +++ b/crates/oxc_semantic/src/dot.rs @@ -30,7 +30,7 @@ pub struct DebugDotContext<'a, 'b> { } impl<'a, 'b> DebugDotContext<'a, 'b> { - pub fn new(nodes: &'b AstNodes<'a>, verbose: bool) -> DebugDotContext<'a, 'b> { + pub fn new(nodes: &'b AstNodes<'a>, verbose: bool) -> Self { DebugDotContext { nodes, verbose } } } diff --git a/crates/oxc_semantic/src/jsdoc/parser/jsdoc.rs b/crates/oxc_semantic/src/jsdoc/parser/jsdoc.rs index 249b93608314f..c9955fb4967ea 100644 --- a/crates/oxc_semantic/src/jsdoc/parser/jsdoc.rs +++ b/crates/oxc_semantic/src/jsdoc/parser/jsdoc.rs @@ -17,7 +17,7 @@ pub struct JSDoc<'a> { impl<'a> JSDoc<'a> { /// comment_content: Inside of /**HERE*/, not include `/**` and `*/` /// span: `Span` for this JSDoc comment, range for `/**HERE*/` - pub fn new(comment_content: &'a str, span: Span) -> JSDoc<'a> { + pub fn new(comment_content: &'a str, span: Span) -> Self { Self { raw: comment_content, cached: OnceCell::new(), span } } diff --git a/crates/oxc_semantic/src/jsdoc/parser/jsdoc_tag.rs b/crates/oxc_semantic/src/jsdoc/parser/jsdoc_tag.rs index cf4d4d2da2c50..2a6ce159f271d 100644 --- a/crates/oxc_semantic/src/jsdoc/parser/jsdoc_tag.rs +++ b/crates/oxc_semantic/src/jsdoc/parser/jsdoc_tag.rs @@ -39,7 +39,7 @@ pub struct JSDocTag<'a> { } impl<'a> JSDocTag<'a> { - pub fn new(kind: JSDocTagKindPart<'a>, body_content: &'a str, body_span: Span) -> JSDocTag<'a> { + pub fn new(kind: JSDocTagKindPart<'a>, body_content: &'a str, body_span: Span) -> Self { Self { span: kind.span.merge(body_span), kind, body_raw: body_content, body_span } } diff --git a/crates/oxc_semantic/src/stats.rs b/crates/oxc_semantic/src/stats.rs index b326581036c74..a6148e0e73b70 100644 --- a/crates/oxc_semantic/src/stats.rs +++ b/crates/oxc_semantic/src/stats.rs @@ -76,7 +76,7 @@ pub struct Stats { impl Stats { /// Create new [`Stats`] from specified counts. pub fn new(nodes: u32, scopes: u32, symbols: u32, references: u32) -> Self { - Stats { nodes, scopes, symbols, references } + Self { nodes, scopes, symbols, references } } /// Gather [`Stats`] by visiting AST and counting nodes, scopes, symbols, and references. diff --git a/crates/oxc_semantic/tests/conformance/mod.rs b/crates/oxc_semantic/tests/conformance/mod.rs index 6673e29fd45de..dde71f1d40b76 100644 --- a/crates/oxc_semantic/tests/conformance/mod.rs +++ b/crates/oxc_semantic/tests/conformance/mod.rs @@ -137,30 +137,30 @@ pub enum TestResult { } impl From for TestResult { fn from(reason: String) -> Self { - TestResult::Fail(vec![OxcDiagnostic::error(Cow::Owned(reason))]) + Self::Fail(vec![OxcDiagnostic::error(Cow::Owned(reason))]) } } impl From> for TestResult { fn from(result: Option) -> Self { match result { - Some(reason) => TestResult::Fail(vec![OxcDiagnostic::error(Cow::Owned(reason))]), - None => TestResult::Pass, + Some(reason) => Self::Fail(vec![OxcDiagnostic::error(Cow::Owned(reason))]), + None => Self::Pass, } } } impl From for TestResult { fn from(diagnostic: OxcDiagnostic) -> Self { - TestResult::Fail(vec![diagnostic]) + Self::Fail(vec![diagnostic]) } } impl From> for TestResult { fn from(diagnostics: Vec) -> Self { - TestResult::Fail(diagnostics) + Self::Fail(diagnostics) } } impl FromIterator for TestResult { fn from_iter>(iter: I) -> Self { - TestResult::Fail(iter.into_iter().collect()) + Self::Fail(iter.into_iter().collect()) } } diff --git a/crates/oxc_span/src/atom.rs b/crates/oxc_span/src/atom.rs index afaef900fa437..06df88b8e8ced 100644 --- a/crates/oxc_span/src/atom.rs +++ b/crates/oxc_span/src/atom.rs @@ -69,8 +69,8 @@ impl<'new_alloc> CloneIn<'new_alloc> for Atom<'_> { } } -impl<'alloc> FromIn<'alloc, &Atom<'alloc>> for Atom<'alloc> { - fn from_in(s: &Atom<'alloc>, _: &'alloc Allocator) -> Self { +impl<'alloc> FromIn<'alloc, &Self> for Atom<'alloc> { + fn from_in(s: &Self, _: &'alloc Allocator) -> Self { *s } } diff --git a/crates/oxc_span/src/compact_str.rs b/crates/oxc_span/src/compact_str.rs index c783ec302d3f2..53d3be4acf907 100644 --- a/crates/oxc_span/src/compact_str.rs +++ b/crates/oxc_span/src/compact_str.rs @@ -140,8 +140,8 @@ impl From for Cow<'_, str> { impl From> for CompactStr { fn from(value: Cow<'_, str>) -> Self { match value { - Cow::Borrowed(s) => CompactStr::new(s), - Cow::Owned(s) => CompactStr::from(s), + Cow::Borrowed(s) => Self::new(s), + Cow::Owned(s) => Self::from(s), } } } diff --git a/crates/oxc_span/src/generated/derive_estree.rs b/crates/oxc_span/src/generated/derive_estree.rs index 695e145bc0e25..b8ae75281ae7f 100644 --- a/crates/oxc_span/src/generated/derive_estree.rs +++ b/crates/oxc_span/src/generated/derive_estree.rs @@ -30,11 +30,9 @@ impl Serialize for SourceType { impl Serialize for ModuleKind { fn serialize(&self, serializer: S) -> Result { match self { - 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", 2, "unambiguous") - } + Self::Script => serializer.serialize_unit_variant("ModuleKind", 0, "script"), + Self::Module => serializer.serialize_unit_variant("ModuleKind", 1, "module"), + Self::Unambiguous => serializer.serialize_unit_variant("ModuleKind", 2, "unambiguous"), } } } diff --git a/crates/oxc_span/src/span.rs b/crates/oxc_span/src/span.rs index a42e1bf1e3a5c..85cf998d393d1 100644 --- a/crates/oxc_span/src/span.rs +++ b/crates/oxc_span/src/span.rs @@ -196,7 +196,7 @@ impl Span { /// assert!(!span.contains_inclusive(Span::empty(0))); /// ``` #[inline] - pub const fn contains_inclusive(self, span: Span) -> bool { + pub const fn contains_inclusive(self, span: Self) -> bool { self.start <= span.start && span.end <= self.end } @@ -442,7 +442,7 @@ impl Span { } impl Index for str { - type Output = str; + type Output = Self; #[inline] fn index(&self, index: Span) -> &Self::Output { @@ -472,7 +472,7 @@ impl From for SourceSpan { impl From for LabeledSpan { fn from(val: Span) -> Self { - LabeledSpan::underline(val) + Self::underline(val) } } diff --git a/crates/oxc_syntax/src/generated/derive_clone_in.rs b/crates/oxc_syntax/src/generated/derive_clone_in.rs index b73e99d8e76eb..4ef5362cc0311 100644 --- a/crates/oxc_syntax/src/generated/derive_clone_in.rs +++ b/crates/oxc_syntax/src/generated/derive_clone_in.rs @@ -1,7 +1,7 @@ // Auto-generated code, DO NOT EDIT DIRECTLY! // To edit this generated file you have to edit `tasks/ast_tools/src/derives/clone_in.rs` -#![allow(clippy::default_trait_access)] +#![allow(clippy::default_trait_access, clippy::use_self)] use oxc_allocator::{Allocator, CloneIn}; diff --git a/crates/oxc_syntax/src/generated/derive_estree.rs b/crates/oxc_syntax/src/generated/derive_estree.rs index 7631327c9a526..b514a9b8bfc85 100644 --- a/crates/oxc_syntax/src/generated/derive_estree.rs +++ b/crates/oxc_syntax/src/generated/derive_estree.rs @@ -12,52 +12,26 @@ use crate::operator::*; impl Serialize for AssignmentOperator { fn serialize(&self, serializer: S) -> Result { match self { - AssignmentOperator::Assign => { - serializer.serialize_unit_variant("AssignmentOperator", 0, "=") - } - AssignmentOperator::Addition => { - serializer.serialize_unit_variant("AssignmentOperator", 1, "+=") - } - AssignmentOperator::Subtraction => { - serializer.serialize_unit_variant("AssignmentOperator", 2, "-=") - } - AssignmentOperator::Multiplication => { + Self::Assign => serializer.serialize_unit_variant("AssignmentOperator", 0, "="), + Self::Addition => serializer.serialize_unit_variant("AssignmentOperator", 1, "+="), + Self::Subtraction => serializer.serialize_unit_variant("AssignmentOperator", 2, "-="), + Self::Multiplication => { serializer.serialize_unit_variant("AssignmentOperator", 3, "*=") } - AssignmentOperator::Division => { - serializer.serialize_unit_variant("AssignmentOperator", 4, "/=") - } - AssignmentOperator::Remainder => { - serializer.serialize_unit_variant("AssignmentOperator", 5, "%=") - } - AssignmentOperator::Exponential => { - serializer.serialize_unit_variant("AssignmentOperator", 6, "**=") - } - AssignmentOperator::ShiftLeft => { - serializer.serialize_unit_variant("AssignmentOperator", 7, "<<=") - } - AssignmentOperator::ShiftRight => { - serializer.serialize_unit_variant("AssignmentOperator", 8, ">>=") - } - AssignmentOperator::ShiftRightZeroFill => { + Self::Division => serializer.serialize_unit_variant("AssignmentOperator", 4, "/="), + Self::Remainder => serializer.serialize_unit_variant("AssignmentOperator", 5, "%="), + Self::Exponential => serializer.serialize_unit_variant("AssignmentOperator", 6, "**="), + Self::ShiftLeft => serializer.serialize_unit_variant("AssignmentOperator", 7, "<<="), + Self::ShiftRight => serializer.serialize_unit_variant("AssignmentOperator", 8, ">>="), + Self::ShiftRightZeroFill => { serializer.serialize_unit_variant("AssignmentOperator", 9, ">>>=") } - AssignmentOperator::BitwiseOR => { - serializer.serialize_unit_variant("AssignmentOperator", 10, "|=") - } - AssignmentOperator::BitwiseXOR => { - serializer.serialize_unit_variant("AssignmentOperator", 11, "^=") - } - AssignmentOperator::BitwiseAnd => { - serializer.serialize_unit_variant("AssignmentOperator", 12, "&=") - } - AssignmentOperator::LogicalOr => { - serializer.serialize_unit_variant("AssignmentOperator", 13, "||=") - } - AssignmentOperator::LogicalAnd => { - serializer.serialize_unit_variant("AssignmentOperator", 14, "&&=") - } - AssignmentOperator::LogicalNullish => { + Self::BitwiseOR => serializer.serialize_unit_variant("AssignmentOperator", 10, "|="), + Self::BitwiseXOR => serializer.serialize_unit_variant("AssignmentOperator", 11, "^="), + Self::BitwiseAnd => serializer.serialize_unit_variant("AssignmentOperator", 12, "&="), + Self::LogicalOr => serializer.serialize_unit_variant("AssignmentOperator", 13, "||="), + Self::LogicalAnd => serializer.serialize_unit_variant("AssignmentOperator", 14, "&&="), + Self::LogicalNullish => { serializer.serialize_unit_variant("AssignmentOperator", 15, "??=") } } @@ -67,64 +41,30 @@ impl Serialize for AssignmentOperator { impl Serialize for BinaryOperator { fn serialize(&self, serializer: S) -> Result { match self { - BinaryOperator::Equality => { - serializer.serialize_unit_variant("BinaryOperator", 0, "==") - } - BinaryOperator::Inequality => { - serializer.serialize_unit_variant("BinaryOperator", 1, "!=") - } - BinaryOperator::StrictEquality => { - serializer.serialize_unit_variant("BinaryOperator", 2, "===") - } - BinaryOperator::StrictInequality => { - serializer.serialize_unit_variant("BinaryOperator", 3, "!==") - } - BinaryOperator::LessThan => serializer.serialize_unit_variant("BinaryOperator", 4, "<"), - BinaryOperator::LessEqualThan => { - serializer.serialize_unit_variant("BinaryOperator", 5, "<=") - } - BinaryOperator::GreaterThan => { - serializer.serialize_unit_variant("BinaryOperator", 6, ">") - } - BinaryOperator::GreaterEqualThan => { - serializer.serialize_unit_variant("BinaryOperator", 7, ">=") - } - BinaryOperator::Addition => serializer.serialize_unit_variant("BinaryOperator", 8, "+"), - BinaryOperator::Subtraction => { - serializer.serialize_unit_variant("BinaryOperator", 9, "-") - } - BinaryOperator::Multiplication => { - serializer.serialize_unit_variant("BinaryOperator", 10, "*") - } - BinaryOperator::Division => { - serializer.serialize_unit_variant("BinaryOperator", 11, "/") - } - BinaryOperator::Remainder => { - serializer.serialize_unit_variant("BinaryOperator", 12, "%") - } - BinaryOperator::Exponential => { - serializer.serialize_unit_variant("BinaryOperator", 13, "**") - } - BinaryOperator::ShiftLeft => { - serializer.serialize_unit_variant("BinaryOperator", 14, "<<") - } - BinaryOperator::ShiftRight => { - serializer.serialize_unit_variant("BinaryOperator", 15, ">>") - } - BinaryOperator::ShiftRightZeroFill => { + Self::Equality => serializer.serialize_unit_variant("BinaryOperator", 0, "=="), + Self::Inequality => serializer.serialize_unit_variant("BinaryOperator", 1, "!="), + Self::StrictEquality => serializer.serialize_unit_variant("BinaryOperator", 2, "==="), + Self::StrictInequality => serializer.serialize_unit_variant("BinaryOperator", 3, "!=="), + Self::LessThan => serializer.serialize_unit_variant("BinaryOperator", 4, "<"), + Self::LessEqualThan => serializer.serialize_unit_variant("BinaryOperator", 5, "<="), + Self::GreaterThan => serializer.serialize_unit_variant("BinaryOperator", 6, ">"), + Self::GreaterEqualThan => serializer.serialize_unit_variant("BinaryOperator", 7, ">="), + Self::Addition => serializer.serialize_unit_variant("BinaryOperator", 8, "+"), + Self::Subtraction => serializer.serialize_unit_variant("BinaryOperator", 9, "-"), + Self::Multiplication => serializer.serialize_unit_variant("BinaryOperator", 10, "*"), + Self::Division => serializer.serialize_unit_variant("BinaryOperator", 11, "/"), + Self::Remainder => serializer.serialize_unit_variant("BinaryOperator", 12, "%"), + Self::Exponential => serializer.serialize_unit_variant("BinaryOperator", 13, "**"), + Self::ShiftLeft => serializer.serialize_unit_variant("BinaryOperator", 14, "<<"), + Self::ShiftRight => serializer.serialize_unit_variant("BinaryOperator", 15, ">>"), + Self::ShiftRightZeroFill => { serializer.serialize_unit_variant("BinaryOperator", 16, ">>>") } - BinaryOperator::BitwiseOR => { - serializer.serialize_unit_variant("BinaryOperator", 17, "|") - } - BinaryOperator::BitwiseXOR => { - serializer.serialize_unit_variant("BinaryOperator", 18, "^") - } - BinaryOperator::BitwiseAnd => { - serializer.serialize_unit_variant("BinaryOperator", 19, "&") - } - BinaryOperator::In => serializer.serialize_unit_variant("BinaryOperator", 20, "in"), - BinaryOperator::Instanceof => { + Self::BitwiseOR => serializer.serialize_unit_variant("BinaryOperator", 17, "|"), + Self::BitwiseXOR => serializer.serialize_unit_variant("BinaryOperator", 18, "^"), + Self::BitwiseAnd => serializer.serialize_unit_variant("BinaryOperator", 19, "&"), + Self::In => serializer.serialize_unit_variant("BinaryOperator", 20, "in"), + Self::Instanceof => { serializer.serialize_unit_variant("BinaryOperator", 21, "instanceof") } } @@ -134,11 +74,9 @@ impl Serialize for BinaryOperator { impl Serialize for LogicalOperator { fn serialize(&self, serializer: S) -> Result { match self { - LogicalOperator::Or => serializer.serialize_unit_variant("LogicalOperator", 0, "||"), - LogicalOperator::And => serializer.serialize_unit_variant("LogicalOperator", 1, "&&"), - LogicalOperator::Coalesce => { - serializer.serialize_unit_variant("LogicalOperator", 2, "??") - } + Self::Or => serializer.serialize_unit_variant("LogicalOperator", 0, "||"), + Self::And => serializer.serialize_unit_variant("LogicalOperator", 1, "&&"), + Self::Coalesce => serializer.serialize_unit_variant("LogicalOperator", 2, "??"), } } } @@ -146,19 +84,13 @@ impl Serialize for LogicalOperator { impl Serialize for UnaryOperator { fn serialize(&self, serializer: S) -> Result { match self { - UnaryOperator::UnaryPlus => serializer.serialize_unit_variant("UnaryOperator", 0, "+"), - UnaryOperator::UnaryNegation => { - 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", 4, "typeof") - } - UnaryOperator::Void => serializer.serialize_unit_variant("UnaryOperator", 5, "void"), - UnaryOperator::Delete => { - serializer.serialize_unit_variant("UnaryOperator", 6, "delete") - } + Self::UnaryPlus => serializer.serialize_unit_variant("UnaryOperator", 0, "+"), + Self::UnaryNegation => serializer.serialize_unit_variant("UnaryOperator", 1, "-"), + Self::LogicalNot => serializer.serialize_unit_variant("UnaryOperator", 2, "!"), + Self::BitwiseNot => serializer.serialize_unit_variant("UnaryOperator", 3, "~"), + Self::Typeof => serializer.serialize_unit_variant("UnaryOperator", 4, "typeof"), + Self::Void => serializer.serialize_unit_variant("UnaryOperator", 5, "void"), + Self::Delete => serializer.serialize_unit_variant("UnaryOperator", 6, "delete"), } } } @@ -166,12 +98,8 @@ impl Serialize for UnaryOperator { impl Serialize for UpdateOperator { fn serialize(&self, serializer: S) -> Result { match self { - UpdateOperator::Increment => { - serializer.serialize_unit_variant("UpdateOperator", 0, "++") - } - UpdateOperator::Decrement => { - serializer.serialize_unit_variant("UpdateOperator", 1, "--") - } + Self::Increment => serializer.serialize_unit_variant("UpdateOperator", 0, "++"), + Self::Decrement => serializer.serialize_unit_variant("UpdateOperator", 1, "--"), } } } diff --git a/crates/oxc_syntax/src/node.rs b/crates/oxc_syntax/src/node.rs index af492e321ede7..f8a510c4820ff 100644 --- a/crates/oxc_syntax/src/node.rs +++ b/crates/oxc_syntax/src/node.rs @@ -13,7 +13,7 @@ impl NodeId { /// Mock node id. /// /// This is used for synthetically-created AST nodes, among other things. - pub const DUMMY: Self = NodeId::new(0); + pub const DUMMY: Self = Self::new(0); /// Create `NodeId` from `u32`. /// diff --git a/crates/oxc_transformer/src/es2017/mod.rs b/crates/oxc_transformer/src/es2017/mod.rs index 7f18f8cb7cadc..2fc0987f11079 100644 --- a/crates/oxc_transformer/src/es2017/mod.rs +++ b/crates/oxc_transformer/src/es2017/mod.rs @@ -16,7 +16,7 @@ pub struct ES2017<'a, 'ctx> { } impl<'a, 'ctx> ES2017<'a, 'ctx> { - pub fn new(options: ES2017Options, ctx: &'ctx TransformCtx<'a>) -> ES2017<'a, 'ctx> { + pub fn new(options: ES2017Options, ctx: &'ctx TransformCtx<'a>) -> Self { ES2017 { async_to_generator: AsyncToGenerator::new(ctx), options } } } diff --git a/crates/oxc_transformer/src/options/babel/mod.rs b/crates/oxc_transformer/src/options/babel/mod.rs index 3b1dab2b53849..68eac854eafe3 100644 --- a/crates/oxc_transformer/src/options/babel/mod.rs +++ b/crates/oxc_transformer/src/options/babel/mod.rs @@ -136,7 +136,7 @@ impl BabelOptions { presets_json = new_presets; } - let new_options: Self = serde_json::from_value::(new_value) + let new_options: Self = serde_json::from_value::(new_value) .unwrap_or_else(|err| panic!("{err:?}\n{file:?}\n{content}")); if let Some(existing_options) = babel_options.as_mut() { diff --git a/crates/oxc_transformer/src/options/browserslist_query.rs b/crates/oxc_transformer/src/options/browserslist_query.rs index aa77a6c7ca195..23c109605a214 100644 --- a/crates/oxc_transformer/src/options/browserslist_query.rs +++ b/crates/oxc_transformer/src/options/browserslist_query.rs @@ -30,14 +30,14 @@ impl BrowserslistQuery { }; let result = match self { - BrowserslistQuery::Single(s) => { + Self::Single(s) => { if s.is_empty() { browserslist::resolve(&["defaults"], &options) } else { browserslist::resolve(&[s], &options) } } - BrowserslistQuery::Multiple(s) => browserslist::resolve(s, &options), + Self::Multiple(s) => browserslist::resolve(s, &options), }; let result = match result { diff --git a/crates/oxc_transformer/src/options/engine.rs b/crates/oxc_transformer/src/options/engine.rs index 699f84ac184d4..65f833961daae 100644 --- a/crates/oxc_transformer/src/options/engine.rs +++ b/crates/oxc_transformer/src/options/engine.rs @@ -37,7 +37,7 @@ impl Engine { /// /// * No matching target /// * Invalid version - pub fn parse_name_and_version(s: &str) -> Result<(Engine, Version), String> { + pub fn parse_name_and_version(s: &str) -> Result<(Self, Version), String> { let s = s.cow_to_ascii_lowercase(); for (name, engine) in engines() { if let Some(v) = s.strip_prefix(name) { diff --git a/crates/oxc_transformer/src/options/env.rs b/crates/oxc_transformer/src/options/env.rs index b1c1f64479105..c5acf92b7e1ea 100644 --- a/crates/oxc_transformer/src/options/env.rs +++ b/crates/oxc_transformer/src/options/env.rs @@ -136,7 +136,7 @@ impl EnvOptions { } } engine_targets.insert(Engine::Es, es_target.unwrap_or(ESTarget::default()).version()); - Ok(EnvOptions::from(engine_targets)) + Ok(Self::from(engine_targets)) } } diff --git a/crates/oxc_transformer/src/plugins/inject_global_variables.rs b/crates/oxc_transformer/src/plugins/inject_global_variables.rs index 456e1d6591c5b..7f9ef9bd17755 100644 --- a/crates/oxc_transformer/src/plugins/inject_global_variables.rs +++ b/crates/oxc_transformer/src/plugins/inject_global_variables.rs @@ -35,8 +35,8 @@ pub struct InjectImport { } impl InjectImport { - pub fn named_specifier(source: &str, imported: Option<&str>, local: &str) -> InjectImport { - InjectImport { + pub fn named_specifier(source: &str, imported: Option<&str>, local: &str) -> Self { + Self { source: CompactStr::from(source), specifier: InjectImportSpecifier::Specifier { imported: imported.map(CompactStr::from), @@ -46,16 +46,16 @@ impl InjectImport { } } - pub fn namespace_specifier(source: &str, local: &str) -> InjectImport { - InjectImport { + pub fn namespace_specifier(source: &str, local: &str) -> Self { + Self { source: CompactStr::from(source), specifier: InjectImportSpecifier::NamespaceSpecifier { local: CompactStr::from(local) }, replace_value: Self::replace_name(local), } } - pub fn default_specifier(source: &str, local: &str) -> InjectImport { - InjectImport { + pub fn default_specifier(source: &str, local: &str) -> Self { + Self { source: CompactStr::from(source), specifier: InjectImportSpecifier::DefaultSpecifier { local: CompactStr::from(local) }, replace_value: Self::replace_name(local), diff --git a/napi/minify/src/options.rs b/napi/minify/src/options.rs index 918d670936231..cadff167dba6c 100644 --- a/napi/minify/src/options.rs +++ b/napi/minify/src/options.rs @@ -33,7 +33,7 @@ impl Default for CompressOptions { impl TryFrom<&CompressOptions> for oxc_minifier::CompressOptions { type Error = String; fn try_from(o: &CompressOptions) -> Result { - Ok(oxc_minifier::CompressOptions { + Ok(Self { target: o .target .as_ref() @@ -78,9 +78,9 @@ impl Default for CodegenOptions { impl From<&CodegenOptions> for oxc_codegen::CodegenOptions { fn from(o: &CodegenOptions) -> Self { - oxc_codegen::CodegenOptions { + Self { minify: o.whitespace.unwrap_or(true), - ..oxc_codegen::CodegenOptions::default() + ..Self::default() } } } @@ -111,7 +111,7 @@ impl TryFrom<&MinifyOptions> for oxc_minifier::MinifierOptions { None | Some(Either::A(true)) => Some(oxc_minifier::MangleOptions::default()), Some(Either::B(o)) => Some(oxc_minifier::MangleOptions::from(o)), }; - Ok(oxc_minifier::MinifierOptions { compress, mangle }) + Ok(Self { compress, mangle }) } } diff --git a/napi/transform/src/transformer.rs b/napi/transform/src/transformer.rs index 02e18e5109e69..df950d01ac54f 100644 --- a/napi/transform/src/transformer.rs +++ b/napi/transform/src/transformer.rs @@ -189,7 +189,7 @@ pub struct CompilerAssumptions { impl From for oxc::transformer::CompilerAssumptions { fn from(value: CompilerAssumptions) -> Self { - let ops = oxc::transformer::CompilerAssumptions::default(); + let ops = Self::default(); Self { ignore_function_length: value .ignore_function_length @@ -237,8 +237,8 @@ pub struct TypeScriptOptions { impl From for oxc::transformer::TypeScriptOptions { fn from(options: TypeScriptOptions) -> Self { - let ops = oxc::transformer::TypeScriptOptions::default(); - oxc::transformer::TypeScriptOptions { + let ops = Self::default(); + Self { jsx_pragma: options.jsx_pragma.map(Into::into).unwrap_or(ops.jsx_pragma), jsx_pragma_frag: options.jsx_pragma_frag.map(Into::into).unwrap_or(ops.jsx_pragma_frag), only_remove_type_imports: options @@ -291,7 +291,7 @@ pub struct DecoratorOptions { impl From for oxc::transformer::DecoratorOptions { fn from(options: DecoratorOptions) -> Self { - oxc::transformer::DecoratorOptions { + Self { legacy: options.legacy.unwrap_or_default(), emit_decorator_metadata: options.emit_decorator_metadata.unwrap_or_default(), } @@ -384,8 +384,8 @@ pub struct JsxOptions { impl From for oxc::transformer::JsxOptions { fn from(options: JsxOptions) -> Self { - let ops = oxc::transformer::JsxOptions::default(); - oxc::transformer::JsxOptions { + let ops = Self::default(); + Self { runtime: match options.runtime.as_deref() { Some("classic") => JsxRuntime::Classic, /* "automatic" */ _ => JsxRuntime::Automatic, @@ -424,8 +424,8 @@ pub struct ReactRefreshOptions { impl From for oxc::transformer::ReactRefreshOptions { fn from(options: ReactRefreshOptions) -> Self { - let ops = oxc::transformer::ReactRefreshOptions::default(); - oxc::transformer::ReactRefreshOptions { + let ops = Self::default(); + Self { refresh_reg: options.refresh_reg.unwrap_or(ops.refresh_reg), refresh_sig: options.refresh_sig.unwrap_or(ops.refresh_sig), emit_full_signatures: options.emit_full_signatures.unwrap_or(ops.emit_full_signatures), @@ -446,7 +446,7 @@ pub struct ArrowFunctionsOptions { impl From for oxc::transformer::ArrowFunctionsOptions { fn from(options: ArrowFunctionsOptions) -> Self { - oxc::transformer::ArrowFunctionsOptions { spec: options.spec.unwrap_or_default() } + Self { spec: options.spec.unwrap_or_default() } } } @@ -458,7 +458,7 @@ pub struct Es2015Options { impl From for oxc::transformer::ES2015Options { fn from(options: Es2015Options) -> Self { - oxc::transformer::ES2015Options { arrow_function: options.arrow_function.map(Into::into) } + Self { arrow_function: options.arrow_function.map(Into::into) } } } @@ -495,7 +495,7 @@ impl From for HelperLoaderOptions { fn from(value: Helpers) -> Self { Self { mode: value.mode.map(HelperLoaderMode::from).unwrap_or_default(), - ..HelperLoaderOptions::default() + ..Self::default() } } } diff --git a/tasks/ast_tools/src/derives/clone_in.rs b/tasks/ast_tools/src/derives/clone_in.rs index 29d1094793828..99c3495ce3da5 100644 --- a/tasks/ast_tools/src/derives/clone_in.rs +++ b/tasks/ast_tools/src/derives/clone_in.rs @@ -59,7 +59,7 @@ impl Derive for DeriveCloneIn { fn prelude(&self) -> TokenStream { quote! { - #![allow(clippy::default_trait_access)] + #![allow(clippy::default_trait_access, clippy::use_self)] ///@@line_break use oxc_allocator::{Allocator, CloneIn}; diff --git a/tasks/ast_tools/src/derives/estree.rs b/tasks/ast_tools/src/derives/estree.rs index 796336ad1a8cd..59effed1e4d65 100644 --- a/tasks/ast_tools/src/derives/estree.rs +++ b/tasks/ast_tools/src/derives/estree.rs @@ -401,8 +401,6 @@ impl<'s> StructSerializerGenerator<'s> { /// Generate body of `serialize` method for an enum. fn generate_body_for_enum(enum_def: &EnumDef, schema: &Schema) -> TokenStream { - let enum_ident = enum_def.ident(); - let match_branches = enum_def.all_variants(schema).map(|variant| { let variant_ident = variant.ident(); if variant.is_fieldless() { @@ -410,11 +408,11 @@ fn generate_body_for_enum(enum_def: &EnumDef, schema: &Schema) -> TokenStream { let discriminant = number_lit(variant.discriminant); let value = get_fieldless_variant_value(enum_def, variant); quote! { - #enum_ident::#variant_ident => serializer.serialize_unit_variant(#enum_name, #discriminant, #value), + Self::#variant_ident => serializer.serialize_unit_variant(#enum_name, #discriminant, #value), } } else { quote! { - #enum_ident::#variant_ident(it) => it.serialize(serializer), + Self::#variant_ident(it) => it.serialize(serializer), } } }); diff --git a/tasks/ast_tools/src/parse/attr.rs b/tasks/ast_tools/src/parse/attr.rs index 3f3ec0af6bbff..f29022a442a13 100644 --- a/tasks/ast_tools/src/parse/attr.rs +++ b/tasks/ast_tools/src/parse/attr.rs @@ -190,7 +190,7 @@ impl AttrPartListElement { /// Unwrap this [`AttrPartListElement`] if it is an [`AttrPartListElement::List`]. #[expect(dead_code)] - pub fn try_into_list(self) -> Result<(String, Vec)> { + pub fn try_into_list(self) -> Result<(String, Vec)> { if let Self::List(name, elements) = self { Ok((name, elements)) } else { diff --git a/tasks/ast_tools/src/schema/defs/type.rs b/tasks/ast_tools/src/schema/defs/type.rs index 6693a28516462..527a74621d111 100644 --- a/tasks/ast_tools/src/schema/defs/type.rs +++ b/tasks/ast_tools/src/schema/defs/type.rs @@ -21,65 +21,65 @@ impl Def for TypeDef { /// Get [`TypeId`] for type. fn id(&self) -> TypeId { match self { - TypeDef::Struct(def) => def.id(), - TypeDef::Enum(def) => def.id(), - TypeDef::Primitive(def) => def.id(), - TypeDef::Option(def) => def.id(), - TypeDef::Box(def) => def.id(), - TypeDef::Vec(def) => def.id(), - TypeDef::Cell(def) => def.id(), + Self::Struct(def) => def.id(), + Self::Enum(def) => def.id(), + Self::Primitive(def) => def.id(), + Self::Option(def) => def.id(), + Self::Box(def) => def.id(), + Self::Vec(def) => def.id(), + Self::Cell(def) => def.id(), } } /// Get type name. fn name(&self) -> &str { match self { - TypeDef::Struct(def) => def.name(), - TypeDef::Enum(def) => def.name(), - TypeDef::Primitive(def) => def.name(), - TypeDef::Option(def) => def.name(), - TypeDef::Box(def) => def.name(), - TypeDef::Vec(def) => def.name(), - TypeDef::Cell(def) => def.name(), + Self::Struct(def) => def.name(), + Self::Enum(def) => def.name(), + Self::Primitive(def) => def.name(), + Self::Option(def) => def.name(), + Self::Box(def) => def.name(), + Self::Vec(def) => def.name(), + Self::Cell(def) => def.name(), } } /// Get all traits which have derives generated for this type. fn generated_derives(&self) -> Derives { match self { - TypeDef::Struct(def) => def.generated_derives(), - TypeDef::Enum(def) => def.generated_derives(), - TypeDef::Primitive(def) => def.generated_derives(), - TypeDef::Option(def) => def.generated_derives(), - TypeDef::Box(def) => def.generated_derives(), - TypeDef::Vec(def) => def.generated_derives(), - TypeDef::Cell(def) => def.generated_derives(), + Self::Struct(def) => def.generated_derives(), + Self::Enum(def) => def.generated_derives(), + Self::Primitive(def) => def.generated_derives(), + Self::Option(def) => def.generated_derives(), + Self::Box(def) => def.generated_derives(), + Self::Vec(def) => def.generated_derives(), + Self::Cell(def) => def.generated_derives(), } } /// Get if type has a lifetime. fn has_lifetime(&self, schema: &Schema) -> bool { match self { - TypeDef::Struct(def) => def.has_lifetime(schema), - TypeDef::Enum(def) => def.has_lifetime(schema), - TypeDef::Primitive(def) => def.has_lifetime(schema), - TypeDef::Option(def) => def.has_lifetime(schema), - TypeDef::Box(def) => def.has_lifetime(schema), - TypeDef::Vec(def) => def.has_lifetime(schema), - TypeDef::Cell(def) => def.has_lifetime(schema), + Self::Struct(def) => def.has_lifetime(schema), + Self::Enum(def) => def.has_lifetime(schema), + Self::Primitive(def) => def.has_lifetime(schema), + Self::Option(def) => def.has_lifetime(schema), + Self::Box(def) => def.has_lifetime(schema), + Self::Vec(def) => def.has_lifetime(schema), + Self::Cell(def) => def.has_lifetime(schema), } } /// Get type signature (including anonymous lifetimes). fn ty_with_lifetime(&self, schema: &Schema, anon: bool) -> TokenStream { match self { - TypeDef::Struct(def) => def.ty_with_lifetime(schema, anon), - TypeDef::Enum(def) => def.ty_with_lifetime(schema, anon), - TypeDef::Primitive(def) => def.ty_with_lifetime(schema, anon), - TypeDef::Option(def) => def.ty_with_lifetime(schema, anon), - TypeDef::Box(def) => def.ty_with_lifetime(schema, anon), - TypeDef::Vec(def) => def.ty_with_lifetime(schema, anon), - TypeDef::Cell(def) => def.ty_with_lifetime(schema, anon), + Self::Struct(def) => def.ty_with_lifetime(schema, anon), + Self::Enum(def) => def.ty_with_lifetime(schema, anon), + Self::Primitive(def) => def.ty_with_lifetime(schema, anon), + Self::Option(def) => def.ty_with_lifetime(schema, anon), + Self::Box(def) => def.ty_with_lifetime(schema, anon), + Self::Vec(def) => def.ty_with_lifetime(schema, anon), + Self::Cell(def) => def.ty_with_lifetime(schema, anon), } } @@ -93,13 +93,13 @@ impl Def for TypeDef { /// [`innermost_type`]: Self::innermost_type fn maybe_inner_type<'s>(&self, schema: &'s Schema) -> Option<&'s TypeDef> { match self { - TypeDef::Struct(def) => def.maybe_inner_type(schema), - TypeDef::Enum(def) => def.maybe_inner_type(schema), - TypeDef::Primitive(def) => def.maybe_inner_type(schema), - TypeDef::Option(def) => def.maybe_inner_type(schema), - TypeDef::Box(def) => def.maybe_inner_type(schema), - TypeDef::Vec(def) => def.maybe_inner_type(schema), - TypeDef::Cell(def) => def.maybe_inner_type(schema), + Self::Struct(def) => def.maybe_inner_type(schema), + Self::Enum(def) => def.maybe_inner_type(schema), + Self::Primitive(def) => def.maybe_inner_type(schema), + Self::Option(def) => def.maybe_inner_type(schema), + Self::Box(def) => def.maybe_inner_type(schema), + Self::Vec(def) => def.maybe_inner_type(schema), + Self::Cell(def) => def.maybe_inner_type(schema), } } } diff --git a/tasks/transform_checker/src/lib.rs b/tasks/transform_checker/src/lib.rs index bd58d431d506b..09675270f42c4 100644 --- a/tasks/transform_checker/src/lib.rs +++ b/tasks/transform_checker/src/lib.rs @@ -256,7 +256,7 @@ impl Pair { } } -impl AsRef> for Pair { +impl AsRef for Pair { fn as_ref(&self) -> &Self { self }