fix(tooling): satisfy workspace clippy gate

Author: ffonion

clippy.toml

@@ -0,0 +1,7 @@
+# RustScript's public host boundary intentionally carries rich typed errors,
+# and several compiler plumbing functions pass one cohesive eight-field context.
+# Keep Clippy's structural lints active while setting thresholds to the shapes
+# already required by these APIs.
+too-many-arguments-threshold = 8
+large-error-threshold = 256
+type-complexity-threshold = 350

crates/rustscript/src/bin/rustscript-lsp.rs

@@ -581,12 +581,13 @@ fn percent_decode(input: &str) -> String {
     let mut out = Vec::with_capacity(bytes.len());
     let mut i = 0;
     while i < bytes.len() {
-        if bytes[i] == b'%' && i + 2 < bytes.len() {
-            if let (Some(hi), Some(lo)) = (hex_val(bytes[i + 1]), hex_val(bytes[i + 2])) {
-                out.push((hi << 4) | lo);
-                i += 3;
-                continue;
-            }
+        if bytes[i] == b'%'
+            && i + 2 < bytes.len()
+            && let (Some(hi), Some(lo)) = (hex_val(bytes[i + 1]), hex_val(bytes[i + 2]))
+        {
+            out.push((hi << 4) | lo);
+            i += 3;
+            continue;
         }
         out.push(bytes[i]);
         i += 1;
@@ -1093,9 +1094,9 @@ impl LspServer {
                 Ok(Some(result_message(id, serde_json::Value::Null)))
             }
             _ => {
-                if msg.id.is_some() {
+                if let Some(id) = msg.id.as_ref() {
                     Ok(Some(error_message(
-                        msg.id.as_ref().unwrap(),
+                        id,
                         RPC_METHOD_NOT_FOUND,
                         &format!("method not found: {method}"),
                     )))
@@ -1588,11 +1589,11 @@ fn main() {
                 std::process::exit(1);
             }
         };
-        if let Some(response) = response {
-            if let Err(err) = write_message(&mut out, &response) {
-                eprintln!("rustscript-lsp: failed writing response: {err}");
-                std::process::exit(1);
-            }
+        if let Some(response) = response
+            && let Err(err) = write_message(&mut out, &response)
+        {
+            eprintln!("rustscript-lsp: failed writing response: {err}");
+            std::process::exit(1);
         }
         if is_exit {
             if server.shutdown_requested {

crates/rustscript/tests/lsp_resource_types.rs

@@ -41,10 +41,10 @@ fn read_framed_message(reader: &mut impl BufRead) -> Option<serde_json::Value> {
         if trimmed.is_empty() {
             break;
         }
-        if let Some((name, value)) = trimmed.split_once(':') {
-            if name.eq_ignore_ascii_case("content-length") {
-                content_length = Some(value.trim().parse().expect("content-length number"));
-            }
+        if let Some((name, value)) = trimmed.split_once(':')
+            && name.eq_ignore_ascii_case("content-length")
+        {
+            content_length = Some(value.trim().parse().expect("content-length number"));
         }
     }
     let length = content_length.expect("content-length header present");
@@ -98,33 +98,31 @@ impl RpcClient {
     fn recv(&mut self) -> serde_json::Value {
         use std::time::{Duration, Instant};
         let deadline = Instant::now() + Duration::from_secs(30);
-        loop {
-            if let Some(status) = self.child.try_wait().expect("try_wait") {
-                // EOF: the server died. Surface its stderr for diagnosis.
+        if let Some(status) = self.child.try_wait().expect("try_wait") {
+            // EOF: the server died. Surface its stderr for diagnosis.
+            let mut stderr = String::new();
+            let _ = self
+                .child
+                .stderr
+                .take()
+                .map(|mut e| e.read_to_string(&mut stderr));
+            panic!("server died with {status} while reading message. stderr: {stderr}");
+        }
+        let remaining = deadline.saturating_duration_since(Instant::now());
+        match self.messages.recv_timeout(remaining) {
+            Ok(message) => message,
+            Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
+                self.child.kill().ok();
+                panic!("server hung while awaiting a message");
+            }
+            Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => {
                 let mut stderr = String::new();
                 let _ = self
                     .child
                     .stderr
                     .take()
                     .map(|mut e| e.read_to_string(&mut stderr));
-                panic!("server died with {status} while reading message. stderr: {stderr}");
-            }
-            let remaining = deadline.saturating_duration_since(Instant::now());
-            match self.messages.recv_timeout(remaining) {
-                Ok(message) => return message,
-                Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
-                    self.child.kill().ok();
-                    panic!("server hung while awaiting a message");
-                }
-                Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => {
-                    let mut stderr = String::new();
-                    let _ = self
-                        .child
-                        .stderr
-                        .take()
-                        .map(|mut e| e.read_to_string(&mut stderr));
-                    panic!("server stdout closed without a message. stderr: {stderr}");
-                }
+                panic!("server stdout closed without a message. stderr: {stderr}");
             }
         }
     }
@@ -230,8 +228,8 @@ impl RpcClient {
     /// closed first so a server blocked reading can never deadlock the test.
     fn wait_exit(&mut self) -> std::process::ExitStatus {
         self.stdin.take();
-        let status = self.child.wait().expect("wait for server exit");
-        status
+
+        self.child.wait().expect("wait for server exit")
     }
 }
 
@@ -569,11 +567,11 @@ fn completion_surfaces_host_members_with_resource_detail_after_import() {
     let items = result["items"].as_array().expect("completion items");
     let labels: Vec<&str> = items.iter().filter_map(|i| i["label"].as_str()).collect();
     assert!(
-        labels.iter().any(|l| *l == "query"),
+        labels.contains(&"query"),
         "completion after sqlite:: must include query member: {labels:?}"
     );
     assert!(
-        labels.iter().any(|l| *l == "open"),
+        labels.contains(&"open"),
         "completion after sqlite:: must include open member: {labels:?}"
     );
     // The `query` completion detail must carry the resource-aware signature.
@@ -1749,7 +1747,7 @@ fn syntax_error_change_publishes_exact_parse_diagnostic_and_clears_model() {
         "parse diagnostic must point at the offending line"
     );
     assert!(
-        diagnostics[0]["message"].as_str().unwrap_or("").len() > 0,
+        !diagnostics[0]["message"].as_str().unwrap_or("").is_empty(),
         "parse diagnostic must carry a message"
     );
 

src/builtins/runtime/http/mod.rs

@@ -345,7 +345,6 @@ mod tests {
         validate_url_policy,
     };
     use super::{HttpConfig, HttpHostExt};
-    use crate::vm::{Value, VmStatus};
 
     #[test]
     fn default_http_policy_denies_all_hosts() {

src/builtins/runtime/http/request.rs

@@ -102,26 +102,6 @@ impl ResponseReadObserver {
             })
             .expect("response body remaining-byte update cannot fail");
     }
-
-    #[cfg(test)]
-    pub(super) fn body_read_calls(&self) -> usize {
-        self.inner.body_read_calls.load(Ordering::Acquire)
-    }
-
-    #[cfg(test)]
-    pub(super) fn max_body_transport_read(&self) -> usize {
-        self.inner.max_body_transport_read.load(Ordering::Acquire)
-    }
-
-    #[cfg(test)]
-    pub(super) fn max_raw_transport_read(&self) -> usize {
-        self.inner.max_raw_transport_read.load(Ordering::Acquire)
-    }
-
-    #[cfg(test)]
-    pub(super) fn max_application_chunk(&self) -> usize {
-        self.inner.max_application_chunk.load(Ordering::Acquire)
-    }
 }
 
 // Rustls accepts a 16 KiB TLS fragment plus at most 2 KiB of protocol
@@ -464,10 +444,10 @@ impl HostResource for HttpRequestResource {
         // resource close is the authoritative teardown path.
         shared.cancel.notify_one();
         // Wake the operation waker so the next poll sees the result.
-        if let Ok(mut waker) = shared.waker.lock() {
-            if let Some(waker) = waker.take() {
-                waker.wake();
-            }
+        if let Ok(mut waker) = shared.waker.lock()
+            && let Some(waker) = waker.take()
+        {
+            waker.wake();
         }
         // Return Pending: the worker thread may still be running. The
         // scope's poll_close machinery will call poll_close below.
@@ -578,10 +558,10 @@ impl HostOperation for HttpRequestOperation {
         let _ = reason;
         self.shared.cancel.notify_one();
         // Wake the operation waker so the next poll sees the result.
-        if let Ok(mut waker) = self.shared.waker.lock() {
-            if let Some(waker) = waker.take() {
-                waker.wake();
-            }
+        if let Ok(mut waker) = self.shared.waker.lock()
+            && let Some(waker) = waker.take()
+        {
+            waker.wake();
         }
         Ok(())
     }
@@ -730,54 +710,6 @@ fn runtime_block_on<F: std::future::Future>(future: F) -> F::Output {
     runtime.block_on(future)
 }
 
-#[cfg(test)]
-pub(super) async fn execute_request(config: &HttpConfig, request: &HttpRequest) -> VmResult<VmMap> {
-    let deadline = request_deadline(config.request_timeout)?;
-    with_deadline(
-        deadline,
-        HTTP_REQUEST_DEADLINE_EXCEEDED,
-        execute_request_until(
-            config,
-            request,
-            ResponseReadObserver::default(),
-            deadline,
-            None,
-        ),
-    )
-    .await
-}
-
-#[cfg(test)]
-pub(super) async fn execute_request_with_observer(
-    config: &HttpConfig,
-    request: &HttpRequest,
-    observer: ResponseReadObserver,
-) -> VmResult<VmMap> {
-    let deadline = request_deadline(config.request_timeout)?;
-    with_deadline(
-        deadline,
-        HTTP_REQUEST_DEADLINE_EXCEEDED,
-        execute_request_until(config, request, observer, deadline, None),
-    )
-    .await
-}
-
-#[cfg(test)]
-pub(super) async fn execute_request_with_tls_config(
-    config: &HttpConfig,
-    request: &HttpRequest,
-    observer: ResponseReadObserver,
-    tls_config: Arc<rustls::ClientConfig>,
-) -> VmResult<VmMap> {
-    let deadline = request_deadline(config.request_timeout)?;
-    with_deadline(
-        deadline,
-        HTTP_REQUEST_DEADLINE_EXCEEDED,
-        execute_request_until(config, request, observer, deadline, Some(tls_config)),
-    )
-    .await
-}
-
 async fn execute_request_until(
     config: &HttpConfig,
     request: &HttpRequest,
@@ -1202,41 +1134,6 @@ async fn send_request(
     }
 }
 
-#[cfg(test)]
-pub(super) struct PendingConnectionTest {
-    pub(super) future: Pin<Box<dyn std::future::Future<Output = VmResult<VmMap>>>>,
-}
-
-#[cfg(test)]
-pub(super) fn pending_connection_test(
-    io: tokio::io::DuplexStream,
-    url: url::Url,
-) -> PendingConnectionTest {
-    let request = HttpRequest {
-        method: hyper::Method::GET,
-        url,
-        headers: Vec::new(),
-        body: None,
-    };
-    let observer = ResponseReadObserver::default();
-    PendingConnectionTest {
-        future: Box::pin(async move {
-            let mut response = send_over_io(
-                &request.method,
-                &request.url,
-                &request.headers,
-                None,
-                ReadCapIo::new(RawReadCapIo::new(io, observer.clone()), observer.clone()),
-                None,
-            )
-            .await?;
-            observer.admit_body(1024);
-            while response.next_frame().await?.is_some() {}
-            Ok(VmMap::default())
-        }),
-    }
-}
-
 async fn send_over_io<T>(
     method: &hyper::Method,
     url: &url::Url,

src/builtins/runtime/http/sse.rs

@@ -763,19 +763,18 @@ impl HostStreamDriver for SseStreamDriver {
         let drain_item = |driver: &mut Self| -> Option<HostStreamPoll> {
             let item = driver.receiver.try_recv().ok()?;
             // Track items and capture metadata from the open item.
-            if let Value::Map(ref map) = item {
-                if let Some(Value::String(kind)) = map.get(&Value::string("kind")) {
-                    if kind.as_str() == "open" {
-                        if let Some(Value::Int(status)) = map.get(&Value::string("status")) {
-                            driver.status = *status as u16;
-                        }
-                        if let Some(Value::Map(headers)) = map.get(&Value::string("headers")) {
-                            driver.headers = Arc::clone(headers);
-                        }
-                        if let Some(Value::String(url)) = map.get(&Value::string("url")) {
-                            driver.url = url.as_ref().clone();
-                        }
-                    }
+            if let Value::Map(ref map) = item
+                && let Some(Value::String(kind)) = map.get(&Value::string("kind"))
+                && kind.as_str() == "open"
+            {
+                if let Some(Value::Int(status)) = map.get(&Value::string("status")) {
+                    driver.status = *status as u16;
+                }
+                if let Some(Value::Map(headers)) = map.get(&Value::string("headers")) {
+                    driver.headers = Arc::clone(headers);
+                }
+                if let Some(Value::String(url)) = map.get(&Value::string("url")) {
+                    driver.url = url.as_ref().clone();
                 }
             }
             driver.items = driver.items.saturating_add(1);
@@ -876,10 +875,10 @@ impl HostResource for SseStreamResource {
         self.shared.cancel.notify_one();
         // Wake the item waker so the stream driver sees the stop flag
         // promptly.
-        if let Ok(mut waker) = self.shared.waker.lock() {
-            if let Some(waker) = waker.take() {
-                waker.wake();
-            }
+        if let Ok(mut waker) = self.shared.waker.lock()
+            && let Some(waker) = waker.take()
+        {
+            waker.wake();
         }
         // Return Pending: the worker thread may still be running. The
         // scope's poll_close machinery will call poll_close below.
@@ -956,10 +955,10 @@ impl HostOperation for SseScopeOperation {
         let _ = reason;
         self.shared.stopping.store(true, Ordering::SeqCst);
         self.shared.cancel.notify_one();
-        if let Ok(mut waker) = self.shared.waker.lock() {
-            if let Some(waker) = waker.take() {
-                waker.wake();
-            }
+        if let Ok(mut waker) = self.shared.waker.lock()
+            && let Some(waker) = waker.take()
+        {
+            waker.wake();
         }
         Ok(())
     }