Use unsafe Binary constructor and add comments

Author: filmor

rustler/src/resource.rs

@@ -144,13 +144,22 @@ where
         }
     }
 
+    /// Make a resource binary associated with the given resource
+    ///
+    /// The closure `f` is called with the referenced object and must return a slice with the same
+    /// lifetime as the object. This means that the slice either has to be derived directly from
+    /// the instance or that it has to have static lifetime.
     pub fn make_binary<'env, 'a, F>(&self, env: Env<'env>, f: F) -> Binary<'env>
     where
         F: FnOnce(&'a T) -> &'a [u8],
     {
         unsafe { self.make_binary_unsafe(env, f) }
     }
 
+    /// Make a resource binary without strict lifetime checking
+    ///
+    /// The user *must* ensure that the lifetime of the returned slice is at least as long as the
+    /// lifetime of the referenced instance.
     pub unsafe fn make_binary_unsafe<'env, 'a, 'b, F>(&self, env: Env<'env>, f: F) -> Binary<'env>
     where
         F: FnOnce(&'a T) -> &'b [u8],
@@ -164,7 +173,7 @@ where
         );
 
         let term = Term::new(env, binary);
-        Binary::from_term(term).unwrap()
+        Binary::from_term_and_slice(term, bin)
     }
 
     fn from_term(term: Term) -> Result<Self, Error> {

rustler/src/types/binary.rs

@@ -86,7 +86,6 @@
 //! [`OwnedBinary`]: struct.OwnedBinary.html
 
 use crate::{
-    wrapper::NIF_TERM,
     wrapper::binary::{alloc, new_binary, realloc, ErlNifBinary},
     Decoder, Encoder, Env, Error, NifResult, Term,
 };
@@ -237,7 +236,7 @@ unsafe impl Send for OwnedBinary {}
 /// See [module-level doc](index.html) for more information.
 #[derive(Copy, Clone)]
 pub struct Binary<'a> {
-    buf: *mut u8,
+    buf: *const u8,
     size: usize,
     term: Term<'a>,
 }
@@ -300,6 +299,17 @@ impl<'a> Binary<'a> {
         })
     }
 
+    /// Creates a Binary from a `term` and the associated slice
+    ///
+    /// The `term` *must* be constructed from the given slice, it is not checked.
+    pub(crate) unsafe fn from_term_and_slice(term: Term<'a>, binary: &[u8]) -> Self {
+        Binary {
+            term,
+            buf: binary.as_ptr(),
+            size: binary.len(),
+        }
+    }
+
     /// Creates a `Binary` from `term`.
     ///
     /// # Errors