[temp] switch to io::Error

Author: belovdv

src/lib.rs

@@ -159,7 +159,7 @@ pub enum ErrFromEnv {
     /// Cannot connect following this process's environment.
     PlatformSpecific {
         /// Error.
-        err: imp::ErrFromEnv,
+        err: io::Error,
         /// Name of gotten env var.
         env: &'static str,
         /// Value of gotten env var.

src/unix.rs

@@ -25,13 +25,6 @@ pub struct Acquired {
     byte: u8,
 }
 
-#[derive(Debug)]
-pub enum ErrFromEnv {
-    ParseEnvVar,
-    OpenFile(String),
-    InvalidDescriptor(i32, i32),
-}
-
 impl Client {
     pub fn new(mut limit: usize) -> io::Result<Client> {
         let client = unsafe { Client::mk()? };
@@ -88,34 +81,41 @@ impl Client {
         Ok(Client::from_fds(pipes[0], pipes[1]))
     }
 
-    pub unsafe fn open(s: &str) -> Result<Client, ErrFromEnv> {
+    pub unsafe fn open(s: &str) -> io::Result<Client> {
         Ok(Self::from_fifo(s)?.unwrap_or(Self::from_pipe(s)?))
     }
 
     /// `--jobserver-auth=fifo:PATH`
-    fn from_fifo(s: &str) -> Result<Option<Client>, ErrFromEnv> {
+    fn from_fifo(s: &str) -> io::Result<Option<Client>> {
         let mut parts = s.splitn(2, ':');
         if parts.next().unwrap() != "fifo" {
             return Ok(None);
         }
-        let path = Path::new(parts.next().ok_or(ErrFromEnv::ParseEnvVar)?);
-        let file = match OpenOptions::new().read(true).write(true).open(path) {
-            Ok(f) => f,
-            Err(e) => return Err(ErrFromEnv::OpenFile(e.to_string())),
-        };
+        let path = Path::new(parts.next().ok_or(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "expected ':' after `fifo`",
+        ))?);
+        let file = OpenOptions::new().read(true).write(true).open(path)?;
         Ok(Some(Client::Fifo {
             file,
             path: path.into(),
         }))
     }
 
     /// `--jobserver-auth=R,W`
-    unsafe fn from_pipe(s: &str) -> Result<Client, ErrFromEnv> {
+    unsafe fn from_pipe(s: &str) -> io::Result<Client> {
         let mut parts = s.splitn(2, ',');
         let read = parts.next().unwrap();
-        let write = parts.next().ok_or(ErrFromEnv::ParseEnvVar)?;
-        let read = read.parse().map_err(|_| ErrFromEnv::ParseEnvVar)?;
-        let write = write.parse().map_err(|_| ErrFromEnv::ParseEnvVar)?;
+        let write = parts.next().ok_or(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "expected ',' in `auth=R,W`",
+        ))?;
+        let read = read
+            .parse()
+            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+        let write = write
+            .parse()
+            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
 
         // Ok so we've got two integers that look like file descriptors, but
         // for extra sanity checking let's see if they actually look like
@@ -130,7 +130,10 @@ impl Client {
             drop(set_cloexec(write, true));
             Ok(Client::from_fds(read, write))
         } else {
-            Err(ErrFromEnv::InvalidDescriptor(read, write))
+            Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "invalid file descriptors",
+            ))
         }
     }
 

src/wasm.rs

@@ -17,11 +17,6 @@ struct Inner {
 #[derive(Debug)]
 pub struct Acquired(());
 
-#[derive(Debug)]
-pub enum ErrFromEnv {
-    UnavailableOnTarget,
-}
-
 impl Client {
     pub fn new(limit: usize) -> io::Result<Client> {
         Ok(Client {
@@ -32,8 +27,8 @@ impl Client {
         })
     }
 
-    pub unsafe fn open(_s: &str) -> Result<Client, ErrFromEnv> {
-        Err(ErrFromEnv::UnavailableOnTarget)
+    pub unsafe fn open(_s: &str) -> io::Result<Client> {
+        Err(io::ErrorKind::Unsupported.into())
     }
 
     pub fn acquire(&self) -> io::Result<Acquired> {

src/windows.rs

@@ -14,12 +14,6 @@ pub struct Client {
 #[derive(Debug)]
 pub struct Acquired;
 
-#[derive(Debug)]
-pub enum ErrFromEnv {
-    IsNotCString,
-    CannotAcquireSemaphore,
-}
-
 type BOOL = i32;
 type DWORD = u32;
 type HANDLE = *mut u8;
@@ -133,15 +127,12 @@ impl Client {
         ))
     }
 
-    pub unsafe fn open(s: &str) -> Result<Client, ErrFromEnv> {
-        let name = match CString::new(s) {
-            Ok(s) => s,
-            Err(_) => return Err(ErrFromEnv::IsNotCString),
-        };
+    pub unsafe fn open(s: &str) -> io::Result<Client> {
+        let name = CString::new(s).map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
 
         let sem = OpenSemaphoreA(SYNCHRONIZE | SEMAPHORE_MODIFY_STATE, FALSE, name.as_ptr());
         if sem.is_null() {
-            Err(ErrFromEnv::CannotAcquireSemaphore)
+            Err(io::Error::last_os_error())
         } else {
             Ok(Client {
                 sem: Handle(sem),