style: apply clippy suggestions for use_self

Replace NodeType:: with Self:: in match patterns to follow Rust idioms
and reduce unnecessary structure name repetition.

No functional changes - purely cosmetic improvements.

Author: mattsse

crates/artifacts/solc/src/ast/lowfidelity.rs

@@ -213,80 +213,80 @@ impl serde::Serialize for NodeType {
         S: serde::Serializer,
     {
         match self {
-            NodeType::Assignment => serializer.serialize_str("Assignment"),
-            NodeType::BinaryOperation => serializer.serialize_str("BinaryOperation"),
-            NodeType::Conditional => serializer.serialize_str("Conditional"),
-            NodeType::ElementaryTypeNameExpression => {
+            Self::Assignment => serializer.serialize_str("Assignment"),
+            Self::BinaryOperation => serializer.serialize_str("BinaryOperation"),
+            Self::Conditional => serializer.serialize_str("Conditional"),
+            Self::ElementaryTypeNameExpression => {
                 serializer.serialize_str("ElementaryTypeNameExpression")
             }
-            NodeType::FunctionCall => serializer.serialize_str("FunctionCall"),
-            NodeType::FunctionCallOptions => serializer.serialize_str("FunctionCallOptions"),
-            NodeType::Identifier => serializer.serialize_str("Identifier"),
-            NodeType::IndexAccess => serializer.serialize_str("IndexAccess"),
-            NodeType::IndexRangeAccess => serializer.serialize_str("IndexRangeAccess"),
-            NodeType::Literal => serializer.serialize_str("Literal"),
-            NodeType::MemberAccess => serializer.serialize_str("MemberAccess"),
-            NodeType::NewExpression => serializer.serialize_str("NewExpression"),
-            NodeType::TupleExpression => serializer.serialize_str("TupleExpression"),
-            NodeType::UnaryOperation => serializer.serialize_str("UnaryOperation"),
-            NodeType::Block => serializer.serialize_str("Block"),
-            NodeType::Break => serializer.serialize_str("Break"),
-            NodeType::Continue => serializer.serialize_str("Continue"),
-            NodeType::DoWhileStatement => serializer.serialize_str("DoWhileStatement"),
-            NodeType::EmitStatement => serializer.serialize_str("EmitStatement"),
-            NodeType::ExpressionStatement => serializer.serialize_str("ExpressionStatement"),
-            NodeType::ForStatement => serializer.serialize_str("ForStatement"),
-            NodeType::IfStatement => serializer.serialize_str("IfStatement"),
-            NodeType::InlineAssembly => serializer.serialize_str("InlineAssembly"),
-            NodeType::PlaceholderStatement => serializer.serialize_str("PlaceholderStatement"),
-            NodeType::Return => serializer.serialize_str("Return"),
-            NodeType::RevertStatement => serializer.serialize_str("RevertStatement"),
-            NodeType::TryStatement => serializer.serialize_str("TryStatement"),
-            NodeType::UncheckedBlock => serializer.serialize_str("UncheckedBlock"),
-            NodeType::VariableDeclarationStatement => {
+            Self::FunctionCall => serializer.serialize_str("FunctionCall"),
+            Self::FunctionCallOptions => serializer.serialize_str("FunctionCallOptions"),
+            Self::Identifier => serializer.serialize_str("Identifier"),
+            Self::IndexAccess => serializer.serialize_str("IndexAccess"),
+            Self::IndexRangeAccess => serializer.serialize_str("IndexRangeAccess"),
+            Self::Literal => serializer.serialize_str("Literal"),
+            Self::MemberAccess => serializer.serialize_str("MemberAccess"),
+            Self::NewExpression => serializer.serialize_str("NewExpression"),
+            Self::TupleExpression => serializer.serialize_str("TupleExpression"),
+            Self::UnaryOperation => serializer.serialize_str("UnaryOperation"),
+            Self::Block => serializer.serialize_str("Block"),
+            Self::Break => serializer.serialize_str("Break"),
+            Self::Continue => serializer.serialize_str("Continue"),
+            Self::DoWhileStatement => serializer.serialize_str("DoWhileStatement"),
+            Self::EmitStatement => serializer.serialize_str("EmitStatement"),
+            Self::ExpressionStatement => serializer.serialize_str("ExpressionStatement"),
+            Self::ForStatement => serializer.serialize_str("ForStatement"),
+            Self::IfStatement => serializer.serialize_str("IfStatement"),
+            Self::InlineAssembly => serializer.serialize_str("InlineAssembly"),
+            Self::PlaceholderStatement => serializer.serialize_str("PlaceholderStatement"),
+            Self::Return => serializer.serialize_str("Return"),
+            Self::RevertStatement => serializer.serialize_str("RevertStatement"),
+            Self::TryStatement => serializer.serialize_str("TryStatement"),
+            Self::UncheckedBlock => serializer.serialize_str("UncheckedBlock"),
+            Self::VariableDeclarationStatement => {
                 serializer.serialize_str("VariableDeclarationStatement")
             }
-            NodeType::VariableDeclaration => serializer.serialize_str("VariableDeclaration"),
-            NodeType::WhileStatement => serializer.serialize_str("WhileStatement"),
-            NodeType::YulAssignment => serializer.serialize_str("YulAssignment"),
-            NodeType::YulBlock => serializer.serialize_str("YulBlock"),
-            NodeType::YulBreak => serializer.serialize_str("YulBreak"),
-            NodeType::YulCase => serializer.serialize_str("YulCase"),
-            NodeType::YulContinue => serializer.serialize_str("YulContinue"),
-            NodeType::YulExpressionStatement => serializer.serialize_str("YulExpressionStatement"),
-            NodeType::YulLeave => serializer.serialize_str("YulLeave"),
-            NodeType::YulForLoop => serializer.serialize_str("YulForLoop"),
-            NodeType::YulFunctionDefinition => serializer.serialize_str("YulFunctionDefinition"),
-            NodeType::YulIf => serializer.serialize_str("YulIf"),
-            NodeType::YulSwitch => serializer.serialize_str("YulSwitch"),
-            NodeType::YulVariableDeclaration => serializer.serialize_str("YulVariableDeclaration"),
-            NodeType::YulFunctionCall => serializer.serialize_str("YulFunctionCall"),
-            NodeType::YulIdentifier => serializer.serialize_str("YulIdentifier"),
-            NodeType::YulLiteral => serializer.serialize_str("YulLiteral"),
-            NodeType::YulLiteralValue => serializer.serialize_str("YulLiteralValue"),
-            NodeType::YulHexValue => serializer.serialize_str("YulHexValue"),
-            NodeType::YulTypedName => serializer.serialize_str("YulTypedName"),
-            NodeType::ContractDefinition => serializer.serialize_str("ContractDefinition"),
-            NodeType::FunctionDefinition => serializer.serialize_str("FunctionDefinition"),
-            NodeType::EventDefinition => serializer.serialize_str("EventDefinition"),
-            NodeType::ErrorDefinition => serializer.serialize_str("ErrorDefinition"),
-            NodeType::ModifierDefinition => serializer.serialize_str("ModifierDefinition"),
-            NodeType::StructDefinition => serializer.serialize_str("StructDefinition"),
-            NodeType::EnumDefinition => serializer.serialize_str("EnumDefinition"),
-            NodeType::UserDefinedValueTypeDefinition => {
+            Self::VariableDeclaration => serializer.serialize_str("VariableDeclaration"),
+            Self::WhileStatement => serializer.serialize_str("WhileStatement"),
+            Self::YulAssignment => serializer.serialize_str("YulAssignment"),
+            Self::YulBlock => serializer.serialize_str("YulBlock"),
+            Self::YulBreak => serializer.serialize_str("YulBreak"),
+            Self::YulCase => serializer.serialize_str("YulCase"),
+            Self::YulContinue => serializer.serialize_str("YulContinue"),
+            Self::YulExpressionStatement => serializer.serialize_str("YulExpressionStatement"),
+            Self::YulLeave => serializer.serialize_str("YulLeave"),
+            Self::YulForLoop => serializer.serialize_str("YulForLoop"),
+            Self::YulFunctionDefinition => serializer.serialize_str("YulFunctionDefinition"),
+            Self::YulIf => serializer.serialize_str("YulIf"),
+            Self::YulSwitch => serializer.serialize_str("YulSwitch"),
+            Self::YulVariableDeclaration => serializer.serialize_str("YulVariableDeclaration"),
+            Self::YulFunctionCall => serializer.serialize_str("YulFunctionCall"),
+            Self::YulIdentifier => serializer.serialize_str("YulIdentifier"),
+            Self::YulLiteral => serializer.serialize_str("YulLiteral"),
+            Self::YulLiteralValue => serializer.serialize_str("YulLiteralValue"),
+            Self::YulHexValue => serializer.serialize_str("YulHexValue"),
+            Self::YulTypedName => serializer.serialize_str("YulTypedName"),
+            Self::ContractDefinition => serializer.serialize_str("ContractDefinition"),
+            Self::FunctionDefinition => serializer.serialize_str("FunctionDefinition"),
+            Self::EventDefinition => serializer.serialize_str("EventDefinition"),
+            Self::ErrorDefinition => serializer.serialize_str("ErrorDefinition"),
+            Self::ModifierDefinition => serializer.serialize_str("ModifierDefinition"),
+            Self::StructDefinition => serializer.serialize_str("StructDefinition"),
+            Self::EnumDefinition => serializer.serialize_str("EnumDefinition"),
+            Self::UserDefinedValueTypeDefinition => {
                 serializer.serialize_str("UserDefinedValueTypeDefinition")
             }
-            NodeType::PragmaDirective => serializer.serialize_str("PragmaDirective"),
-            NodeType::ImportDirective => serializer.serialize_str("ImportDirective"),
-            NodeType::UsingForDirective => serializer.serialize_str("UsingForDirective"),
-            NodeType::SourceUnit => serializer.serialize_str("SourceUnit"),
-            NodeType::InheritanceSpecifier => serializer.serialize_str("InheritanceSpecifier"),
-            NodeType::ElementaryTypeName => serializer.serialize_str("ElementaryTypeName"),
-            NodeType::FunctionTypeName => serializer.serialize_str("FunctionTypeName"),
-            NodeType::ParameterList => serializer.serialize_str("ParameterList"),
-            NodeType::TryCatchClause => serializer.serialize_str("TryCatchClause"),
-            NodeType::ModifierInvocation => serializer.serialize_str("ModifierInvocation"),
-            NodeType::Other(s) => serializer.serialize_str(s),
+            Self::PragmaDirective => serializer.serialize_str("PragmaDirective"),
+            Self::ImportDirective => serializer.serialize_str("ImportDirective"),
+            Self::UsingForDirective => serializer.serialize_str("UsingForDirective"),
+            Self::SourceUnit => serializer.serialize_str("SourceUnit"),
+            Self::InheritanceSpecifier => serializer.serialize_str("InheritanceSpecifier"),
+            Self::ElementaryTypeName => serializer.serialize_str("ElementaryTypeName"),
+            Self::FunctionTypeName => serializer.serialize_str("FunctionTypeName"),
+            Self::ParameterList => serializer.serialize_str("ParameterList"),
+            Self::TryCatchClause => serializer.serialize_str("TryCatchClause"),
+            Self::ModifierInvocation => serializer.serialize_str("ModifierInvocation"),
+            Self::Other(s) => serializer.serialize_str(s),
         }
     }
 }
@@ -298,74 +298,74 @@ impl<'de> serde::Deserialize<'de> for NodeType {
     {
         let s = String::deserialize(deserializer)?;
         Ok(match s.as_str() {
-            "Assignment" => NodeType::Assignment,
-            "BinaryOperation" => NodeType::BinaryOperation,
-            "Conditional" => NodeType::Conditional,
-            "ElementaryTypeNameExpression" => NodeType::ElementaryTypeNameExpression,
-            "FunctionCall" => NodeType::FunctionCall,
-            "FunctionCallOptions" => NodeType::FunctionCallOptions,
-            "Identifier" => NodeType::Identifier,
-            "IndexAccess" => NodeType::IndexAccess,
-            "IndexRangeAccess" => NodeType::IndexRangeAccess,
-            "Literal" => NodeType::Literal,
-            "MemberAccess" => NodeType::MemberAccess,
-            "NewExpression" => NodeType::NewExpression,
-            "TupleExpression" => NodeType::TupleExpression,
-            "UnaryOperation" => NodeType::UnaryOperation,
-            "Block" => NodeType::Block,
-            "Break" => NodeType::Break,
-            "Continue" => NodeType::Continue,
-            "DoWhileStatement" => NodeType::DoWhileStatement,
-            "EmitStatement" => NodeType::EmitStatement,
-            "ExpressionStatement" => NodeType::ExpressionStatement,
-            "ForStatement" => NodeType::ForStatement,
-            "IfStatement" => NodeType::IfStatement,
-            "InlineAssembly" => NodeType::InlineAssembly,
-            "PlaceholderStatement" => NodeType::PlaceholderStatement,
-            "Return" => NodeType::Return,
-            "RevertStatement" => NodeType::RevertStatement,
-            "TryStatement" => NodeType::TryStatement,
-            "UncheckedBlock" => NodeType::UncheckedBlock,
-            "VariableDeclarationStatement" => NodeType::VariableDeclarationStatement,
-            "VariableDeclaration" => NodeType::VariableDeclaration,
-            "WhileStatement" => NodeType::WhileStatement,
-            "YulAssignment" => NodeType::YulAssignment,
-            "YulBlock" => NodeType::YulBlock,
-            "YulBreak" => NodeType::YulBreak,
-            "YulCase" => NodeType::YulCase,
-            "YulContinue" => NodeType::YulContinue,
-            "YulExpressionStatement" => NodeType::YulExpressionStatement,
-            "YulLeave" => NodeType::YulLeave,
-            "YulForLoop" => NodeType::YulForLoop,
-            "YulFunctionDefinition" => NodeType::YulFunctionDefinition,
-            "YulIf" => NodeType::YulIf,
-            "YulSwitch" => NodeType::YulSwitch,
-            "YulVariableDeclaration" => NodeType::YulVariableDeclaration,
-            "YulFunctionCall" => NodeType::YulFunctionCall,
-            "YulIdentifier" => NodeType::YulIdentifier,
-            "YulLiteral" => NodeType::YulLiteral,
-            "YulLiteralValue" => NodeType::YulLiteralValue,
-            "YulHexValue" => NodeType::YulHexValue,
-            "YulTypedName" => NodeType::YulTypedName,
-            "ContractDefinition" => NodeType::ContractDefinition,
-            "FunctionDefinition" => NodeType::FunctionDefinition,
-            "EventDefinition" => NodeType::EventDefinition,
-            "ErrorDefinition" => NodeType::ErrorDefinition,
-            "ModifierDefinition" => NodeType::ModifierDefinition,
-            "StructDefinition" => NodeType::StructDefinition,
-            "EnumDefinition" => NodeType::EnumDefinition,
-            "UserDefinedValueTypeDefinition" => NodeType::UserDefinedValueTypeDefinition,
-            "PragmaDirective" => NodeType::PragmaDirective,
-            "ImportDirective" => NodeType::ImportDirective,
-            "UsingForDirective" => NodeType::UsingForDirective,
-            "SourceUnit" => NodeType::SourceUnit,
-            "InheritanceSpecifier" => NodeType::InheritanceSpecifier,
-            "ElementaryTypeName" => NodeType::ElementaryTypeName,
-            "FunctionTypeName" => NodeType::FunctionTypeName,
-            "ParameterList" => NodeType::ParameterList,
-            "TryCatchClause" => NodeType::TryCatchClause,
-            "ModifierInvocation" => NodeType::ModifierInvocation,
-            _ => NodeType::Other(s),
+            "Assignment" => Self::Assignment,
+            "BinaryOperation" => Self::BinaryOperation,
+            "Conditional" => Self::Conditional,
+            "ElementaryTypeNameExpression" => Self::ElementaryTypeNameExpression,
+            "FunctionCall" => Self::FunctionCall,
+            "FunctionCallOptions" => Self::FunctionCallOptions,
+            "Identifier" => Self::Identifier,
+            "IndexAccess" => Self::IndexAccess,
+            "IndexRangeAccess" => Self::IndexRangeAccess,
+            "Literal" => Self::Literal,
+            "MemberAccess" => Self::MemberAccess,
+            "NewExpression" => Self::NewExpression,
+            "TupleExpression" => Self::TupleExpression,
+            "UnaryOperation" => Self::UnaryOperation,
+            "Block" => Self::Block,
+            "Break" => Self::Break,
+            "Continue" => Self::Continue,
+            "DoWhileStatement" => Self::DoWhileStatement,
+            "EmitStatement" => Self::EmitStatement,
+            "ExpressionStatement" => Self::ExpressionStatement,
+            "ForStatement" => Self::ForStatement,
+            "IfStatement" => Self::IfStatement,
+            "InlineAssembly" => Self::InlineAssembly,
+            "PlaceholderStatement" => Self::PlaceholderStatement,
+            "Return" => Self::Return,
+            "RevertStatement" => Self::RevertStatement,
+            "TryStatement" => Self::TryStatement,
+            "UncheckedBlock" => Self::UncheckedBlock,
+            "VariableDeclarationStatement" => Self::VariableDeclarationStatement,
+            "VariableDeclaration" => Self::VariableDeclaration,
+            "WhileStatement" => Self::WhileStatement,
+            "YulAssignment" => Self::YulAssignment,
+            "YulBlock" => Self::YulBlock,
+            "YulBreak" => Self::YulBreak,
+            "YulCase" => Self::YulCase,
+            "YulContinue" => Self::YulContinue,
+            "YulExpressionStatement" => Self::YulExpressionStatement,
+            "YulLeave" => Self::YulLeave,
+            "YulForLoop" => Self::YulForLoop,
+            "YulFunctionDefinition" => Self::YulFunctionDefinition,
+            "YulIf" => Self::YulIf,
+            "YulSwitch" => Self::YulSwitch,
+            "YulVariableDeclaration" => Self::YulVariableDeclaration,
+            "YulFunctionCall" => Self::YulFunctionCall,
+            "YulIdentifier" => Self::YulIdentifier,
+            "YulLiteral" => Self::YulLiteral,
+            "YulLiteralValue" => Self::YulLiteralValue,
+            "YulHexValue" => Self::YulHexValue,
+            "YulTypedName" => Self::YulTypedName,
+            "ContractDefinition" => Self::ContractDefinition,
+            "FunctionDefinition" => Self::FunctionDefinition,
+            "EventDefinition" => Self::EventDefinition,
+            "ErrorDefinition" => Self::ErrorDefinition,
+            "ModifierDefinition" => Self::ModifierDefinition,
+            "StructDefinition" => Self::StructDefinition,
+            "EnumDefinition" => Self::EnumDefinition,
+            "UserDefinedValueTypeDefinition" => Self::UserDefinedValueTypeDefinition,
+            "PragmaDirective" => Self::PragmaDirective,
+            "ImportDirective" => Self::ImportDirective,
+            "UsingForDirective" => Self::UsingForDirective,
+            "SourceUnit" => Self::SourceUnit,
+            "InheritanceSpecifier" => Self::InheritanceSpecifier,
+            "ElementaryTypeName" => Self::ElementaryTypeName,
+            "FunctionTypeName" => Self::FunctionTypeName,
+            "ParameterList" => Self::ParameterList,
+            "TryCatchClause" => Self::TryCatchClause,
+            "ModifierInvocation" => Self::ModifierInvocation,
+            _ => Self::Other(s),
         })
     }
 }