misc: format

Author: baszalmstra

cpp/include/mun/runtime_capi.h

@@ -73,6 +73,13 @@ typedef struct MunStructInfo {
     MunStructMemoryKind memory_kind;
 } MunStructInfo;
 
+/**
+ * Represents an array declaration.
+ */
+typedef struct MunArrayInfo {
+    const struct MunTypeInfo *element_type;
+} MunArrayInfo;
+
 /**
  * Contains data specific to a group of types that illicit the same characteristics.
  */
@@ -89,6 +96,10 @@ enum MunTypeInfoData_Tag
      * Struct types (i.e. record, tuple, or unit structs)
      */
     Struct,
+    /**
+     * Array types
+     */
+    Array,
 };
 #ifndef __cplusplus
 typedef uint8_t MunTypeInfoData_Tag;
@@ -100,6 +111,10 @@ typedef union MunTypeInfoData {
         MunTypeInfoData_Tag struct_tag;
         struct MunStructInfo struct_;
     };
+    struct {
+        MunTypeInfoData_Tag array_tag;
+        struct MunArrayInfo array;
+    };
 } MunTypeInfoData;
 
 /**

crates/mun_codegen/src/ir/body.rs

@@ -1440,7 +1440,11 @@ impl<'db, 'ink, 't> BodyIrGenerator<'db, 'ink, 't> {
             .builder
             .build_call(
                 new_array_fn_ptr,
-                &[type_info_ptr.into(), length_value.into(), allocator_handle.into()],
+                &[
+                    type_info_ptr.into(),
+                    length_value.into(),
+                    allocator_handle.into(),
+                ],
                 "new_array",
             )
             .try_as_basic_value()

crates/mun_hir/src/ty.rs

@@ -255,9 +255,7 @@ impl Ty {
     pub fn equals_ctor(&self, other: &Ty) -> bool {
         match (self.interned(), other.interned()) {
             (TyKind::Struct(s1), TyKind::Struct(s2)) => s1 == s2,
-            (TyKind::Tuple(_, substs1), TyKind::Tuple(_, substs2)) => {
-                substs1 == substs2
-            }
+            (TyKind::Tuple(_, substs1), TyKind::Tuple(_, substs2)) => substs1 == substs2,
             (TyKind::Array(_), TyKind::Array(_)) => true,
             (TyKind::Float(f1), TyKind::Float(f2)) => f1 == f2,
             (TyKind::Int(i1), TyKind::Int(i2)) => i1 == i2,

crates/mun_runtime/src/adt.rs

@@ -1,9 +1,7 @@
 use crate::garbage_collector::{GcPtr, GcRootPtr, UnsafeTypeInfo};
 use crate::{
     marshal::Marshal,
-    reflection::{
-        equals_argument_type, ArgumentReflection, ReturnTypeReflection,
-    },
+    reflection::{equals_argument_type, ArgumentReflection, ReturnTypeReflection},
     GarbageCollector, Runtime,
 };
 use abi::TypeInfo;

crates/mun_runtime/src/array.rs

@@ -1,15 +1,11 @@
 use crate::garbage_collector::{GcPtr, GcRootPtr};
-use crate::{ArgumentReflection, Marshal, ReturnTypeReflection, Runtime, UnsafeTypeInfo};
+use crate::{ArgumentReflection, GarbageCollector, Marshal, ReturnTypeReflection, Runtime};
 use abi::TypeInfo;
 use memory::gc::{GcRuntime, HasIndirectionPtr};
 use memory::{ArrayMemoryLayout, ArrayType, CompositeType};
 use once_cell::sync::OnceCell;
-use std::cell::{Ref, RefCell};
-use std::marker::{PhantomData, PhantomPinned};
-use std::mem::MaybeUninit;
-use std::pin::Pin;
+use std::marker::PhantomData;
 use std::ptr::NonNull;
-use std::rc::Rc;
 use std::sync::Arc;
 
 /// Represents a Mun array pointer.
@@ -56,8 +52,8 @@ impl<'array, T: Marshal<'array> + 'array> ArrayRef<'array, T> {
     }
 
     /// Roots the `ArrayRef`.
-    pub fn root(self, runtime: Rc<RefCell<Runtime>>) -> RootedArray<T> {
-        RootedArray::new(&self.runtime.gc, runtime, self.raw)
+    pub fn root(self) -> RootedArray<T> {
+        RootedArray::new(&self.runtime.gc, self.raw)
     }
 
     /// Returns the number of elements stored in the array
@@ -181,100 +177,28 @@ impl<'a, T: Marshal<'a> + 'a> Marshal<'a> for ArrayRef<'a, T> {
 #[derive(Clone)]
 pub struct RootedArray<T> {
     handle: GcRootPtr,
-    runtime: Rc<RefCell<Runtime>>,
     _data: PhantomData<T>,
 }
 
 impl<T> RootedArray<T> {
     /// Creates a `RootedArray` that wraps a raw Mun struct.
-    fn new<G: GcRuntime<UnsafeTypeInfo>>(
-        gc: &Arc<G>,
-        runtime: Rc<RefCell<Runtime>>,
-        raw: RawArray,
-    ) -> Self {
-        let handle = {
-            let runtime_ref = runtime.borrow();
-            // Safety: The type returned from `ptr_type` is guaranteed to live at least as long as
-            // `Runtime` does not change. As we hold a shared reference to `Runtime`, this is safe.
-            assert!(unsafe { gc.ptr_type(raw.0).into_inner().as_ref().data.is_array() });
-
-            GcRootPtr::new(&runtime_ref.gc, raw.0)
-        };
-
+    fn new(gc: &Arc<GarbageCollector>, raw: RawArray) -> Self {
+        // Safety: The type returned from `ptr_type` is guaranteed to live at least as long as
+        // `Runtime` does not change. As we hold a shared reference to `Runtime`, this is safe.
+        assert!(unsafe { gc.ptr_type(raw.0).into_inner().as_ref().data.is_array() });
         Self {
-            handle,
-            runtime,
+            handle: GcRootPtr::new(gc, raw.0),
             _data: Default::default(),
         }
     }
 
-    /// Converts the `RootedArray` into a `ArrayRef`, using an external shared reference to a
+    /// Converts the `RootedArray` into an `ArrayRef<T>`, using an external shared reference to a
     /// `Runtime`.
-    ///
-    /// # Safety
-    ///
-    /// The `RootedArray` should have been allocated by the `Runtime`.
-    pub unsafe fn as_ref<'r>(&self, runtime: &'r Runtime) -> ArrayRef<'r, T>
+    pub fn as_ref<'r>(&self, runtime: &'r Runtime) -> ArrayRef<'r, T>
     where
-        T: Marshal<'r>,
-        T: 'r,
+        T: Marshal<'r> + 'r,
     {
+        assert_eq!(Arc::as_ptr(&runtime.gc), self.handle.runtime().as_ptr());
         ArrayRef::new(RawArray(self.handle.handle()), runtime)
     }
-
-    /// Converts the `RootedArray` to a pinned `RootedArrayRef` that can be used just like a
-    /// `ArrayRef`.
-    pub fn by_ref<'r>(&'r self) -> Pin<Box<RootedArrayRef<'r, T>>>
-    where
-        T: Marshal<'r>,
-        T: 'r,
-    {
-        RootedArrayRef::new(RawArray(self.handle.handle()), self.borrow_runtime())
-    }
-
-    /// Borrows the struct's runtime.
-    pub fn borrow_runtime(&self) -> Ref<Runtime> {
-        self.runtime.borrow()
-    }
-}
-
-/// Type-agnostic wrapper for safely obtaining a `ArrayRef` from a `RootedArray`.
-pub struct RootedArrayRef<'s, T> {
-    runtime: Ref<'s, Runtime>,
-    array_ref: MaybeUninit<ArrayRef<'s, T>>,
-    _pin: PhantomPinned,
-}
-
-impl<'s, T: Marshal<'s> + 's> RootedArrayRef<'s, T> {
-    fn new(raw: RawArray, runtime: Ref<'s, Runtime>) -> Pin<Box<Self>> {
-        let array_ref = RootedArrayRef {
-            runtime,
-            array_ref: MaybeUninit::uninit(),
-            _pin: PhantomPinned,
-        };
-        let mut boxed = Box::pin(array_ref);
-
-        let runtime = NonNull::from(&boxed.runtime);
-
-        // Safety: Modifying a field doesn't move the whole struct
-        unsafe {
-            let array_ref = ArrayRef::new(raw, &*runtime.as_ptr());
-            let mut_ref: Pin<&mut Self> = Pin::as_mut(&mut boxed);
-            Pin::get_unchecked_mut(mut_ref)
-                .array_ref
-                .as_mut_ptr()
-                .write(array_ref);
-        }
-
-        boxed
-    }
-}
-
-impl<'s, T> std::ops::Deref for RootedArrayRef<'s, T> {
-    type Target = ArrayRef<'s, T>;
-
-    fn deref(&self) -> &Self::Target {
-        // Safety: We always guarantee to set the `array_ref` upon construction.
-        unsafe { &*self.array_ref.as_ptr() }
-    }
 }

crates/mun_runtime/src/lib.rs

@@ -655,12 +655,8 @@ impl Runtime {
         // Validate the return type
         match if let Some(return_type) = function_info.prototype.signature.return_type() {
             if !ReturnType::equals_type(return_type) {
-                Err((
-                    return_type.name(),
-                    ReturnType::type_name(),
-                ))
-            }
-            else {
+                Err((return_type.name(), ReturnType::type_name()))
+            } else {
                 Ok(())
             }
         } else if <() as ReturnTypeReflection>::type_guid() != ReturnType::type_guid() {

crates/mun_runtime/tests/arrays.rs

@@ -57,16 +57,16 @@ fn arrays_as_argument() {
     )
     .expect("Failed to build test driver");
 
-    let runtime = driver.runtime();
-    let runtime_ref = runtime.borrow();
-    let result: ArrayRef<'_, i32> = invoke_fn!(runtime_ref, "generate").unwrap();
+    let result: ArrayRef<'_, i32> = driver.runtime.invoke("generate", ()).unwrap();
 
     assert_eq!(result.len(), 5);
     assert!(result.capacity() >= 5);
     assert_eq!(result.iter().collect::<Vec<_>>(), vec![5, 4, 3, 2, 1]);
 
-    let result_array: ArrayRef<'_, i32> =
-        invoke_fn!(runtime_ref, "add_one", result.clone(), result.len()).unwrap();
+    let result_array: ArrayRef<'_, i32> = driver
+        .runtime
+        .invoke("add_one", (result.clone(), result.len()))
+        .unwrap();
 
     assert_eq!(result_array.len(), 5);
     assert!(result_array.capacity() >= 5);
@@ -84,16 +84,12 @@ fn root_array() {
     .expect("Failed to build test driver");
 
     let result = {
-        let runtime = driver.runtime();
-        let runtime_ref = runtime.borrow();
-        let array: ArrayRef<i32> = invoke_fn!(runtime_ref, "main").unwrap();
-        array.root(driver.runtime())
+        let array: ArrayRef<i32> = driver.runtime.invoke("main", ()).unwrap();
+        array.root()
     };
 
-    assert_eq!(result.by_ref().len(), 5);
-    assert!(result.by_ref().capacity() >= 5);
-    assert_eq!(
-        result.by_ref().iter().collect::<Vec<_>>(),
-        vec![5, 4, 3, 2, 1]
-    );
+    let result = result.as_ref(&driver.runtime);
+    assert_eq!(result.len(), 5);
+    assert!(result.capacity() >= 5);
+    assert_eq!(result.iter().collect::<Vec<_>>(), vec![5, 4, 3, 2, 1]);
 }

crates/mun_runtime/tests/runtime.rs

@@ -30,7 +30,9 @@ fn arrays_are_collected() {
     .expect("Failed to build test driver");
 
     assert_eq!(driver.runtime.gc_collect(), false);
-    let _: () = driver.runtime.invoke("main", ())
+    let _: () = driver
+        .runtime
+        .invoke("main", ())
         .expect("error invoking main function");
     assert_eq!(driver.runtime.gc_collect(), true);
     assert_eq!(driver.runtime.gc_collect(), false);