Update lean-ffi

Author: samuelburnham

flake.nix

@@ -151,6 +151,7 @@
             clang
             lean.lean-all
             rustToolchain
+            rust-analyzer
           ];
         };
 

rust/Cargo.lock

@@ -8,7 +8,7 @@ crate-type = ["staticlib"]
 
 [dependencies]
 blake3 = "1.8.3"
-lean-ffi = { git = "https://github.com/argumentcomputer/lean-ffi", rev = "91185181da859eb3941df2fbede24ae03838ed5b" }
+lean-ffi = { git = "https://github.com/argumentcomputer/lean-ffi", rev = "b194f3f17d1959562ef850527aa70bde43358086" }
 
 [profile.dev]
 panic = "abort"

rust/Cargo.toml

@@ -1,70 +1,61 @@
 use std::sync::LazyLock;
 
-use lean_ffi::include;
-use lean_ffi::object::{ExternalClass, LeanByteArray, LeanExternal, LeanObject, LeanString};
+use lean_ffi::object::{
+    ExternalClass, LeanBorrowed, LeanByteArray, LeanExternal, LeanOwned, LeanString,
+};
 
 static HASHER_CLASS: LazyLock<ExternalClass> =
     LazyLock::new(ExternalClass::register_with_drop::<blake3::Hasher>);
 
 #[unsafe(no_mangle)]
-pub extern "C" fn rs_blake3_version() -> LeanString {
+pub extern "C" fn rs_blake3_version() -> LeanString<LeanOwned> {
     LeanString::new("1.8.3")
 }
 
 #[unsafe(no_mangle)]
-pub extern "C" fn rs_blake3_init() -> LeanObject {
-    LeanExternal::alloc(&HASHER_CLASS, blake3::Hasher::new()).into()
+pub extern "C" fn rs_blake3_init() -> LeanExternal<blake3::Hasher, LeanOwned> {
+    LeanExternal::alloc(&HASHER_CLASS, blake3::Hasher::new())
 }
 
 #[unsafe(no_mangle)]
-pub extern "C" fn rs_blake3_init_keyed(key: LeanByteArray) -> LeanObject {
+pub extern "C" fn rs_blake3_init_keyed(
+    key: LeanByteArray<LeanBorrowed<'_>>,
+) -> LeanExternal<blake3::Hasher, LeanOwned> {
     let bytes = key.as_bytes();
     let key_array: &[u8; 32] = bytes.try_into().expect("key must be 32 bytes");
-    LeanExternal::alloc(&HASHER_CLASS, blake3::Hasher::new_keyed(key_array)).into()
+    LeanExternal::alloc(&HASHER_CLASS, blake3::Hasher::new_keyed(key_array))
 }
 
 #[unsafe(no_mangle)]
-pub extern "C" fn rs_blake3_init_derive_key(context: LeanByteArray) -> LeanObject {
+pub extern "C" fn rs_blake3_init_derive_key(
+    context: LeanByteArray<LeanBorrowed<'_>>,
+) -> LeanExternal<blake3::Hasher, LeanOwned> {
     let bytes = context.as_bytes();
     let ctx_str = std::str::from_utf8(bytes).expect("context must be valid UTF-8");
-    LeanExternal::alloc(&HASHER_CLASS, blake3::Hasher::new_derive_key(ctx_str)).into()
-}
-
-/// Ensure copy-on-write: if the object is shared, clone the hasher into a new
-/// external object; otherwise return it as-is for in-place mutation.
-unsafe fn ensure_exclusive(obj: LeanObject) -> LeanObject {
-    if unsafe { include::lean_is_exclusive(obj.as_ptr() as *mut _) } {
-        obj
-    } else {
-        let ext = unsafe { LeanExternal::<blake3::Hasher>::from_raw(obj.as_ptr()) };
-        let cloned = ext.get().clone();
-        obj.dec_ref();
-        LeanExternal::alloc(&HASHER_CLASS, cloned).into()
-    }
+    LeanExternal::alloc(&HASHER_CLASS, blake3::Hasher::new_derive_key(ctx_str))
 }
 
 #[unsafe(no_mangle)]
 pub extern "C" fn rs_blake3_hasher_update(
-    self_: LeanObject,
-    input: LeanByteArray,
-) -> LeanObject {
-    let obj = unsafe { ensure_exclusive(self_) };
-    let hasher_ptr =
-        unsafe { include::lean_get_external_data(obj.as_ptr() as *mut _) as *mut blake3::Hasher };
-    unsafe { (*hasher_ptr).update(input.as_bytes()) };
-    obj
+    mut hasher: LeanExternal<blake3::Hasher, LeanOwned>,
+    input: LeanByteArray<LeanBorrowed<'_>>,
+) -> LeanExternal<blake3::Hasher, LeanOwned> {
+    if let Some(h) = hasher.get_mut() {
+        h.update(input.as_bytes());
+        hasher
+    } else {
+        let mut new_hasher = hasher.get().clone();
+        new_hasher.update(input.as_bytes());
+        LeanExternal::alloc(&HASHER_CLASS, new_hasher)
+    }
 }
 
 #[unsafe(no_mangle)]
-pub extern "C" fn rs_blake3_hasher_finalize(self_: LeanObject, len: usize) -> LeanObject {
-    let ext = unsafe { LeanExternal::<blake3::Hasher>::from_raw(self_.as_ptr()) };
-    let hasher = ext.get();
-    let out = LeanByteArray::alloc(len);
-    let buf = unsafe {
-        let cptr = include::lean_sarray_cptr(out.as_ptr() as *mut _);
-        std::slice::from_raw_parts_mut(cptr, len)
-    };
-    hasher.finalize_xof().fill(buf);
-    self_.dec_ref();
-    out.into()
+pub extern "C" fn rs_blake3_hasher_finalize(
+    hasher: LeanExternal<blake3::Hasher, LeanOwned>,
+    len: usize,
+) -> LeanByteArray<LeanOwned> {
+    let mut buf = vec![0u8; len];
+    hasher.get().finalize_xof().fill(&mut buf);
+    LeanByteArray::from_bytes(&buf)
 }