fix clippy lints for Rust 1.86 (#1682)

Author: davidhewitt

src/errors/location.rs

@@ -147,7 +147,7 @@ impl Location {
             Self::Empty => {
                 *self = Self::new_some(loc_item);
             }
-        };
+        }
     }
 }
 

src/input/datetime.rs

@@ -10,6 +10,7 @@ use speedate::MicrosecondsPrecisionOverflowBehavior;
 use speedate::{Date, DateTime, Duration, ParseError, Time, TimeConfig};
 use std::borrow::Cow;
 use std::collections::hash_map::DefaultHasher;
+use std::fmt::Write;
 use std::hash::Hash;
 use std::hash::Hasher;
 
@@ -59,7 +60,7 @@ impl<'py> EitherDate<'py> {
                         },
                         input,
                     ));
-                };
+                }
                 let py_date = PyDate::new(py, date.year.into(), date.month, date.day)?;
                 Ok(py_date.into())
             }
@@ -296,7 +297,7 @@ impl<'py> EitherDateTime<'py> {
                         },
                         input,
                     ));
-                };
+                }
                 let py_dt = PyDateTime::new(
                     py,
                     dt.date.year.into(),
@@ -590,7 +591,7 @@ impl TzInfo {
         );
 
         if seconds != 0 {
-            result.push_str(&format!(":{:02}", seconds.abs()));
+            write!(result, ":{:02}", seconds.abs()).expect("writing to string should never fail");
         }
 
         result

src/input/shared.rs

@@ -181,7 +181,7 @@ fn strip_leading_zeros(s: &str) -> Option<&str> {
         Some((_, c)) if ('1'..='9').contains(&c) || c == '-' => return Some(s),
         // anything else is invalid, we return None
         _ => return None,
-    };
+    }
     for (i, c) in char_iter {
         match c {
             // continue on more leading zeros or if we get an underscore we continue - we're "within the number"

src/serializers/errors.rs

@@ -1,4 +1,5 @@
 use std::fmt;
+use std::fmt::Write;
 
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
@@ -154,7 +155,7 @@ impl PydanticSerializationUnexpectedValue {
             if !message.is_empty() {
                 message.push_str(": ");
             }
-            message.push_str(&format!("Expected `{field_type}`"));
+            write!(message, "Expected `{field_type}`").expect("writing to string should never fail");
             if self.input_value.is_some() {
                 message.push_str(" - serialized value may not be as expected");
             }
@@ -170,7 +171,8 @@ impl PydanticSerializationUnexpectedValue {
 
             let value_str = truncate_safe_repr(bound_input, None);
 
-            message.push_str(&format!(" [input_value={value_str}, input_type={input_type}]"));
+            write!(message, " [input_value={value_str}, input_type={input_type}]")
+                .expect("writing to string should never fail");
         }
 
         if message.is_empty() {

src/serializers/type_serializers/generator.rs

@@ -115,10 +115,7 @@ impl TypeSerializer for GeneratorSerializer {
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyIterator>() {
             Ok(py_iter) => {
-                let len = match value.len() {
-                    Ok(len) => Some(len),
-                    Err(_) => None,
-                };
+                let len = value.len().ok();
                 let mut seq = serializer.serialize_seq(len)?;
                 let item_serializer = self.item_serializer.as_ref();
 

src/serializers/type_serializers/tuple.rs

@@ -243,10 +243,10 @@ impl TupleSerializer {
                         serializer: &CombinedSerializer::Any(AnySerializer),
                     }) {
                         return Ok(Err(e));
-                    };
+                    }
                 }
             }
-        };
+        }
         Ok(Ok(()))
     }
 }

src/url.rs

@@ -392,7 +392,7 @@ impl PyMultiHostUrl {
                     multi_url.push_str(&single_host.to_string());
                     if index != hosts.len() - 1 {
                         multi_url.push(',');
-                    };
+                    }
                 }
                 multi_url
             } else if host.is_some() {
@@ -456,7 +456,7 @@ impl fmt::Display for UrlHostParts {
             (None, Some(password)) => write!(f, ":{password}@")?,
             (Some(username), Some(password)) => write!(f, "{username}:{password}@")?,
             (None, None) => {}
-        };
+        }
         if let Some(host) = &self.host {
             write!(f, "{host}")?;
         }

src/validators/arguments.rs

@@ -280,7 +280,7 @@ impl Validator for ArgumentsValidator {
                             input,
                             index,
                         ));
-                    };
+                    }
                 }
             }
         }

src/validators/dataclass.rs

@@ -190,9 +190,9 @@ impl Validator for DataclassArgsValidator {
                     // We could try to "fix" this in the future if desired.
                     Err(ValError::LineErrors(line_errors)) => errors.extend(line_errors),
                     Err(err) => return Err(err),
-                };
+                }
                 continue;
-            };
+            }
 
             let mut pos_value = None;
             if let Some(args) = args.args() {
@@ -265,7 +265,7 @@ impl Validator for DataclassArgsValidator {
                                 &field.name,
                             ));
                         }
-                        Err(ValError::Omit) => continue,
+                        Err(ValError::Omit) => {}
                         Err(ValError::LineErrors(line_errors)) => {
                             for err in line_errors {
                                 // Note: this will always use the field name even if there is an alias

src/validators/decimal.rs

@@ -194,7 +194,7 @@ impl Validator for DecimalValidator {
                             }
                         }
                     }
-                };
+                }
             }
         }