fix: Fix tests and apply some stylistic code changes

Author: SersemPeca

src/db-backend/Cargo.toml

@@ -74,7 +74,7 @@ required-features = ["io-transport"]
 [features]
 debugging = []
 
-default = ["browser-transport"]
+default = ["io-transport"]
 
 io-transport = ["dep:expanduser"]
 browser-transport = ["dep:serde-wasm-bindgen", "dep:wasm-bindgen",

src/db-backend/src/c_compat.rs

@@ -1,13 +1,10 @@
-#[cfg(feature = "browser-transport")]
 extern crate alloc;
 
 use alloc::alloc::{alloc as sys_alloc, dealloc as sys_dealloc, realloc as sys_realloc, Layout};
 use core::ffi::{c_char, c_int, c_void};
 use core::mem::{align_of, size_of};
 use core::ptr::null_mut;
-use std::ffi::CStr;
 
-#[cfg(feature = "browser-transport")]
 #[global_allocator]
 static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
 
@@ -134,23 +131,17 @@ pub extern "C" fn calloc(nmemb: usize, size: usize) -> *mut c_void {
 
 #[no_mangle]
 pub extern "C" fn fprintf(_stream: *mut c_void, _fmt: *const c_char, _arg: *const c_void) -> c_int {
-    // Pretend 0 chars written.
-    0
+    unreachable!("Running in wasm mode. Should not be calling `fprintf`");
 }
 
 #[no_mangle]
 pub extern "C" fn fclose(_stream: *mut c_void) -> c_int {
-    0
+    unreachable!("Running in wasm mode. Should not be calling `fclose`");
 }
 
 #[no_mangle]
 pub extern "C" fn snprintf(buf: *mut c_char, n: usize, _fmt: *const c_char, _arg: usize) -> c_int {
-    unsafe {
-        if !buf.is_null() && n > 0 {
-            *buf = 0;
-        }
-    }
-    0
+    unreachable!("Running in wasm mode. Should not be calling `sprintf`");
 }
 
 // Dummy va_list type for signature compatibility
@@ -161,74 +152,26 @@ pub struct va_list__dummy {
 
 #[no_mangle]
 pub extern "C" fn vsnprintf(buf: *mut c_char, n: usize, _fmt: *const c_char, _ap: *mut va_list__dummy) -> c_int {
-    unsafe {
-        if !buf.is_null() && n > 0 {
-            *buf = 0;
-        }
-    }
-    0
+    unreachable!("Running in wasm mode. Should not be calling `vsprintf`");
 }
 
 #[no_mangle]
 pub extern "C" fn abort() -> ! {
-    #[cfg(feature = "browser-transport")]
     wasm_bindgen::throw_str("abort");
 }
 
 #[inline]
 unsafe fn cstr_prefix_len(mut p: *const u8, limit: usize) -> usize {
-    // Count up to first NUL or `limit` bytes.
-    let mut i = 0usize;
-    while i < limit {
-        let b = *p;
-        if b == 0 {
-            break;
-        }
-        i += 1;
-        p = p.add(1);
-    }
-    i
+    unreachable!("Running in wasm mode. Should not be calling `vsprintf`");
 }
 
 #[no_mangle]
 pub extern "C" fn strncmp(s1: *const c_char, s2: *const c_char, n: usize) -> c_int {
-    if n == 0 {
-        return 0;
-    }
-    if s1.is_null() || s2.is_null() {
-        return 0;
-    } // benign stub behavior
-
-    // SAFETY: caller promises valid C strings; we only touch up to `n` bytes or NUL.
-    let a = s1 as *const u8;
-    let b = s2 as *const u8;
-    let len = unsafe {
-        let l1 = cstr_prefix_len(a, n);
-        let l2 = cstr_prefix_len(b, n);
-        core::cmp::min(core::cmp::min(l1, l2), n)
-    };
-
-    // Compare common prefix (unsigned char semantics)
-    for i in 0..len {
-        let av = unsafe { *a.add(i) } as u8;
-        let bv = unsafe { *b.add(i) } as u8;
-        if av != bv {
-            return (av as c_int) - (bv as c_int);
-        }
-    }
-
-    // If we stopped early (before n), one string may have ended (NUL) earlier.
-    if len < n {
-        let av = unsafe { *a.add(len) } as u8; // 0 if NUL, else next byte
-        let bv = unsafe { *b.add(len) } as u8;
-        return (av as c_int) - (bv as c_int);
-    }
-    0
+    unreachable!("Running in wasm mode. Should not be calling `vsprintf`");
 }
 
 #[no_mangle]
 pub extern "C" fn clock() -> c_int {
-    #[cfg(feature = "browser-transport")]
     {
         // js_sys::Date::now() -> f64 milliseconds since epoch
 
@@ -240,41 +183,22 @@ pub extern "C" fn clock() -> c_int {
 
 #[inline]
 fn write_host(_s: &str, _stream: *mut c_void) {
-    // no-op
+    unreachable!("Running in wasm mode. Should not be calling `vsprintf`");
 }
 
 /// int fputc(int c, FILE *stream)
 #[no_mangle]
 pub extern "C" fn fputc(c: c_int, stream: *mut c_void) -> c_int {
-    let ch = (c as u8) as char;
-    let mut buf = [0u8; 4];
-    let s = ch.encode_utf8(&mut buf);
-    write_host(s, stream);
-    // C fputc returns the written character cast to unsigned char as int
-    (c as u8) as c_int
+    unreachable!("Running in wasm mode. Should not be calling `vsprintf`");
 }
 
 /// int fputs(const char *s, FILE *stream)
 #[no_mangle]
 pub extern "C" fn fputs(s: *const c_char, stream: *mut c_void) -> c_int {
-    if s.is_null() {
-        return -1;
-    }
-    // SAFETY: caller promises valid NUL-terminated string
-    let bytes = unsafe { CStr::from_ptr(s) }.to_bytes();
-    let text = core::str::from_utf8(bytes).unwrap_or("<invalid utf-8>");
-    write_host(text, stream);
-    // C fputs returns a nonnegative value on success (commonly a non-portable value, so we return len)
-    bytes.len() as c_int
+    unreachable!("Running in wasm mode. Should not be calling `vsprintf`");
 }
 
 #[no_mangle]
 pub extern "C" fn fdopen(fd: c_int, _mode: *const c_char) -> *mut c_void {
-    // Provide distinct, non-null sentinel handles for stdin/stdout/stderr (0/1/2).
-    // We never dereference these; other stubs ignore `stream` and treat any non-null as valid.
-    if (0..=2).contains(&fd) {
-        (fd as usize + 1) as *mut c_void
-    } else {
-        null_mut()
-    }
+    unreachable!("Running in wasm mode. Should not be calling `vsprintf`");
 }

src/db-backend/src/dap.rs

@@ -1,15 +1,10 @@
 use crate::dap_types::{self, OutputEventBody, SetBreakpointsArguments, StoppedEventBody};
 use crate::task::{self, CtUpdatedTableResponseBody};
-use log::{error, info};
+use crate::transport::DapResult;
 use serde::{de::DeserializeOwned, de::Error as SerdeError, Deserialize, Serialize};
 use serde_json::Value;
-use std::io::BufRead;
 use std::path::PathBuf;
 
-type DapResult<T> = std::result::Result<T, DapError>;
-
-use crate::dap_error::DapError;
-
 #[derive(Serialize, Deserialize, Default, Debug, PartialEq, Clone)]
 pub struct ProtocolMessage {
     pub seq: i64,
@@ -368,10 +363,14 @@ pub fn to_json(message: &DapMessage) -> DapResult<String> {
 }
 
 #[cfg(feature = "io-transport")]
-pub fn read_dap_message_from_reader<R: BufRead>(reader: &mut R) -> DapResult<DapMessage> {
+pub fn read_dap_message_from_reader<R: std::io::BufRead>(reader: &mut R) -> DapResult<DapMessage> {
+    use log::info;
+
     info!("from_reader");
     let mut header = String::new();
     reader.read_line(&mut header).map_err(|e| {
+        use log::error;
+
         error!("Read Line: {:?}", e);
         serde_json::Error::custom(e.to_string())
     })?;