separate Input trait 'a and 'py lifetimes (#1227)

Author: davidhewitt

benches/main.rs

@@ -277,11 +277,11 @@ fn dict_value_error(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            r#"{
+            r"{
                 'type': 'dict',
                 'keys_schema': {'type': 'str'},
                 'values_schema': {'type': 'int', 'lt': 0},
-            }"#,
+            }",
         );
 
         let code = format!(
@@ -322,7 +322,7 @@ fn typed_dict_json(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            r#"{
+            r"{
           'type': 'typed-dict',
           'extra_behavior': 'ignore',
           'fields': {
@@ -337,7 +337,7 @@ fn typed_dict_json(bench: &mut Bencher) {
             'i': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
             'j': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
           },
-        }"#,
+        }",
         );
 
         let code = r#"{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7, "h": 8, "i": 9, "j": 0}"#.to_string();
@@ -351,7 +351,7 @@ fn typed_dict_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            r#"{
+            r"{
           'type': 'typed-dict',
           'extra_behavior': 'ignore',
           'fields': {
@@ -366,7 +366,7 @@ fn typed_dict_python(bench: &mut Bencher) {
             'i': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
             'j': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
           },
-        }"#,
+        }",
         );
 
         let code = r#"{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7, "h": 8, "i": 9, "j": 0}"#.to_string();
@@ -384,7 +384,7 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            r#"{
+            r"{
             'type': 'typed-dict',
             'fields': {
                 'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
@@ -405,7 +405,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'}}}";
@@ -557,15 +557,15 @@ fn literal_enums_few_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let globals = PyDict::new_bound(py);
         py.run_bound(
-            r#"
+            r"
 from enum import Enum
 
 class Foo(Enum):
     v1 = object()
     v2 = object()
     v3 = object()
     v4 = object()
-"#,
+",
             Some(&globals),
             None,
         )
@@ -682,15 +682,15 @@ fn literal_mixed_few_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let globals = PyDict::new_bound(py);
         py.run_bound(
-            r#"
+            r"
 from enum import Enum
 
 class Foo(Enum):
     v1 = object()
     v2 = object()
     v3 = object()
     v4 = object()
-"#,
+",
             Some(&globals),
             None,
         )

src/input/input_abstract.rs

@@ -46,7 +46,7 @@ impl TryFrom<&str> for InputType {
 /// the convention is to either implement:
 /// * `strict_*` & `lax_*` if they have different behavior
 /// * or, `validate_*` and `strict_*` to just call `validate_*` if the behavior for strict and lax is the same
-pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
+pub trait Input<'py>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
     fn as_error_value(&self) -> InputValue;
 
     fn identity(&self) -> Option<usize> {
@@ -57,15 +57,15 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
         false
     }
 
-    fn input_is_instance(&self, _class: &Bound<'_, PyType>) -> Option<&Bound<'a, PyAny>> {
+    fn input_is_instance(&self, _class: &Bound<'py, PyType>) -> Option<&Bound<'py, PyAny>> {
         None
     }
 
     fn is_python(&self) -> bool {
         false
     }
 
-    fn as_kwargs(&self, py: Python<'a>) -> Option<Bound<'a, PyDict>>;
+    fn as_kwargs(&self, py: Python<'py>) -> Option<Bound<'py, PyDict>>;
 
     fn input_is_subclass(&self, _class: &Bound<'_, PyType>) -> PyResult<bool> {
         Ok(false)
@@ -83,23 +83,19 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
         false
     }
 
-    fn validate_args(&'a self) -> ValResult<GenericArguments<'a>>;
+    fn validate_args(&self) -> ValResult<GenericArguments<'_>>;
 
-    fn validate_dataclass_args(&'a self, dataclass_name: &str) -> ValResult<GenericArguments<'a>>;
+    fn validate_dataclass_args<'a>(&'a self, dataclass_name: &str) -> ValResult<GenericArguments<'a>>;
 
-    fn validate_str(
-        &'a self,
-        strict: bool,
-        coerce_numbers_to_str: bool,
-    ) -> ValResult<ValidationMatch<EitherString<'a>>>;
+    fn validate_str(&self, strict: bool, coerce_numbers_to_str: bool) -> ValResult<ValidationMatch<EitherString<'_>>>;
 
-    fn validate_bytes(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a>>>;
+    fn validate_bytes<'a>(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>>;
 
     fn validate_bool(&self, strict: bool) -> ValResult<ValidationMatch<bool>>;
 
-    fn validate_int(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherInt<'a>>>;
+    fn validate_int(&self, strict: bool) -> ValResult<ValidationMatch<EitherInt<'_>>>;
 
-    fn exact_int(&'a self) -> ValResult<EitherInt<'a>> {
+    fn exact_int(&self) -> ValResult<EitherInt<'_>> {
         self.validate_int(true).and_then(|val_match| {
             val_match
                 .require_exact()
@@ -109,99 +105,99 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
 
     /// Extract a String from the input, only allowing exact
     /// matches for a String (no subclasses)
-    fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
+    fn exact_str(&self) -> ValResult<EitherString<'_>> {
         self.validate_str(true, false).and_then(|val_match| {
             val_match
                 .require_exact()
                 .ok_or_else(|| ValError::new(ErrorTypeDefaults::StringType, self))
         })
     }
 
-    fn validate_float(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>>;
+    fn validate_float(&self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'_>>>;
 
-    fn validate_decimal(&'a self, strict: bool, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
+    fn validate_decimal(&self, strict: bool, py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
         if strict {
             self.strict_decimal(py)
         } else {
             self.lax_decimal(py)
         }
     }
-    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>>;
+    fn strict_decimal(&self, py: Python<'py>) -> ValResult<Bound<'py, PyAny>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
+    fn lax_decimal(&self, py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
         self.strict_decimal(py)
     }
 
-    fn validate_dict(&'a self, strict: bool) -> ValResult<GenericMapping<'a>> {
+    fn validate_dict<'a>(&'a self, strict: bool) -> ValResult<GenericMapping<'a, 'py>> {
         if strict {
             self.strict_dict()
         } else {
             self.lax_dict()
         }
     }
-    fn strict_dict(&'a self) -> ValResult<GenericMapping<'a>>;
+    fn strict_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_dict(&'a self) -> ValResult<GenericMapping<'a>> {
+    fn lax_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>> {
         self.strict_dict()
     }
 
-    fn validate_model_fields(&'a self, strict: bool, _from_attributes: bool) -> ValResult<GenericMapping<'a>> {
+    fn validate_model_fields<'a>(&'a self, strict: bool, _from_attributes: bool) -> ValResult<GenericMapping<'a, 'py>> {
         self.validate_dict(strict)
     }
 
-    fn validate_list(&'a self, strict: bool) -> ValResult<GenericIterable<'a>> {
+    fn validate_list<'a>(&'a self, strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
         if strict {
             self.strict_list()
         } else {
             self.lax_list()
         }
     }
-    fn strict_list(&'a self) -> ValResult<GenericIterable<'a>>;
+    fn strict_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_list(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn lax_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         self.strict_list()
     }
 
-    fn validate_tuple(&'a self, strict: bool) -> ValResult<GenericIterable<'a>> {
+    fn validate_tuple<'a>(&'a self, strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
         if strict {
             self.strict_tuple()
         } else {
             self.lax_tuple()
         }
     }
-    fn strict_tuple(&'a self) -> ValResult<GenericIterable<'a>>;
+    fn strict_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_tuple(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn lax_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         self.strict_tuple()
     }
 
-    fn validate_set(&'a self, strict: bool) -> ValResult<GenericIterable<'a>> {
+    fn validate_set<'a>(&'a self, strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
         if strict {
             self.strict_set()
         } else {
             self.lax_set()
         }
     }
-    fn strict_set(&'a self) -> ValResult<GenericIterable<'a>>;
+    fn strict_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_set(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn lax_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         self.strict_set()
     }
 
-    fn validate_frozenset(&'a self, strict: bool) -> ValResult<GenericIterable<'a>> {
+    fn validate_frozenset<'a>(&'a self, strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
         if strict {
             self.strict_frozenset()
         } else {
             self.lax_frozenset()
         }
     }
-    fn strict_frozenset(&'a self) -> ValResult<GenericIterable<'a>>;
+    fn strict_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_frozenset(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn lax_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         self.strict_frozenset()
     }
 
-    fn extract_generic_iterable(&'a self) -> ValResult<GenericIterable<'a>>;
+    fn extract_generic_iterable<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>>;
 
     fn validate_iter(&self) -> ValResult<GenericIterator>;
 
@@ -231,9 +227,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
 /// this trait we abstract over whether the return value from the iterator is owned
 /// or borrowed; all we care about is that we can borrow it again with `borrow_input`
 /// for some lifetime 'a.
-pub trait BorrowInput {
-    type Input<'a>: Input<'a>
-    where
-        Self: 'a;
-    fn borrow_input(&self) -> &Self::Input<'_>;
+pub trait BorrowInput<'py> {
+    type Input: Input<'py>;
+    fn borrow_input(&self) -> &Self::Input;
 }