Apply suggestion: remove unnecessary Ok(())

Author: tiif

src/shims/unix/fd.rs

@@ -142,8 +142,7 @@ impl FileDescription for io::Stdin {
             helpers::isolation_abort_error("`read` from stdin")?;
         }
         let result = Read::read(&mut { self }, &mut bytes);
-        ecx.return_read_bytes_and_count(ptr, bytes, result, dest)?;
-        Ok(())
+        ecx.return_read_bytes_and_count(ptr, bytes, result, dest)
     }
 
     fn is_tty(&self, communicate_allowed: bool) -> bool {

src/shims/unix/fs.rs

@@ -42,8 +42,7 @@ impl FileDescription for FileHandle {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
         let mut bytes = vec![0; usize::try_from(len).unwrap()];
         let result = (&mut &self.file).read(&mut bytes);
-        ecx.return_read_bytes_and_count(ptr, bytes.to_vec(), result, dest)?;
-        Ok(())
+        ecx.return_read_bytes_and_count(ptr, bytes.to_vec(), result, dest)
     }
 
     fn write<'tcx>(
@@ -56,8 +55,7 @@ impl FileDescription for FileHandle {
     ) -> InterpResult<'tcx> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
         let result = (&mut &self.file).write(bytes);
-        ecx.return_written_byte_count_or_error(result, dest)?;
-        Ok(())
+        ecx.return_written_byte_count_or_error(result, dest)
     }
 
     fn pread<'tcx>(
@@ -85,8 +83,7 @@ impl FileDescription for FileHandle {
             res
         };
         let result = f();
-        ecx.return_read_bytes_and_count(ptr, bytes.to_vec(), result, dest)?;
-        Ok(())
+        ecx.return_read_bytes_and_count(ptr, bytes.to_vec(), result, dest)
     }
 
     fn pwrite<'tcx>(
@@ -112,8 +109,7 @@ impl FileDescription for FileHandle {
             res
         };
         let result = f();
-        ecx.return_written_byte_count_or_error(result, dest)?;
-        Ok(())
+        ecx.return_written_byte_count_or_error(result, dest)
     }
 
     fn seek<'tcx>(

src/shims/unix/linux/eventfd.rs

@@ -72,17 +72,15 @@ impl FileDescription for Event {
         // Check the size of slice, and return error only if the size of the slice < 8.
         if len < U64_ARRAY_SIZE.try_into().unwrap() {
             let result = Err(Error::from(ErrorKind::InvalidInput));
-            return_read_bytes_and_count_ev(&buf_place, None, result, dest, ecx)?;
-            return Ok(());
+            return return_read_bytes_and_count_ev(&buf_place, None, result, dest, ecx);
         }
 
         // Block when counter == 0.
         let counter = self.counter.get();
         if counter == 0 {
             if self.is_nonblock {
                 let result = Err(Error::from(ErrorKind::WouldBlock));
-                return_read_bytes_and_count_ev(&buf_place, None, result, dest, ecx)?;
-                return Ok(());
+                return return_read_bytes_and_count_ev(&buf_place, None, result, dest, ecx);
             } else {
                 //FIXME: blocking is not supported
                 throw_unsup_format!("eventfd: blocking is unsupported");
@@ -91,13 +89,12 @@ impl FileDescription for Event {
             // Synchronize with all prior `write` calls to this FD.
             ecx.acquire_clock(&self.clock.borrow());
             let result = Ok(U64_ARRAY_SIZE);
-            return_read_bytes_and_count_ev(&buf_place, Some(counter), result, dest, ecx)?;
             self.counter.set(0);
             // When any of the event happened, we check and update the status of all supported event
             // types for current file description.
             ecx.check_and_update_readiness(self_ref)?;
 
-            return Ok(());
+            return_read_bytes_and_count_ev(&buf_place, Some(counter), result, dest, ecx)
         }
     }
 
@@ -124,8 +121,7 @@ impl FileDescription for Event {
         // Check the size of slice, and return error only if the size of the slice < 8.
         let Some(bytes) = bytes.first_chunk::<U64_ARRAY_SIZE>() else {
             let result = Err(Error::from(ErrorKind::InvalidInput));
-            ecx.return_written_byte_count_or_error(result, dest)?;
-            return Ok(());
+            return ecx.return_written_byte_count_or_error(result, dest);
         };
         // Convert from bytes to int according to host endianness.
         let num = match ecx.tcx.sess.target.endian {
@@ -135,8 +131,7 @@ impl FileDescription for Event {
         // u64::MAX as input is invalid because the maximum value of counter is u64::MAX - 1.
         if num == u64::MAX {
             let result = Err(Error::from(ErrorKind::InvalidInput));
-            ecx.return_written_byte_count_or_error(result, dest)?;
-            return Ok(());
+            return ecx.return_written_byte_count_or_error(result, dest);
         }
         // If the addition does not let the counter to exceed the maximum value, update the counter.
         // Else, block.
@@ -151,8 +146,7 @@ impl FileDescription for Event {
             None | Some(u64::MAX) => {
                 if self.is_nonblock {
                     let result = Err(Error::from(ErrorKind::WouldBlock));
-                    ecx.return_written_byte_count_or_error(result, dest)?;
-                    return Ok(());
+                    return ecx.return_written_byte_count_or_error(result, dest);
                 } else {
                     //FIXME: blocking is not supported
                     throw_unsup_format!("eventfd: blocking is unsupported");
@@ -164,8 +158,7 @@ impl FileDescription for Event {
         ecx.check_and_update_readiness(self_ref)?;
 
         let result = Ok(U64_ARRAY_SIZE);
-        ecx.return_written_byte_count_or_error(result, dest)?;
-        Ok(())
+        ecx.return_written_byte_count_or_error(result, dest)
     }
 }
 

src/shims/unix/unnamed_socket.rs

@@ -137,8 +137,7 @@ impl FileDescription for AnonSocket {
         // Always succeed on read size 0.
         if request_byte_size == 0 {
             let result = Ok(0);
-            ecx.return_read_bytes_and_count(ptr, bytes.to_vec(), result, dest)?;
-            return Ok(());
+            return ecx.return_read_bytes_and_count(ptr, bytes.to_vec(), result, dest);
         }
 
         let Some(readbuf) = &self.readbuf else {
@@ -152,8 +151,7 @@ impl FileDescription for AnonSocket {
                 // Socketpair with no peer and empty buffer.
                 // 0 bytes successfully read indicates end-of-file.
                 let result = Ok(0);
-                ecx.return_read_bytes_and_count(ptr, bytes.to_vec(), result, dest)?;
-                return Ok(());
+                return ecx.return_read_bytes_and_count(ptr, bytes.to_vec(), result, dest);
             } else {
                 if self.is_nonblock {
                     // Non-blocking socketpair with writer and empty buffer.
@@ -162,8 +160,7 @@ impl FileDescription for AnonSocket {
                     // POSIX.1-2001 allows either error to be returned for this case.
                     // Since there is no ErrorKind for EAGAIN, WouldBlock is used.
                     let result = Err(Error::from(ErrorKind::WouldBlock));
-                    ecx.return_read_bytes_and_count(ptr, bytes.to_vec(), result, dest)?;
-                    return Ok(());
+                    return ecx.return_read_bytes_and_count(ptr, bytes.to_vec(), result, dest);
                 } else {
                     // Blocking socketpair with writer and empty buffer.
                     // FIXME: blocking is currently not supported
@@ -196,8 +193,7 @@ impl FileDescription for AnonSocket {
         }
 
         let result = Ok(actual_read_size);
-        ecx.return_read_bytes_and_count(ptr, bytes.to_vec(), result, dest)?;
-        return Ok(());
+        ecx.return_read_bytes_and_count(ptr, bytes.to_vec(), result, dest)
     }
 
     fn write<'tcx>(
@@ -213,17 +209,15 @@ impl FileDescription for AnonSocket {
         // ("If count is zero and fd refers to a file other than a regular file, the results are not specified.")
         if write_size == 0 {
             let result = Ok(0);
-            ecx.return_written_byte_count_or_error(result, dest)?;
-            return Ok(());
+            return ecx.return_written_byte_count_or_error(result, dest);
         }
 
         // We are writing to our peer's readbuf.
         let Some(peer_fd) = self.peer_fd().upgrade() else {
             // If the upgrade from Weak to Rc fails, it indicates that all read ends have been
             // closed.
             let result = Err(Error::from(ErrorKind::BrokenPipe));
-            ecx.return_written_byte_count_or_error(result, dest)?;
-            return Ok(());
+            return ecx.return_written_byte_count_or_error(result, dest);
         };
 
         let Some(writebuf) = &peer_fd.downcast::<AnonSocket>().unwrap().readbuf else {
@@ -238,8 +232,7 @@ impl FileDescription for AnonSocket {
             if self.is_nonblock {
                 // Non-blocking socketpair with a full buffer.
                 let result = Err(Error::from(ErrorKind::WouldBlock));
-                ecx.return_written_byte_count_or_error(result, dest)?;
-                return Ok(());
+                return ecx.return_written_byte_count_or_error(result, dest);
             } else {
                 // Blocking socketpair with a full buffer.
                 throw_unsup_format!("socketpair write: blocking isn't supported yet");
@@ -261,8 +254,7 @@ impl FileDescription for AnonSocket {
         ecx.check_and_update_readiness(&peer_fd)?;
 
         let result = Ok(actual_write_size);
-        ecx.return_written_byte_count_or_error(result, dest)?;
-        return Ok(());
+        ecx.return_written_byte_count_or_error(result, dest)
     }
 }