Merge pull request #250 from tdyas/visibility_keywords

allow all visibility keywords on classes and functions

Author: markbt

README.md

@@ -112,3 +112,13 @@ rustflags = [
 ```
 
 For `setup.py` integration, see https://github.com/PyO3/setuptools-rust
+
+# Development
+
+To build the crate, run: `make build`
+
+To test the crate, run: `make test`
+
+Note: This crate has several files that are auto-generated using scripts. Using the Makefile ensures that these
+files are re-generated as needed.
+>>>>>>> 9ce2de8 (Add comment explaining how to regenerate)

python27-sys/src/lib.rs

@@ -1,5 +1,10 @@
 #![no_std]
-#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case, unused_parens)]
+#![allow(
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    unused_parens
+)]
 
 pub use crate::boolobject::*;
 pub use crate::bufferobject::*;

python3-sys/src/initconfig.rs

@@ -1,9 +1,9 @@
 // This entire module is Python 3.8+ and !Py_LIMITED_API only.
 
 use crate::pyport::Py_ssize_t;
-use libc::{c_char, c_int, c_ulong, wchar_t};
 #[cfg(Py_3_9)]
 use libc::c_void;
+use libc::{c_char, c_int, c_ulong, wchar_t};
 
 #[repr(C)]
 #[derive(Copy, Clone)]

python3-sys/src/lib.rs

@@ -1,5 +1,10 @@
 #![no_std]
-#![allow(non_camel_case_types, non_snake_case, non_upper_case_globals, unused_parens)]
+#![allow(
+    non_camel_case_types,
+    non_snake_case,
+    non_upper_case_globals,
+    unused_parens
+)]
 #![cfg_attr(Py_LIMITED_API, allow(unused_imports))]
 
 // old: marked with TODO

python3-sys/src/methodobject.rs

@@ -94,7 +94,7 @@ extern "C" {
         arg2: *mut PyObject,
         arg3: *mut PyObject,
     ) -> *mut PyObject;
-    
+
     #[cfg(Py_3_9)]
     pub fn PyCMethod_New(
         arg1: *mut PyMethodDef,

python3-sys/src/modsupport.rs

@@ -2,10 +2,10 @@ use libc::{c_char, c_int, c_long};
 
 #[cfg(Py_3_5)]
 use crate::methodobject::PyMethodDef;
-#[cfg(Py_3_9)]
-use crate::object::PyTypeObject;
 use crate::moduleobject::PyModuleDef;
 use crate::object::PyObject;
+#[cfg(Py_3_9)]
+use crate::object::PyTypeObject;
 use crate::pyport::Py_ssize_t;
 
 #[cfg_attr(windows, link(name = "pythonXY"))]

python3-sys/src/object.rs

@@ -724,9 +724,12 @@ extern "C" {
     #[cfg(Py_3_4)]
     pub fn PyType_GetSlot(arg1: *mut PyTypeObject, arg2: c_int) -> *mut c_void;
 
-
     #[cfg(Py_3_9)]
-    pub fn PyType_FromModuleAndSpec(arg1: *mut PyObject, arg2: *mut PyType_Spec, arg3: *mut PyObject) -> *mut PyObject;
+    pub fn PyType_FromModuleAndSpec(
+        arg1: *mut PyObject,
+        arg2: *mut PyType_Spec,
+        arg3: *mut PyObject,
+    ) -> *mut PyObject;
 
     #[cfg(Py_3_9)]
     pub fn PyType_GetModule(arg1: *mut PyTypeObject) -> *mut PyObject;

python3-sys/src/pystate.rs

@@ -1,8 +1,8 @@
 use libc;
 
-use crate::moduleobject::PyModuleDef;
 #[cfg(Py_3_9)]
 use crate::frameobject::PyFrameObject;
+use crate::moduleobject::PyModuleDef;
 use crate::object::PyObject;
 
 #[cfg(Py_3_6)]

src/py_class/py_class.rs

@@ -25,7 +25,9 @@ instances of that Python class from Rust.
 # Syntax
 `py_class!(pub class MyType |py| { ... })`
 
-* `pub` makes the generated Rust struct visible outside the current module. It has no effect on the visibility from Python.
+* `pub` makes the generated Rust struct visible outside the current module. It has no effect on
+the visibility from Python. You may use any Rust visibility keyword. For example, `pub(crate)`
+would also be valid.
 * `MyType` is the name of the Python class.
 * `py` is an identifier that will be made available as a variable of type `Python`
 in all function bodies.
@@ -89,6 +91,7 @@ impl MyType {
 * The generated type implements a number of traits from the `cpython` crate.
 * The inherent `create_instance` method can create new Python objects
   given the values for the data fields.
+    - Note: Any visibility keyword on the class will also be used for this method.
 * Private accessors functions are created for the data fields.
 * All functions callable from Python are also exposed as public Rust functions.
 * To convert from `MyType` to `PyObject`, use `as_object()` or `into_object()` (from the `PythonObject` trait).
@@ -139,16 +142,21 @@ impl MyType {
 
 ## Instance methods
 `def method_name(&self, parameter-list) -> PyResult<...> { ... }`
+`pub(crate) def method_name(&self, parameter-list) -> PyResult<...> { ... }`
 
 Declares an instance method callable from Python.
 
 * Because Python objects are potentially shared, the self parameter must always
   be a shared reference (`&self`).
 * For details on `parameter-list`, see the documentation of `py_argparse!()`.
 * The return type must be `PyResult<T>` for some `T` that implements `ToPyObject`.
+* Visibility of the method in Rust defaults to `pub`. You may specify a visibility keyword
+  before the `def` to change the visibility, for example, to `pub(crate)`. Changing visibility
+  in Rust does not affect visibility in Python.
 
 ## Class methods
 `@classmethod def method_name(cls, parameter-list) -> PyResult<...> { ... }`
+`@classmethod pub(crate) def method_name(cls, parameter-list) -> PyResult<...> { ... }`
 
 Declares a class method callable from Python.
 
@@ -157,14 +165,21 @@ Declares a class method callable from Python.
 * The first parameter implicitly has type `&PyType`. This type must not be explicitly specified.
 * For details on `parameter-list`, see the documentation of `py_argparse!()`.
 * The return type must be `PyResult<T>` for some `T` that implements `ToPyObject`.
+* Visibility of the method in Rust defaults to `pub`. You may specify a visibility keyword
+  before the `def` to change the visibility, for example, to `pub(crate)`. Changing visibility
+  in Rust does not affect visibility in Python.
 
 ## Static methods
 `@staticmethod def method_name(parameter-list) -> PyResult<...> { ... }`
+`@staticmethod pub(crate) def method_name(parameter-list) -> PyResult<...> { ... }`
 
 Declares a static method callable from Python.
 
 * For details on `parameter-list`, see the documentation of `py_argparse!()`.
 * The return type must be `PyResult<T>` for some `T` that implements `ToPyObject`.
+* Visibility of the method in Rust defaults to `pub`. You may specify a visibility keyword
+  before the `def` to change the visibility, for example, to `pub(crate)`. Changing visibility
+  in Rust does not affect visibility in Python.
 
 ## Properties
 `@property def property_name(&self) -> PyResult<...> { ... }`
@@ -475,14 +490,14 @@ macro_rules! py_class {
             /* props: */ { [ /* getters */ ] [ /* setters */ ] }
         }
     );
-    (pub class $class:ident |$py: ident| { $( $body:tt )* }) => (
+    ($visibility:vis class $class:ident |$py: ident| { $( $body:tt )* }) => (
         $crate::py_class_impl! {
             { $( $body )* }
             $class $py
             /* info: */ {
                 /* base_type: */ $crate::PyObject,
                 /* size: */ <$crate::PyObject as $crate::py_class::BaseObject>::size(),
-                /* class_visibility: */ {pub},
+                /* class_visibility: */ {$visibility},
                 /* gc: */ {
                     /* traverse_proc: */ None,
                     /* traverse_data: */ [ /*name*/ ]
@@ -510,11 +525,11 @@ macro_rules! py_class {
 #[macro_export]
 #[doc(hidden)]
 macro_rules! py_class_impl_item {
-    { $class:ident, $py:ident, $name:ident( $( $selfarg:tt )* )
+    { $class:ident, $py:ident, $visibility:vis, $name:ident( $( $selfarg:tt )* )
         $res_type:ty; $body:block [ $( { $pname:ident : $ptype:ty = $detail:tt } )* ]
     } => { $crate::py_coerce_item! {
         impl $class {
-            pub fn $name($( $selfarg )* $py: $crate::Python $( , $pname: $ptype )* )
+            $visibility fn $name($( $selfarg )* $py: $crate::Python $( , $pname: $ptype )* )
             -> $res_type $body
         }
     }}