fix linting for newest clippy (#309)

Author: samuelcolvin

benches/main.rs

@@ -89,7 +89,7 @@ fn list_int_python_isinstance(bench: &mut Bencher) {
         let (validator, input) = list_int_input(py);
         let input = black_box(input.as_ref(py));
         let v = validator.isinstance_python(py, input, None, None).unwrap();
-        assert_eq!(v, true);
+        assert!(v);
 
         bench.iter(|| {
             let v = validator.isinstance_python(py, input, None, None).unwrap();
@@ -177,7 +177,7 @@ fn list_error_python_isinstance(bench: &mut Bencher) {
         let r = validator
             .isinstance_python(py, black_box(input.as_ref(py)), None, None)
             .unwrap();
-        assert_eq!(r, false);
+        assert!(!r);
 
         let input = black_box(input.as_ref(py));
         bench.iter(|| {
@@ -235,7 +235,7 @@ fn dict_json(bench: &mut Bencher) {
         let code = format!(
             "{{{}}}",
             (0..100_u8)
-                .map(|i| format!(r#""{}": {}"#, as_str(i), i))
+                .map(|i| format!(r#""{}": {i}"#, as_str(i)))
                 .collect::<Vec<String>>()
                 .join(", ")
         );
@@ -255,7 +255,7 @@ fn dict_python(bench: &mut Bencher) {
         let code = format!(
             "{{{}}}",
             (0..100_u8)
-                .map(|i| format!(r#""{}{}": {}"#, as_char(i / 26), as_char(i), i))
+                .map(|i| format!(r#""{}{}": {i}"#, as_char(i / 26), as_char(i)))
                 .collect::<Vec<String>>()
                 .join(", ")
         );
@@ -283,7 +283,7 @@ fn dict_value_error(bench: &mut Bencher) {
         let code = format!(
             "{{{}}}",
             (0..100_u8)
-                .map(|i| format!(r#""{}": {}"#, as_str(i), i))
+                .map(|i| format!(r#""{}": {i}"#, as_str(i)))
                 .collect::<Vec<String>>()
                 .join(", ")
         );
@@ -404,7 +404,7 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
 
         let code = "{'field_a': '1', 'field_b': {'field_c': '2', 'field_d': {'field_e': '4', 'field_f': 'xx'}}}";
 
-        let input = py.eval(&code, None, None).unwrap();
+        let input = py.eval(code, None, None).unwrap();
         let input = black_box(input);
 
         match validator.validate_python(py, input, None, None) {

build.rs

@@ -18,7 +18,7 @@ fn generate_self_schema() {
     if !output.status.success() {
         let stdout = from_utf8(&output.stdout).unwrap();
         let stderr = from_utf8(&output.stderr).unwrap();
-        eprint!("{}{}", stdout, stderr);
+        eprint!("{stdout}{stderr}");
         panic!("generate_self_schema.py failed with {}", output.status);
     }
 }

src/build_tools.rs

@@ -135,7 +135,7 @@ impl SchemaError {
         match error {
             ValError::LineErrors(line_errors) => {
                 let details = pretty_line_errors(py, line_errors);
-                SchemaError::new_err(format!("Invalid Schema:\n{}", details))
+                SchemaError::new_err(format!("Invalid Schema:\n{details}"))
             }
             ValError::InternalErr(py_err) => py_err,
             ValError::Omit => unreachable!(),
@@ -151,7 +151,7 @@ impl SchemaError {
     }
 
     fn __repr__(&self) -> String {
-        format!("{:?}", self)
+        format!("{self:?}")
     }
 
     fn __str__(&self) -> String {

src/errors/kinds.rs

@@ -638,9 +638,9 @@ impl FromPyObject<'_> for Number {
 impl fmt::Display for Number {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::Float(s) => write!(f, "{}", s),
-            Self::Int(i) => write!(f, "{}", i),
-            Self::String(s) => write!(f, "{}", s),
+            Self::Float(s) => write!(f, "{s}"),
+            Self::Int(i) => write!(f, "{i}"),
+            Self::String(s) => write!(f, "{s}"),
         }
     }
 }

src/errors/location.rs

@@ -17,8 +17,8 @@ pub enum LocItem {
 impl fmt::Display for LocItem {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::S(s) => write!(f, "{}", s),
-            Self::I(i) => write!(f, "{}", i),
+            Self::S(s) => write!(f, "{s}"),
+            Self::I(i) => write!(f, "{i}"),
         }
     }
 }

src/errors/mod.rs

@@ -20,12 +20,12 @@ pub fn py_err_string(py: Python, err: PyErr) -> String {
                 let str_cow = py_str.to_string_lossy();
                 let str = str_cow.as_ref();
                 if !str.is_empty() {
-                    format!("{}: {}", type_name, str)
+                    format!("{type_name}: {str}")
                 } else {
                     type_name.to_string()
                 }
             }
-            Err(_) => format!("{}: <exception str() failed>", type_name),
+            Err(_) => format!("{type_name}: <exception str() failed>"),
         },
         Err(_) => "Unknown Error".to_string(),
     }

src/errors/validation_exception.rs

@@ -45,7 +45,7 @@ impl ValidationError {
         let plural = if count == 1 { "" } else { "s" };
         let title: &str = self.title.extract(py).unwrap();
         let line_errors = pretty_py_line_errors(py, self.line_errors.iter());
-        format!("{} validation error{} for {}\n{}", count, plural, title, line_errors)
+        format!("{count} validation error{plural} for {title}\n{line_errors}")
     }
 
     pub fn omit_error() -> PyErr {
@@ -117,7 +117,7 @@ pub fn pretty_py_line_errors<'a>(py: Python, line_errors_iter: impl Iterator<Ite
     line_errors_iter
         .map(|i| i.pretty(py))
         .collect::<Result<Vec<_>, _>>()
-        .unwrap_or_else(|err| vec![format!("[error formatting line errors: {}]", err)])
+        .unwrap_or_else(|err| vec![format!("[error formatting line errors: {err}]")])
         .join("\n")
 }
 
@@ -173,9 +173,9 @@ impl PyLineError {
 
         let message = match self.kind.render_message(py) {
             Ok(message) => message,
-            Err(err) => format!("(error rendering message: {})", err),
+            Err(err) => format!("(error rendering message: {err})"),
         };
-        write!(output, "  {} [kind={}", message, self.kind.kind())?;
+        write!(output, "  {message} [kind={}", self.kind.kind())?;
 
         let input_value = self.input_value.as_ref(py);
         let input_str = match repr_string(input_value) {
@@ -185,7 +185,7 @@ impl PyLineError {
         truncate_input_value!(output, input_str);
 
         if let Ok(type_) = input_value.get_type().name() {
-            write!(output, ", input_type={}", type_)?;
+            write!(output, ", input_type={type_}")?;
         }
         output.push(']');
         Ok(output)

src/errors/value_exception.rs

@@ -85,8 +85,8 @@ impl PydanticCustomError {
     fn __repr__(&self, py: Python) -> PyResult<String> {
         let msg = self.message(py)?;
         match { self.context.as_ref() } {
-            Some(ctx) => Ok(format!("{} [kind={}, context={}]", msg, self.kind, ctx.as_ref(py))),
-            None => Ok(format!("{} [kind={}, context=None]", msg, self.kind)),
+            Some(ctx) => Ok(format!("{msg} [kind={}, context={}]", self.kind, ctx.as_ref(py))),
+            None => Ok(format!("{msg} [kind={}, context=None]", self.kind)),
         }
     }
 }
@@ -138,8 +138,8 @@ impl PydanticKindError {
     fn __repr__(&self, py: Python) -> PyResult<String> {
         let msg = self.message(py)?;
         match { self.context(py)?.as_ref() } {
-            Some(ctx) => Ok(format!("{} [kind={}, context={}]", msg, self.kind(), ctx.as_ref(py))),
-            None => Ok(format!("{} [kind={}, context=None]", msg, self.kind())),
+            Some(ctx) => Ok(format!("{msg} [kind={}, context={}]", self.kind(), ctx.as_ref(py))),
+            None => Ok(format!("{msg} [kind={}, context=None]", self.kind())),
         }
     }
 }

src/input/input_json.rs

@@ -25,7 +25,7 @@ impl<'a> Input<'a> for JsonInput {
         match self {
             JsonInput::Int(i) => LocItem::I(*i as usize),
             JsonInput::String(s) => s.as_str().into(),
-            v => format!("{:?}", v).into(),
+            v => format!("{v:?}").into(),
         }
     }
 

src/input/input_python.rs

@@ -68,7 +68,7 @@ impl<'a> Input<'a> for PyAny {
         } else {
             match repr_string(self) {
                 Ok(s) => s.into(),
-                Err(_) => format!("{:?}", self).into(),
+                Err(_) => format!("{self:?}").into(),
             }
         }
     }