Doc: Use C-string literals where possible (#5549)

Missed from previous MR

Author: Tpt

README.md

@@ -146,15 +146,14 @@ Example program displaying the value of `sys.version` and the current user name:
 ```rust
 use pyo3::prelude::*;
 use pyo3::types::IntoPyDict;
-use pyo3::ffi::c_str;
 
 fn main() -> PyResult<()> {
     Python::attach(|py| {
         let sys = py.import("sys")?;
         let version: String = sys.getattr("version")?.extract()?;
 
         let locals = [("os", py.import("os")?)].into_py_dict(py)?;
-        let code = c_str!("os.getenv('USER') or os.getenv('USERNAME') or 'Unknown'");
+        let code = c"os.getenv('USER') or os.getenv('USERNAME') or 'Unknown'";
         let user: String = py.eval(code, None, Some(&locals))?.extract()?;
 
         println!("Hello {}, I'm Python {}", user, version);

guide/src/class.md

@@ -1426,8 +1426,8 @@ impl pyo3::impl_::pyclass::PyClassImpl for MyClass {
     type WeakRef = pyo3::impl_::pyclass::PyClassDummySlot;
     type BaseNativeType = pyo3::PyAny;
 
-    const RAW_DOC: &'static std::ffi::CStr = pyo3::ffi::c_str!("...");
-    const DOC: &'static std::ffi::CStr = pyo3::ffi::c_str!("...");
+    const RAW_DOC: &'static std::ffi::CStr = c"...";
+    const DOC: &'static std::ffi::CStr = c"...";
 
     fn items_iter() -> pyo3::impl_::pyclass::PyClassItemsIter {
         use pyo3::impl_::pyclass::*;

guide/src/class/numeric.md

@@ -335,7 +335,7 @@ mod my_module {
     #[pymodule_export]
     use super::Number;
 }
-# const SCRIPT: &'static std::ffi::CStr = pyo3::ffi::c_str!(r#"
+# const SCRIPT: &'static std::ffi::CStr = cr#"
 # def hash_djb2(s: str):
 #     n = Number(0)
 #     five = Number(5)
@@ -384,7 +384,7 @@ mod my_module {
 #     pass
 # assert Number(1337).__str__() == '1337'
 # assert Number(1337).__repr__() == 'Number(1337)'
-"#);
+"#;
 
 #
 # use pyo3::PyTypeInfo;

guide/src/conversions/traits.md

@@ -46,7 +46,6 @@ the Python object, i.e. `obj.getattr("my_string")`, and call `extract()` on the
 
 ```rust
 use pyo3::prelude::*;
-use pyo3_ffi::c_str;
 
 #[derive(FromPyObject)]
 struct RustyStruct {
@@ -57,11 +56,11 @@ struct RustyStruct {
 #     Python::attach(|py| -> PyResult<()> {
 #         let module = PyModule::from_code(
 #             py,
-#             c_str!("class Foo:
+#             c"class Foo:
 #             def __init__(self):
-#                 self.my_string = 'test'"),
-#             c_str!("<string>"),
-#             c_str!(""),
+#                 self.my_string = 'test'",
+#             c"<string>",
+#             c"",
 #         )?;
 #
 #         let class = module.getattr("Foo")?;
@@ -101,7 +100,6 @@ The argument passed to `getattr` and `get_item` can also be configured:
 
 ```rust
 use pyo3::prelude::*;
-use pyo3_ffi::c_str;
 
 #[derive(FromPyObject)]
 struct RustyStruct {
@@ -115,12 +113,12 @@ struct RustyStruct {
 #     Python::attach(|py| -> PyResult<()> {
 #         let module = PyModule::from_code(
 #             py,
-#             c_str!("class Foo(dict):
+#             c"class Foo(dict):
 #             def __init__(self):
 #                 self.name = 'test'
-#                 self['key'] = 'test2'"),
-#             c_str!("<string>"),
-#             c_str!(""),
+#                 self['key'] = 'test2'",
+#             c"<string>",
+#             c"",
 #         )?;
 #
 #         let class = module.getattr("Foo")?;
@@ -157,7 +155,7 @@ struct RustyStruct {
 #
 # fn main() -> PyResult<()> {
 #     Python::attach(|py| -> PyResult<()> {
-#         let py_dict = py.eval(pyo3::ffi::c_str!("{'foo': 'foo', 'bar': 'bar', 'foobar': 'foobar'}"), None, None)?;
+#         let py_dict = py.eval(c"{'foo': 'foo', 'bar': 'bar', 'foobar': 'foobar'}", None, None)?;
 #         let rustystruct: RustyStruct = py_dict.extract()?;
 # 		  assert_eq!(rustystruct.foo, "foo");
 #         assert_eq!(rustystruct.bar, "bar");
@@ -265,7 +263,6 @@ attribute can be applied to single-field-variants.
 
 ```rust
 use pyo3::prelude::*;
-use pyo3_ffi::c_str;
 
 #[derive(FromPyObject)]
 # #[derive(Debug)]
@@ -345,13 +342,13 @@ enum RustyEnum<'py> {
 #         {
 #             let module = PyModule::from_code(
 #                 py,
-#                 c_str!("class Foo(dict):
+#                 c"class Foo(dict):
 #             def __init__(self):
 #                 self.x = 0
 #                 self.y = 1
-#                 self.z = 2"),
-#                 c_str!("<string>"),
-#                 c_str!(""),
+#                 self.z = 2",
+#                 c"<string>",
+#                 c"",
 #             )?;
 #
 #             let class = module.getattr("Foo")?;
@@ -370,12 +367,12 @@ enum RustyEnum<'py> {
 #         {
 #             let module = PyModule::from_code(
 #                 py,
-#                 c_str!("class Foo(dict):
+#                 c"class Foo(dict):
 #             def __init__(self):
 #                 self.x = 3
-#                 self.y = 4"),
-#                 c_str!("<string>"),
-#                 c_str!(""),
+#                 self.y = 4",
+#                 c"<string>",
+#                 c"",
 #             )?;
 #
 #             let class = module.getattr("Foo")?;

guide/src/module.md

@@ -101,11 +101,10 @@ fn func() -> String {
 #   Python::attach(|py| {
 #       use pyo3::wrap_pymodule;
 #       use pyo3::types::IntoPyDict;
-#       use pyo3::ffi::c_str;
 #       let parent_module = wrap_pymodule!(parent_module)(py);
 #       let ctx = [("parent_module", parent_module)].into_py_dict(py).unwrap();
 #
-#      py.run(c_str!("assert parent_module.child_module.func() == 'func'"), None, Some(&ctx)).unwrap();
+#      py.run(c"assert parent_module.child_module.func() == 'func'", None, Some(&ctx)).unwrap();
 #   })
 }
 ```

guide/src/python-from-rust/calling-existing-code.md

@@ -33,12 +33,11 @@ and return the evaluated value as a `Bound<'py, PyAny>` object.
 
 ```rust
 use pyo3::prelude::*;
-use pyo3::ffi::c_str;
 
 # fn main() -> Result<(), ()> {
 Python::attach(|py| {
     let result = py
-        .eval(c_str!("[i * 10 for i in range(5)]"), None, None)
+        .eval(c"[i * 10 for i in range(5)]", None, None)
         .map_err(|e| {
             e.print_and_set_sys_last_vars(py);
         })?;
@@ -108,22 +107,21 @@ to this function!
 
 ```rust
 use pyo3::{prelude::*, types::IntoPyDict};
-use pyo3_ffi::c_str;
 
 # fn main() -> PyResult<()> {
 Python::attach(|py| {
     let activators = PyModule::from_code(
         py,
-        c_str!(r#"
+        cr#"
 def relu(x):
     """see https://en.wikipedia.org/wiki/Rectifier_(neural_networks)"""
     return max(0.0, x)
 
 def leaky_relu(x, slope=0.01):
     return x if x >= 0 else x * slope
-    "#),
-        c_str!("activators.py"),
-        c_str!("activators"),
+    "#,
+        c"activators.py",
+        c"activators",
     )?;
 
     let relu_result: f64 = activators.getattr("relu")?.call1((-1.0,))?.extract()?;
@@ -155,7 +153,6 @@ As an example, the below adds the module `foo` to the embedded interpreter:
 
 ```rust
 use pyo3::prelude::*;
-use pyo3::ffi::c_str;
 
 #[pymodule]
 mod foo {
@@ -169,7 +166,7 @@ mod foo {
 
 fn main() -> PyResult<()> {
     pyo3::append_to_inittab!(foo);
-    Python::attach(|py| Python::run(py, c_str!("import foo; foo.add_one(6)"), None, None))
+    Python::attach(|py| Python::run(py, c"import foo; foo.add_one(6)", None, None))
 }
 ```
 
@@ -180,7 +177,6 @@ and insert it manually into `sys.modules`:
 ```rust
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
-use pyo3::ffi::c_str;
 
 #[pyfunction]
 pub fn add_one(x: i64) -> i64 {
@@ -201,7 +197,7 @@ fn main() -> PyResult<()> {
         py_modules.set_item("foo", foo_module)?;
 
         // Now we can import + run our python code
-        Python::run(py, c_str!("import foo; foo.add_one(6)"), None, None)
+        Python::run(py, c"import foo; foo.add_one(6)", None, None)
     })
 }
 ```
@@ -267,8 +263,8 @@ fn main() -> PyResult<()> {
     )));
     let py_app = c_str!(include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/python_app/app.py")));
     let from_python = Python::attach(|py| -> PyResult<Py<PyAny>> {
-        PyModule::from_code(py, py_foo, c_str!("foo.py"), c_str!("utils.foo"))?;
-        let app: Py<PyAny> = PyModule::from_code(py, py_app, c_str!("app.py"), c_str!(""))?
+        PyModule::from_code(py, py_foo, c"foo.py", c"utils.foo")?;
+        let app: Py<PyAny> = PyModule::from_code(py, py_app, c"app.py", c"")?
             .getattr("run")?
             .into();
         app.call0(py)
@@ -295,7 +291,6 @@ that directory is `/usr/share/python_app`).
 ```rust,no_run
 use pyo3::prelude::*;
 use pyo3::types::PyList;
-use pyo3_ffi::c_str;
 use std::fs;
 use std::path::Path;
 use std::ffi::CString;
@@ -309,7 +304,7 @@ fn main() -> PyResult<()> {
             .getattr("path")?
             .cast_into::<PyList>()?;
         syspath.insert(0, path)?;
-        let app: Py<PyAny> = PyModule::from_code(py, py_app.as_c_str(), c_str!("app.py"), c_str!(""))?
+        let app: Py<PyAny> = PyModule::from_code(py, py_app.as_c_str(), c"app.py", c"")?
             .getattr("run")?
             .into();
         app.call0(py)
@@ -326,13 +321,12 @@ Use context managers by directly invoking `__enter__` and `__exit__`.
 
 ```rust
 use pyo3::prelude::*;
-use pyo3::ffi::c_str;
 
 fn main() {
     Python::attach(|py| {
         let custom_manager = PyModule::from_code(
             py,
-            c_str!(r#"
+            cr#"
 class House(object):
     def __init__(self, address):
         self.address = address
@@ -344,9 +338,9 @@ class House(object):
         else:
             print(f"Thank you for visiting {self.address}, come again soon!")
 
-        "#),
-            c_str!("house.py"),
-            c_str!("house"),
+        "#,
+            c"house.py",
+            c"house",
         )
         .unwrap();
 
@@ -355,7 +349,7 @@ class House(object):
 
         house.call_method0("__enter__").unwrap();
 
-        let result = py.eval(c_str!("undefined_variable + 1"), None, None);
+        let result = py.eval(c"undefined_variable + 1", None, None);
 
         // If the eval threw an exception we'll pass it through to the context manager.
         // Otherwise, __exit__  is called with empty arguments (Python "None").

guide/src/python-from-rust/function-calls.md

@@ -19,7 +19,6 @@ The example below calls a Python function behind a `Py<PyAny>` reference:
 ```rust
 use pyo3::prelude::*;
 use pyo3::types::PyTuple;
-use pyo3_ffi::c_str;
 
 fn main() -> PyResult<()> {
     let arg1 = "arg1";
@@ -29,15 +28,15 @@ fn main() -> PyResult<()> {
     Python::attach(|py| {
         let fun: Py<PyAny> = PyModule::from_code(
             py,
-            c_str!("def example(*args, **kwargs):
+            c"def example(*args, **kwargs):
                 if args != ():
                     print('called with args', args)
                 if kwargs != {}:
                     print('called with kwargs', kwargs)
                 if args == () and kwargs == {}:
-                    print('called with no arguments')"),
-            c_str!("example.py"),
-            c_str!(""),
+                    print('called with no arguments')",
+            c"example.py",
+            c"",
         )?
         .getattr("example")?
         .into();
@@ -65,7 +64,6 @@ For the `call` and `call_method` APIs, `kwargs` are `Option<&Bound<'py, PyDict>>
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, IntoPyDict};
 use std::collections::HashMap;
-use pyo3::ffi::c_str;
 
 fn main() -> PyResult<()> {
     let key1 = "key1";
@@ -76,15 +74,15 @@ fn main() -> PyResult<()> {
     Python::attach(|py| {
         let fun: Py<PyAny> = PyModule::from_code(
             py,
-            c_str!("def example(*args, **kwargs):
+            c"def example(*args, **kwargs):
                 if args != ():
                     print('called with args', args)
                 if kwargs != {}:
                     print('called with kwargs', kwargs)
                 if args == () and kwargs == {}:
-                    print('called with no arguments')"),
-            c_str!("example.py"),
-            c_str!(""),
+                    print('called with no arguments')",
+            c"example.py",
+            c"",
         )?
         .getattr("example")?
         .into();

pyo3-ffi/README.md

@@ -73,8 +73,8 @@ use pyo3_ffi::*;
 
 static mut MODULE_DEF: PyModuleDef = PyModuleDef {
     m_base: PyModuleDef_HEAD_INIT,
-    m_name: c_str!("string_sum").as_ptr(),
-    m_doc: c_str!("A Python module written in Rust.").as_ptr(),
+    m_name: c"string_sum".as_ptr(),
+    m_doc: c"A Python module written in Rust.".as_ptr(),
     m_size: 0,
     m_methods: std::ptr::addr_of_mut!(METHODS).cast(),
     m_slots: unsafe { SLOTS as *const [PyModuleDef_Slot] as *mut PyModuleDef_Slot },
@@ -85,12 +85,12 @@ static mut MODULE_DEF: PyModuleDef = PyModuleDef {
 
 static mut METHODS: [PyMethodDef; 2] = [
     PyMethodDef {
-        ml_name: c_str!("sum_as_string").as_ptr(),
+        ml_name: c"sum_as_string".as_ptr(),
         ml_meth: PyMethodDefPointer {
             PyCFunctionFast: sum_as_string,
         },
         ml_flags: METH_FASTCALL,
-        ml_doc: c_str!("returns the sum of two integers as a string").as_ptr(),
+        ml_doc: c"returns the sum of two integers as a string".as_ptr(),
     },
     // A zeroed PyMethodDef to mark the end of the array.
     PyMethodDef::zeroed(),
@@ -178,7 +178,7 @@ pub unsafe extern "C" fn sum_as_string(
     if nargs != 2 {
         PyErr_SetString(
             PyExc_TypeError,
-            c_str!("sum_as_string expected 2 positional arguments").as_ptr(),
+            c"sum_as_string expected 2 positional arguments".as_ptr(),
         );
         return std::ptr::null_mut();
     }
@@ -202,7 +202,7 @@ pub unsafe extern "C" fn sum_as_string(
         None => {
             PyErr_SetString(
                 PyExc_OverflowError,
-                c_str!("arguments too large to add").as_ptr(),
+                c"arguments too large to add".as_ptr(),
             );
             std::ptr::null_mut()
         }