rust: automatically provide use kernel::prelude::* for doctests

Many tests use bits from the prelude one way or another (e.g. `Result`), thus it seems simpler to provide it by default. Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
pfpacket · May 5, 2022 · d5e044e · d5e044e
1 parent 58aca84
commit d5e044e
Show file tree

Hide file tree

Showing 21 changed files with 3 additions and 56 deletions.
diff --git a/rust/kernel/amba.rs b/rust/kernel/amba.rs
@@ -204,7 +204,6 @@ unsafe impl device::RawDevice for Device {
 /// # Examples
 ///
 /// ```ignore
-/// # use kernel::prelude::*;
 /// # use kernel::{amba, define_amba_id_table, module_amba_driver};
 /// #
 /// struct MyDriver;
@@ -237,7 +236,6 @@ macro_rules! module_amba_driver {
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// # use kernel::{amba, define_amba_id_table};
 /// #
 /// # struct Sample;

diff --git a/rust/kernel/build_assert.rs b/rust/kernel/build_assert.rs
@@ -44,7 +44,6 @@ macro_rules! build_error {
 /// possible, so [`static_assert!`] should be used whenever possible.
 // TODO: Could be `compile_fail` when supported.
 /// ```ignore
-/// # use kernel::prelude::*;
 /// fn foo() {
 ///     static_assert!(1 > 1); // Compile-time error
 ///     build_assert!(1 > 1); // Build-time error
@@ -55,7 +54,6 @@ macro_rules! build_error {
 /// When the condition refers to generic parameters or parameters of an inline function,
 /// [`static_assert!`] cannot be used. Use `build_assert!` in this scenario.
 /// ```
-/// # use kernel::prelude::*;
 /// fn foo<const N: usize>() {
 ///     // `static_assert!(N > 1);` is not allowed
 ///     build_assert!(N > 1); // Build-time check

diff --git a/rust/kernel/device.rs b/rust/kernel/device.rs
@@ -359,7 +359,6 @@ macro_rules! dev_printk {
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// # use kernel::device::Device;
 ///
 /// fn example(dev: &Device) {
@@ -385,7 +384,6 @@ macro_rules! dev_emerg {
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// # use kernel::device::Device;
 ///
 /// fn example(dev: &Device) {
@@ -411,7 +409,6 @@ macro_rules! dev_alert {
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// # use kernel::device::Device;
 ///
 /// fn example(dev: &Device) {
@@ -437,7 +434,6 @@ macro_rules! dev_crit {
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// # use kernel::device::Device;
 ///
 /// fn example(dev: &Device) {
@@ -463,7 +459,6 @@ macro_rules! dev_err {
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// # use kernel::device::Device;
 ///
 /// fn example(dev: &Device) {
@@ -489,7 +484,6 @@ macro_rules! dev_warn {
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// # use kernel::device::Device;
 ///
 /// fn example(dev: &Device) {
@@ -515,7 +509,6 @@ macro_rules! dev_notice {
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// # use kernel::device::Device;
 ///
 /// fn example(dev: &Device) {
@@ -541,7 +534,6 @@ macro_rules! dev_info {
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// # use kernel::device::Device;
 ///
 /// fn example(dev: &Device) {

diff --git a/rust/kernel/error.rs b/rust/kernel/error.rs
@@ -514,7 +514,6 @@ pub(crate) use from_kernel_result;
 /// # Examples
 ///
 /// ```ignore
-/// # use kernel::prelude::*;
 /// # use kernel::from_kernel_err_ptr;
 /// # use kernel::c_types;
 /// # use kernel::bindings;

diff --git a/rust/kernel/io_mem.rs b/rust/kernel/io_mem.rs
@@ -191,7 +191,6 @@ impl<const SIZE: usize> IoMem<SIZE> {
     ///
     /// # Examples
     /// ```
-    /// # use kernel::prelude::*;
     /// use kernel::io_mem::{self, IoMem, Resource};
     ///
     /// fn test(res: Resource) -> Result {

diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
@@ -227,7 +227,6 @@ macro_rules! offset_of {
 /// # Example
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// # use kernel::container_of;
 /// struct Test {
 ///     a: u64,

diff --git a/rust/kernel/net/filter.rs b/rust/kernel/net/filter.rs
@@ -82,7 +82,6 @@ pub enum Family {
 /// all packets after printing their lengths) on the specified device (in the `init` ns).
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// use kernel::net::{self, filter as netfilter};
 ///
 /// struct MyFilter;

diff --git a/rust/kernel/platform.rs b/rust/kernel/platform.rs
@@ -195,7 +195,6 @@ unsafe impl device::RawDevice for Device {
 /// # Examples
 ///
 /// ```ignore
-/// # use kernel::prelude::*;
 /// # use kernel::{platform, define_of_id_table, module_platform_driver};
 /// #
 /// struct MyDriver;

diff --git a/rust/kernel/print.rs b/rust/kernel/print.rs
@@ -196,7 +196,6 @@ macro_rules! print_macro (
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// pr_emerg!("hello {}\n", "there");
 /// ```
 #[macro_export]
@@ -221,7 +220,6 @@ macro_rules! pr_emerg (
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// pr_alert!("hello {}\n", "there");
 /// ```
 #[macro_export]
@@ -246,7 +244,6 @@ macro_rules! pr_alert (
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// pr_crit!("hello {}\n", "there");
 /// ```
 #[macro_export]
@@ -271,7 +268,6 @@ macro_rules! pr_crit (
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// pr_err!("hello {}\n", "there");
 /// ```
 #[macro_export]
@@ -296,7 +292,6 @@ macro_rules! pr_err (
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// pr_warn!("hello {}\n", "there");
 /// ```
 #[macro_export]
@@ -321,7 +316,6 @@ macro_rules! pr_warn (
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// pr_notice!("hello {}\n", "there");
 /// ```
 #[macro_export]
@@ -346,7 +340,6 @@ macro_rules! pr_notice (
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// pr_info!("hello {}\n", "there");
 /// ```
 #[macro_export]
@@ -373,7 +366,6 @@ macro_rules! pr_info (
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// pr_debug!("hello {}\n", "there");
 /// ```
 #[macro_export]
@@ -401,7 +393,6 @@ macro_rules! pr_debug (
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// # use kernel::pr_cont;
 /// pr_info!("hello");
 /// pr_cont!(" {}\n", "there");

diff --git a/rust/kernel/rbtree.rs b/rust/kernel/rbtree.rs
@@ -37,7 +37,6 @@ struct Node<K, V> {
 /// the system is out of memory.
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// use kernel::rbtree::RBTree;
 ///
 /// # fn test() -> Result {
@@ -122,7 +121,6 @@ struct Node<K, V> {
 /// holding a spinlock.
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// use kernel::{rbtree::RBTree, sync::SpinLock};
 ///
 /// fn insert_test(tree: &SpinLock<RBTree<u32, u32>>) -> Result {
@@ -140,7 +138,6 @@ struct Node<K, V> {
 /// In the example below, we reuse an existing node allocation from an element we removed.
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// use kernel::rbtree::RBTree;
 ///
 /// # fn test() -> Result {

diff --git a/rust/kernel/static_assert.rs b/rust/kernel/static_assert.rs
@@ -15,7 +15,6 @@
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// static_assert!(42 > 24);
 /// static_assert!(core::mem::size_of::<u8>() == 1);
 ///

diff --git a/rust/kernel/std_vendor.rs b/rust/kernel/std_vendor.rs
@@ -12,7 +12,6 @@
 /// An example:
 ///
 /// ```rust
-/// # use kernel::prelude::*;
 /// let a = 2;
 /// # #[allow(clippy::dbg_macro)]
 /// let b = dbg!(a * 2) + 1;
@@ -49,7 +48,6 @@
 /// With a method call:
 ///
 /// ```rust
-/// # use kernel::prelude::*;
 /// # #[allow(clippy::dbg_macro)]
 /// fn foo(n: usize) {
 ///     if dbg!(n.checked_sub(4)).is_some() {
@@ -69,7 +67,6 @@
 /// Naive factorial implementation:
 ///
 /// ```rust
-/// # use kernel::prelude::*;
 /// # #[allow(clippy::dbg_macro)]
 /// # {
 /// fn factorial(n: u32) -> u32 {
@@ -102,7 +99,6 @@
 ///
 // TODO: Could be `compile_fail` when supported.
 /// ```ignore
-/// # use kernel::prelude::*;
 /// /// A wrapper around `usize` which importantly is not Copyable.
 /// #[derive(Debug)]
 /// struct NoCopy(usize);
@@ -119,7 +115,6 @@
 /// a tuple (and return it, too):
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// # #[allow(clippy::dbg_macro)]
 /// assert_eq!(dbg!(1usize, 2u32), (1, 2));
 /// ```
@@ -129,7 +124,6 @@
 /// invocations. You can use a 1-tuple directly if you need one:
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// # #[allow(clippy::dbg_macro)]
 /// # {
 /// assert_eq!(1, dbg!(1u32,)); // trailing comma ignored

diff --git a/rust/kernel/str.rs b/rust/kernel/str.rs
@@ -214,7 +214,6 @@ impl fmt::Display for CStr {
     /// Formats printable ASCII characters, escaping the rest.
     ///
     /// ```
-    /// # use kernel::prelude::*;
     /// # use kernel::c_str;
     /// # use kernel::str::CStr;
     /// # use kernel::str::CString;
@@ -243,7 +242,6 @@ impl fmt::Debug for CStr {
     /// Formats printable ASCII characters with a double quote on either end, escaping the rest.
     ///
     /// ```
-    /// # use kernel::prelude::*;
     /// # use kernel::c_str;
     /// # use kernel::str::CStr;
     /// # use kernel::str::CString;
@@ -530,7 +528,6 @@ impl fmt::Write for Formatter {
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// use kernel::str::CString;
 ///
 /// let s = CString::try_from_fmt(fmt!("{}{}{}", "abc", 10, 20)).unwrap();

diff --git a/rust/kernel/sync.rs b/rust/kernel/sync.rs
@@ -8,7 +8,6 @@
 //! # Example
 //!
 //! ```
-//! # use kernel::prelude::*;
 //! # use kernel::mutex_init;
 //! # use kernel::sync::Mutex;
 //! # use alloc::boxed::Box;

diff --git a/rust/kernel/sync/arc.rs b/rust/kernel/sync/arc.rs
@@ -391,7 +391,6 @@ impl<T: ?Sized> Deref for RefBorrow<'_, T> {
 /// cannot fail.
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// use kernel::sync::{Ref, UniqueRef};
 ///
 /// struct Example {
@@ -415,7 +414,6 @@ impl<T: ?Sized> Deref for RefBorrow<'_, T> {
 /// in one context (e.g., sleepable) and initialisation in another (e.g., atomic):
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// use kernel::sync::{Ref, UniqueRef};
 ///
 /// struct Example {
@@ -436,7 +434,6 @@ impl<T: ?Sized> Deref for RefBorrow<'_, T> {
 /// initialisation, for example, when initialising fields that are wrapped in locks.
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// use kernel::sync::{Ref, UniqueRef};
 ///
 /// struct Example {

diff --git a/rust/kernel/sync/locked_by.rs b/rust/kernel/sync/locked_by.rs
@@ -24,7 +24,6 @@ use core::{cell::UnsafeCell, ops::Deref, ptr};
 /// locked; we enforce at run time that the right `InnerDirectory` is locked.
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// use kernel::sync::{LockedBy, Mutex};
 ///
 /// struct InnerFile {

diff --git a/rust/kernel/sync/seqlock.rs b/rust/kernel/sync/seqlock.rs
@@ -18,7 +18,6 @@ use core::{cell::UnsafeCell, marker::PhantomPinned, ops::Deref, pin::Pin};
 /// # Examples
 ///
 ///```
-/// # use kernel::prelude::*;
 /// use kernel::sync::{SeqLock, SpinLock};
 /// use core::sync::atomic::{AtomicU32, Ordering};
 ///

diff --git a/rust/kernel/sync/spinlock.rs b/rust/kernel/sync/spinlock.rs
@@ -38,7 +38,6 @@ macro_rules! spinlock_init {
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// # use kernel::sync::SpinLock;
 /// # use core::pin::Pin;
 ///
@@ -212,7 +211,6 @@ macro_rules! rawspinlock_init {
 /// # Examples
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// # use kernel::sync::RawSpinLock;
 /// # use core::pin::Pin;
 ///

diff --git a/rust/kernel/task.rs b/rust/kernel/task.rs
@@ -19,7 +19,6 @@ use core::{marker::PhantomData, mem::ManuallyDrop, ops::Deref};
 /// when compared to the C version:
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// use kernel::task::Task;
 ///
 /// let pid = Task::current().pid();
@@ -28,7 +27,6 @@ use core::{marker::PhantomData, mem::ManuallyDrop, ops::Deref};
 /// Getting the PID of the current process, also zero additional cost:
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// use kernel::task::Task;
 ///
 /// let pid = Task::current().group_leader().pid();
@@ -38,7 +36,6 @@ use core::{marker::PhantomData, mem::ManuallyDrop, ops::Deref};
 /// incremented when creating `State` and decremented when it is dropped:
 ///
 /// ```
-/// # use kernel::prelude::*;
 /// use kernel::task::Task;
 ///
 /// struct State {