Merge pull request RustPython#4605 from coolreader18/no-hacky-gats

youknowone · web-flow · commit e5cf139b03b8 · 2023-03-02T12:58:26.000+09:00
Switch hacky GAT-workarounds to use actual GATs
diff --git a/stdlib/src/array.rs b/stdlib/src/array.rs
@@ -1324,10 +1324,10 @@ mod array {
         }
     }
 
-    impl<'a> BufferResizeGuard<'a> for PyArray {
-        type Resizable = PyRwLockWriteGuard<'a, ArrayContentType>;
+    impl BufferResizeGuard for PyArray {
+        type Resizable<'a> = PyRwLockWriteGuard<'a, ArrayContentType>;
 
-        fn try_resizable_opt(&'a self) -> Option<Self::Resizable> {
+        fn try_resizable_opt(&self) -> Option<Self::Resizable<'_>> {
             let w = self.write();
             (self.exports.load(atomic::Ordering::SeqCst) == 0).then_some(w)
         }
diff --git a/vm/src/anystr.rs b/vm/src/anystr.rs
@@ -7,15 +7,14 @@ use crate::{
 use num_traits::{cast::ToPrimitive, sign::Signed};
 
 #[derive(FromArgs)]
-pub struct SplitArgs<'s, T: TryFromObject + AnyStrWrapper<'s>> {
+pub struct SplitArgs<T: TryFromObject + AnyStrWrapper> {
     #[pyarg(any, default)]
     sep: Option<T>,
     #[pyarg(any, default = "-1")]
     maxsplit: isize,
-    _phantom: std::marker::PhantomData<&'s ()>,
 }
 
-impl<'s, T: TryFromObject + AnyStrWrapper<'s>> SplitArgs<'s, T> {
+impl<T: TryFromObject + AnyStrWrapper> SplitArgs<T> {
     pub fn get_value(self, vm: &VirtualMachine) -> PyResult<(Option<T>, isize)> {
         let sep = if let Some(s) = self.sep {
             let sep = s.as_ref();
@@ -69,10 +68,10 @@ impl StartsEndsWithArgs {
     }
 
     #[inline]
-    pub fn prepare<'s, S, F>(self, s: &'s S, len: usize, substr: F) -> Option<(PyObjectRef, &'s S)>
+    pub fn prepare<S, F>(self, s: &S, len: usize, substr: F) -> Option<(PyObjectRef, &S)>
     where
-        S: ?Sized + AnyStr<'s>,
-        F: Fn(&'s S, std::ops::Range<usize>) -> &'s S,
+        S: ?Sized + AnyStr,
+        F: Fn(&S, std::ops::Range<usize>) -> &S,
     {
         let (affix, range) = self.get_value(len);
         let substr = if let Some(range) = range {
@@ -133,8 +132,8 @@ impl StringRange for std::ops::Range<usize> {
     }
 }
 
-pub trait AnyStrWrapper<'s> {
-    type Str: ?Sized + AnyStr<'s>;
+pub trait AnyStrWrapper {
+    type Str: ?Sized + AnyStr;
     fn as_ref(&self) -> &Self::Str;
 }
 
@@ -147,20 +146,23 @@ where
     fn push_str(&mut self, s: &S);
 }
 
-// TODO: GATs for `'s` once stabilized
-pub trait AnyStr<'s>: 's {
+pub trait AnyStr {
     type Char: Copy;
     type Container: AnyStrContainer<Self> + Extend<Self::Char>;
-    type CharIter: Iterator<Item = char> + 's;
-    type ElementIter: Iterator<Item = Self::Char> + 's;
+    type CharIter<'a>: Iterator<Item = char> + 'a
+    where
+        Self: 'a;
+    type ElementIter<'a>: Iterator<Item = Self::Char> + 'a
+    where
+        Self: 'a;
 
     fn element_bytes_len(c: Self::Char) -> usize;
 
     fn to_container(&self) -> Self::Container;
     fn as_bytes(&self) -> &[u8];
     fn as_utf8_str(&self) -> Result<&str, std::str::Utf8Error>;
-    fn chars(&'s self) -> Self::CharIter;
-    fn elements(&'s self) -> Self::ElementIter;
+    fn chars(&self) -> Self::CharIter<'_>;
+    fn elements(&self) -> Self::ElementIter<'_>;
     fn get_bytes(&self, range: std::ops::Range<usize>) -> &Self;
     // FIXME: get_chars is expensive for str
     fn get_chars(&self, range: std::ops::Range<usize>) -> &Self;
@@ -179,14 +181,14 @@ pub trait AnyStr<'s>: 's {
 
     fn py_split<T, SP, SN, SW, R>(
         &self,
-        args: SplitArgs<'s, T>,
+        args: SplitArgs<T>,
         vm: &VirtualMachine,
         split: SP,
         splitn: SN,
         splitw: SW,
     ) -> PyResult<Vec<R>>
     where
-        T: TryFromObject + AnyStrWrapper<'s, Str = Self>,
+        T: TryFromObject + AnyStrWrapper<Str = Self>,
         SP: Fn(&Self, &Self, &VirtualMachine) -> Vec<R>,
         SN: Fn(&Self, &Self, usize, &VirtualMachine) -> Vec<R>,
         SW: Fn(&Self, isize, &VirtualMachine) -> Vec<R>,
@@ -247,7 +249,7 @@ pub trait AnyStr<'s>: 's {
         func_default: FD,
     ) -> &'a Self
     where
-        S: AnyStrWrapper<'s, Str = Self>,
+        S: AnyStrWrapper<Str = Self>,
         FC: Fn(&'a Self, &Self) -> &'a Self,
         FD: Fn(&'a Self) -> &'a Self,
     {
@@ -308,10 +310,10 @@ pub trait AnyStr<'s>: 's {
         self.py_pad(width - len, 0, fillchar)
     }
 
-    fn py_join<'a>(
+    fn py_join(
         &self,
         mut iter: impl std::iter::Iterator<
-            Item = PyResult<impl AnyStrWrapper<'s, Str = Self> + TryFromObject>,
+            Item = PyResult<impl AnyStrWrapper<Str = Self> + TryFromObject>,
         >,
     ) -> PyResult<Self::Container> {
         let mut joined = if let Some(elem) = iter.next() {
@@ -413,7 +415,7 @@ pub trait AnyStr<'s>: 's {
         rustpython_common::str::zfill(self.as_bytes(), width)
     }
 
-    fn py_iscase<F, G>(&'s self, is_case: F, is_opposite: G) -> bool
+    fn py_iscase<F, G>(&self, is_case: F, is_opposite: G) -> bool
     where
         F: Fn(char) -> bool,
         G: Fn(char) -> bool,
diff --git a/vm/src/builtins/bytearray.rs b/vm/src/builtins/bytearray.rs
@@ -782,10 +782,10 @@ impl AsBuffer for PyByteArray {
     }
 }
 
-impl<'a> BufferResizeGuard<'a> for PyByteArray {
-    type Resizable = PyRwLockWriteGuard<'a, PyBytesInner>;
+impl BufferResizeGuard for PyByteArray {
+    type Resizable<'a> = PyRwLockWriteGuard<'a, PyBytesInner>;
 
-    fn try_resizable_opt(&'a self) -> Option<Self::Resizable> {
+    fn try_resizable_opt(&self) -> Option<Self::Resizable<'_>> {
         let w = self.inner.write();
         (self.exports.load(Ordering::SeqCst) == 0).then_some(w)
     }
diff --git a/vm/src/builtins/list.rs b/vm/src/builtins/list.rs
@@ -365,14 +365,14 @@ where
     }
 }
 
-impl<'a> MutObjectSequenceOp<'a> for PyList {
-    type Guard = PyMappedRwLockReadGuard<'a, [PyObjectRef]>;
+impl MutObjectSequenceOp for PyList {
+    type Guard<'a> = PyMappedRwLockReadGuard<'a, [PyObjectRef]>;
 
-    fn do_get(index: usize, guard: &Self::Guard) -> Option<&PyObjectRef> {
+    fn do_get<'a>(index: usize, guard: &'a Self::Guard<'_>) -> Option<&'a PyObjectRef> {
         guard.get(index)
     }
 
-    fn do_lock(&'a self) -> Self::Guard {
+    fn do_lock(&self) -> Self::Guard<'_> {
         self.borrow_vec()
     }
 }
diff --git a/vm/src/builtins/str.rs b/vm/src/builtins/str.rs
@@ -1369,7 +1369,7 @@ impl ToPyObject for AsciiString {
     }
 }
 
-type SplitArgs<'a> = anystr::SplitArgs<'a, PyStrRef>;
+type SplitArgs = anystr::SplitArgs<PyStrRef>;
 
 #[derive(FromArgs)]
 pub struct FindArgs {
@@ -1582,7 +1582,7 @@ mod tests {
     }
 }
 
-impl<'s> AnyStrWrapper<'s> for PyStrRef {
+impl AnyStrWrapper for PyStrRef {
     type Str = str;
     fn as_ref(&self) -> &str {
         self.as_str()
@@ -1603,11 +1603,11 @@ impl AnyStrContainer<str> for String {
     }
 }
 
-impl<'s> AnyStr<'s> for str {
+impl AnyStr for str {
     type Char = char;
     type Container = String;
-    type CharIter = std::str::Chars<'s>;
-    type ElementIter = std::str::Chars<'s>;
+    type CharIter<'a> = std::str::Chars<'a>;
+    type ElementIter<'a> = std::str::Chars<'a>;
 
     fn element_bytes_len(c: char) -> usize {
         c.len_utf8()
@@ -1625,11 +1625,11 @@ impl<'s> AnyStr<'s> for str {
         Ok(self)
     }
 
-    fn chars(&'s self) -> Self::CharIter {
+    fn chars(&self) -> Self::CharIter<'_> {
         str::chars(self)
     }
 
-    fn elements(&'s self) -> Self::ElementIter {
+    fn elements(&self) -> Self::ElementIter<'_> {
         str::chars(self)
     }
 
diff --git a/vm/src/bytesinner.rs b/vm/src/bytesinner.rs
@@ -239,7 +239,7 @@ impl ByteInnerTranslateOptions {
     }
 }
 
-pub type ByteInnerSplitOptions<'a> = anystr::SplitArgs<'a, PyBytesInner>;
+pub type ByteInnerSplitOptions = anystr::SplitArgs<PyBytesInner>;
 
 impl PyBytesInner {
     #[inline]
@@ -971,7 +971,7 @@ pub trait ByteOr: ToPrimitive {
 
 impl ByteOr for BigInt {}
 
-impl<'s> AnyStrWrapper<'s> for PyBytesInner {
+impl AnyStrWrapper for PyBytesInner {
     type Str = [u8];
     fn as_ref(&self) -> &[u8] {
         &self.elements
@@ -994,11 +994,11 @@ impl AnyStrContainer<[u8]> for Vec<u8> {
 
 const ASCII_WHITESPACES: [u8; 6] = [0x20, 0x09, 0x0a, 0x0c, 0x0d, 0x0b];
 
-impl<'s> AnyStr<'s> for [u8] {
+impl AnyStr for [u8] {
     type Char = u8;
     type Container = Vec<u8>;
-    type CharIter = bstr::Chars<'s>;
-    type ElementIter = std::iter::Copied<std::slice::Iter<'s, u8>>;
+    type CharIter<'a> = bstr::Chars<'a>;
+    type ElementIter<'a> = std::iter::Copied<std::slice::Iter<'a, u8>>;
 
     fn element_bytes_len(_: u8) -> usize {
         1
@@ -1016,11 +1016,11 @@ impl<'s> AnyStr<'s> for [u8] {
         std::str::from_utf8(self)
     }
 
-    fn chars(&'s self) -> Self::CharIter {
+    fn chars(&self) -> Self::CharIter<'_> {
         bstr::ByteSlice::chars(self)
     }
 
-    fn elements(&'s self) -> Self::ElementIter {
+    fn elements(&self) -> Self::ElementIter<'_> {
         self.iter().copied()
     }
 
diff --git a/vm/src/protocol/buffer.rs b/vm/src/protocol/buffer.rs
@@ -384,10 +384,12 @@ impl BufferDescriptor {
     // TODO: support fortain order
 }
 
-pub trait BufferResizeGuard<'a> {
-    type Resizable: 'a;
-    fn try_resizable_opt(&'a self) -> Option<Self::Resizable>;
-    fn try_resizable(&'a self, vm: &VirtualMachine) -> PyResult<Self::Resizable> {
+pub trait BufferResizeGuard {
+    type Resizable<'a>: 'a
+    where
+        Self: 'a;
+    fn try_resizable_opt(&self) -> Option<Self::Resizable<'_>>;
+    fn try_resizable(&self, vm: &VirtualMachine) -> PyResult<Self::Resizable<'_>> {
         self.try_resizable_opt().ok_or_else(|| {
             vm.new_buffer_error("Existing exports of data: object cannot be re-sized".to_owned())
         })
diff --git a/vm/src/sequence.rs b/vm/src/sequence.rs
@@ -5,13 +5,13 @@ use crate::{
 use optional::Optioned;
 use std::ops::Range;
 
-pub trait MutObjectSequenceOp<'a> {
-    type Guard;
+pub trait MutObjectSequenceOp {
+    type Guard<'a>: 'a;
 
-    fn do_get(index: usize, guard: &Self::Guard) -> Option<&PyObjectRef>;
-    fn do_lock(&'a self) -> Self::Guard;
+    fn do_get<'a>(index: usize, guard: &'a Self::Guard<'_>) -> Option<&'a PyObjectRef>;
+    fn do_lock(&self) -> Self::Guard<'_>;
 
-    fn mut_count(&'a self, vm: &VirtualMachine, needle: &PyObject) -> PyResult<usize> {
+    fn mut_count(&self, vm: &VirtualMachine, needle: &PyObject) -> PyResult<usize> {
         let mut count = 0;
         self._mut_iter_equal_skeleton::<_, false>(vm, needle, 0..isize::MAX as usize, || {
             count += 1
@@ -20,24 +20,24 @@ pub trait MutObjectSequenceOp<'a> {
     }
 
     fn mut_index_range(
-        &'a self,
+        &self,
         vm: &VirtualMachine,
         needle: &PyObject,
         range: Range<usize>,
     ) -> PyResult<Optioned<usize>> {
         self._mut_iter_equal_skeleton::<_, true>(vm, needle, range, || {})
     }
 
-    fn mut_index(&'a self, vm: &VirtualMachine, needle: &PyObject) -> PyResult<Optioned<usize>> {
+    fn mut_index(&self, vm: &VirtualMachine, needle: &PyObject) -> PyResult<Optioned<usize>> {
         self.mut_index_range(vm, needle, 0..isize::MAX as usize)
     }
 
-    fn mut_contains(&'a self, vm: &VirtualMachine, needle: &PyObject) -> PyResult<bool> {
+    fn mut_contains(&self, vm: &VirtualMachine, needle: &PyObject) -> PyResult<bool> {
         self.mut_index(vm, needle).map(|x| x.is_some())
     }
 
     fn _mut_iter_equal_skeleton<F, const SHORT: bool>(
-        &'a self,
+        &self,
         vm: &VirtualMachine,
         needle: &PyObject,
         range: Range<usize>,
diff --git a/vm/src/stdlib/collections.rs b/vm/src/stdlib/collections.rs
@@ -429,14 +429,14 @@ mod _collections {
         }
     }
 
-    impl<'a> MutObjectSequenceOp<'a> for PyDeque {
-        type Guard = PyRwLockReadGuard<'a, VecDeque<PyObjectRef>>;
+    impl MutObjectSequenceOp for PyDeque {
+        type Guard<'a> = PyRwLockReadGuard<'a, VecDeque<PyObjectRef>>;
 
-        fn do_get(index: usize, guard: &Self::Guard) -> Option<&PyObjectRef> {
+        fn do_get<'a>(index: usize, guard: &'a Self::Guard<'_>) -> Option<&'a PyObjectRef> {
             guard.get(index)
         }
 
-        fn do_lock(&'a self) -> Self::Guard {
+        fn do_lock(&self) -> Self::Guard<'_> {
             self.borrow_deque()
         }
     }
diff --git a/vm/src/stdlib/io.rs b/vm/src/stdlib/io.rs
@@ -3389,10 +3389,10 @@ mod _io {
         },
     };
 
-    impl<'a> BufferResizeGuard<'a> for BytesIO {
-        type Resizable = PyRwLockWriteGuard<'a, BufferedIO>;
+    impl BufferResizeGuard for BytesIO {
+        type Resizable<'a> = PyRwLockWriteGuard<'a, BufferedIO>;
 
-        fn try_resizable_opt(&'a self) -> Option<Self::Resizable> {
+        fn try_resizable_opt(&self) -> Option<Self::Resizable<'_>> {
             let w = self.buffer.write();
             (self.exports.load() == 0).then_some(w)
         }

Original file line number	Diff line number	Diff line change
`@@ -1324,10 +1324,10 @@ mod array {`
`1324`	`1324`	`}`
`1325`	`1325`	`}`
`1326`	`1326`
`1327`		`- impl<'a> BufferResizeGuard<'a> for PyArray {`
`1328`		`- type Resizable = PyRwLockWriteGuard<'a, ArrayContentType>;`
	`1327`	`+ impl BufferResizeGuard for PyArray {`
	`1328`	`+ type Resizable<'a> = PyRwLockWriteGuard<'a, ArrayContentType>;`
`1329`	`1329`
`1330`		`- fn try_resizable_opt(&'a self) -> Option<Self::Resizable> {`
	`1330`	`+ fn try_resizable_opt(&self) -> Option<Self::Resizable<'_>> {`
`1331`	`1331`	`let w = self.write();`
`1332`	`1332`	`(self.exports.load(atomic::Ordering::SeqCst) == 0).then_some(w)`
`1333`	`1333`	`}`
Original file line number	Diff line number	Diff line change
`@@ -782,10 +782,10 @@ impl AsBuffer for PyByteArray {`
`782`	`782`	`}`
`783`	`783`	`}`
`784`	`784`
`785`		`-impl<'a> BufferResizeGuard<'a> for PyByteArray {`
`786`		`- type Resizable = PyRwLockWriteGuard<'a, PyBytesInner>;`
	`785`	`+impl BufferResizeGuard for PyByteArray {`
	`786`	`+ type Resizable<'a> = PyRwLockWriteGuard<'a, PyBytesInner>;`
`787`	`787`
`788`		`- fn try_resizable_opt(&'a self) -> Option<Self::Resizable> {`
	`788`	`+ fn try_resizable_opt(&self) -> Option<Self::Resizable<'_>> {`
`789`	`789`	`let w = self.inner.write();`
`790`	`790`	`(self.exports.load(Ordering::SeqCst) == 0).then_some(w)`
`791`	`791`	`}`
Original file line number	Diff line number	Diff line change
`@@ -365,14 +365,14 @@ where`
`365`	`365`	`}`
`366`	`366`	`}`
`367`	`367`
`368`		`-impl<'a> MutObjectSequenceOp<'a> for PyList {`
`369`		`- type Guard = PyMappedRwLockReadGuard<'a, [PyObjectRef]>;`
	`368`	`+impl MutObjectSequenceOp for PyList {`
	`369`	`+ type Guard<'a> = PyMappedRwLockReadGuard<'a, [PyObjectRef]>;`
`370`	`370`
`371`		`- fn do_get(index: usize, guard: &Self::Guard) -> Option<&PyObjectRef> {`
	`371`	`+ fn do_get<'a>(index: usize, guard: &'a Self::Guard<'_>) -> Option<&'a PyObjectRef> {`
`372`	`372`	`guard.get(index)`
`373`	`373`	`}`
`374`	`374`
`375`		`- fn do_lock(&'a self) -> Self::Guard {`
	`375`	`+ fn do_lock(&self) -> Self::Guard<'_> {`
`376`	`376`	`self.borrow_vec()`
`377`	`377`	`}`
`378`	`378`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1369,7 +1369,7 @@ impl ToPyObject for AsciiString {`
`1369`	`1369`	`}`
`1370`	`1370`	`}`
`1371`	`1371`
`1372`		`-type SplitArgs<'a> = anystr::SplitArgs<'a, PyStrRef>;`
	`1372`	`+type SplitArgs = anystr::SplitArgs<PyStrRef>;`
`1373`	`1373`
`1374`	`1374`	`#[derive(FromArgs)]`
`1375`	`1375`	`pub struct FindArgs {`
`@@ -1582,7 +1582,7 @@ mod tests {`
`1582`	`1582`	`}`
`1583`	`1583`	`}`
`1584`	`1584`
`1585`		`-impl<'s> AnyStrWrapper<'s> for PyStrRef {`
	`1585`	`+impl AnyStrWrapper for PyStrRef {`
`1586`	`1586`	`type Str = str;`
`1587`	`1587`	`fn as_ref(&self) -> &str {`
`1588`	`1588`	`self.as_str()`
`@@ -1603,11 +1603,11 @@ impl AnyStrContainer<str> for String {`
`1603`	`1603`	`}`
`1604`	`1604`	`}`
`1605`	`1605`
`1606`		`-impl<'s> AnyStr<'s> for str {`
	`1606`	`+impl AnyStr for str {`
`1607`	`1607`	`type Char = char;`
`1608`	`1608`	`type Container = String;`
`1609`		`- type CharIter = std::str::Chars<'s>;`
`1610`		`- type ElementIter = std::str::Chars<'s>;`
	`1609`	`+ type CharIter<'a> = std::str::Chars<'a>;`
	`1610`	`+ type ElementIter<'a> = std::str::Chars<'a>;`
`1611`	`1611`
`1612`	`1612`	`fn element_bytes_len(c: char) -> usize {`
`1613`	`1613`	`c.len_utf8()`
`@@ -1625,11 +1625,11 @@ impl<'s> AnyStr<'s> for str {`
`1625`	`1625`	`Ok(self)`
`1626`	`1626`	`}`
`1627`	`1627`
`1628`		`- fn chars(&'s self) -> Self::CharIter {`
	`1628`	`+ fn chars(&self) -> Self::CharIter<'_> {`
`1629`	`1629`	`str::chars(self)`
`1630`	`1630`	`}`
`1631`	`1631`
`1632`		`- fn elements(&'s self) -> Self::ElementIter {`
	`1632`	`+ fn elements(&self) -> Self::ElementIter<'_> {`
`1633`	`1633`	`str::chars(self)`
`1634`	`1634`	`}`
`1635`	`1635`
Original file line number	Diff line number	Diff line change
`@@ -239,7 +239,7 @@ impl ByteInnerTranslateOptions {`
`239`	`239`	`}`
`240`	`240`	`}`
`241`	`241`
`242`		`-pub type ByteInnerSplitOptions<'a> = anystr::SplitArgs<'a, PyBytesInner>;`
	`242`	`+pub type ByteInnerSplitOptions = anystr::SplitArgs<PyBytesInner>;`
`243`	`243`
`244`	`244`	`impl PyBytesInner {`
`245`	`245`	`#[inline]`
`@@ -971,7 +971,7 @@ pub trait ByteOr: ToPrimitive {`
`971`	`971`
`972`	`972`	`impl ByteOr for BigInt {}`
`973`	`973`
`974`		`-impl<'s> AnyStrWrapper<'s> for PyBytesInner {`
	`974`	`+impl AnyStrWrapper for PyBytesInner {`
`975`	`975`	`type Str = [u8];`
`976`	`976`	`fn as_ref(&self) -> &[u8] {`
`977`	`977`	`&self.elements`
`@@ -994,11 +994,11 @@ impl AnyStrContainer<[u8]> for Vec<u8> {`
`994`	`994`
`995`	`995`	`const ASCII_WHITESPACES: [u8; 6] = [0x20, 0x09, 0x0a, 0x0c, 0x0d, 0x0b];`
`996`	`996`
`997`		`-impl<'s> AnyStr<'s> for [u8] {`
	`997`	`+impl AnyStr for [u8] {`
`998`	`998`	`type Char = u8;`
`999`	`999`	`type Container = Vec<u8>;`
`1000`		`- type CharIter = bstr::Chars<'s>;`
`1001`		`- type ElementIter = std::iter::Copied<std::slice::Iter<'s, u8>>;`
	`1000`	`+ type CharIter<'a> = bstr::Chars<'a>;`
	`1001`	`+ type ElementIter<'a> = std::iter::Copied<std::slice::Iter<'a, u8>>;`
`1002`	`1002`
`1003`	`1003`	`fn element_bytes_len(_: u8) -> usize {`
`1004`	`1004`	`1`
`@@ -1016,11 +1016,11 @@ impl<'s> AnyStr<'s> for [u8] {`
`1016`	`1016`	`std::str::from_utf8(self)`
`1017`	`1017`	`}`
`1018`	`1018`
`1019`		`- fn chars(&'s self) -> Self::CharIter {`
	`1019`	`+ fn chars(&self) -> Self::CharIter<'_> {`
`1020`	`1020`	`bstr::ByteSlice::chars(self)`
`1021`	`1021`	`}`
`1022`	`1022`
`1023`		`- fn elements(&'s self) -> Self::ElementIter {`
	`1023`	`+ fn elements(&self) -> Self::ElementIter<'_> {`
`1024`	`1024`	`self.iter().copied()`
`1025`	`1025`	`}`
`1026`	`1026`
Original file line number	Diff line number	Diff line change
`@@ -429,14 +429,14 @@ mod _collections {`
`429`	`429`	`}`
`430`	`430`	`}`
`431`	`431`
`432`		`- impl<'a> MutObjectSequenceOp<'a> for PyDeque {`
`433`		`- type Guard = PyRwLockReadGuard<'a, VecDeque<PyObjectRef>>;`
	`432`	`+ impl MutObjectSequenceOp for PyDeque {`
	`433`	`+ type Guard<'a> = PyRwLockReadGuard<'a, VecDeque<PyObjectRef>>;`
`434`	`434`
`435`		`- fn do_get(index: usize, guard: &Self::Guard) -> Option<&PyObjectRef> {`
	`435`	`+ fn do_get<'a>(index: usize, guard: &'a Self::Guard<'_>) -> Option<&'a PyObjectRef> {`
`436`	`436`	`guard.get(index)`
`437`	`437`	`}`
`438`	`438`
`439`		`- fn do_lock(&'a self) -> Self::Guard {`
	`439`	`+ fn do_lock(&self) -> Self::Guard<'_> {`
`440`	`440`	`self.borrow_deque()`
`441`	`441`	`}`
`442`	`442`	`}`