use 'Self' keyword (clippy::use_self)

Author: daniel.eades

graphql-introspection-query/src/introspection_response.rs

@@ -28,25 +28,25 @@ pub enum __DirectiveLocation {
 impl Serialize for __DirectiveLocation {
     fn serialize<S: serde::Serializer>(&self, ser: S) -> Result<S::Ok, S::Error> {
         ser.serialize_str(match *self {
-            __DirectiveLocation::QUERY => "QUERY",
-            __DirectiveLocation::MUTATION => "MUTATION",
-            __DirectiveLocation::SUBSCRIPTION => "SUBSCRIPTION",
-            __DirectiveLocation::FIELD => "FIELD",
-            __DirectiveLocation::FRAGMENT_DEFINITION => "FRAGMENT_DEFINITION",
-            __DirectiveLocation::FRAGMENT_SPREAD => "FRAGMENT_SPREAD",
-            __DirectiveLocation::INLINE_FRAGMENT => "INLINE_FRAGMENT",
-            __DirectiveLocation::SCHEMA => "SCHEMA",
-            __DirectiveLocation::SCALAR => "SCALAR",
-            __DirectiveLocation::OBJECT => "OBJECT",
-            __DirectiveLocation::FIELD_DEFINITION => "FIELD_DEFINITION",
-            __DirectiveLocation::ARGUMENT_DEFINITION => "ARGUMENT_DEFINITION",
-            __DirectiveLocation::INTERFACE => "INTERFACE",
-            __DirectiveLocation::UNION => "UNION",
-            __DirectiveLocation::ENUM => "ENUM",
-            __DirectiveLocation::ENUM_VALUE => "ENUM_VALUE",
-            __DirectiveLocation::INPUT_OBJECT => "INPUT_OBJECT",
-            __DirectiveLocation::INPUT_FIELD_DEFINITION => "INPUT_FIELD_DEFINITION",
-            __DirectiveLocation::Other(ref s) => s.as_str(),
+            Self::QUERY => "QUERY",
+            Self::MUTATION => "MUTATION",
+            Self::SUBSCRIPTION => "SUBSCRIPTION",
+            Self::FIELD => "FIELD",
+            Self::FRAGMENT_DEFINITION => "FRAGMENT_DEFINITION",
+            Self::FRAGMENT_SPREAD => "FRAGMENT_SPREAD",
+            Self::INLINE_FRAGMENT => "INLINE_FRAGMENT",
+            Self::SCHEMA => "SCHEMA",
+            Self::SCALAR => "SCALAR",
+            Self::OBJECT => "OBJECT",
+            Self::FIELD_DEFINITION => "FIELD_DEFINITION",
+            Self::ARGUMENT_DEFINITION => "ARGUMENT_DEFINITION",
+            Self::INTERFACE => "INTERFACE",
+            Self::UNION => "UNION",
+            Self::ENUM => "ENUM",
+            Self::ENUM_VALUE => "ENUM_VALUE",
+            Self::INPUT_OBJECT => "INPUT_OBJECT",
+            Self::INPUT_FIELD_DEFINITION => "INPUT_FIELD_DEFINITION",
+            Self::Other(ref s) => s.as_str(),
         })
     }
 }
@@ -55,25 +55,25 @@ impl<'de> Deserialize<'de> for __DirectiveLocation {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
         let s = <&'de str>::deserialize(deserializer)?;
         match s {
-            "QUERY" => Ok(__DirectiveLocation::QUERY),
-            "MUTATION" => Ok(__DirectiveLocation::MUTATION),
-            "SUBSCRIPTION" => Ok(__DirectiveLocation::SUBSCRIPTION),
-            "FIELD" => Ok(__DirectiveLocation::FIELD),
-            "FRAGMENT_DEFINITION" => Ok(__DirectiveLocation::FRAGMENT_DEFINITION),
-            "FRAGMENT_SPREAD" => Ok(__DirectiveLocation::FRAGMENT_SPREAD),
-            "INLINE_FRAGMENT" => Ok(__DirectiveLocation::INLINE_FRAGMENT),
-            "SCHEMA" => Ok(__DirectiveLocation::SCHEMA),
-            "SCALAR" => Ok(__DirectiveLocation::SCALAR),
-            "OBJECT" => Ok(__DirectiveLocation::OBJECT),
-            "FIELD_DEFINITION" => Ok(__DirectiveLocation::FIELD_DEFINITION),
-            "ARGUMENT_DEFINITION" => Ok(__DirectiveLocation::ARGUMENT_DEFINITION),
-            "INTERFACE" => Ok(__DirectiveLocation::INTERFACE),
-            "UNION" => Ok(__DirectiveLocation::UNION),
-            "ENUM" => Ok(__DirectiveLocation::ENUM),
-            "ENUM_VALUE" => Ok(__DirectiveLocation::ENUM_VALUE),
-            "INPUT_OBJECT" => Ok(__DirectiveLocation::INPUT_OBJECT),
-            "INPUT_FIELD_DEFINITION" => Ok(__DirectiveLocation::INPUT_FIELD_DEFINITION),
-            _ => Ok(__DirectiveLocation::Other(s.to_string())),
+            "QUERY" => Ok(Self::QUERY),
+            "MUTATION" => Ok(Self::MUTATION),
+            "SUBSCRIPTION" => Ok(Self::SUBSCRIPTION),
+            "FIELD" => Ok(Self::FIELD),
+            "FRAGMENT_DEFINITION" => Ok(Self::FRAGMENT_DEFINITION),
+            "FRAGMENT_SPREAD" => Ok(Self::FRAGMENT_SPREAD),
+            "INLINE_FRAGMENT" => Ok(Self::INLINE_FRAGMENT),
+            "SCHEMA" => Ok(Self::SCHEMA),
+            "SCALAR" => Ok(Self::SCALAR),
+            "OBJECT" => Ok(Self::OBJECT),
+            "FIELD_DEFINITION" => Ok(Self::FIELD_DEFINITION),
+            "ARGUMENT_DEFINITION" => Ok(Self::ARGUMENT_DEFINITION),
+            "INTERFACE" => Ok(Self::INTERFACE),
+            "UNION" => Ok(Self::UNION),
+            "ENUM" => Ok(Self::ENUM),
+            "ENUM_VALUE" => Ok(Self::ENUM_VALUE),
+            "INPUT_OBJECT" => Ok(Self::INPUT_OBJECT),
+            "INPUT_FIELD_DEFINITION" => Ok(Self::INPUT_FIELD_DEFINITION),
+            _ => Ok(Self::Other(s.to_string())),
         }
     }
 }
@@ -94,15 +94,15 @@ pub enum __TypeKind {
 impl Serialize for __TypeKind {
     fn serialize<S: serde::Serializer>(&self, ser: S) -> Result<S::Ok, S::Error> {
         ser.serialize_str(match *self {
-            __TypeKind::SCALAR => "SCALAR",
-            __TypeKind::OBJECT => "OBJECT",
-            __TypeKind::INTERFACE => "INTERFACE",
-            __TypeKind::UNION => "UNION",
-            __TypeKind::ENUM => "ENUM",
-            __TypeKind::INPUT_OBJECT => "INPUT_OBJECT",
-            __TypeKind::LIST => "LIST",
-            __TypeKind::NON_NULL => "NON_NULL",
-            __TypeKind::Other(ref s) => s.as_str(),
+            Self::SCALAR => "SCALAR",
+            Self::OBJECT => "OBJECT",
+            Self::INTERFACE => "INTERFACE",
+            Self::UNION => "UNION",
+            Self::ENUM => "ENUM",
+            Self::INPUT_OBJECT => "INPUT_OBJECT",
+            Self::LIST => "LIST",
+            Self::NON_NULL => "NON_NULL",
+            Self::Other(ref s) => s.as_str(),
         })
     }
 }
@@ -111,15 +111,15 @@ impl<'de> Deserialize<'de> for __TypeKind {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
         let s = <&'de str>::deserialize(deserializer)?;
         match s {
-            "SCALAR" => Ok(__TypeKind::SCALAR),
-            "OBJECT" => Ok(__TypeKind::OBJECT),
-            "INTERFACE" => Ok(__TypeKind::INTERFACE),
-            "UNION" => Ok(__TypeKind::UNION),
-            "ENUM" => Ok(__TypeKind::ENUM),
-            "INPUT_OBJECT" => Ok(__TypeKind::INPUT_OBJECT),
-            "LIST" => Ok(__TypeKind::LIST),
-            "NON_NULL" => Ok(__TypeKind::NON_NULL),
-            _ => Ok(__TypeKind::Other(s.to_string())),
+            "SCALAR" => Ok(Self::SCALAR),
+            "OBJECT" => Ok(Self::OBJECT),
+            "INTERFACE" => Ok(Self::INTERFACE),
+            "UNION" => Ok(Self::UNION),
+            "ENUM" => Ok(Self::ENUM),
+            "INPUT_OBJECT" => Ok(Self::INPUT_OBJECT),
+            "LIST" => Ok(Self::LIST),
+            "NON_NULL" => Ok(Self::NON_NULL),
+            _ => Ok(Self::Other(s.to_string())),
         }
     }
 }
@@ -288,15 +288,15 @@ pub enum IntrospectionResponse {
 impl IntrospectionResponse {
     pub fn as_schema(&self) -> &SchemaContainer {
         match self {
-            IntrospectionResponse::FullResponse(full_response) => &full_response.data,
-            IntrospectionResponse::Schema(schema) => schema,
+            Self::FullResponse(full_response) => &full_response.data,
+            Self::Schema(schema) => schema,
         }
     }
 
     pub fn into_schema(self) -> SchemaContainer {
         match self {
-            IntrospectionResponse::FullResponse(full_response) => full_response.data,
-            IntrospectionResponse::Schema(schema) => schema,
+            Self::FullResponse(full_response) => full_response.data,
+            Self::Schema(schema) => schema,
         }
     }
 }

graphql_client/src/lib.rs

@@ -122,8 +122,8 @@ pub enum PathFragment {
 impl Display for PathFragment {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
-            PathFragment::Key(ref key) => write!(f, "{key}"),
-            PathFragment::Index(ref idx) => write!(f, "{idx}"),
+            Self::Key(ref key) => write!(f, "{key}"),
+            Self::Index(ref idx) => write!(f, "{idx}"),
         }
     }
 }

graphql_client_cli/src/error.rs

@@ -9,7 +9,7 @@ pub struct Error {
 impl Error {
     #[track_caller]
     pub fn message(msg: String) -> Self {
-        Error {
+        Self {
             source: None,
             message: Some(msg),
             location: std::panic::Location::caller(),
@@ -21,7 +21,7 @@ impl Error {
         source: impl std::error::Error + Send + Sync + 'static,
         message: String,
     ) -> Self {
-        let mut err = Error::message(message);
+        let mut err = Self::message(message);
         err.source = Some(Box::new(source));
         err
     }
@@ -56,7 +56,7 @@ where
 {
     #[track_caller]
     fn from(err: T) -> Self {
-        Error {
+        Self {
             message: None,
             source: Some(Box::new(err)),
             location: std::panic::Location::caller(),

graphql_client_codegen/src/codegen/selection.rs

@@ -91,7 +91,7 @@ impl<'a> VariantSelection<'a> {
         selection: &'a Selection,
         type_id: TypeId,
         query: &BoundQuery<'a>,
-    ) -> Option<VariantSelection<'a>> {
+    ) -> Option<Self> {
         match selection {
             Selection::InlineFragment(inline_fragment) => {
                 Some(VariantSelection::InlineFragment(inline_fragment))

graphql_client_codegen/src/codegen_options.rs

@@ -53,8 +53,8 @@ pub struct GraphQLClientCodegenOptions {
 
 impl GraphQLClientCodegenOptions {
     /// Creates an empty options object with default params. It probably wants to be configured.
-    pub fn new(mode: CodegenMode) -> GraphQLClientCodegenOptions {
-        GraphQLClientCodegenOptions {
+    pub fn new(mode: CodegenMode) -> Self {
+        Self {
             mode,
             variables_derives: Default::default(),
             response_derives: Default::default(),

graphql_client_codegen/src/deprecation.rs

@@ -24,9 +24,9 @@ impl std::str::FromStr for DeprecationStrategy {
 
     fn from_str(s: &str) -> Result<Self, ()> {
         match s.trim() {
-            "allow" => Ok(DeprecationStrategy::Allow),
-            "deny" => Ok(DeprecationStrategy::Deny),
-            "warn" => Ok(DeprecationStrategy::Warn),
+            "allow" => Ok(Self::Allow),
+            "deny" => Ok(Self::Deny),
+            "warn" => Ok(Self::Warn),
             _ => Err(()),
         }
     }

graphql_client_codegen/src/lib.rs

@@ -178,11 +178,11 @@ enum ReadFileError {
 impl Display for ReadFileError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            ReadFileError::FileNotFound { path, .. } => {
+            Self::FileNotFound { path, .. } => {
                 write!(f, "Could not find file with path: {path}\n
                 Hint: file paths in the GraphQLQuery attribute are relative to the project root (location of the Cargo.toml). Example: query_path = \"src/my_query.graphql\".")
             }
-            ReadFileError::ReadError { path, .. } => {
+            Self::ReadError { path, .. } => {
                 f.write_str("Error reading file at: ")?;
                 f.write_str(path)
             }
@@ -193,8 +193,9 @@ impl Display for ReadFileError {
 impl std::error::Error for ReadFileError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
-            ReadFileError::FileNotFound { io_error, .. }
-            | ReadFileError::ReadError { io_error, .. } => Some(io_error),
+            Self::FileNotFound { io_error, .. } | Self::ReadError { io_error, .. } => {
+                Some(io_error)
+            }
         }
     }
 }

graphql_client_codegen/src/normalization.rs

@@ -56,8 +56,8 @@ impl std::str::FromStr for Normalization {
 
     fn from_str(s: &str) -> Result<Self, ()> {
         match s.trim() {
-            "none" => Ok(Normalization::None),
-            "rust" => Ok(Normalization::Rust),
+            "none" => Ok(Self::None),
+            "rust" => Ok(Self::Rust),
             _ => Err(()),
         }
     }

graphql_client_codegen/src/query.rs

@@ -38,7 +38,7 @@ impl std::error::Error for QueryValidationError {}
 
 impl QueryValidationError {
     pub(crate) fn new(message: String) -> Self {
-        QueryValidationError { message }
+        Self { message }
     }
 }
 
@@ -49,7 +49,7 @@ pub(crate) struct OperationId(u32);
 
 impl OperationId {
     pub(crate) fn new(idx: usize) -> Self {
-        OperationId(idx as u32)
+        Self(idx as u32)
     }
 }