Use NotSupported in more places

CDirkx · CDirkx · commit 1b5f117c47dc · 2021-04-18T09:29:23.000+02:00
diff --git a/library/std/src/sys/hermit/fd.rs b/library/std/src/sys/hermit/fd.rs
@@ -1,9 +1,10 @@
 #![unstable(reason = "not public", issue = "none", feature = "fd")]
 
-use crate::io::{self, ErrorKind, Read};
+use crate::io::{self, Read};
 use crate::mem;
 use crate::sys::cvt;
 use crate::sys::hermit::abi;
+use crate::sys::unsupported;
 use crate::sys_common::AsInner;
 
 #[derive(Debug)]
@@ -46,19 +47,19 @@ impl FileDesc {
         self.duplicate_path(&[])
     }
     pub fn duplicate_path(&self, _path: &[u8]) -> io::Result<FileDesc> {
-        Err(io::Error::new_const(ErrorKind::Other, &"duplicate isn't supported"))
+        unsupported()
     }
 
     pub fn nonblocking(&self) -> io::Result<bool> {
         Ok(false)
     }
 
     pub fn set_cloexec(&self) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"cloexec isn't supported"))
+        unsupported()
     }
 
     pub fn set_nonblocking(&self, _nonblocking: bool) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"nonblocking isn't supported"))
+        unsupported()
     }
 }
 
diff --git a/library/std/src/sys/hermit/mod.rs b/library/std/src/sys/hermit/mod.rs
@@ -56,7 +56,7 @@ pub fn unsupported<T>() -> crate::io::Result<T> {
 
 pub fn unsupported_err() -> crate::io::Error {
     crate::io::Error::new_const(
-        crate::io::ErrorKind::Other,
+        crate::io::ErrorKind::NotSupported,
         &"operation not supported on HermitCore yet",
     )
 }
diff --git a/library/std/src/sys/hermit/net.rs b/library/std/src/sys/hermit/net.rs
@@ -166,7 +166,7 @@ impl TcpStream {
     }
 
     pub fn socket_addr(&self) -> io::Result<SocketAddr> {
-        Err(io::Error::new_const(ErrorKind::Other, &"socket_addr isn't supported"))
+        unsupported()
     }
 
     pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
@@ -199,7 +199,7 @@ impl TcpStream {
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        Err(io::Error::new_const(ErrorKind::Other, &"take_error isn't supported"))
+        unsupported()
     }
 
     pub fn set_nonblocking(&self, mode: bool) -> io::Result<()> {
@@ -247,27 +247,27 @@ impl TcpListener {
     }
 
     pub fn set_ttl(&self, _: u32) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn ttl(&self) -> io::Result<u32> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn set_only_v6(&self, _: bool) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn only_v6(&self) -> io::Result<bool> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn set_nonblocking(&self, _: bool) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 }
 
@@ -281,127 +281,127 @@ pub struct UdpSocket(abi::Handle);
 
 impl UdpSocket {
     pub fn bind(_: io::Result<&SocketAddr>) -> io::Result<UdpSocket> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn socket_addr(&self) -> io::Result<SocketAddr> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn recv_from(&self, _: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn peek_from(&self, _: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn send_to(&self, _: &[u8], _: &SocketAddr) -> io::Result<usize> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn duplicate(&self) -> io::Result<UdpSocket> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn set_read_timeout(&self, _: Option<Duration>) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn set_write_timeout(&self, _: Option<Duration>) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn set_broadcast(&self, _: bool) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn broadcast(&self) -> io::Result<bool> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn set_multicast_loop_v4(&self, _: bool) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn multicast_loop_v4(&self) -> io::Result<bool> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn set_multicast_ttl_v4(&self, _: u32) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn multicast_ttl_v4(&self) -> io::Result<u32> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn set_multicast_loop_v6(&self, _: bool) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn multicast_loop_v6(&self) -> io::Result<bool> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn join_multicast_v4(&self, _: &Ipv4Addr, _: &Ipv4Addr) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn join_multicast_v6(&self, _: &Ipv6Addr, _: u32) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn leave_multicast_v4(&self, _: &Ipv4Addr, _: &Ipv4Addr) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn leave_multicast_v6(&self, _: &Ipv6Addr, _: u32) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn set_ttl(&self, _: u32) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn ttl(&self) -> io::Result<u32> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn set_nonblocking(&self, _: bool) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn recv(&self, _: &mut [u8]) -> io::Result<usize> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn peek(&self, _: &mut [u8]) -> io::Result<usize> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn send(&self, _: &[u8]) -> io::Result<usize> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 
     pub fn connect(&self, _: io::Result<&SocketAddr>) -> io::Result<()> {
-        Err(io::Error::new_const(ErrorKind::Other, &"not supported"))
+        unsupported()
     }
 }
 
diff --git a/library/std/src/sys/sgx/mod.rs b/library/std/src/sys/sgx/mod.rs
@@ -50,7 +50,7 @@ pub fn unsupported<T>() -> crate::io::Result<T> {
 }
 
 pub fn unsupported_err() -> crate::io::Error {
-    crate::io::Error::new_const(ErrorKind::Other, &"operation not supported on SGX yet")
+    crate::io::Error::new_const(ErrorKind::NotSupported, &"operation not supported on SGX yet")
 }
 
 /// This function is used to implement various functions that doesn't exist,
diff --git a/library/std/src/sys/unix/fs.rs b/library/std/src/sys/unix/fs.rs
@@ -366,7 +366,7 @@ impl FileAttr {
         }
 
         Err(io::Error::new_const(
-            io::ErrorKind::Other,
+            io::ErrorKind::NotSupported,
             &"creation time is not available on this platform \
                             currently",
         ))
diff --git a/library/std/src/sys/unix/os.rs b/library/std/src/sys/unix/os.rs
@@ -447,7 +447,7 @@ pub fn current_exe() -> io::Result<PathBuf> {
 #[cfg(any(target_os = "fuchsia", target_os = "l4re"))]
 pub fn current_exe() -> io::Result<PathBuf> {
     use crate::io::ErrorKind;
-    Err(io::Error::new_const(ErrorKind::Other, &"Not yet implemented!"))
+    Err(io::Error::new_const(ErrorKind::NotSupported, &"Not yet implemented!"))
 }
 
 #[cfg(target_os = "vxworks")]

Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,10 @@`
`1`	`1`	`#![unstable(reason = "not public", issue = "none", feature = "fd")]`
`2`	`2`
`3`		`-use crate::io::{self, ErrorKind, Read};`
	`3`	`+use crate::io::{self, Read};`
`4`	`4`	`use crate::mem;`
`5`	`5`	`use crate::sys::cvt;`
`6`	`6`	`use crate::sys::hermit::abi;`
	`7`	`+use crate::sys::unsupported;`
`7`	`8`	`use crate::sys_common::AsInner;`
`8`	`9`
`9`	`10`	`#[derive(Debug)]`
`@@ -46,19 +47,19 @@ impl FileDesc {`
`46`	`47`	`self.duplicate_path(&[])`
`47`	`48`	`}`
`48`	`49`	`pub fn duplicate_path(&self, _path: &[u8]) -> io::Result<FileDesc> {`
`49`		`- Err(io::Error::new_const(ErrorKind::Other, &"duplicate isn't supported"))`
	`50`	`+ unsupported()`
`50`	`51`	`}`
`51`	`52`
`52`	`53`	`pub fn nonblocking(&self) -> io::Result<bool> {`
`53`	`54`	`Ok(false)`
`54`	`55`	`}`
`55`	`56`
`56`	`57`	`pub fn set_cloexec(&self) -> io::Result<()> {`
`57`		`- Err(io::Error::new_const(ErrorKind::Other, &"cloexec isn't supported"))`
	`58`	`+ unsupported()`
`58`	`59`	`}`
`59`	`60`
`60`	`61`	`pub fn set_nonblocking(&self, _nonblocking: bool) -> io::Result<()> {`
`61`		`- Err(io::Error::new_const(ErrorKind::Other, &"nonblocking isn't supported"))`
	`62`	`+ unsupported()`
`62`	`63`	`}`
`63`	`64`	`}`
`64`	`65`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ pub fn unsupported<T>() -> crate::io::Result<T> {`
`56`	`56`
`57`	`57`	`pub fn unsupported_err() -> crate::io::Error {`
`58`	`58`	`crate::io::Error::new_const(`
`59`		`- crate::io::ErrorKind::Other,`
	`59`	`+ crate::io::ErrorKind::NotSupported,`
`60`	`60`	`&"operation not supported on HermitCore yet",`
`61`	`61`	`)`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -166,7 +166,7 @@ impl TcpStream {`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`pub fn socket_addr(&self) -> io::Result<SocketAddr> {`
`169`		`- Err(io::Error::new_const(ErrorKind::Other, &"socket_addr isn't supported"))`
	`169`	`+ unsupported()`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {`
`@@ -199,7 +199,7 @@ impl TcpStream {`
`199`	`199`	`}`
`200`	`200`
`201`	`201`	`pub fn take_error(&self) -> io::Result<Option<io::Error>> {`
`202`		`- Err(io::Error::new_const(ErrorKind::Other, &"take_error isn't supported"))`
	`202`	`+ unsupported()`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`pub fn set_nonblocking(&self, mode: bool) -> io::Result<()> {`
`@@ -247,27 +247,27 @@ impl TcpListener {`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`pub fn set_ttl(&self, _: u32) -> io::Result<()> {`
`250`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`250`	`+ unsupported()`
`251`	`251`	`}`
`252`	`252`
`253`	`253`	`pub fn ttl(&self) -> io::Result<u32> {`
`254`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`254`	`+ unsupported()`
`255`	`255`	`}`
`256`	`256`
`257`	`257`	`pub fn set_only_v6(&self, _: bool) -> io::Result<()> {`
`258`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`258`	`+ unsupported()`
`259`	`259`	`}`
`260`	`260`
`261`	`261`	`pub fn only_v6(&self) -> io::Result<bool> {`
`262`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`262`	`+ unsupported()`
`263`	`263`	`}`
`264`	`264`
`265`	`265`	`pub fn take_error(&self) -> io::Result<Option<io::Error>> {`
`266`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`266`	`+ unsupported()`
`267`	`267`	`}`
`268`	`268`
`269`	`269`	`pub fn set_nonblocking(&self, _: bool) -> io::Result<()> {`
`270`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`270`	`+ unsupported()`
`271`	`271`	`}`
`272`	`272`	`}`
`273`	`273`
`@@ -281,127 +281,127 @@ pub struct UdpSocket(abi::Handle);`
`281`	`281`
`282`	`282`	`impl UdpSocket {`
`283`	`283`	`pub fn bind(_: io::Result<&SocketAddr>) -> io::Result<UdpSocket> {`
`284`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`284`	`+ unsupported()`
`285`	`285`	`}`
`286`	`286`
`287`	`287`	`pub fn peer_addr(&self) -> io::Result<SocketAddr> {`
`288`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`288`	`+ unsupported()`
`289`	`289`	`}`
`290`	`290`
`291`	`291`	`pub fn socket_addr(&self) -> io::Result<SocketAddr> {`
`292`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`292`	`+ unsupported()`
`293`	`293`	`}`
`294`	`294`
`295`	`295`	`pub fn recv_from(&self, _: &mut [u8]) -> io::Result<(usize, SocketAddr)> {`
`296`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`296`	`+ unsupported()`
`297`	`297`	`}`
`298`	`298`
`299`	`299`	`pub fn peek_from(&self, _: &mut [u8]) -> io::Result<(usize, SocketAddr)> {`
`300`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`300`	`+ unsupported()`
`301`	`301`	`}`
`302`	`302`
`303`	`303`	`pub fn send_to(&self, _: &[u8], _: &SocketAddr) -> io::Result<usize> {`
`304`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`304`	`+ unsupported()`
`305`	`305`	`}`
`306`	`306`
`307`	`307`	`pub fn duplicate(&self) -> io::Result<UdpSocket> {`
`308`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`308`	`+ unsupported()`
`309`	`309`	`}`
`310`	`310`
`311`	`311`	`pub fn set_read_timeout(&self, _: Option<Duration>) -> io::Result<()> {`
`312`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`312`	`+ unsupported()`
`313`	`313`	`}`
`314`	`314`
`315`	`315`	`pub fn set_write_timeout(&self, _: Option<Duration>) -> io::Result<()> {`
`316`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`316`	`+ unsupported()`
`317`	`317`	`}`
`318`	`318`
`319`	`319`	`pub fn read_timeout(&self) -> io::Result<Option<Duration>> {`
`320`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`320`	`+ unsupported()`
`321`	`321`	`}`
`322`	`322`
`323`	`323`	`pub fn write_timeout(&self) -> io::Result<Option<Duration>> {`
`324`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`324`	`+ unsupported()`
`325`	`325`	`}`
`326`	`326`
`327`	`327`	`pub fn set_broadcast(&self, _: bool) -> io::Result<()> {`
`328`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`328`	`+ unsupported()`
`329`	`329`	`}`
`330`	`330`
`331`	`331`	`pub fn broadcast(&self) -> io::Result<bool> {`
`332`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`332`	`+ unsupported()`
`333`	`333`	`}`
`334`	`334`
`335`	`335`	`pub fn set_multicast_loop_v4(&self, _: bool) -> io::Result<()> {`
`336`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`336`	`+ unsupported()`
`337`	`337`	`}`
`338`	`338`
`339`	`339`	`pub fn multicast_loop_v4(&self) -> io::Result<bool> {`
`340`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`340`	`+ unsupported()`
`341`	`341`	`}`
`342`	`342`
`343`	`343`	`pub fn set_multicast_ttl_v4(&self, _: u32) -> io::Result<()> {`
`344`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`344`	`+ unsupported()`
`345`	`345`	`}`
`346`	`346`
`347`	`347`	`pub fn multicast_ttl_v4(&self) -> io::Result<u32> {`
`348`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`348`	`+ unsupported()`
`349`	`349`	`}`
`350`	`350`
`351`	`351`	`pub fn set_multicast_loop_v6(&self, _: bool) -> io::Result<()> {`
`352`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`352`	`+ unsupported()`
`353`	`353`	`}`
`354`	`354`
`355`	`355`	`pub fn multicast_loop_v6(&self) -> io::Result<bool> {`
`356`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`356`	`+ unsupported()`
`357`	`357`	`}`
`358`	`358`
`359`	`359`	`pub fn join_multicast_v4(&self, _: &Ipv4Addr, _: &Ipv4Addr) -> io::Result<()> {`
`360`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`360`	`+ unsupported()`
`361`	`361`	`}`
`362`	`362`
`363`	`363`	`pub fn join_multicast_v6(&self, _: &Ipv6Addr, _: u32) -> io::Result<()> {`
`364`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`364`	`+ unsupported()`
`365`	`365`	`}`
`366`	`366`
`367`	`367`	`pub fn leave_multicast_v4(&self, _: &Ipv4Addr, _: &Ipv4Addr) -> io::Result<()> {`
`368`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`368`	`+ unsupported()`
`369`	`369`	`}`
`370`	`370`
`371`	`371`	`pub fn leave_multicast_v6(&self, _: &Ipv6Addr, _: u32) -> io::Result<()> {`
`372`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`372`	`+ unsupported()`
`373`	`373`	`}`
`374`	`374`
`375`	`375`	`pub fn set_ttl(&self, _: u32) -> io::Result<()> {`
`376`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`376`	`+ unsupported()`
`377`	`377`	`}`
`378`	`378`
`379`	`379`	`pub fn ttl(&self) -> io::Result<u32> {`
`380`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`380`	`+ unsupported()`
`381`	`381`	`}`
`382`	`382`
`383`	`383`	`pub fn take_error(&self) -> io::Result<Option<io::Error>> {`
`384`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`384`	`+ unsupported()`
`385`	`385`	`}`
`386`	`386`
`387`	`387`	`pub fn set_nonblocking(&self, _: bool) -> io::Result<()> {`
`388`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`388`	`+ unsupported()`
`389`	`389`	`}`
`390`	`390`
`391`	`391`	`pub fn recv(&self, _: &mut [u8]) -> io::Result<usize> {`
`392`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`392`	`+ unsupported()`
`393`	`393`	`}`
`394`	`394`
`395`	`395`	`pub fn peek(&self, _: &mut [u8]) -> io::Result<usize> {`
`396`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`396`	`+ unsupported()`
`397`	`397`	`}`
`398`	`398`
`399`	`399`	`pub fn send(&self, _: &[u8]) -> io::Result<usize> {`
`400`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`400`	`+ unsupported()`
`401`	`401`	`}`
`402`	`402`
`403`	`403`	`pub fn connect(&self, _: io::Result<&SocketAddr>) -> io::Result<()> {`
`404`		`- Err(io::Error::new_const(ErrorKind::Other, &"not supported"))`
	`404`	`+ unsupported()`
`405`	`405`	`}`
`406`	`406`	`}`
`407`	`407`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ pub fn unsupported<T>() -> crate::io::Result<T> {`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`pub fn unsupported_err() -> crate::io::Error {`
`53`		`- crate::io::Error::new_const(ErrorKind::Other, &"operation not supported on SGX yet")`
	`53`	`+ crate::io::Error::new_const(ErrorKind::NotSupported, &"operation not supported on SGX yet")`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`/// This function is used to implement various functions that doesn't exist,`
Original file line number	Diff line number	Diff line change
`@@ -366,7 +366,7 @@ impl FileAttr {`
`366`	`366`	`}`
`367`	`367`
`368`	`368`	`Err(io::Error::new_const(`
`369`		`- io::ErrorKind::Other,`
	`369`	`+ io::ErrorKind::NotSupported,`
`370`	`370`	`&"creation time is not available on this platform \`
`371`	`371`	`currently",`
`372`	`372`	`))`
Original file line number	Diff line number	Diff line change
`@@ -447,7 +447,7 @@ pub fn current_exe() -> io::Result<PathBuf> {`
`447`	`447`	`#[cfg(any(target_os = "fuchsia", target_os = "l4re"))]`
`448`	`448`	`pub fn current_exe() -> io::Result<PathBuf> {`
`449`	`449`	`use crate::io::ErrorKind;`
`450`		`- Err(io::Error::new_const(ErrorKind::Other, &"Not yet implemented!"))`
	`450`	`+ Err(io::Error::new_const(ErrorKind::NotSupported, &"Not yet implemented!"))`
`451`	`451`	`}`
`452`	`452`
`453`	`453`	`#[cfg(target_os = "vxworks")]`