rust-lang
diff --git a/‎src/libstd/fs.rs‎
Lines changed: 8 additions & 8 deletions b/‎src/libstd/fs.rs‎
Lines changed: 8 additions & 8 deletions
diff --git a/‎src/libstd/io/buffered.rs‎
Lines changed: 4 additions & 4 deletions b/‎src/libstd/io/buffered.rs‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎src/libstd/io/cursor.rs‎
Lines changed: 5 additions & 5 deletions b/‎src/libstd/io/cursor.rs‎
Lines changed: 5 additions & 5 deletions
diff --git a/‎src/libstd/io/impls.rs‎
Lines changed: 11 additions & 11 deletions b/‎src/libstd/io/impls.rs‎
Lines changed: 11 additions & 11 deletions
diff --git a/‎src/libstd/io/mod.rs‎
Lines changed: 4 additions & 4 deletions b/‎src/libstd/io/mod.rs‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎src/libstd/io/stdio.rs‎
Lines changed: 22 additions & 22 deletions b/‎src/libstd/io/stdio.rs‎
Lines changed: 22 additions & 22 deletions
diff --git a/‎src/libstd/io/util.rs‎
Lines changed: 2 additions & 2 deletions b/‎src/libstd/io/util.rs‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎src/libstd/net/tcp.rs‎
Lines changed: 8 additions & 8 deletions b/‎src/libstd/net/tcp.rs‎
Lines changed: 8 additions & 8 deletions
@@ -660,8 +660,8 @@ impl Read for File {
     }
 
     #[inline]
-    fn can_read_vectored(&self) -> bool {
-        self.inner.can_read_vectored()
+    fn is_read_vectored(&self) -> bool {
+        self.inner.is_read_vectored()
     }
 
     #[inline]
@@ -680,8 +680,8 @@ impl Write for File {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
-        self.inner.can_write_vectored()
+    fn is_write_vectored(&self) -> bool {
+        self.inner.is_write_vectored()
     }
 
     fn flush(&mut self) -> io::Result<()> {
@@ -705,8 +705,8 @@ impl Read for &File {
     }
 
     #[inline]
-    fn can_read_vectored(&self) -> bool {
-        self.inner.can_read_vectored()
+    fn is_read_vectored(&self) -> bool {
+        self.inner.is_read_vectored()
     }
 
     #[inline]
@@ -725,8 +725,8 @@ impl Write for &File {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
-        self.inner.can_write_vectored()
+    fn is_write_vectored(&self) -> bool {
+        self.inner.is_write_vectored()
     }
 
     fn flush(&mut self) -> io::Result<()> {
 
@@ -292,8 +292,8 @@ impl<R: Read> Read for BufReader<R> {
         Ok(nread)
     }
 
-    fn can_read_vectored(&self) -> bool {
-        self.inner.can_read_vectored()
+    fn is_read_vectored(&self) -> bool {
+        self.inner.is_read_vectored()
     }
 
     // we can't skip unconditionally because of the large buffer case in read.
@@ -684,8 +684,8 @@ impl<W: Write> Write for BufWriter<W> {
         }
     }
 
-    fn can_write_vectored(&self) -> bool {
-        self.get_ref().can_write_vectored()
+    fn is_write_vectored(&self) -> bool {
+        self.get_ref().is_write_vectored()
     }
 
     fn flush(&mut self) -> io::Result<()> {
 
@@ -266,7 +266,7 @@ where
         Ok(nread)
     }
 
-    fn can_read_vectored(&self) -> bool {
+    fn is_read_vectored(&self) -> bool {
         true
     }
 
@@ -377,7 +377,7 @@ impl Write for Cursor<&mut [u8]> {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
+    fn is_write_vectored(&self) -> bool {
         true
     }
 
@@ -398,7 +398,7 @@ impl Write for Cursor<&mut Vec<u8>> {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
+    fn is_write_vectored(&self) -> bool {
         true
     }
 
@@ -419,7 +419,7 @@ impl Write for Cursor<Vec<u8>> {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
+    fn is_write_vectored(&self) -> bool {
         true
     }
 
@@ -442,7 +442,7 @@ impl Write for Cursor<Box<[u8]>> {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
+    fn is_write_vectored(&self) -> bool {
         true
     }
 
 
@@ -21,8 +21,8 @@ impl<R: Read + ?Sized> Read for &mut R {
     }
 
     #[inline]
-    fn can_read_vectored(&self) -> bool {
-        (**self).can_read_vectored()
+    fn is_read_vectored(&self) -> bool {
+        (**self).is_read_vectored()
     }
 
     #[inline]
@@ -58,8 +58,8 @@ impl<W: Write + ?Sized> Write for &mut W {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
-        (**self).can_write_vectored()
+    fn is_write_vectored(&self) -> bool {
+        (**self).is_write_vectored()
     }
 
     #[inline]
@@ -120,8 +120,8 @@ impl<R: Read + ?Sized> Read for Box<R> {
     }
 
     #[inline]
-    fn can_read_vectored(&self) -> bool {
-        (**self).can_read_vectored()
+    fn is_read_vectored(&self) -> bool {
+        (**self).is_read_vectored()
     }
 
     #[inline]
@@ -157,8 +157,8 @@ impl<W: Write + ?Sized> Write for Box<W> {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
-        (**self).can_write_vectored()
+    fn is_write_vectored(&self) -> bool {
+        (**self).is_write_vectored()
     }
 
     #[inline]
@@ -261,7 +261,7 @@ impl Read for &[u8] {
     }
 
     #[inline]
-    fn can_read_vectored(&self) -> bool {
+    fn is_read_vectored(&self) -> bool {
         true
     }
 
@@ -342,7 +342,7 @@ impl Write for &mut [u8] {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
+    fn is_write_vectored(&self) -> bool {
         true
     }
 
@@ -382,7 +382,7 @@ impl Write for Vec<u8> {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
+    fn is_write_vectored(&self) -> bool {
         true
     }
 
 
@@ -588,8 +588,8 @@ pub trait Read {
     /// and coalesce writes into a single buffer for higher performance.
     ///
     /// The default implementation returns `false`.
-    #[unstable(feature = "can_vector", issue = "none")]
-    fn can_read_vectored(&self) -> bool {
+    #[unstable(feature = "can_vector", issue = "69941")]
+    fn is_read_vectored(&self) -> bool {
         false
     }
 
@@ -1325,8 +1325,8 @@ pub trait Write {
     /// and coalesce writes into a single buffer for higher performance.
     ///
     /// The default implementation returns `false`.
-    #[unstable(feature = "can_vector", issue = "none")]
-    fn can_write_vectored(&self) -> bool {
+    #[unstable(feature = "can_vector", issue = "69941")]
+    fn is_write_vectored(&self) -> bool {
         false
     }
 
 
@@ -88,8 +88,8 @@ impl Read for StdinRaw {
     }
 
     #[inline]
-    fn can_read_vectored(&self) -> bool {
-        self.0.can_read_vectored()
+    fn is_read_vectored(&self) -> bool {
+        self.0.is_read_vectored()
     }
 
     #[inline]
@@ -107,8 +107,8 @@ impl Write for StdoutRaw {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
-        self.0.can_write_vectored()
+    fn is_write_vectored(&self) -> bool {
+        self.0.is_write_vectored()
     }
 
     fn flush(&mut self) -> io::Result<()> {
@@ -125,8 +125,8 @@ impl Write for StderrRaw {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
-        self.0.can_write_vectored()
+    fn is_write_vectored(&self) -> bool {
+        self.0.is_write_vectored()
     }
 
     fn flush(&mut self) -> io::Result<()> {
@@ -156,9 +156,9 @@ impl<W: io::Write> io::Write for Maybe<W> {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
+    fn is_write_vectored(&self) -> bool {
         match self {
-            Maybe::Real(w) => w.can_write_vectored(),
+            Maybe::Real(w) => w.is_write_vectored(),
             Maybe::Fake => true,
         }
     }
@@ -187,9 +187,9 @@ impl<R: io::Read> io::Read for Maybe<R> {
     }
 
     #[inline]
-    fn can_read_vectored(&self) -> bool {
+    fn is_read_vectored(&self) -> bool {
         match self {
-            Maybe::Real(w) => w.can_read_vectored(),
+            Maybe::Real(w) => w.is_read_vectored(),
             Maybe::Fake => true,
         }
     }
@@ -383,8 +383,8 @@ impl Read for Stdin {
         self.lock().read_vectored(bufs)
     }
     #[inline]
-    fn can_read_vectored(&self) -> bool {
-        self.lock().can_read_vectored()
+    fn is_read_vectored(&self) -> bool {
+        self.lock().is_read_vectored()
     }
     #[inline]
     unsafe fn initializer(&self) -> Initializer {
@@ -412,8 +412,8 @@ impl Read for StdinLock<'_> {
     }
 
     #[inline]
-    fn can_read_vectored(&self) -> bool {
-        self.inner.can_read_vectored()
+    fn is_read_vectored(&self) -> bool {
+        self.inner.is_read_vectored()
     }
 
     #[inline]
@@ -584,8 +584,8 @@ impl Write for Stdout {
         self.lock().write_vectored(bufs)
     }
     #[inline]
-    fn can_write_vectored(&self) -> bool {
-        self.lock().can_write_vectored()
+    fn is_write_vectored(&self) -> bool {
+        self.lock().is_write_vectored()
     }
     fn flush(&mut self) -> io::Result<()> {
         self.lock().flush()
@@ -606,8 +606,8 @@ impl Write for StdoutLock<'_> {
         self.inner.borrow_mut().write_vectored(bufs)
     }
     #[inline]
-    fn can_write_vectored(&self) -> bool {
-        self.inner.borrow_mut().can_write_vectored()
+    fn is_write_vectored(&self) -> bool {
+        self.inner.borrow_mut().is_write_vectored()
     }
     fn flush(&mut self) -> io::Result<()> {
         self.inner.borrow_mut().flush()
@@ -758,8 +758,8 @@ impl Write for Stderr {
         self.lock().write_vectored(bufs)
     }
     #[inline]
-    fn can_write_vectored(&self) -> bool {
-        self.lock().can_write_vectored()
+    fn is_write_vectored(&self) -> bool {
+        self.lock().is_write_vectored()
     }
     fn flush(&mut self) -> io::Result<()> {
         self.lock().flush()
@@ -780,8 +780,8 @@ impl Write for StderrLock<'_> {
         self.inner.borrow_mut().write_vectored(bufs)
     }
     #[inline]
-    fn can_write_vectored(&self) -> bool {
-        self.inner.borrow_mut().can_write_vectored()
+    fn is_write_vectored(&self) -> bool {
+        self.inner.borrow_mut().is_write_vectored()
     }
     fn flush(&mut self) -> io::Result<()> {
         self.inner.borrow_mut().flush()
 
@@ -180,7 +180,7 @@ impl Read for Repeat {
     }
 
     #[inline]
-    fn can_read_vectored(&self) -> bool {
+    fn is_read_vectored(&self) -> bool {
         true
     }
 
@@ -241,7 +241,7 @@ impl Write for Sink {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
+    fn is_write_vectored(&self) -> bool {
         true
     }
 
 
@@ -577,8 +577,8 @@ impl Read for TcpStream {
     }
 
     #[inline]
-    fn can_read_vectored(&self) -> bool {
-        self.0.can_read_vectored()
+    fn is_read_vectored(&self) -> bool {
+        self.0.is_read_vectored()
     }
 
     #[inline]
@@ -597,8 +597,8 @@ impl Write for TcpStream {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
-        self.0.can_write_vectored()
+    fn is_write_vectored(&self) -> bool {
+        self.0.is_write_vectored()
     }
 
     fn flush(&mut self) -> io::Result<()> {
@@ -616,8 +616,8 @@ impl Read for &TcpStream {
     }
 
     #[inline]
-    fn can_read_vectored(&self) -> bool {
-        self.0.can_read_vectored()
+    fn is_read_vectored(&self) -> bool {
+        self.0.is_read_vectored()
     }
 
     #[inline]
@@ -636,8 +636,8 @@ impl Write for &TcpStream {
     }
 
     #[inline]
-    fn can_write_vectored(&self) -> bool {
-        self.0.can_write_vectored()
+    fn is_write_vectored(&self) -> bool {
+        self.0.is_write_vectored()
     }
 
     fn flush(&mut self) -> io::Result<()> {
Original file line number	Diff line number	Diff line change
`@@ -660,8 +660,8 @@ impl Read for File {`
`660`	`660`	`}`
`661`	`661`
`662`	`662`	`#[inline]`
`663`		`- fn can_read_vectored(&self) -> bool {`
`664`		`- self.inner.can_read_vectored()`
	`663`	`+ fn is_read_vectored(&self) -> bool {`
	`664`	`+ self.inner.is_read_vectored()`
`665`	`665`	`}`
`666`	`666`
`667`	`667`	`#[inline]`
`@@ -680,8 +680,8 @@ impl Write for File {`
`680`	`680`	`}`
`681`	`681`
`682`	`682`	`#[inline]`
`683`		`- fn can_write_vectored(&self) -> bool {`
`684`		`- self.inner.can_write_vectored()`
	`683`	`+ fn is_write_vectored(&self) -> bool {`
	`684`	`+ self.inner.is_write_vectored()`
`685`	`685`	`}`
`686`	`686`
`687`	`687`	`fn flush(&mut self) -> io::Result<()> {`
`@@ -705,8 +705,8 @@ impl Read for &File {`
`705`	`705`	`}`
`706`	`706`
`707`	`707`	`#[inline]`
`708`		`- fn can_read_vectored(&self) -> bool {`
`709`		`- self.inner.can_read_vectored()`
	`708`	`+ fn is_read_vectored(&self) -> bool {`
	`709`	`+ self.inner.is_read_vectored()`
`710`	`710`	`}`
`711`	`711`
`712`	`712`	`#[inline]`
`@@ -725,8 +725,8 @@ impl Write for &File {`
`725`	`725`	`}`
`726`	`726`
`727`	`727`	`#[inline]`
`728`		`- fn can_write_vectored(&self) -> bool {`
`729`		`- self.inner.can_write_vectored()`
	`728`	`+ fn is_write_vectored(&self) -> bool {`
	`729`	`+ self.inner.is_write_vectored()`
`730`	`730`	`}`
`731`	`731`
`732`	`732`	`fn flush(&mut self) -> io::Result<()> {`
Original file line number	Diff line number	Diff line change
`@@ -292,8 +292,8 @@ impl<R: Read> Read for BufReader<R> {`
`292`	`292`	`Ok(nread)`
`293`	`293`	`}`
`294`	`294`
`295`		`- fn can_read_vectored(&self) -> bool {`
`296`		`- self.inner.can_read_vectored()`
	`295`	`+ fn is_read_vectored(&self) -> bool {`
	`296`	`+ self.inner.is_read_vectored()`
`297`	`297`	`}`
`298`	`298`
`299`	`299`	`// we can't skip unconditionally because of the large buffer case in read.`
`@@ -684,8 +684,8 @@ impl<W: Write> Write for BufWriter<W> {`
`684`	`684`	`}`
`685`	`685`	`}`
`686`	`686`
`687`		`- fn can_write_vectored(&self) -> bool {`
`688`		`- self.get_ref().can_write_vectored()`
	`687`	`+ fn is_write_vectored(&self) -> bool {`
	`688`	`+ self.get_ref().is_write_vectored()`
`689`	`689`	`}`
`690`	`690`
`691`	`691`	`fn flush(&mut self) -> io::Result<()> {`
Original file line number	Diff line number	Diff line change
`@@ -266,7 +266,7 @@ where`
`266`	`266`	`Ok(nread)`
`267`	`267`	`}`
`268`	`268`
`269`		`- fn can_read_vectored(&self) -> bool {`
	`269`	`+ fn is_read_vectored(&self) -> bool {`
`270`	`270`	`true`
`271`	`271`	`}`
`272`	`272`
`@@ -377,7 +377,7 @@ impl Write for Cursor<&mut [u8]> {`
`377`	`377`	`}`
`378`	`378`
`379`	`379`	`#[inline]`
`380`		`- fn can_write_vectored(&self) -> bool {`
	`380`	`+ fn is_write_vectored(&self) -> bool {`
`381`	`381`	`true`
`382`	`382`	`}`
`383`	`383`
`@@ -398,7 +398,7 @@ impl Write for Cursor<&mut Vec<u8>> {`
`398`	`398`	`}`
`399`	`399`
`400`	`400`	`#[inline]`
`401`		`- fn can_write_vectored(&self) -> bool {`
	`401`	`+ fn is_write_vectored(&self) -> bool {`
`402`	`402`	`true`
`403`	`403`	`}`
`404`	`404`
`@@ -419,7 +419,7 @@ impl Write for Cursor<Vec<u8>> {`
`419`	`419`	`}`
`420`	`420`
`421`	`421`	`#[inline]`
`422`		`- fn can_write_vectored(&self) -> bool {`
	`422`	`+ fn is_write_vectored(&self) -> bool {`
`423`	`423`	`true`
`424`	`424`	`}`
`425`	`425`
`@@ -442,7 +442,7 @@ impl Write for Cursor<Box<[u8]>> {`
`442`	`442`	`}`
`443`	`443`
`444`	`444`	`#[inline]`
`445`		`- fn can_write_vectored(&self) -> bool {`
	`445`	`+ fn is_write_vectored(&self) -> bool {`
`446`	`446`	`true`
`447`	`447`	`}`
`448`	`448`
Original file line number	Diff line number	Diff line change
`@@ -21,8 +21,8 @@ impl<R: Read + ?Sized> Read for &mut R {`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`#[inline]`
`24`		`- fn can_read_vectored(&self) -> bool {`
`25`		`- (**self).can_read_vectored()`
	`24`	`+ fn is_read_vectored(&self) -> bool {`
	`25`	`+ (**self).is_read_vectored()`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`#[inline]`
`@@ -58,8 +58,8 @@ impl<W: Write + ?Sized> Write for &mut W {`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`#[inline]`
`61`		`- fn can_write_vectored(&self) -> bool {`
`62`		`- (**self).can_write_vectored()`
	`61`	`+ fn is_write_vectored(&self) -> bool {`
	`62`	`+ (**self).is_write_vectored()`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`#[inline]`
`@@ -120,8 +120,8 @@ impl<R: Read + ?Sized> Read for Box<R> {`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`#[inline]`
`123`		`- fn can_read_vectored(&self) -> bool {`
`124`		`- (**self).can_read_vectored()`
	`123`	`+ fn is_read_vectored(&self) -> bool {`
	`124`	`+ (**self).is_read_vectored()`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`#[inline]`
`@@ -157,8 +157,8 @@ impl<W: Write + ?Sized> Write for Box<W> {`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`#[inline]`
`160`		`- fn can_write_vectored(&self) -> bool {`
`161`		`- (**self).can_write_vectored()`
	`160`	`+ fn is_write_vectored(&self) -> bool {`
	`161`	`+ (**self).is_write_vectored()`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`#[inline]`
`@@ -261,7 +261,7 @@ impl Read for &[u8] {`
`261`	`261`	`}`
`262`	`262`
`263`	`263`	`#[inline]`
`264`		`- fn can_read_vectored(&self) -> bool {`
	`264`	`+ fn is_read_vectored(&self) -> bool {`
`265`	`265`	`true`
`266`	`266`	`}`
`267`	`267`
`@@ -342,7 +342,7 @@ impl Write for &mut [u8] {`
`342`	`342`	`}`
`343`	`343`
`344`	`344`	`#[inline]`
`345`		`- fn can_write_vectored(&self) -> bool {`
	`345`	`+ fn is_write_vectored(&self) -> bool {`
`346`	`346`	`true`
`347`	`347`	`}`
`348`	`348`
`@@ -382,7 +382,7 @@ impl Write for Vec<u8> {`
`382`	`382`	`}`
`383`	`383`
`384`	`384`	`#[inline]`
`385`		`- fn can_write_vectored(&self) -> bool {`
	`385`	`+ fn is_write_vectored(&self) -> bool {`
`386`	`386`	`true`
`387`	`387`	`}`
`388`	`388`
Original file line number	Diff line number	Diff line change
`@@ -88,8 +88,8 @@ impl Read for StdinRaw {`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`#[inline]`
`91`		`- fn can_read_vectored(&self) -> bool {`
`92`		`- self.0.can_read_vectored()`
	`91`	`+ fn is_read_vectored(&self) -> bool {`
	`92`	`+ self.0.is_read_vectored()`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`#[inline]`
`@@ -107,8 +107,8 @@ impl Write for StdoutRaw {`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`#[inline]`
`110`		`- fn can_write_vectored(&self) -> bool {`
`111`		`- self.0.can_write_vectored()`
	`110`	`+ fn is_write_vectored(&self) -> bool {`
	`111`	`+ self.0.is_write_vectored()`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`fn flush(&mut self) -> io::Result<()> {`
`@@ -125,8 +125,8 @@ impl Write for StderrRaw {`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`#[inline]`
`128`		`- fn can_write_vectored(&self) -> bool {`
`129`		`- self.0.can_write_vectored()`
	`128`	`+ fn is_write_vectored(&self) -> bool {`
	`129`	`+ self.0.is_write_vectored()`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`fn flush(&mut self) -> io::Result<()> {`
`@@ -156,9 +156,9 @@ impl<W: io::Write> io::Write for Maybe<W> {`
`156`	`156`	`}`
`157`	`157`
`158`	`158`	`#[inline]`
`159`		`- fn can_write_vectored(&self) -> bool {`
	`159`	`+ fn is_write_vectored(&self) -> bool {`
`160`	`160`	`match self {`
`161`		`- Maybe::Real(w) => w.can_write_vectored(),`
	`161`	`+ Maybe::Real(w) => w.is_write_vectored(),`
`162`	`162`	`Maybe::Fake => true,`
`163`	`163`	`}`
`164`	`164`	`}`
`@@ -187,9 +187,9 @@ impl<R: io::Read> io::Read for Maybe<R> {`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`#[inline]`
`190`		`- fn can_read_vectored(&self) -> bool {`
	`190`	`+ fn is_read_vectored(&self) -> bool {`
`191`	`191`	`match self {`
`192`		`- Maybe::Real(w) => w.can_read_vectored(),`
	`192`	`+ Maybe::Real(w) => w.is_read_vectored(),`
`193`	`193`	`Maybe::Fake => true,`
`194`	`194`	`}`
`195`	`195`	`}`
`@@ -383,8 +383,8 @@ impl Read for Stdin {`
`383`	`383`	`self.lock().read_vectored(bufs)`
`384`	`384`	`}`
`385`	`385`	`#[inline]`
`386`		`- fn can_read_vectored(&self) -> bool {`
`387`		`- self.lock().can_read_vectored()`
	`386`	`+ fn is_read_vectored(&self) -> bool {`
	`387`	`+ self.lock().is_read_vectored()`
`388`	`388`	`}`
`389`	`389`	`#[inline]`
`390`	`390`	`unsafe fn initializer(&self) -> Initializer {`
`@@ -412,8 +412,8 @@ impl Read for StdinLock<'_> {`
`412`	`412`	`}`
`413`	`413`
`414`	`414`	`#[inline]`
`415`		`- fn can_read_vectored(&self) -> bool {`
`416`		`- self.inner.can_read_vectored()`
	`415`	`+ fn is_read_vectored(&self) -> bool {`
	`416`	`+ self.inner.is_read_vectored()`
`417`	`417`	`}`
`418`	`418`
`419`	`419`	`#[inline]`
`@@ -584,8 +584,8 @@ impl Write for Stdout {`
`584`	`584`	`self.lock().write_vectored(bufs)`
`585`	`585`	`}`
`586`	`586`	`#[inline]`
`587`		`- fn can_write_vectored(&self) -> bool {`
`588`		`- self.lock().can_write_vectored()`
	`587`	`+ fn is_write_vectored(&self) -> bool {`
	`588`	`+ self.lock().is_write_vectored()`
`589`	`589`	`}`
`590`	`590`	`fn flush(&mut self) -> io::Result<()> {`
`591`	`591`	`self.lock().flush()`
`@@ -606,8 +606,8 @@ impl Write for StdoutLock<'_> {`
`606`	`606`	`self.inner.borrow_mut().write_vectored(bufs)`
`607`	`607`	`}`
`608`	`608`	`#[inline]`
`609`		`- fn can_write_vectored(&self) -> bool {`
`610`		`- self.inner.borrow_mut().can_write_vectored()`
	`609`	`+ fn is_write_vectored(&self) -> bool {`
	`610`	`+ self.inner.borrow_mut().is_write_vectored()`
`611`	`611`	`}`
`612`	`612`	`fn flush(&mut self) -> io::Result<()> {`
`613`	`613`	`self.inner.borrow_mut().flush()`
`@@ -758,8 +758,8 @@ impl Write for Stderr {`
`758`	`758`	`self.lock().write_vectored(bufs)`
`759`	`759`	`}`
`760`	`760`	`#[inline]`
`761`		`- fn can_write_vectored(&self) -> bool {`
`762`		`- self.lock().can_write_vectored()`
	`761`	`+ fn is_write_vectored(&self) -> bool {`
	`762`	`+ self.lock().is_write_vectored()`
`763`	`763`	`}`
`764`	`764`	`fn flush(&mut self) -> io::Result<()> {`
`765`	`765`	`self.lock().flush()`
`@@ -780,8 +780,8 @@ impl Write for StderrLock<'_> {`
`780`	`780`	`self.inner.borrow_mut().write_vectored(bufs)`
`781`	`781`	`}`
`782`	`782`	`#[inline]`
`783`		`- fn can_write_vectored(&self) -> bool {`
`784`		`- self.inner.borrow_mut().can_write_vectored()`
	`783`	`+ fn is_write_vectored(&self) -> bool {`
	`784`	`+ self.inner.borrow_mut().is_write_vectored()`
`785`	`785`	`}`
`786`	`786`	`fn flush(&mut self) -> io::Result<()> {`
`787`	`787`	`self.inner.borrow_mut().flush()`
Original file line number	Diff line number	Diff line change
`@@ -180,7 +180,7 @@ impl Read for Repeat {`
`180`	`180`	`}`
`181`	`181`
`182`	`182`	`#[inline]`
`183`		`- fn can_read_vectored(&self) -> bool {`
	`183`	`+ fn is_read_vectored(&self) -> bool {`
`184`	`184`	`true`
`185`	`185`	`}`
`186`	`186`
`@@ -241,7 +241,7 @@ impl Write for Sink {`
`241`	`241`	`}`
`242`	`242`
`243`	`243`	`#[inline]`
`244`		`- fn can_write_vectored(&self) -> bool {`
	`244`	`+ fn is_write_vectored(&self) -> bool {`
`245`	`245`	`true`
`246`	`246`	`}`
`247`	`247`
Original file line number	Diff line number	Diff line change
`@@ -577,8 +577,8 @@ impl Read for TcpStream {`
`577`	`577`	`}`
`578`	`578`
`579`	`579`	`#[inline]`
`580`		`- fn can_read_vectored(&self) -> bool {`
`581`		`- self.0.can_read_vectored()`
	`580`	`+ fn is_read_vectored(&self) -> bool {`
	`581`	`+ self.0.is_read_vectored()`
`582`	`582`	`}`
`583`	`583`
`584`	`584`	`#[inline]`
`@@ -597,8 +597,8 @@ impl Write for TcpStream {`
`597`	`597`	`}`
`598`	`598`
`599`	`599`	`#[inline]`
`600`		`- fn can_write_vectored(&self) -> bool {`
`601`		`- self.0.can_write_vectored()`
	`600`	`+ fn is_write_vectored(&self) -> bool {`
	`601`	`+ self.0.is_write_vectored()`
`602`	`602`	`}`
`603`	`603`
`604`	`604`	`fn flush(&mut self) -> io::Result<()> {`
`@@ -616,8 +616,8 @@ impl Read for &TcpStream {`
`616`	`616`	`}`
`617`	`617`
`618`	`618`	`#[inline]`
`619`		`- fn can_read_vectored(&self) -> bool {`
`620`		`- self.0.can_read_vectored()`
	`619`	`+ fn is_read_vectored(&self) -> bool {`
	`620`	`+ self.0.is_read_vectored()`
`621`	`621`	`}`
`622`	`622`
`623`	`623`	`#[inline]`
`@@ -636,8 +636,8 @@ impl Write for &TcpStream {`
`636`	`636`	`}`
`637`	`637`
`638`	`638`	`#[inline]`
`639`		`- fn can_write_vectored(&self) -> bool {`
`640`		`- self.0.can_write_vectored()`
	`639`	`+ fn is_write_vectored(&self) -> bool {`
	`640`	`+ self.0.is_write_vectored()`
`641`	`641`	`}`
`642`	`642`
`643`	`643`	`fn flush(&mut self) -> io::Result<()> {`