Fix a few clippy lints.

I'm especially fond of replacing `RefCell<Option<T>>` with `OnceCell<T>`.

Author: sunfishcode

Cargo.toml

@@ -9,6 +9,7 @@ edition.workspace = true
 authors.workspace = true
 keywords.workspace = true
 categories.workspace = true
+repository.workspace = true
 
 [features]
 
@@ -42,7 +43,7 @@ edition = "2021"
 license = "MIT OR Apache-2.0 OR Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/yoshuawuyts/wstd"
 keywords = ["WebAssembly", "async", "stdlib", "Components"]
-categories = []
+categories = ["wasm", "asynchronous"]
 authors = [
     "Yoshua Wuyts <rust@yosh.is>",
     "Pat Hickey <pat@moreproductive.org>",

src/http/client.rs

@@ -174,7 +174,10 @@ impl Client {
     }
 
     fn wasi_options(&self) -> Result<Option<WasiRequestOptions>> {
-        self.options.as_ref().map(|o| o.to_wasi()).transpose()
+        self.options
+            .as_ref()
+            .map(RequestOptions::to_wasi)
+            .transpose()
     }
 }
 

src/http/request.rs

@@ -34,7 +34,7 @@ pub(crate) fn try_into_outgoing<T>(request: Request<T>) -> Result<(OutgoingReque
         .map_err(|()| Error::other(format!("scheme rejected by wasi-http: {scheme:?}")))?;
 
     // Set authority
-    let authority = parts.uri.authority().map(|a| a.as_str());
+    let authority = parts.uri.authority().map(Authority::as_str);
     wasi_req
         .set_authority(authority)
         .map_err(|()| Error::other(format!("authority rejected by wasi-http {authority:?}")))?;

src/io/stdio.rs

@@ -15,7 +15,7 @@ pub fn stdin() -> Stdin {
     let stream = AsyncInputStream::new(wasi::cli::stdin::get_stdin());
     Stdin {
         stream,
-        terminput: LazyCell::new(|| wasi::cli::terminal_stdin::get_terminal_stdin()),
+        terminput: LazyCell::new(wasi::cli::terminal_stdin::get_terminal_stdin),
     }
 }
 
@@ -55,7 +55,7 @@ pub fn stdout() -> Stdout {
     let stream = AsyncOutputStream::new(wasi::cli::stdout::get_stdout());
     Stdout {
         stream,
-        termoutput: LazyCell::new(|| wasi::cli::terminal_stdout::get_terminal_stdout()),
+        termoutput: LazyCell::new(wasi::cli::terminal_stdout::get_terminal_stdout),
     }
 }
 
@@ -100,7 +100,7 @@ pub fn stderr() -> Stderr {
     let stream = AsyncOutputStream::new(wasi::cli::stderr::get_stderr());
     Stderr {
         stream,
-        termoutput: LazyCell::new(|| wasi::cli::terminal_stderr::get_terminal_stderr()),
+        termoutput: LazyCell::new(wasi::cli::terminal_stderr::get_terminal_stderr),
     }
 }
 

src/io/streams.rs

@@ -1,36 +1,30 @@
 use super::{AsyncPollable, AsyncRead, AsyncWrite};
-use std::cell::RefCell;
+use std::cell::OnceCell;
 use std::io::Result;
 use wasi::io::streams::{InputStream, OutputStream, StreamError};
 
 #[derive(Debug)]
 pub struct AsyncInputStream {
     // Lazily initialized pollable, used for lifetime of stream to check readiness.
     // Field ordering matters: this child must be dropped before stream
-    subscription: RefCell<Option<AsyncPollable>>,
+    subscription: OnceCell<AsyncPollable>,
     stream: InputStream,
 }
 
 impl AsyncInputStream {
     pub fn new(stream: InputStream) -> Self {
         Self {
-            subscription: RefCell::new(None),
+            subscription: OnceCell::new(),
             stream,
         }
     }
     async fn ready(&self) {
         // Lazily initialize the AsyncPollable
-        if self.subscription.borrow().is_none() {
-            self.subscription
-                .replace(Some(AsyncPollable::new(self.stream.subscribe())));
-        }
+        let subscription = self
+            .subscription
+            .get_or_init(|| AsyncPollable::new(self.stream.subscribe()));
         // Wait on readiness
-        self.subscription
-            .borrow()
-            .as_ref()
-            .expect("populated refcell")
-            .wait_for()
-            .await;
+        subscription.wait_for().await;
     }
     /// Like [`AsyncRead::read`], but doesn't require a `&mut self`.
     pub async fn read(&self, buf: &mut [u8]) -> Result<usize> {
@@ -70,30 +64,24 @@ impl AsyncRead for AsyncInputStream {
 pub struct AsyncOutputStream {
     // Lazily initialized pollable, used for lifetime of stream to check readiness.
     // Field ordering matters: this child must be dropped before stream
-    subscription: RefCell<Option<AsyncPollable>>,
+    subscription: OnceCell<AsyncPollable>,
     stream: OutputStream,
 }
 
 impl AsyncOutputStream {
     pub fn new(stream: OutputStream) -> Self {
         Self {
-            subscription: RefCell::new(None),
+            subscription: OnceCell::new(),
             stream,
         }
     }
     async fn ready(&self) {
         // Lazily initialize the AsyncPollable
-        if self.subscription.borrow().is_none() {
-            self.subscription
-                .replace(Some(AsyncPollable::new(self.stream.subscribe())));
-        }
+        let subscription = self
+            .subscription
+            .get_or_init(|| AsyncPollable::new(self.stream.subscribe()));
         // Wait on readiness
-        self.subscription
-            .borrow()
-            .as_ref()
-            .expect("populated refcell")
-            .wait_for()
-            .await;
+        subscription.wait_for().await;
     }
     /// Like [`AsyncWrite::write`], but doesn't require a `&mut self`.
     pub async fn write(&self, buf: &[u8]) -> Result<usize> {

src/time/duration.rs

@@ -118,9 +118,9 @@ impl From<std::time::Duration> for Duration {
     }
 }
 
-impl Into<std::time::Duration> for Duration {
-    fn into(self) -> std::time::Duration {
-        std::time::Duration::from_nanos(self.0)
+impl From<Duration> for std::time::Duration {
+    fn from(duration: Duration) -> Self {
+        Self::from_nanos(duration.0)
     }
 }
 

src/time/mod.rs

@@ -72,7 +72,7 @@ impl Timer {
         *self = Self::after(duration);
     }
     pub fn wait(&self) -> Wait {
-        let wait_for = self.0.as_ref().map(|pollable| pollable.wait_for());
+        let wait_for = self.0.as_ref().map(AsyncPollable::wait_for);
         Wait { wait_for }
     }
 }