Marshal ForeignPtr into rust references

Author: vkleen

src/Language/Rust/Inline/Context.hs

@@ -319,6 +319,8 @@ foreignPointers =
   where
     rule (Ptr _ t _) context
         | First (Just (t', Nothing)) <- lookupRTypeInContext t context = pure ([t|ForeignPtr $t'|], Nothing)
+    rule (Rptr _ _ t _) context
+        | First (Just (t', Nothing)) <- lookupRTypeInContext t context = pure ([t|ForeignPtr $t'|], Nothing)
     rule (PathTy Nothing (Path False [PathSegment "ForeignPtr" (Just (AngleBracketed [] [t] [] _)) _] _) _) context
         | First (Just (t', Nothing)) <- lookupRTypeInContext t context = pure ([t|ForeignPtr $t'|], Nothing)
     rule _ _ = mempty
@@ -334,6 +336,10 @@ foreignPointers =
             [ "impl<T> MarshalInto<*const T> for *const T {"
             , "  fn marshal(self) -> *const T { self }"
             , "}"
+            , ""
+            , "impl<'a, T> MarshalInto<&'a T> for &'a T {"
+            , "  fn marshal(self) -> &'a T { self }"
+            , "}"
             ]
 
     mutPtr =
@@ -344,6 +350,7 @@ foreignPointers =
             , "    ptr"
             , "  }"
             , "}"
+            , ""
             , "impl<T> MarshalInto<ForeignPtr<T>> for ForeignPtr<T> {"
             , "  fn marshal(self) -> Self {"
             , "    self"
@@ -363,6 +370,10 @@ foreignPointers =
             , "impl<T> MarshalInto<*mut T> for *mut T {"
             , "  fn marshal(self) -> *mut T { self }"
             , "}"
+            , ""
+            , "impl<'a, T> MarshalInto<&'a mut T> for &'a mut T {"
+            , "  fn marshal(self) -> &'a mut T { self }"
+            , "}"
             ]
 
 {- | This maps a Rust function type into the corresponding 'FunPtr' wrapped

tests/ForeignPtr.hs

@@ -24,6 +24,26 @@ foreignPtrTypes = describe "ForeignPtr types" $ do
         let read = [rust| u64 { unsafe { *$(p: *const u64) } } |]
         42 `shouldBe` read
 
+    it "Can marshal ForeignPtr arguments as references" $ do
+        p <- mallocForeignPtr
+        withForeignPtr p (`poke` 42)
+        let read =
+                [rust| u64 { *$(p: &u64) } |]
+        42 `shouldBe` read
+
+    it "Can marshal ForeignPtr arguments as mutable references" $ do
+        p <- mallocForeignPtr
+        withForeignPtr p (`poke` 42)
+        let prev =
+                [rust| u64 {
+                        let p = $(p: &mut u64);
+                        let ret = *p;
+                        *p = 43;
+                        ret
+                    } |]
+        prev `shouldBe` 42
+        withForeignPtr p peek >>= (`shouldBe` 43)
+
     it "Can mutate ForeignPtr arguments" $ do
         p <- mallocForeignPtr
         [rustIO| () {