Refactor for small clean up and delete deprecated functions

Author: jhg

README.md

@@ -1,6 +1,6 @@
 # Opaque Pointer for seamless Rust FFI
 
-Harnessing generics with opaque pointers for seamless Rust FFI interoperability with C and C++
+Harnessing generics with opaque pointers for seamless Rust FFI interoperability with C and C++.
 
 [![Crates.io](https://img.shields.io/crates/v/opaque-pointer)](https://crates.io/crates/opaque-pointer)
 [![Crates.io](https://img.shields.io/crates/l/opaque-pointer)](https://unlicense.org/)

src/c.rs

@@ -9,12 +9,12 @@ use std::collections::TryReserveError;
 /// Errors that can be detected by the functions of this crate.
 ///
 /// Of course, invalid address can not be detected, then it's unsafe yet.
-#[allow(clippy::module_name_repetitions)] // Like std::error::Error, it is for pointer errors
 #[derive(Debug, PartialEq, Eq)]
 pub enum PointerError {
-    #[allow(missing_docs)] // Obviously, the name is the ref doc.
+    // Obviously, the name is the ref doc.
     Null,
     /// A pointer that was not previously lent to the FFI user.
+    #[cfg(all(feature = "std", feature = "lender"))]
     Invalid,
     /// Trying to convert to `&str` a C string which content is not valid UTF-8.
     Utf8Error(Utf8Error),
@@ -26,18 +26,12 @@ pub enum PointerError {
 impl core::fmt::Display for PointerError {
     fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         match self {
-            Self::Null => {
-                write!(f, "dereference a null pointer will produce a crash")
-            }
-            Self::Invalid => {
-                write!(f, "dereference a unknown pointer could produce a crash")
-            }
-            Self::Utf8Error(error) => {
-                write!(
-                    f,
-                    "the provided C string is not a valid UTF-8 string: {error}"
-                )
-            }
+            Self::Null => write!(f, "dereference a null pointer will produce a crash"),
+            Self::Invalid => write!(f, "dereference a unknown pointer could produce a crash"),
+            Self::Utf8Error(error) => write!(
+                f,
+                "the provided C string is not a valid UTF-8 string: {error}"
+            ),
             #[cfg(any(feature = "alloc", feature = "std"))]
             Self::TryReserveError(error) => {
                 write!(f, "can not alloc memory of internal usage: {error}")

src/error.rs

@@ -1,10 +1,5 @@
 #![cfg(all(feature = "std", feature = "lender"))]
 
-//! # Lender of Rust's memory by FFI
-//!
-//! To control that pointers at least were returned by [`crate::raw`]. But
-//! it can not ensure if type is correct, yet.
-
 use lazy_static::lazy_static;
 use std::collections::HashSet;
 use std::sync::{RwLock, RwLockWriteGuard};
@@ -25,7 +20,7 @@ lazy_static! {
 pub(super) fn is_lent<T>(pointer: *const T) -> bool {
     let Ok(lent_pointers) = LENT_POINTERS.read() else {
         log::error!("RwLock poisoned, it is not possible to check pointers");
-        unreachable!("RwLock poisoned when there is not panics in code that can hold it");
+        unreachable!();
     };
     return lent_pointers.contains(&(pointer as usize));
 }
@@ -39,6 +34,7 @@ pub(super) fn is_lent<T>(pointer: *const T) -> bool {
 /// avoid panics while holding it.
 pub(super) fn lend<T>(pointer: *const T) -> Result<(), PointerError> {
     let mut lent_pointers = writable_lent_pointers();
+
     if let Err(error) = lent_pointers.try_reserve(1) {
         log::error!("Can not alloc memory to lent a pointer: {error}");
         return Err(PointerError::from(error));
@@ -61,7 +57,8 @@ pub(super) fn retrieve<T>(pointer: *const T) {
 fn writable_lent_pointers() -> RwLockWriteGuard<'static, HashSet<usize>> {
     let Ok(lent_pointers) = LENT_POINTERS.write() else {
         log::error!("RwLock poisoned, it is not possible to add or remove pointers");
-        unreachable!("RwLock poisoned when there is not panics in code that can hold it");
+        unreachable!();
     };
-    return lent_pointers;
+
+    lent_pointers
 }

src/lender.rs

@@ -1,10 +1,7 @@
 #![doc = include_str!("../README.md")] // This also allow to run examples in that file.
 #![allow(unsafe_code)]
-#![warn(missing_docs)]
-#![warn(clippy::pedantic)]
 #![deny(clippy::complexity)]
 #![deny(clippy::cognitive_complexity)]
-#![allow(clippy::needless_return)] // To avoid surprise in devs more familiar with languages where return is always explicit
 #![doc(html_no_source)]
 #![no_std]
 
@@ -18,9 +15,6 @@ extern crate std;
 #[cfg(feature = "std")]
 use std::boxed::Box;
 
-#[cfg(all(feature = "std", feature = "c-types"))]
-pub mod c;
-
 pub mod error;
 use error::PointerError;
 
@@ -40,56 +34,42 @@ mod validation;
 #[inline]
 pub fn raw<T>(data: T) -> Result<*mut T, PointerError> {
     let pointer = Box::into_raw(Box::new(data));
+
     #[cfg(all(feature = "std", feature = "lender"))]
     lender::lend(pointer)?;
-    return Ok(pointer);
+
+    Ok(pointer)
 }
 
-/// Call to [`own_back<T>()`] ignoring the result.
-///
-/// This is deprecated and will be removed in the version 0.9.0 then you can do this:
+/// Opposite of [`raw<T>()`], to use Rust's ownership as usually.
 ///
-/// ```no_run
+/// ```
 /// # let value = 0;
 /// # let pointer = opaque_pointer::raw(value).unwrap();
-/// std::mem::drop(unsafe { opaque_pointer::own_back(pointer) });
+/// drop(unsafe { opaque_pointer::own_back(pointer) });
 /// ```
 ///
-/// # Safety
-///
-/// See [`own_back<T>()`] reference doc.
-#[deprecated(
-    since = "0.7.2",
-    note = "Use own_back<T>() instead, it'll be removed at version 0.9.0"
-)]
-#[cfg(any(feature = "alloc", feature = "std"))]
-#[inline]
-pub unsafe fn free<T>(pointer: *mut T) {
-    core::mem::drop(own_back(pointer));
-}
-
-/// Opposite of [`raw<T>()`], to use Rust's ownership as usually.
-///
 /// # Errors
 ///
 /// The pointer must be not null as it is an obvious invalid pointer.
 ///
 /// # Safety
 ///
 /// Invalid pointer or call it twice could cause an undefined behavior or heap error and a crash.
-#[doc(alias = "free")]
 #[cfg(any(feature = "alloc", feature = "std"))]
 #[inline]
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 pub unsafe fn own_back<T>(pointer: *mut T) -> Result<T, PointerError> {
     validation::lent_pointer(pointer)?;
     let boxed = { Box::from_raw(pointer) };
+
     #[cfg(all(feature = "std", feature = "lender"))]
     lender::retrieve(pointer);
-    return Ok(*boxed);
+
+    Ok(*boxed)
 }
 
-/// Reference to a object but without to own it.
+/// Reference to an object but without to own it.
 ///
 /// # Errors
 ///
@@ -101,7 +81,7 @@ pub unsafe fn own_back<T>(pointer: *mut T) -> Result<T, PointerError> {
 #[inline]
 pub unsafe fn object<'a, T>(pointer: *const T) -> Result<&'a T, PointerError> {
     validation::not_null_pointer(pointer)?;
-    return Ok(&*pointer);
+    Ok(&*pointer)
 }
 
 /// Mutable reference to a object but without back to own it.
@@ -116,5 +96,5 @@ pub unsafe fn object<'a, T>(pointer: *const T) -> Result<&'a T, PointerError> {
 #[inline]
 pub unsafe fn mut_object<'a, T>(pointer: *mut T) -> Result<&'a mut T, PointerError> {
     validation::not_null_pointer(pointer)?;
-    return Ok(&mut *pointer);
+    Ok(&mut *pointer)
 }

src/lib.rs

@@ -8,16 +8,19 @@ pub fn not_null_pointer<T>(pointer: *const T) -> Result<(), PointerError> {
         log::error!("Using a NULL pointer as an opaque pointer to Rust's data");
         return Err(PointerError::Null);
     }
-    return Ok(());
+
+    Ok(())
 }
 
 #[inline]
 pub fn lent_pointer<T>(pointer: *const T) -> Result<(), PointerError> {
     not_null_pointer(pointer)?;
+
     #[cfg(all(feature = "std", feature = "lender"))]
     if !lender::is_lent(pointer) {
         log::error!("Using an invalid pointer as an opaque pointer to Rust's data");
         return Err(PointerError::Invalid);
     }
-    return Ok(());
+
+    Ok(())
 }

src/validation.rs

@@ -1,4 +1,5 @@
 use opaque_pointer;
+use opaque_pointer::error::PointerError;
 
 #[derive(Debug)]
 struct TestIt {
@@ -28,10 +29,10 @@ fn own_back() {
 #[test]
 fn own_back_invalid_pointer() {
     let pointer = Box::into_raw(Box::new(TestIt::new(2)));
-    let invalid_pointer_error = unsafe { opaque_pointer::own_back(pointer).unwrap_err() };
+    let error = unsafe { opaque_pointer::own_back(pointer).unwrap_err() };
     assert_eq!(
-        invalid_pointer_error,
-        opaque_pointer::error::PointerError::Invalid
+        error,
+        PointerError::Invalid
     );
 }
 
@@ -40,6 +41,7 @@ fn immutable_reference() {
     let pointer = opaque_pointer::raw(TestIt::new(2)).unwrap();
     let object = unsafe { opaque_pointer::object(pointer).unwrap() };
     assert_eq!(object.get(), 2);
+
     unsafe { opaque_pointer::own_back(pointer).unwrap() };
 }
 
@@ -49,5 +51,6 @@ fn mutable_reference() {
     let object = unsafe { opaque_pointer::mut_object(pointer).unwrap() };
     object.add(3);
     assert_eq!(object.get(), 5);
+
     unsafe { opaque_pointer::own_back(pointer).unwrap() };
 }