Rename Iterator::get_unchecked -> Iterator::__iterator_get_unchecked

Mark-Simulacrum · Mark-Simulacrum · commit 656fa79bf058 · 2020-09-28T16:19:08.000-04:00
Backport of #77201, manually done because of file renaming.
diff --git a/library/core/src/iter/adapters/fuse.rs b/library/core/src/iter/adapters/fuse.rs
@@ -116,7 +116,7 @@ where
     }
 
     #[inline]
-    unsafe fn get_unchecked(&mut self, idx: usize) -> Self::Item
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item
     where
         Self: TrustedRandomAccess,
     {
diff --git a/library/core/src/iter/adapters/mod.rs b/library/core/src/iter/adapters/mod.rs
@@ -215,7 +215,7 @@ where
         self.it.count()
     }
 
-    unsafe fn get_unchecked(&mut self, idx: usize) -> T
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> T
     where
         Self: TrustedRandomAccess,
     {
@@ -350,7 +350,7 @@ where
         self.it.map(T::clone).fold(init, f)
     }
 
-    unsafe fn get_unchecked(&mut self, idx: usize) -> T
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> T
     where
         Self: TrustedRandomAccess,
     {
@@ -865,7 +865,7 @@ where
         self.iter.fold(init, map_fold(self.f, g))
     }
 
-    unsafe fn get_unchecked(&mut self, idx: usize) -> B
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> B
     where
         Self: TrustedRandomAccess,
     {
@@ -1304,7 +1304,7 @@ where
         self.iter.fold(init, enumerate(self.count, fold))
     }
 
-    unsafe fn get_unchecked(&mut self, idx: usize) -> <Self as Iterator>::Item
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> <Self as Iterator>::Item
     where
         Self: TrustedRandomAccess,
     {
diff --git a/library/core/src/iter/adapters/zip.rs b/library/core/src/iter/adapters/zip.rs
@@ -59,7 +59,7 @@ where
     }
 
     #[inline]
-    unsafe fn get_unchecked(&mut self, idx: usize) -> Self::Item
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item
     where
         Self: TrustedRandomAccess,
     {
@@ -197,12 +197,14 @@ where
             let i = self.index;
             self.index += 1;
             // SAFETY: `i` is smaller than `self.len`, thus smaller than `self.a.len()` and `self.b.len()`
-            unsafe { Some((self.a.get_unchecked(i), self.b.get_unchecked(i))) }
+            unsafe {
+                Some((self.a.__iterator_get_unchecked(i), self.b.__iterator_get_unchecked(i)))
+            }
         } else if A::may_have_side_effect() && self.index < self.a.size() {
             // match the base implementation's potential side effects
             // SAFETY: we just checked that `self.index` < `self.a.len()`
             unsafe {
-                self.a.get_unchecked(self.index);
+                self.a.__iterator_get_unchecked(self.index);
             }
             self.index += 1;
             None
@@ -229,13 +231,13 @@ where
                 // ensures that `end` is smaller than or equal to `self.len`,
                 // so `i` is also smaller than `self.len`.
                 unsafe {
-                    self.a.get_unchecked(i);
+                    self.a.__iterator_get_unchecked(i);
                 }
             }
             if B::may_have_side_effect() {
                 // SAFETY: same as above.
                 unsafe {
-                    self.b.get_unchecked(i);
+                    self.b.__iterator_get_unchecked(i);
                 }
             }
         }
@@ -277,7 +279,9 @@ where
             let i = self.len;
             // SAFETY: `i` is smaller than the previous value of `self.len`,
             // which is also smaller than or equal to `self.a.len()` and `self.b.len()`
-            unsafe { Some((self.a.get_unchecked(i), self.b.get_unchecked(i))) }
+            unsafe {
+                Some((self.a.__iterator_get_unchecked(i), self.b.__iterator_get_unchecked(i)))
+            }
         } else {
             None
         }
@@ -287,7 +291,7 @@ where
     unsafe fn get_unchecked(&mut self, idx: usize) -> <Self as Iterator>::Item {
         // SAFETY: the caller must uphold the contract for
         // `Iterator::get_unchecked`.
-        unsafe { (self.a.get_unchecked(idx), self.b.get_unchecked(idx)) }
+        unsafe { (self.a.__iterator_get_unchecked(idx), self.b.__iterator_get_unchecked(idx)) }
     }
 }
 
@@ -430,6 +434,6 @@ unsafe impl<I: Iterator + TrustedRandomAccess> SpecTrustedRandomAccess for I {
     unsafe fn try_get_unchecked(&mut self, index: usize) -> Self::Item {
         // SAFETY: the caller must uphold the contract for
         // `Iterator::get_unchecked`.
-        unsafe { self.get_unchecked(index) }
+        unsafe { self.__iterator_get_unchecked(index) }
     }
 }
diff --git a/library/core/src/iter/traits/iterator.rs b/library/core/src/iter/traits/iterator.rs
@@ -3251,7 +3251,7 @@ pub trait Iterator {
     #[inline]
     #[doc(hidden)]
     #[unstable(feature = "trusted_random_access", issue = "none")]
-    unsafe fn get_unchecked(&mut self, _idx: usize) -> Self::Item
+    unsafe fn __iterator_get_unchecked(&mut self, _idx: usize) -> Self::Item
     where
         Self: TrustedRandomAccess,
     {
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
@@ -3922,7 +3922,7 @@ macro_rules! iterator {
             }
 
             #[doc(hidden)]
-            unsafe fn get_unchecked(&mut self, idx: usize) -> Self::Item {
+            unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
                 // SAFETY: the caller must guarantee that `i` is in bounds of
                 // the underlying slice, so `i` cannot overflow an `isize`, and
                 // the returned references is guaranteed to refer to an element
@@ -5022,7 +5022,7 @@ impl<'a, T> Iterator for Windows<'a, T> {
     }
 
     #[doc(hidden)]
-    unsafe fn get_unchecked(&mut self, idx: usize) -> Self::Item {
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
         // SAFETY: since the caller guarantees that `i` is in bounds,
         // which means that `i` cannot overflow an `isize`, and the
         // slice created by `from_raw_parts` is a subslice of `self.v`
@@ -5161,7 +5161,7 @@ impl<'a, T> Iterator for Chunks<'a, T> {
     }
 
     #[doc(hidden)]
-    unsafe fn get_unchecked(&mut self, idx: usize) -> Self::Item {
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
         let start = idx * self.chunk_size;
         let end = match start.checked_add(self.chunk_size) {
             None => self.v.len(),
@@ -5310,7 +5310,7 @@ impl<'a, T> Iterator for ChunksMut<'a, T> {
     }
 
     #[doc(hidden)]
-    unsafe fn get_unchecked(&mut self, idx: usize) -> Self::Item {
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
         let start = idx * self.chunk_size;
         let end = match start.checked_add(self.chunk_size) {
             None => self.v.len(),
@@ -5463,7 +5463,7 @@ impl<'a, T> Iterator for ChunksExact<'a, T> {
     }
 
     #[doc(hidden)]
-    unsafe fn get_unchecked(&mut self, idx: usize) -> Self::Item {
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
         let start = idx * self.chunk_size;
         // SAFETY: mostly identical to `Chunks::get_unchecked`.
         unsafe { from_raw_parts(self.v.as_ptr().add(start), self.chunk_size) }
@@ -5597,7 +5597,7 @@ impl<'a, T> Iterator for ChunksExactMut<'a, T> {
     }
 
     #[doc(hidden)]
-    unsafe fn get_unchecked(&mut self, idx: usize) -> Self::Item {
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
         let start = idx * self.chunk_size;
         // SAFETY: see comments for `ChunksMut::get_unchecked`.
         unsafe { from_raw_parts_mut(self.v.as_mut_ptr().add(start), self.chunk_size) }
@@ -5723,10 +5723,10 @@ impl<'a, T, const N: usize> Iterator for ArrayChunks<'a, T, N> {
         self.iter.last()
     }
 
-    unsafe fn get_unchecked(&mut self, i: usize) -> &'a [T; N] {
+    unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> &'a [T; N] {
         // SAFETY: The safety guarantees of `get_unchecked` are transferred to
         // the caller.
-        unsafe { self.iter.get_unchecked(i) }
+        unsafe { self.iter.__iterator_get_unchecked(i) }
     }
 }
 
@@ -5853,7 +5853,7 @@ impl<'a, T> Iterator for RChunks<'a, T> {
     }
 
     #[doc(hidden)]
-    unsafe fn get_unchecked(&mut self, idx: usize) -> Self::Item {
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
         let end = self.v.len() - idx * self.chunk_size;
         let start = match end.checked_sub(self.chunk_size) {
             None => 0,
@@ -5999,7 +5999,7 @@ impl<'a, T> Iterator for RChunksMut<'a, T> {
     }
 
     #[doc(hidden)]
-    unsafe fn get_unchecked(&mut self, idx: usize) -> Self::Item {
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
         let end = self.v.len() - idx * self.chunk_size;
         let start = match end.checked_sub(self.chunk_size) {
             None => 0,
@@ -6145,7 +6145,7 @@ impl<'a, T> Iterator for RChunksExact<'a, T> {
     }
 
     #[doc(hidden)]
-    unsafe fn get_unchecked(&mut self, idx: usize) -> Self::Item {
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
         let end = self.v.len() - idx * self.chunk_size;
         let start = end - self.chunk_size;
         // SAFETY:
@@ -6286,7 +6286,7 @@ impl<'a, T> Iterator for RChunksExactMut<'a, T> {
     }
 
     #[doc(hidden)]
-    unsafe fn get_unchecked(&mut self, idx: usize) -> Self::Item {
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
         let end = self.v.len() - idx * self.chunk_size;
         let start = end - self.chunk_size;
         // SAFETY: see comments for `RChunksMut::get_unchecked`.
diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
@@ -824,10 +824,10 @@ impl Iterator for Bytes<'_> {
     }
 
     #[inline]
-    unsafe fn get_unchecked(&mut self, idx: usize) -> u8 {
+    unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> u8 {
         // SAFETY: the caller must uphold the safety contract
         // for `Iterator::get_unchecked`.
-        unsafe { self.0.get_unchecked(idx) }
+        unsafe { self.0.__iterator_get_unchecked(idx) }
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -116,7 +116,7 @@ where`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`#[inline]`
`119`		`- unsafe fn get_unchecked(&mut self, idx: usize) -> Self::Item`
	`119`	`+ unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item`
`120`	`120`	`where`
`121`	`121`	`Self: TrustedRandomAccess,`
`122`	`122`	`{`
Original file line number	Diff line number	Diff line change
`@@ -215,7 +215,7 @@ where`
`215`	`215`	`self.it.count()`
`216`	`216`	`}`
`217`	`217`
`218`		`- unsafe fn get_unchecked(&mut self, idx: usize) -> T`
	`218`	`+ unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> T`
`219`	`219`	`where`
`220`	`220`	`Self: TrustedRandomAccess,`
`221`	`221`	`{`
`@@ -350,7 +350,7 @@ where`
`350`	`350`	`self.it.map(T::clone).fold(init, f)`
`351`	`351`	`}`
`352`	`352`
`353`		`- unsafe fn get_unchecked(&mut self, idx: usize) -> T`
	`353`	`+ unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> T`
`354`	`354`	`where`
`355`	`355`	`Self: TrustedRandomAccess,`
`356`	`356`	`{`
`@@ -865,7 +865,7 @@ where`
`865`	`865`	`self.iter.fold(init, map_fold(self.f, g))`
`866`	`866`	`}`
`867`	`867`
`868`		`- unsafe fn get_unchecked(&mut self, idx: usize) -> B`
	`868`	`+ unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> B`
`869`	`869`	`where`
`870`	`870`	`Self: TrustedRandomAccess,`
`871`	`871`	`{`
`@@ -1304,7 +1304,7 @@ where`
`1304`	`1304`	`self.iter.fold(init, enumerate(self.count, fold))`
`1305`	`1305`	`}`
`1306`	`1306`
`1307`		`- unsafe fn get_unchecked(&mut self, idx: usize) -> <Self as Iterator>::Item`
	`1307`	`+ unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> <Self as Iterator>::Item`
`1308`	`1308`	`where`
`1309`	`1309`	`Self: TrustedRandomAccess,`
`1310`	`1310`	`{`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ where`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`#[inline]`
`62`		`- unsafe fn get_unchecked(&mut self, idx: usize) -> Self::Item`
	`62`	`+ unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item`
`63`	`63`	`where`
`64`	`64`	`Self: TrustedRandomAccess,`
`65`	`65`	`{`
`@@ -197,12 +197,14 @@ where`
`197`	`197`	`let i = self.index;`
`198`	`198`	`self.index += 1;`
`199`	`199`	// SAFETY: `i` is smaller than `self.len`, thus smaller than `self.a.len()` and `self.b.len()`
`200`		`- unsafe { Some((self.a.get_unchecked(i), self.b.get_unchecked(i))) }`
	`200`	`+ unsafe {`
	`201`	`+ Some((self.a.__iterator_get_unchecked(i), self.b.__iterator_get_unchecked(i)))`
	`202`	`+ }`
`201`	`203`	`} else if A::may_have_side_effect() && self.index < self.a.size() {`
`202`	`204`	`// match the base implementation's potential side effects`
`203`	`205`	// SAFETY: we just checked that `self.index` < `self.a.len()`
`204`	`206`	`unsafe {`
`205`		`- self.a.get_unchecked(self.index);`
	`207`	`+ self.a.__iterator_get_unchecked(self.index);`
`206`	`208`	`}`
`207`	`209`	`self.index += 1;`
`208`	`210`	`None`
`@@ -229,13 +231,13 @@ where`
`229`	`231`	// ensures that `end` is smaller than or equal to `self.len`,
`230`	`232`	// so `i` is also smaller than `self.len`.
`231`	`233`	`unsafe {`
`232`		`- self.a.get_unchecked(i);`
	`234`	`+ self.a.__iterator_get_unchecked(i);`
`233`	`235`	`}`
`234`	`236`	`}`
`235`	`237`	`if B::may_have_side_effect() {`
`236`	`238`	`// SAFETY: same as above.`
`237`	`239`	`unsafe {`
`238`		`- self.b.get_unchecked(i);`
	`240`	`+ self.b.__iterator_get_unchecked(i);`
`239`	`241`	`}`
`240`	`242`	`}`
`241`	`243`	`}`
`@@ -277,7 +279,9 @@ where`
`277`	`279`	`let i = self.len;`
`278`	`280`	// SAFETY: `i` is smaller than the previous value of `self.len`,
`279`	`281`	// which is also smaller than or equal to `self.a.len()` and `self.b.len()`
`280`		`- unsafe { Some((self.a.get_unchecked(i), self.b.get_unchecked(i))) }`
	`282`	`+ unsafe {`
	`283`	`+ Some((self.a.__iterator_get_unchecked(i), self.b.__iterator_get_unchecked(i)))`
	`284`	`+ }`
`281`	`285`	`} else {`
`282`	`286`	`None`
`283`	`287`	`}`
`@@ -287,7 +291,7 @@ where`
`287`	`291`	`unsafe fn get_unchecked(&mut self, idx: usize) -> <Self as Iterator>::Item {`
`288`	`292`	`// SAFETY: the caller must uphold the contract for`
`289`	`293`	// `Iterator::get_unchecked`.
`290`		`- unsafe { (self.a.get_unchecked(idx), self.b.get_unchecked(idx)) }`
	`294`	`+ unsafe { (self.a.__iterator_get_unchecked(idx), self.b.__iterator_get_unchecked(idx)) }`
`291`	`295`	`}`
`292`	`296`	`}`
`293`	`297`
`@@ -430,6 +434,6 @@ unsafe impl<I: Iterator + TrustedRandomAccess> SpecTrustedRandomAccess for I {`
`430`	`434`	`unsafe fn try_get_unchecked(&mut self, index: usize) -> Self::Item {`
`431`	`435`	`// SAFETY: the caller must uphold the contract for`
`432`	`436`	// `Iterator::get_unchecked`.
`433`		`- unsafe { self.get_unchecked(index) }`
	`437`	`+ unsafe { self.__iterator_get_unchecked(index) }`
`434`	`438`	`}`
`435`	`439`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3251,7 +3251,7 @@ pub trait Iterator {`
`3251`	`3251`	`#[inline]`
`3252`	`3252`	`#[doc(hidden)]`
`3253`	`3253`	`#[unstable(feature = "trusted_random_access", issue = "none")]`
`3254`		`- unsafe fn get_unchecked(&mut self, _idx: usize) -> Self::Item`
	`3254`	`+ unsafe fn __iterator_get_unchecked(&mut self, _idx: usize) -> Self::Item`
`3255`	`3255`	`where`
`3256`	`3256`	`Self: TrustedRandomAccess,`
`3257`	`3257`	`{`
Original file line number	Diff line number	Diff line change
`@@ -824,10 +824,10 @@ impl Iterator for Bytes<'_> {`
`824`	`824`	`}`
`825`	`825`
`826`	`826`	`#[inline]`
`827`		`- unsafe fn get_unchecked(&mut self, idx: usize) -> u8 {`
	`827`	`+ unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> u8 {`
`828`	`828`	`// SAFETY: the caller must uphold the safety contract`
`829`	`829`	// for `Iterator::get_unchecked`.
`830`		`- unsafe { self.0.get_unchecked(idx) }`
	`830`	`+ unsafe { self.0.__iterator_get_unchecked(idx) }`
`831`	`831`	`}`
`832`	`832`	`}`
`833`	`833`