Merge remote-tracking branch 'origin/master' into maizatskyi/2025-06-09-async-io-stream

Author: mikea

.bazelrc

@@ -29,7 +29,10 @@ build:windows --copt='/Zc:dllexportInlines-' --host_copt='/Zc:dllexportInlines-'
 
 build:clippy --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect
 build:clippy --output_groups=+clippy_checks
-build:clippy  --@rules_rust//:clippy_flags=-Dclippy::all,-Dclippy::pedantic,-Dwarnings
+build:clippy --@rules_rust//:clippy_flags=-Dclippy::all,-Dclippy::pedantic,-Dwarnings
+build:clippy --aspects=@rules_rust//rust:defs.bzl%rustfmt_aspect
+build:clippy --output_groups=+rustfmt_checks
+build:clippy --@rules_rust//:extra_rustc_flag=-Dwarnings
 
 ## Sanitizers
 

gen/src/write.rs

@@ -1648,7 +1648,6 @@ fn write_kj_own(out: &mut OutFile, key: NamedImplKey) {
     let ident = key.rust;
     let resolve = out.types.resolve(ident);
     let inner = resolve.name.to_fully_qualified();
-    let instance = resolve.name.to_symbol();
 
     out.include.utility = true;
     out.include.kj_rs = true;

kj-rs/awaiter.rs

@@ -47,7 +47,7 @@ impl<Data: std::marker::Unpin> PromiseAwaiter<Data> {
             let node = this.node.take();
 
             // Safety: `awaiter` stores `rust_waker_ptr` and uses it to call `wake()`. Note that
-            // `awaiter` is `this.awaiter`, which lives before `this.option_waker`. 
+            // `awaiter` is `this.awaiter`, which lives before `this.option_waker`.
             // Since we drop awaiter manually, the `rust_waker_ptr` that `awaiter` stores will always
             // be valid during its lifetime.
             //
@@ -59,7 +59,9 @@ impl<Data: std::marker::Unpin> PromiseAwaiter<Data> {
             // Safety: The memory slot is valid and this type ensures that it will stay pinned.
             unsafe {
                 crate::ffi::guarded_rust_promise_awaiter_new_in_place(
-                    this.awaiter.as_mut_ptr().cast::<GuardedRustPromiseAwaiter>(),
+                    this.awaiter
+                        .as_mut_ptr()
+                        .cast::<GuardedRustPromiseAwaiter>(),
                     rust_waker_ptr,
                     node.expect("node should be Some in call to init()"),
                 );
@@ -88,7 +90,9 @@ impl<Data: std::marker::Unpin> Drop for PromiseAwaiter<Data> {
         if self.awaiter_initialized {
             unsafe {
                 crate::ffi::guarded_rust_promise_awaiter_drop_in_place(
-                    self.awaiter.as_mut_ptr().cast::<GuardedRustPromiseAwaiter>()
+                    self.awaiter
+                        .as_mut_ptr()
+                        .cast::<GuardedRustPromiseAwaiter>(),
                 );
             }
         }

kj-rs/lib.rs

@@ -12,9 +12,9 @@ pub use promise::new_callbacks_promise_future;
 
 mod awaiter;
 mod future;
+mod own;
 mod promise;
 mod waker;
-mod own;
 
 pub mod repr {
     pub use crate::future::repr::*;

kj-rs/own.c++

@@ -5,7 +5,7 @@ extern "C" {
 // This works because disposers work by virtual call, and the disposer is created during creation of
 // the Own, so the type of the Own at destruction doesn't actually matter for Owns that do not use a
 // static disposer, which are not currently supported by workerd-cxx.
-void cxxbridge$kjrs$own$drop(void *own) {
-  reinterpret_cast<kj::Own<void> *>(own)->~Own();
+void cxxbridge$kjrs$own$drop(void* own) {
+  reinterpret_cast<kj::Own<void>*>(own)->~Own();
 }
 }

kj-rs/own.h

@@ -3,5 +3,5 @@
 #include <kj/memory.h>
 
 extern "C" {
-    void cxxbridge$kjrs$own$drop(void* own);
+void cxxbridge$kjrs$own$drop(void* own);
 }

kj-rs/tests/BUILD.bazel

@@ -13,7 +13,7 @@ platform(
 )
 
 rust_library(
-    name = "awaitables-rust",
+    name = "tests",
     srcs = glob(["*.rs"]),
     edition = "2024",
     deps = [
@@ -29,13 +29,13 @@ rust_unpretty(
     name = "expand-rust_test",
     testonly = True,
     deps = [
-        ":awaitables-rust_test"
+        ":rust_tests"
     ]
 )
 
 rust_test(
-    name = "awaitables-rust_test",
-    crate = "awaitables-rust",
+    name = "rust_tests",
+    crate = "tests",
     deps = [
         ":test-promises",
     ],
@@ -81,7 +81,7 @@ cc_test(
         "//conditions:default": False,
     }),
     deps = [
-        ":awaitables-rust",
+        ":tests",
         ":bridge",
         ":test-promises",
         "//third-party:runtime",

kj-rs/tests/lib.rs

@@ -53,17 +53,26 @@ mod ffi {
         #[cxx_name = "setData"]
         fn set_data(self: Pin<&mut OpaqueCxxClass>, val: u64);
 
+        #[allow(dead_code)]
         fn cxx_kj_own() -> Own<OpaqueCxxClass>;
         fn null_kj_own() -> Own<OpaqueCxxClass>;
+        #[allow(dead_code)]
         fn give_own_back(own: Own<OpaqueCxxClass>);
+        #[allow(dead_code)]
         fn modify_own_return_test();
+        #[allow(dead_code)]
         fn breaking_things() -> Own<OpaqueCxxClass>;
 
+        #[allow(dead_code)]
         fn own_integer() -> Own<i64>;
+        #[allow(dead_code)]
         fn own_integer_attached() -> Own<i64>;
 
+        #[allow(dead_code)]
         fn null_exception_test_driver_1() -> String;
+        #[allow(dead_code)]
         fn null_exception_test_driver_2() -> String;
+        #[allow(dead_code)]
         fn rust_take_own_driver();
     }
 

kj-rs/tests/test-own.c++

@@ -1,15 +1,17 @@
 #include "test-own.h"
+
 #include "kj/string.h"
+
 #include <exception>
 
 namespace kj_rs_demo {
 
-kj::Own<OpaqueCxxClass> cxx_kj_own() { 
-  return kj::heap<OpaqueCxxClass>(42); 
+kj::Own<OpaqueCxxClass> cxx_kj_own() {
+  return kj::heap<OpaqueCxxClass>(42);
 }
 
-kj::Own<OpaqueCxxClass> null_kj_own() { 
-  return kj::Own<OpaqueCxxClass>(); 
+kj::Own<OpaqueCxxClass> null_kj_own() {
+  return kj::Own<OpaqueCxxClass>();
 }
 
 void give_own_back(kj::Own<OpaqueCxxClass> own) {
@@ -42,19 +44,19 @@ kj::Own<int64_t> own_integer_attached() {
 
 rust::string null_exception_test_driver_1() {
   try {
-      auto _ = modify_own_return(null_kj_own());
-      return rust::string("");
-  } catch (const std::exception &e) {
-      return rust::string(e.what());
+    auto _ = modify_own_return(null_kj_own());
+    return rust::string("");
+  } catch (const std::exception& e) {
+    return rust::string(e.what());
   }
 }
 
 rust::string null_exception_test_driver_2() {
   try {
-      auto _ = get_null();
-      return rust::string("");
-  } catch (const std::exception &e) {
-      return rust::string(e.what());
+    auto _ = get_null();
+    return rust::string("");
+  } catch (const std::exception& e) {
+    return rust::string(e.what());
   }
 }
 
@@ -63,4 +65,4 @@ void rust_take_own_driver() {
   take_own(kj::mv(own));
 }
 
-} // namespace kj_rs_demo
+}  // namespace kj_rs_demo

kj-rs/tests/test-own.h

@@ -1,21 +1,27 @@
 #pragma once
 
 #include "kj/memory.h"
-#include <cstdint>
-#include <kj/debug.h>
+
 #include <rust/cxx.h>
+
+#include <kj/debug.h>
+
 #include <cstdint>
 
 namespace kj_rs_demo {
 
 class OpaqueCxxClass {
-public:
-  OpaqueCxxClass(uint64_t data) : data(data) {}
+ public:
+  OpaqueCxxClass(uint64_t data): data(data) {}
   ~OpaqueCxxClass() {}
-  uint64_t getData() const { return this->data; }
-  void setData(uint64_t val) { this->data = val; }
-
-private:
+  uint64_t getData() const {
+    return this->data;
+  }
+  void setData(uint64_t val) {
+    this->data = val;
+  }
+
+ private:
   uint64_t data;
 };
 
@@ -41,4 +47,4 @@ kj::Own<OpaqueCxxClass> breaking_things();
 kj::Own<int64_t> own_integer();
 kj::Own<int64_t> own_integer_attached();
 
-} // namespace kj_rs_demo
+}  // namespace kj_rs_demo