refactor(runtime/permissions): use concrete error types (#26464)

runtime/permissions/Cargo.toml

@@ -23,6 +23,7 @@ log.workspace = true
 once_cell.workspace = true
 percent-encoding = { version = "2.3.1", features = [] }
 serde.workspace = true
+thiserror.workspace = true
 which.workspace = true
 
 [target.'cfg(windows)'.dependencies]

runtime/permissions/prompter.rs

@@ -1,6 +1,5 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 
-use deno_core::error::AnyError;
 use deno_core::parking_lot::Mutex;
 use deno_terminal::colors;
 use once_cell::sync::Lazy;
@@ -101,8 +100,7 @@ pub struct TtyPrompter;
 fn clear_stdin(
   _stdin_lock: &mut StdinLock,
   _stderr_lock: &mut StderrLock,
-) -> Result<(), AnyError> {
-  use deno_core::anyhow::bail;
+) -> Result<(), std::io::Error> {
   use std::mem::MaybeUninit;
 
   const STDIN_FD: i32 = 0;
@@ -117,7 +115,10 @@ fn clear_stdin(
     loop {
       let r = libc::tcflush(STDIN_FD, libc::TCIFLUSH);
       if r != 0 {
-        bail!("clear_stdin failed (tcflush)");
+        return Err(std::io::Error::new(
+          std::io::ErrorKind::Other,
+          "clear_stdin failed (tcflush)",
+        ));
       }
 
       // Initialize timeout for select to be 100ms
@@ -137,7 +138,10 @@ fn clear_stdin(
 
       // Check if select returned an error
       if r < 0 {
-        bail!("clear_stdin failed (select)");
+        return Err(std::io::Error::new(
+          std::io::ErrorKind::Other,
+          "clear_stdin failed (select)",
+        ));
       }
 
       // Check if select returned due to timeout (stdin is quiescent)
@@ -156,8 +160,7 @@ fn clear_stdin(
 fn clear_stdin(
   stdin_lock: &mut StdinLock,
   stderr_lock: &mut StderrLock,
-) -> Result<(), AnyError> {
-  use deno_core::anyhow::bail;
+) -> Result<(), std::io::Error> {
   use winapi::shared::minwindef::TRUE;
   use winapi::shared::minwindef::UINT;
   use winapi::shared::minwindef::WORD;
@@ -194,18 +197,23 @@ fn clear_stdin(
 
   return Ok(());
 
-  unsafe fn flush_input_buffer(stdin: HANDLE) -> Result<(), AnyError> {
+  unsafe fn flush_input_buffer(stdin: HANDLE) -> Result<(), std::io::Error> {
     let success = FlushConsoleInputBuffer(stdin);
     if success != TRUE {
-      bail!(
-        "Could not flush the console input buffer: {}",
-        std::io::Error::last_os_error()
-      )
+      return Err(std::io::Error::new(
+        std::io::ErrorKind::Other,
+        format!(
+          "Could not flush the console input buffer: {}",
+          std::io::Error::last_os_error()
+        ),
+      ));
     }
     Ok(())
   }
 
-  unsafe fn emulate_enter_key_press(stdin: HANDLE) -> Result<(), AnyError> {
+  unsafe fn emulate_enter_key_press(
+    stdin: HANDLE,
+  ) -> Result<(), std::io::Error> {
     // https://github.com/libuv/libuv/blob/a39009a5a9252a566ca0704d02df8dabc4ce328f/src/win/tty.c#L1121-L1131
     let mut input_record: INPUT_RECORD = std::mem::zeroed();
     input_record.EventType = KEY_EVENT;
@@ -220,34 +228,43 @@ fn clear_stdin(
     let success =
       WriteConsoleInputW(stdin, &input_record, 1, &mut record_written);
     if success != TRUE {
-      bail!(
-        "Could not emulate enter key press: {}",
-        std::io::Error::last_os_error()
-      );
+      return Err(std::io::Error::new(
+        std::io::ErrorKind::Other,
+        format!(
+          "Could not emulate enter key press: {}",
+          std::io::Error::last_os_error()
+        ),
+      ));
     }
     Ok(())
   }
 
-  unsafe fn is_input_buffer_empty(stdin: HANDLE) -> Result<bool, AnyError> {
+  unsafe fn is_input_buffer_empty(
+    stdin: HANDLE,
+  ) -> Result<bool, std::io::Error> {
     let mut buffer = Vec::with_capacity(1);
     let mut events_read = 0;
     let success =
       PeekConsoleInputW(stdin, buffer.as_mut_ptr(), 1, &mut events_read);
     if success != TRUE {
-      bail!(
-        "Could not peek the console input buffer: {}",
-        std::io::Error::last_os_error()
-      )
+      return Err(std::io::Error::new(
+        std::io::ErrorKind::Other,
+        format!(
+          "Could not peek the console input buffer: {}",
+          std::io::Error::last_os_error()
+        ),
+      ));
     }
     Ok(events_read == 0)
   }
 
-  fn move_cursor_up(stderr_lock: &mut StderrLock) -> Result<(), AnyError> {
-    write!(stderr_lock, "\x1B[1A")?;
-    Ok(())
+  fn move_cursor_up(
+    stderr_lock: &mut StderrLock,
+  ) -> Result<(), std::io::Error> {
+    write!(stderr_lock, "\x1B[1A")
   }
 
-  fn read_stdin_line(stdin_lock: &mut StdinLock) -> Result<(), AnyError> {
+  fn read_stdin_line(stdin_lock: &mut StdinLock) -> Result<(), std::io::Error> {
     let mut input = String::new();
     stdin_lock.read_line(&mut input)?;
     Ok(())