WIP

crates/glue/src/rust_glue.rs

@@ -1858,7 +1858,7 @@ fn add_function(
     writeln!(buf, "{INDENT}{INDENT}extern \"C\" {{").unwrap();
     writeln!(
         buf,
-        "{INDENT}{INDENT}{INDENT} fn {extern_name}(output: *mut {return_type_str}, {argument_types});"
+        "{INDENT}{INDENT}{INDENT} fn {extern_name}(output: *mut {return_type_str}, {argument_types}, closure_data: *mut u8);"
     )
     .unwrap();
     writeln!(buf, "{INDENT}{INDENT}}}").unwrap();
@@ -1873,7 +1873,7 @@ fn add_function(
 
     writeln!(
         buf,
-        "{INDENT}{INDENT}unsafe {{ {extern_name}(output.as_mut_ptr(), {argument_names}) }};"
+        "{INDENT}{INDENT}unsafe {{ {extern_name}(output.as_mut_ptr(), {argument_names}, self.closure_data) }};"
     )
     .unwrap();
 

crates/glue/src/types.rs

@@ -997,8 +997,8 @@ fn add_type_help<'a>(
                 _ => unreachable!(),
             };
 
-            // String::from("roc__mainForHost_1__Fx2_caller");
-            let extern_name = env.extern_names.get(&lambda_set).cloned().unwrap();
+            let extern_name = String::from("roc__mainForHost_1__Fx2_caller");
+            // let extern_name = env.extern_names.get(&lambda_set).cloned().unwrap();
 
             dbg!(&extern_name, &name);
 

examples/platform-switching/rust-platform/src/glue.rs

@@ -59,17 +59,18 @@ pub struct Op {
     pointer: *mut union_Op,
 }
 
-
 #[cfg(any(
     target_arch = "arm",
+    target_arch = "aarch64",
     target_arch = "wasm32",
-    target_arch = "x86"
+    target_arch = "x86",
+    target_arch = "x86_64"
 ))]
 #[repr(C)]
 union union_Op {
     StderrWrite: core::mem::ManuallyDrop<Op_StderrWrite>,
     StdoutWrite: core::mem::ManuallyDrop<Op_StdoutWrite>,
-    _sizer: [u8; 4],
+    _sizer: [u8; 8],
 }
 
 #[cfg(any(
@@ -85,7 +86,6 @@ union union_Op {
     target_arch = "x86_64"
 ))]
 //TODO HAS CLOSURE 2
-
 #[cfg(any(
     target_arch = "arm",
     target_arch = "aarch64",
@@ -93,20 +93,20 @@ union union_Op {
     target_arch = "x86",
     target_arch = "x86_64"
 ))]
-
 #[repr(C)]
-pub struct RocFunction_65 {
-    pub closure_data: (),
+pub struct RocFunction_65<'a> {
+    closure_data: *const u8,
+    _marker: std::marker::PhantomData<&'a ()>,
 }
 
-impl RocFunction_65 {
-    pub fn force_thunk(self, ) -> Op {
+impl<'a> RocFunction_65<'a> {
+    pub fn force_thunk(self) -> Op {
         extern "C" {
-             fn roc__getter__5(output: *mut Op, );
+            fn roc__mainForHost_1__Fx2_caller(output: *mut Op, input: *const u8);
         }
 
         let mut output = std::mem::MaybeUninit::uninit();
-        unsafe { roc__getter__5(output.as_mut_ptr(), ) };
+        unsafe { roc__mainForHost_1__Fx2_caller(output.as_mut_ptr(), self.closure_data) };
         unsafe { output.assume_init() }
     }
 }
@@ -118,35 +118,23 @@ impl RocFunction_65 {
     target_arch = "x86",
     target_arch = "x86_64"
 ))]
-
 #[repr(C)]
 pub struct RocFunction_67 {
     pub closure_data: (),
 }
 
 impl RocFunction_67 {
-    pub fn force_thunk(self, ) -> Op {
+    pub fn force_thunk(self) -> Op {
         extern "C" {
-             fn roc__getter__5(output: *mut Op, );
+            fn roc__mainForHost_1__Fx2_caller(output: *mut Op);
         }
 
         let mut output = std::mem::MaybeUninit::uninit();
-        unsafe { roc__getter__5(output.as_mut_ptr(), ) };
+        unsafe { roc__mainForHost_1__Fx2_caller(output.as_mut_ptr()) };
         unsafe { output.assume_init() }
     }
 }
 
-#[cfg(any(
-    target_arch = "aarch64",
-    target_arch = "x86_64"
-))]
-#[repr(C)]
-union union_Op {
-    StderrWrite: core::mem::ManuallyDrop<Op_StderrWrite>,
-    StdoutWrite: core::mem::ManuallyDrop<Op_StdoutWrite>,
-    _sizer: [u8; 8],
-}
-
 impl Op {
     #[cfg(any(
         target_arch = "arm",
@@ -170,28 +158,18 @@ impl Op {
         if untagged.is_null() {
             None
         } else {
-            unsafe {
-                Some(&*untagged.sub(1))
-            }
+            unsafe { Some(&*untagged.sub(1)) }
         }
     }
 
-    #[cfg(any(
-        target_arch = "arm",
-        target_arch = "wasm32",
-        target_arch = "x86"
-    ))]
+    #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))]
     /// Returns which variant this tag union holds. Note that this never includes a payload!
     pub fn discriminant(&self) -> discriminant_Op {
         // The discriminant is stored in the unused bytes at the end of the recursive pointer
         unsafe { core::mem::transmute::<u8, discriminant_Op>((self.pointer as u8) & 0b11) }
     }
 
-    #[cfg(any(
-        target_arch = "arm",
-        target_arch = "wasm32",
-        target_arch = "x86"
-    ))]
+    #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))]
     /// Internal helper
     fn tag_discriminant(pointer: *mut union_Op, discriminant: discriminant_Op) -> *mut union_Op {
         // The discriminant is stored in the unused bytes at the end of the union pointer
@@ -201,11 +179,7 @@ impl Op {
         tagged as *mut union_Op
     }
 
-    #[cfg(any(
-        target_arch = "arm",
-        target_arch = "wasm32",
-        target_arch = "x86"
-    ))]
+    #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))]
     /// Internal helper
     fn union_pointer(&self) -> *mut union_Op {
         // The discriminant is stored in the unused bytes at the end of the union pointer
@@ -290,7 +264,7 @@ impl Op {
             let ptr = roc_std::roc_alloc_refcounted::<union_Op>();
 
             *ptr = union_Op {
-                    StderrWrite: core::mem::ManuallyDrop::new(arg)
+                StderrWrite: core::mem::ManuallyDrop::new(arg),
             };
 
             Self {
@@ -299,11 +273,7 @@ impl Op {
         }
     }
 
-    #[cfg(any(
-        target_arch = "arm",
-        target_arch = "wasm32",
-        target_arch = "x86"
-    ))]
+    #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))]
     /// Unsafely assume this `Op` has a `.discriminant()` of `StderrWrite` and convert it to `StderrWrite`'s payload.
     /// (Always examine `.discriminant()` first to make sure this is the correct variant!)
     /// Panics in debug builds if the `.discriminant()` doesn't return `StderrWrite`.
@@ -327,11 +297,7 @@ impl Op {
         payload
     }
 
-    #[cfg(any(
-        target_arch = "arm",
-        target_arch = "wasm32",
-        target_arch = "x86"
-    ))]
+    #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))]
     /// Unsafely assume this `Op` has a `.discriminant()` of `StderrWrite` and return its payload.
     /// (Always examine `.discriminant()` first to make sure this is the correct variant!)
     /// Panics in debug builds if the `.discriminant()` doesn't return `StderrWrite`.
@@ -386,14 +352,16 @@ impl Op {
 
         extern "C" {
             #[link_name = "roc__getter__3"]
-            fn getter(_: *mut RocFunction_65, _: *const Op);
+            fn getter(_: *const Op) -> *const u8;
+            // fn getter(_: *mut RocFunction_65, _: *const Op);
         }
 
-        let mut ret = core::mem::MaybeUninit::uninit();
+        let ptr = getter(self);
 
-        getter(ret.as_mut_ptr(), self);
-
-        ret.assume_init()
+        RocFunction_65 {
+            closure_data: ptr,
+            _marker: Default::default(),
+        }
     }
 
     #[cfg(any(
@@ -412,7 +380,7 @@ impl Op {
             let ptr = roc_std::roc_alloc_refcounted::<union_Op>();
 
             *ptr = union_Op {
-                    StdoutWrite: core::mem::ManuallyDrop::new(arg)
+                StdoutWrite: core::mem::ManuallyDrop::new(arg),
             };
 
             Self {
@@ -421,11 +389,7 @@ impl Op {
         }
     }
 
-    #[cfg(any(
-        target_arch = "arm",
-        target_arch = "wasm32",
-        target_arch = "x86"
-    ))]
+    #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))]
     /// Unsafely assume this `Op` has a `.discriminant()` of `StdoutWrite` and convert it to `StdoutWrite`'s payload.
     /// (Always examine `.discriminant()` first to make sure this is the correct variant!)
     /// Panics in debug builds if the `.discriminant()` doesn't return `StdoutWrite`.
@@ -449,11 +413,7 @@ impl Op {
         payload
     }
 
-    #[cfg(any(
-        target_arch = "arm",
-        target_arch = "wasm32",
-        target_arch = "x86"
-    ))]
+    #[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))]
     /// Unsafely assume this `Op` has a `.discriminant()` of `StdoutWrite` and return its payload.
     /// (Always examine `.discriminant()` first to make sure this is the correct variant!)
     /// Panics in debug builds if the `.discriminant()` doesn't return `StdoutWrite`.
@@ -468,20 +428,14 @@ impl Op {
         &payload
     }
 
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "x86_64"
-    ))]
+    #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
     /// Returns which variant this tag union holds. Note that this never includes a payload!
     pub fn discriminant(&self) -> discriminant_Op {
         // The discriminant is stored in the unused bytes at the end of the recursive pointer
         unsafe { core::mem::transmute::<u8, discriminant_Op>((self.pointer as u8) & 0b111) }
     }
 
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "x86_64"
-    ))]
+    #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
     /// Internal helper
     fn tag_discriminant(pointer: *mut union_Op, discriminant: discriminant_Op) -> *mut union_Op {
         // The discriminant is stored in the unused bytes at the end of the union pointer
@@ -491,20 +445,14 @@ impl Op {
         tagged as *mut union_Op
     }
 
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "x86_64"
-    ))]
+    #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
     /// Internal helper
     fn union_pointer(&self) -> *mut union_Op {
         // The discriminant is stored in the unused bytes at the end of the union pointer
         ((self.pointer as usize) & (!0b111 as usize)) as *mut union_Op
     }
 
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "x86_64"
-    ))]
+    #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
     /// Unsafely assume this `Op` has a `.discriminant()` of `StderrWrite` and convert it to `StderrWrite`'s payload.
     /// (Always examine `.discriminant()` first to make sure this is the correct variant!)
     /// Panics in debug builds if the `.discriminant()` doesn't return `StderrWrite`.
@@ -528,10 +476,7 @@ impl Op {
         payload
     }
 
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "x86_64"
-    ))]
+    #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
     /// Unsafely assume this `Op` has a `.discriminant()` of `StderrWrite` and return its payload.
     /// (Always examine `.discriminant()` first to make sure this is the correct variant!)
     /// Panics in debug builds if the `.discriminant()` doesn't return `StderrWrite`.
@@ -546,10 +491,7 @@ impl Op {
         &payload
     }
 
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "x86_64"
-    ))]
+    #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
     /// Unsafely assume this `Op` has a `.discriminant()` of `StdoutWrite` and convert it to `StdoutWrite`'s payload.
     /// (Always examine `.discriminant()` first to make sure this is the correct variant!)
     /// Panics in debug builds if the `.discriminant()` doesn't return `StdoutWrite`.
@@ -573,10 +515,7 @@ impl Op {
         payload
     }
 
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "x86_64"
-    ))]
+    #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
     /// Unsafely assume this `Op` has a `.discriminant()` of `StdoutWrite` and return its payload.
     /// (Always examine `.discriminant()` first to make sure this is the correct variant!)
     /// Panics in debug builds if the `.discriminant()` doesn't return `StdoutWrite`.
@@ -612,15 +551,21 @@ impl Drop for Op {
                 // Drop the payload first.
                 match self.discriminant() {
                     discriminant_Op::Done => {}
-                discriminant_Op::StderrWrite => unsafe { core::mem::ManuallyDrop::drop(&mut (&mut *self.union_pointer()).StderrWrite) },
-                discriminant_Op::StdoutWrite => unsafe { core::mem::ManuallyDrop::drop(&mut (&mut *self.union_pointer()).StdoutWrite) },
+                    discriminant_Op::StderrWrite => unsafe {
+                        core::mem::ManuallyDrop::drop(&mut (&mut *self.union_pointer()).StderrWrite)
+                    },
+                    discriminant_Op::StdoutWrite => unsafe {
+                        core::mem::ManuallyDrop::drop(&mut (&mut *self.union_pointer()).StdoutWrite)
+                    },
                 }
 
-
                 // Dealloc the pointer
-                let alignment = core::mem::align_of::<Self>().max(core::mem::align_of::<roc_std::Storage>());
+                let alignment =
+                    core::mem::align_of::<Self>().max(core::mem::align_of::<roc_std::Storage>());
 
-                unsafe { crate::roc_dealloc(storage.as_ptr().cast(), alignment as u32); }
+                unsafe {
+                    crate::roc_dealloc(storage.as_ptr().cast(), alignment as u32);
+                }
             } else {
                 // Write the storage back.
                 storage.set(new_storage);
@@ -647,8 +592,12 @@ impl PartialEq for Op {
         unsafe {
             match self.discriminant() {
                 discriminant_Op::Done => true,
-                discriminant_Op::StderrWrite => (&*self.union_pointer()).StderrWrite == (&*other.union_pointer()).StderrWrite,
-                discriminant_Op::StdoutWrite => (&*self.union_pointer()).StdoutWrite == (&*other.union_pointer()).StdoutWrite,
+                discriminant_Op::StderrWrite => {
+                    (&*self.union_pointer()).StderrWrite == (&*other.union_pointer()).StderrWrite
+                }
+                discriminant_Op::StdoutWrite => {
+                    (&*self.union_pointer()).StdoutWrite == (&*other.union_pointer()).StdoutWrite
+                }
             }
         }
     }
@@ -671,8 +620,12 @@ impl PartialOrd for Op {
         unsafe {
             match self.discriminant() {
                 discriminant_Op::Done => Some(core::cmp::Ordering::Equal),
-                discriminant_Op::StderrWrite => (&*self.union_pointer()).StderrWrite.partial_cmp(&(&*other.union_pointer()).StderrWrite),
-                discriminant_Op::StdoutWrite => (&*self.union_pointer()).StdoutWrite.partial_cmp(&(&*other.union_pointer()).StdoutWrite),
+                discriminant_Op::StderrWrite => (&*self.union_pointer())
+                    .StderrWrite
+                    .partial_cmp(&(&*other.union_pointer()).StderrWrite),
+                discriminant_Op::StdoutWrite => (&*self.union_pointer())
+                    .StdoutWrite
+                    .partial_cmp(&(&*other.union_pointer()).StdoutWrite),
             }
         }
     }
@@ -695,8 +648,12 @@ impl Ord for Op {
         unsafe {
             match self.discriminant() {
                 discriminant_Op::Done => core::cmp::Ordering::Equal,
-                discriminant_Op::StderrWrite => (&*self.union_pointer()).StderrWrite.cmp(&(&*other.union_pointer()).StderrWrite),
-                discriminant_Op::StdoutWrite => (&*self.union_pointer()).StdoutWrite.cmp(&(&*other.union_pointer()).StdoutWrite),
+                discriminant_Op::StderrWrite => (&*self.union_pointer())
+                    .StderrWrite
+                    .cmp(&(&*other.union_pointer()).StderrWrite),
+                discriminant_Op::StdoutWrite => (&*self.union_pointer())
+                    .StdoutWrite
+                    .cmp(&(&*other.union_pointer()).StdoutWrite),
             }
         }
     }
@@ -720,7 +677,7 @@ impl Clone for Op {
         }
 
         Self {
-            pointer: self.pointer
+            pointer: self.pointer,
         }
     }
 }
@@ -733,7 +690,8 @@ impl core::hash::Hash for Op {
         target_arch = "x86",
         target_arch = "x86_64"
     ))]
-    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {        match self.discriminant() {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        match self.discriminant() {
             discriminant_Op::Done => discriminant_Op::Done.hash(state),
             discriminant_Op::StderrWrite => unsafe {
                 discriminant_Op::StderrWrite.hash(state);
@@ -761,10 +719,12 @@ impl core::fmt::Debug for Op {
         unsafe {
             match self.discriminant() {
                 discriminant_Op::Done => f.write_str("Done"),
-                discriminant_Op::StderrWrite => f.debug_tuple("StderrWrite")
+                discriminant_Op::StderrWrite => f
+                    .debug_tuple("StderrWrite")
                     // TODO HAS CLOSURE
                     .finish(),
-                discriminant_Op::StdoutWrite => f.debug_tuple("StdoutWrite")
+                discriminant_Op::StdoutWrite => f
+                    .debug_tuple("StdoutWrite")
                     // TODO HAS CLOSURE
                     .finish(),
             }