Use *const T and *mut T more consistently

Some context in rust-lang/rfcs#68

Author: chancancode

crates/libcruby-sys/src/lib.rs

@@ -16,17 +16,18 @@ pub fn check_version() {
     }
 }
 
-pub type void_ptr = *const libc::c_void;
+pub type void = libc::c_void;
+pub type c_func = *const void;
 pub type c_string = *const libc::c_char;
 // pub type c_func = extern "C" fn(...);
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
-pub struct ID(void_ptr);
+pub struct ID(*mut void);
 
 #[repr(C)]
 #[derive(Eq, PartialEq, Copy, Clone, Debug)]
-pub struct VALUE(void_ptr);
+pub struct VALUE(*mut void);
 
 #[repr(C)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
@@ -78,7 +79,10 @@ extern "C" {
     pub fn RARRAY_LEN(array: VALUE) -> isize;
 
     #[link_name = "HELIX_RARRAY_PTR"]
-    pub fn RARRAY_PTR(array: VALUE) -> void_ptr;
+    pub fn RARRAY_PTR(array: VALUE) -> *mut VALUE;
+
+    #[link_name = "HELIX_RARRAY_CONST_PTR"]
+    pub fn RARRAY_CONST_PTR(array: VALUE) -> *const VALUE;
 
     #[link_name = "HELIX_RB_TYPE_P"]
     pub fn RB_TYPE_P(val: VALUE, rb_type: isize) -> bool;
@@ -150,22 +154,22 @@ extern "C" {
     pub fn rb_define_class(name: c_string, superclass: VALUE) -> VALUE;
     pub fn rb_define_class_under(namespace: VALUE, name: c_string, superclass: VALUE) -> VALUE;
     pub fn rb_define_alloc_func(klass: VALUE, func: extern "C" fn(klass: VALUE) -> VALUE);
-    pub fn rb_define_method(class: VALUE, name: c_string, func: void_ptr, arity: isize);
-    pub fn rb_define_singleton_method(class: VALUE, name: c_string, func: void_ptr, arity: isize);
+    pub fn rb_define_method(class: VALUE, name: c_string, func: c_func, arity: isize);
+    pub fn rb_define_singleton_method(class: VALUE, name: c_string, func: c_func, arity: isize);
     pub fn rb_inspect(value: VALUE) -> VALUE;
     pub fn rb_intern(string: c_string) -> ID;
     pub fn rb_jump_tag(state: RubyException) -> !;
-    pub fn rb_protect(try: extern "C" fn(v: void_ptr) -> VALUE,
-                      arg: void_ptr,
+    pub fn rb_protect(try: extern "C" fn(v: *mut void) -> VALUE,
+                      arg: *mut void,
                       state: *mut RubyException)
                       -> VALUE;
 
     #[link_name = "HELIX_Data_Wrap_Struct"]
-    pub fn Data_Wrap_Struct(klass: VALUE, mark: extern "C" fn(void_ptr), free: extern "C" fn(void_ptr), data: void_ptr) -> VALUE;
+    pub fn Data_Wrap_Struct(klass: VALUE, mark: extern "C" fn(*mut void), free: extern "C" fn(*mut void), data: *mut void) -> VALUE;
 
     #[link_name = "HELIX_Data_Get_Struct_Value"]
-    pub fn Data_Get_Struct_Value(obj: VALUE) -> void_ptr;
+    pub fn Data_Get_Struct_Value(obj: VALUE) -> *mut void;
 
     #[link_name = "HELIX_Data_Set_Struct_Value"]
-    pub fn Data_Set_Struct_Value(obj: VALUE, data: void_ptr);
+    pub fn Data_Set_Struct_Value(obj: VALUE, data: *mut void);
 }

ruby/ext/helix_runtime/native/helix_runtime.c

@@ -28,6 +28,10 @@ void* HELIX_RARRAY_PTR(VALUE array) {
   return RARRAY_PTR(array);
 }
 
+const void* HELIX_RARRAY_CONST_PTR(VALUE array) {
+  return RARRAY_CONST_PTR(array);
+}
+
 bool HELIX_RB_TYPE_P(VALUE v, int type) {
   return RB_TYPE_P(v, type);
 }

ruby/ext/helix_runtime/native/helix_runtime.h

@@ -49,6 +49,7 @@ HELIX_EXTERN const char* HELIX_RSTRING_PTR(VALUE string);
 
 HELIX_EXTERN long HELIX_RARRAY_LEN(VALUE array);
 HELIX_EXTERN void* HELIX_RARRAY_PTR(VALUE array);
+HELIX_EXTERN const void* HELIX_RARRAY_CONST_PTR(VALUE array);
 
 HELIX_EXTERN bool HELIX_RB_TYPE_P(VALUE v, int type);
 HELIX_EXTERN int HELIX_TYPE(VALUE v);

ruby/spec/helix_runtime_spec.rb

@@ -70,6 +70,12 @@ module TYPES
     expect(Dummy.RARRAY_PTR(arr)).to eq(Dummy::RARRAY_PTR(arr))
   end
 
+  it 'exports the RARRAY_CONST_PTR macro' do
+    arr = [1,2,3,4,5]
+    expect(Dummy.RARRAY_CONST_PTR([1,2,3,4,5])).to_not eq(Dummy::RARRAY_CONST_PTR([1,2,3,4,5]))
+    expect(Dummy.RARRAY_CONST_PTR(arr)).to eq(Dummy::RARRAY_CONST_PTR(arr))
+  end
+
   describe 'coercions' do
     it "(INT2FIX)" do
       expect(Dummy.INT2FIX(10)).to eq(10)

ruby/spec/support/dummy/ext/dummy/dummy.c

@@ -31,6 +31,14 @@ static VALUE TEST_RARRAY_PTR(VALUE _self, VALUE val) {
   return SIZET2NUM((uintptr_t)HELIX_RARRAY_PTR(val));
 }
 
+static VALUE TEST_RB_RARRAY_CONST_PTR(VALUE _self, VALUE val) {
+  return SIZET2NUM((uintptr_t)RARRAY_CONST_PTR(val));
+}
+
+static VALUE TEST_RARRAY_CONST_PTR(VALUE _self, VALUE val) {
+  return SIZET2NUM((uintptr_t)HELIX_RARRAY_CONST_PTR(val));
+}
+
 static VALUE TEST_RB_TYPE_P(VALUE _self, VALUE val, VALUE type) {
   int result = HELIX_RB_TYPE_P(val, FIX2INT(type));
   return result ? Qtrue : Qfalse;
@@ -176,6 +184,8 @@ void Init_dummy() {
   EXPORT_FUNC(RARRAY_LEN, 1);
   EXPORT_FUNC(RARRAY_PTR, 1);
   EXPORT_RUBY_FUNC(RARRAY_PTR, 1);
+  EXPORT_FUNC(RARRAY_CONST_PTR, 1);
+  EXPORT_RUBY_FUNC(RARRAY_CONST_PTR, 1);
   EXPORT_FUNC(RB_TYPE_P, 2);
   EXPORT_FUNC(TYPE, 1);
   EXPORT_FUNC(INT2FIX, 1);

src/class_definition.rs

@@ -1,15 +1,9 @@
-use libc;
-use { Class, sys };
-
-#[allow(non_camel_case_types)]
-type c_string = *const libc::c_char;
-
-#[allow(non_camel_case_types)]
-type void_ptr = *const libc::c_void;
+use { Class };
+use sys::{self, c_string, c_func};
 
 pub struct MethodSpecification {
     name: c_string,
-    function: void_ptr,
+    function: c_func,
     arity: isize,
 }
 
@@ -19,11 +13,11 @@ pub enum MethodDefinition {
 }
 
 impl MethodDefinition {
-    pub fn class(name: c_string, function: void_ptr, arity: isize) -> MethodDefinition {
+    pub fn class(name: c_string, function: c_func, arity: isize) -> MethodDefinition {
         MethodDefinition::Class(MethodSpecification { name: name, function: function, arity: arity })
     }
 
-    pub fn instance(name: c_string, function: void_ptr, arity: isize) -> MethodDefinition {
+    pub fn instance(name: c_string, function: c_func, arity: isize) -> MethodDefinition {
         MethodDefinition::Instance(MethodSpecification { name: name, function: function, arity: arity })
     }
 }

src/macros.rs

@@ -407,7 +407,7 @@ macro_rules! impl_struct_to_rust {
                     use ::std::ffi::{CStr, CString};
 
                     if unsafe { __HELIX_ID == ::std::mem::transmute(sys::rb_obj_class(self)) } {
-                        if unsafe { $crate::sys::Data_Get_Struct_Value(self) == ::std::ptr::null() } {
+                        if unsafe { $crate::sys::Data_Get_Struct_Value(self) == ::std::ptr::null_mut() } {
                             Err(CString::new(format!("Uninitialized {}", $crate::inspect(unsafe { sys::rb_obj_class(self) }))).unwrap())
                         } else {
                             Ok(unsafe { CheckedValue::new(self) })