fix clippy::match_same_arms lint

davidhewitt · davidhewitt · commit 0d60f15a31f1 · 2025-10-29T15:50:49.000Z
diff --git a/Cargo.toml b/Cargo.toml
@@ -92,7 +92,6 @@ float_cmp = "allow"
 fn_params_excessive_bools = "allow"
 if_not_else = "allow"
 match_bool = "allow"
-match_same_arms = "allow"
 missing_errors_doc = "allow"
 missing_panics_doc = "allow"
 module_name_repetitions = "allow"
diff --git a/src/errors/types.rs b/src/errors/types.rs
@@ -480,6 +480,7 @@ impl ErrorType {
     }
 
     pub fn message_template_python(&self) -> &'static str {
+        #[allow(clippy::match_same_arms)]  // much nicer to have the messages explicitly listed
         match self {
             Self::NoSuchAttribute {..} => "Object has no attribute '{attribute}'",
             Self::JsonInvalid {..} => "Invalid JSON: {error}",
@@ -636,12 +637,24 @@ impl ErrorType {
         };
         match self {
             Self::NoSuchAttribute { attribute, .. } => render!(tmpl, attribute),
-            Self::JsonInvalid { error, .. } => render!(tmpl, error),
+            Self::JsonInvalid { error, .. }
+            | Self::GetAttributeError { error, .. }
+            | Self::IterationError { error, .. }
+            | Self::DatetimeObjectInvalid { error, .. }
+            | Self::UrlParsing { error, .. }
+            | Self::UuidParsing { error, .. } => render!(tmpl, error),
+            Self::MappingType { error, .. }
+            | Self::DateParsing { error, .. }
+            | Self::DateFromDatetimeParsing { error, .. }
+            | Self::TimeParsing { error, .. }
+            | Self::DatetimeParsing { error, .. }
+            | Self::DatetimeFromDateParsing { error, .. }
+            | Self::TimeDeltaParsing { error, .. }
+            | Self::UrlSyntaxViolation { error, .. } => render!(tmpl, error),
             Self::NeedsPythonObject { method_name, .. } => render!(tmpl, method_name),
-            Self::GetAttributeError { error, .. } => render!(tmpl, error),
-            Self::ModelType { class_name, .. } => render!(tmpl, class_name),
-            Self::DataclassType { class_name, .. } => render!(tmpl, class_name),
-            Self::DataclassExactType { class_name, .. } => render!(tmpl, class_name),
+            Self::ModelType { class_name, .. }
+            | Self::DataclassType { class_name, .. }
+            | Self::DataclassExactType { class_name, .. } => render!(tmpl, class_name),
             Self::GreaterThan { gt, .. } => to_string_render!(tmpl, gt),
             Self::GreaterThanEqual { ge, .. } => to_string_render!(tmpl, ge),
             Self::LessThan { lt, .. } => to_string_render!(tmpl, lt),
@@ -666,26 +679,18 @@ impl ErrorType {
                 let actual_length = actual_length.map_or(Cow::Borrowed("more"), |v| Cow::Owned(v.to_string()));
                 to_string_render!(tmpl, field_type, max_length, actual_length, expected_plural,)
             }
-            Self::IterationError { error, .. } => render!(tmpl, error),
-            Self::StringTooShort { min_length, .. } => {
+            Self::StringTooShort { min_length, .. } | Self::BytesTooShort { min_length, .. } => {
                 let expected_plural = plural_s(*min_length);
                 to_string_render!(tmpl, min_length, expected_plural)
             }
-            Self::StringTooLong { max_length, .. } => {
+            Self::StringTooLong { max_length, .. }
+            | Self::BytesTooLong { max_length, .. }
+            | Self::UrlTooLong { max_length, .. } => {
                 let expected_plural = plural_s(*max_length);
                 to_string_render!(tmpl, max_length, expected_plural)
             }
             Self::StringPatternMismatch { pattern, .. } => render!(tmpl, pattern),
             Self::Enum { expected, .. } => to_string_render!(tmpl, expected),
-            Self::MappingType { error, .. } => render!(tmpl, error),
-            Self::BytesTooShort { min_length, .. } => {
-                let expected_plural = plural_s(*min_length);
-                to_string_render!(tmpl, min_length, expected_plural)
-            }
-            Self::BytesTooLong { max_length, .. } => {
-                let expected_plural = plural_s(*max_length);
-                to_string_render!(tmpl, max_length, expected_plural)
-            }
             Self::BytesInvalidEncoding {
                 encoding,
                 encoding_error,
@@ -709,33 +714,18 @@ impl ErrorType {
                 ..
             } => PydanticCustomError::format_message(message_template, context.as_ref().map(|c| c.bind(py))),
             Self::LiteralError { expected, .. } => render!(tmpl, expected),
-            Self::DateParsing { error, .. } => render!(tmpl, error),
-            Self::DateFromDatetimeParsing { error, .. } => render!(tmpl, error),
-            Self::TimeParsing { error, .. } => render!(tmpl, error),
-            Self::DatetimeParsing { error, .. } => render!(tmpl, error),
-            Self::DatetimeFromDateParsing { error, .. } => render!(tmpl, error),
-            Self::DatetimeObjectInvalid { error, .. } => render!(tmpl, error),
             Self::TimezoneOffset {
                 tz_expected, tz_actual, ..
             } => to_string_render!(tmpl, tz_expected, tz_actual),
-            Self::TimeDeltaParsing { error, .. } => render!(tmpl, error),
-            Self::IsInstanceOf { class, .. } => render!(tmpl, class),
-            Self::IsSubclassOf { class, .. } => render!(tmpl, class),
+            Self::IsInstanceOf { class, .. } | Self::IsSubclassOf { class, .. } => render!(tmpl, class),
             Self::UnionTagInvalid {
                 discriminator,
                 tag,
                 expected_tags,
                 ..
             } => render!(tmpl, discriminator, tag, expected_tags),
             Self::UnionTagNotFound { discriminator, .. } => render!(tmpl, discriminator),
-            Self::UrlParsing { error, .. } => render!(tmpl, error),
-            Self::UrlSyntaxViolation { error, .. } => render!(tmpl, error),
-            Self::UrlTooLong { max_length, .. } => {
-                let expected_plural = plural_s(*max_length);
-                to_string_render!(tmpl, max_length, expected_plural)
-            }
             Self::UrlScheme { expected_schemes, .. } => render!(tmpl, expected_schemes),
-            Self::UuidParsing { error, .. } => render!(tmpl, error),
             Self::UuidVersion { expected_version, .. } => to_string_render!(tmpl, expected_version),
             Self::DecimalMaxDigits { max_digits, .. } => {
                 let expected_plural = plural_s(*max_digits);
diff --git a/src/input/datetime.rs b/src/input/datetime.rs
@@ -113,8 +113,7 @@ impl<'py> IntoPyObject<'py> for EitherTimedelta<'py> {
     fn into_pyobject(self, py: Python<'py>) -> PyResult<Self::Output> {
         match self {
             Self::Raw(duration) => duration_as_pytimedelta(py, &duration),
-            Self::PyExact(py_timedelta) => Ok(py_timedelta),
-            Self::PySubclass(py_timedelta) => Ok(py_timedelta),
+            Self::PyExact(py_timedelta) | Self::PySubclass(py_timedelta) => Ok(py_timedelta),
         }
     }
 }
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
@@ -372,9 +372,8 @@ impl From<Option<&str>> for SerMode {
     fn from(s: Option<&str>) -> Self {
         match s {
             Some("json") => SerMode::Json,
-            Some("python") => SerMode::Python,
+            Some("python") | None => SerMode::Python,
             Some(other) => SerMode::Other(other.to_string()),
-            None => SerMode::Python,
         }
     }
 }
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
@@ -168,8 +168,7 @@ pub(crate) fn infer_to_python_known<'py>(
                 let either_delta = EitherTimedelta::try_from(value)?;
                 state.config.temporal_mode.timedelta_to_json(value.py(), either_delta)?
             }
-            ObType::Url => serialize_via_str(value, serialize_to_python())?,
-            ObType::MultiHostUrl => serialize_via_str(value, serialize_to_python())?,
+            ObType::Url | ObType::MultiHostUrl | ObType::Path => serialize_via_str(value, serialize_to_python())?,
             ObType::Uuid => {
                 let uuid = super::type_serializers::uuid::uuid_to_string(value)?;
                 uuid.into_py_any(py)?
@@ -202,7 +201,6 @@ pub(crate) fn infer_to_python_known<'py>(
                 let complex_str = type_serializers::complex::complex_to_str(v);
                 complex_str.into_py_any(py)?
             }
-            ObType::Path => serialize_via_str(value, serialize_to_python())?,
             ObType::Pattern => serialize_pattern(value, serialize_to_python())?,
             ObType::Unknown => {
                 if let Some(fallback) = state.extra.fallback {
@@ -415,8 +413,9 @@ pub(crate) fn infer_serialize_known<'py, S: Serializer>(
             let either_delta = EitherTimedelta::try_from(value).map_err(py_err_se_err)?;
             state.config.temporal_mode.timedelta_serialize(either_delta, serializer)
         }
-        ObType::Url => serialize_via_str(value, serialize_to_json(serializer)).map_err(unwrap_ser_error),
-        ObType::MultiHostUrl => serialize_via_str(value, serialize_to_json(serializer)).map_err(unwrap_ser_error),
+        ObType::Url | ObType::MultiHostUrl | ObType::Path => {
+            serialize_via_str(value, serialize_to_json(serializer)).map_err(unwrap_ser_error)
+        }
         ObType::PydanticSerializable => {
             call_pydantic_serializer(value, state, serialize_to_json(serializer)).map_err(unwrap_ser_error)
         }
@@ -447,7 +446,6 @@ pub(crate) fn infer_serialize_known<'py, S: Serializer>(
             }
             seq.end()
         }
-        ObType::Path => serialize_via_str(value, serialize_to_json(serializer)).map_err(unwrap_ser_error),
         ObType::Pattern => serialize_pattern(value, serialize_to_json(serializer)).map_err(unwrap_ser_error),
         ObType::Unknown => {
             if let Some(fallback) = state.extra.fallback {
diff --git a/src/serializers/ob_type.rs b/src/serializers/ob_type.rs
@@ -156,7 +156,7 @@ impl ObTypeLookup {
             ObType::Enum => self.enum_object.as_ptr() as usize == ob_type,
             ObType::Generator => self.generator_object.as_ptr() as usize == ob_type,
             ObType::Path => self.path_object.as_ptr() as usize == ob_type,
-            ObType::Pattern => self.path_object.as_ptr() as usize == ob_type,
+            ObType::Pattern => self.pattern_object.as_ptr() as usize == ob_type,
             ObType::Uuid => self.uuid_object.as_ptr() as usize == ob_type,
             ObType::Complex => self.complex == ob_type,
             ObType::Unknown => false,
@@ -429,12 +429,12 @@ impl PartialEq for ObType {
         } else {
             match (self, other) {
                 // special cases for subclasses
-                (Self::IntSubclass, Self::Int) => true,
-                (Self::Int, Self::IntSubclass) => true,
-                (Self::FloatSubclass, Self::Float) => true,
-                (Self::Float, Self::FloatSubclass) => true,
-                (Self::StrSubclass, Self::Str) => true,
-                (Self::Str, Self::StrSubclass) => true,
+                (Self::IntSubclass, Self::Int)
+                | (Self::Int, Self::IntSubclass)
+                | (Self::FloatSubclass, Self::Float)
+                | (Self::Float, Self::FloatSubclass)
+                | (Self::StrSubclass, Self::Str)
+                | (Self::Str, Self::StrSubclass) => true,
                 _ => false,
             }
         }
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
@@ -199,17 +199,19 @@ impl CombinedSerializer {
                     )
                     .map_err(|err| py_schema_error_type!("Error building `function-wrap` serializer:\n  {}", err));
                 }
-                // applies to lists tuples and dicts, does not override the main schema `type`
-                Some("include-exclude-sequence" | "include-exclude-dict") => (),
-                // applies specifically to bytes, does not override the main schema `type`
-                Some("base64") => (),
+                Some(
+                    // applies to lists tuples and dicts, does not override the main schema `type`
+                    "include-exclude-sequence" | "include-exclude-dict"
+                    // applies specifically to bytes, does not override the main schema `type`
+                    | "base64"
+                )
+                // if `schema.serialization.type` is None, fall back to `schema.type`
+                | None => (),
                 Some(ser_type) => {
                     // otherwise if `schema.serialization.type` is defined, use that with `find_serializer`
                     // instead of `schema.type`. In this case it's an error if a serializer isn't found.
                     return Self::find_serializer(ser_type, &ser_schema, config, definitions);
                 }
-                // if `schema.serialization.type` is None, fall back to `schema.type`
-                None => (),
             };
         }
 
diff --git a/src/validators/model.rs b/src/validators/model.rs
@@ -34,9 +34,8 @@ pub(super) enum Revalidate {
 impl Revalidate {
     pub fn from_str(s: Option<&str>) -> PyResult<Self> {
         match s {
-            None => Ok(Self::Never),
             Some("always") => Ok(Self::Always),
-            Some("never") => Ok(Self::Never),
+            Some("never") | None => Ok(Self::Never),
             Some("subclass-instances") => Ok(Self::SubclassInstances),
             Some(s) => py_schema_err!("Invalid revalidate_instances value: {}", s),
         }
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
@@ -113,15 +113,14 @@ impl BuildValidator for WithDefaultValidator {
             .map(|s| s.to_str())
             .transpose()?
         {
-            Some("raise") => OnError::Raise,
+            Some("raise") | None => OnError::Raise,
             Some("omit") => OnError::Omit,
             Some("default") => {
                 if matches!(default, DefaultType::None) {
                     return py_schema_err!("'on_error = default' requires a `default` or `default_factory`");
                 }
                 OnError::Default
             }
-            None => OnError::Raise,
             // schema validation means other values are impossible
             _ => unreachable!(),
         };

Original file line number	Diff line number	Diff line change
`@@ -113,8 +113,7 @@ impl<'py> IntoPyObject<'py> for EitherTimedelta<'py> {`
`113`	`113`	`fn into_pyobject(self, py: Python<'py>) -> PyResult<Self::Output> {`
`114`	`114`	`match self {`
`115`	`115`	`Self::Raw(duration) => duration_as_pytimedelta(py, &duration),`
`116`		`- Self::PyExact(py_timedelta) => Ok(py_timedelta),`
`117`		`- Self::PySubclass(py_timedelta) => Ok(py_timedelta),`
	`116`	`+ Self::PyExact(py_timedelta) \| Self::PySubclass(py_timedelta) => Ok(py_timedelta),`
`118`	`117`	`}`
`119`	`118`	`}`
`120`	`119`	`}`
Original file line number	Diff line number	Diff line change
`@@ -372,9 +372,8 @@ impl From<Option<&str>> for SerMode {`
`372`	`372`	`fn from(s: Option<&str>) -> Self {`
`373`	`373`	`match s {`
`374`	`374`	`Some("json") => SerMode::Json,`
`375`		`- Some("python") => SerMode::Python,`
	`375`	`+ Some("python") \| None => SerMode::Python,`
`376`	`376`	`Some(other) => SerMode::Other(other.to_string()),`
`377`		`- None => SerMode::Python,`
`378`	`377`	`}`
`379`	`378`	`}`
`380`	`379`	`}`
Original file line number	Diff line number	Diff line change
`@@ -113,15 +113,14 @@ impl BuildValidator for WithDefaultValidator {`
`113`	`113`	`.map(\|s\| s.to_str())`
`114`	`114`	`.transpose()?`
`115`	`115`	`{`
`116`		`- Some("raise") => OnError::Raise,`
	`116`	`+ Some("raise") \| None => OnError::Raise,`
`117`	`117`	`Some("omit") => OnError::Omit,`
`118`	`118`	`Some("default") => {`
`119`	`119`	`if matches!(default, DefaultType::None) {`
`120`	`120`	return py_schema_err!("'on_error = default' requires a `default` or `default_factory`");
`121`	`121`	`}`
`122`	`122`	`OnError::Default`
`123`	`123`	`}`
`124`		`- None => OnError::Raise,`
`125`	`124`	`// schema validation means other values are impossible`
`126`	`125`	`_ => unreachable!(),`
`127`	`126`	`};`