From: Jesung Yang <[email protected]> Add internal doctests to verify the `Into` derive macro's logic. This ensures comprehensive testing while keeping the public-facing documentation compact and readable.
Signed-off-by: Jesung Yang <[email protected]> --- rust/macros/convert.rs | 436 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 436 insertions(+) diff --git a/rust/macros/convert.rs b/rust/macros/convert.rs index a7a43b1a2caf..41ccbd849348 100644 --- a/rust/macros/convert.rs +++ b/rust/macros/convert.rs @@ -582,3 +582,439 @@ fn is_valid_primitive(ident: &Ident) -> bool { | "isize" ) } + +mod derive_into_tests { + /// ``` + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(u8)] + /// enum Foo { + /// // Works with const expressions. + /// A = add(0, 0), + /// B = 2_isize.pow(1) - 1, + /// } + /// + /// const fn add(a: isize, b: isize) -> isize { + /// a + b + /// } + /// + /// assert_eq!(0_u8, Foo::A.into()); + /// assert_eq!(1_u8, Foo::B.into()); + /// ``` + mod works_with_const_expr {} + + /// ``` + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(bool)] + /// enum Foo { + /// A, + /// B, + /// } + /// + /// assert_eq!(false, Foo::A.into()); + /// assert_eq!(true, Foo::B.into()); + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(bool)] + /// enum Foo { + /// // `-1` cannot be represented with `bool`. + /// A = -1, + /// } + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(bool)] + /// enum Foo { + /// // `2` cannot be represented with `bool`. + /// A = 2, + /// } + /// ``` + mod overflow_assert_works_on_bool {} + + /// ``` + /// use kernel::{ + /// macros::Into, + /// num::Bounded, // + /// }; + /// + /// #[derive(Into)] + /// #[into(Bounded<i8, 7>)] + /// enum Foo { + /// A = -1 << 6, // The minimum value of `Bounded<i8, 7>`. + /// B = (1 << 6) - 1, // The maximum value of `Bounded<i8, 7>`. + /// } + /// + /// let foo_a: Bounded<i8, 7> = Foo::A.into(); + /// let foo_b: Bounded<i8, 7> = Foo::B.into(); + /// assert_eq!(Bounded::<i8, 7>::new::<{ -1_i8 << 6 }>(), foo_a); + /// assert_eq!(Bounded::<i8, 7>::new::<{ (1_i8 << 6) - 1 }>(), foo_b); + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(Bounded<i8, 7>)] + /// enum Foo { + /// // `1 << 6` cannot be represented with `Bounded<i8, 7>`. + /// A = 1 << 6, + /// } + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(Bounded<i8, 7>)] + /// enum Foo { + /// // `(-1 << 6) - 1` cannot be represented with `Bounded<i8, 7>`. + /// A = (-1 << 6) - 1, + /// } + /// ``` + /// + /// ``` + /// use kernel::{ + /// macros::Into, + /// num::Bounded, // + /// }; + /// + /// #[derive(Into)] + /// #[into(Bounded<i8, 1>)] + /// enum Foo { + /// A = -1, // The minimum value of `Bounded<i8, 1>`. + /// B, // The maximum value of `Bounded<i8, 1>`. + /// } + /// + /// let foo_a: Bounded<i8, 1> = Foo::A.into(); + /// let foo_b: Bounded<i8, 1> = Foo::B.into(); + /// assert_eq!(Bounded::<i8, 1>::new::<{ -1_i8 }>(), foo_a); + /// assert_eq!(Bounded::<i8, 1>::new::<{ 0_i8 } >(), foo_b); + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(Bounded<i8, 1>)] + /// enum Foo { + /// // `1` cannot be represented with `Bounded<i8, 1>`. + /// A = 1, + /// } + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(Bounded<i8, 1>)] + /// enum Foo { + /// // `-2` cannot be represented with `Bounded<i8, 1>`. + /// A = -2, + /// } + /// ``` + /// + /// ``` + /// use kernel::{ + /// macros::Into, + /// num::Bounded, // + /// }; + /// + /// #[derive(Into)] + /// #[into(Bounded<i32, 32>)] + /// #[repr(i64)] + /// enum Foo { + /// A = i32::MIN as i64, + /// B = i32::MAX as i64, + /// } + /// + /// let foo_a: Bounded<i32, 32> = Foo::A.into(); + /// let foo_b: Bounded<i32, 32> = Foo::B.into(); + /// assert_eq!(Bounded::<i32, 32>::new::<{ i32::MIN }>(), foo_a); + /// assert_eq!(Bounded::<i32, 32>::new::<{ i32::MAX }>(), foo_b); + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(Bounded<i32, 32>)] + /// #[repr(i64)] + /// enum Foo { + /// // `1 << 31` cannot be represented with `Bounded<i32, 32>`. + /// A = 1 << 31, + /// } + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(Bounded<i32, 32>)] + /// #[repr(i64)] + /// enum Foo { + /// // `(-1 << 31) - 1` cannot be represented with `Bounded<i32, 32>`. + /// A = (-1 << 31) - 1, + /// } + /// ``` + mod overflow_assert_works_on_signed_bounded {} + + /// ``` + /// use kernel::{ + /// macros::Into, + /// num::Bounded, // + /// }; + /// + /// #[derive(Into)] + /// #[into(Bounded<u8, 7>)] + /// enum Foo { + /// A, // The minimum value of `Bounded<u8, 7>`. + /// B = (1 << 7) - 1, // The maximum value of `Bounded<u8, 7>`. + /// } + /// + /// let foo_a: Bounded<u8, 7> = Foo::A.into(); + /// let foo_b: Bounded<u8, 7> = Foo::B.into(); + /// assert_eq!(Bounded::<u8, 7>::new::<{ 0 }>(), foo_a); + /// assert_eq!(Bounded::<u8, 7>::new::<{ (1_u8 << 7) - 1 }>(), foo_b); + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(Bounded<u8, 7>)] + /// enum Foo { + /// // `1 << 7` cannot be represented with `Bounded<u8, 7>`. + /// A = 1 << 7, + /// } + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(Bounded<u8, 7>)] + /// enum Foo { + /// // `-1` cannot be represented with `Bounded<u8, 7>`. + /// A = -1, + /// } + /// ``` + /// + /// ``` + /// use kernel::{ + /// macros::Into, + /// num::Bounded, // + /// }; + /// + /// #[derive(Into)] + /// #[into(Bounded<u8, 1>)] + /// enum Foo { + /// A, // The minimum value of `Bounded<u8, 1>`. + /// B, // The maximum value of `Bounded<u8, 1>`. + /// } + /// + /// let foo_a: Bounded<u8, 1> = Foo::A.into(); + /// let foo_b: Bounded<u8, 1> = Foo::B.into(); + /// assert_eq!(Bounded::<u8, 1>::new::<{ 0 }>(), foo_a); + /// assert_eq!(Bounded::<u8, 1>::new::<{ 1 }>(), foo_b); + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(Bounded<u8, 1>)] + /// enum Foo { + /// // `2` cannot be represented with `Bounded<u8, 1>`. + /// A = 2, + /// } + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(Bounded<u8, 1>)] + /// enum Foo { + /// // `-1` cannot be represented with `Bounded<u8, 1>`. + /// A = -1, + /// } + /// ``` + /// + /// ``` + /// use kernel::{ + /// macros::Into, + /// num::Bounded, // + /// }; + /// + /// #[derive(Into)] + /// #[into(Bounded<u32, 32>)] + /// #[repr(u64)] + /// enum Foo { + /// A = u32::MIN as u64, + /// B = u32::MAX as u64, + /// } + /// + /// let foo_a: Bounded<u32, 32> = Foo::A.into(); + /// let foo_b: Bounded<u32, 32> = Foo::B.into(); + /// assert_eq!(Bounded::<u32, 32>::new::<{ u32::MIN }>(), foo_a); + /// assert_eq!(Bounded::<u32, 32>::new::<{ u32::MAX }>(), foo_b); + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(Bounded<u32, 32>)] + /// #[repr(u64)] + /// enum Foo { + /// // `1 << 32` cannot be represented with `Bounded<u32, 32>`. + /// A = 1 << 32, + /// } + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(Bounded<u32, 32>)] + /// #[repr(u64)] + /// enum Foo { + /// // `-1` cannot be represented with `Bounded<u32, 32>`. + /// A = -1, + /// } + /// ``` + mod overflow_assert_works_on_unsigned_bounded {} + + /// ``` + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(isize)] + /// #[repr(isize)] + /// enum Foo { + /// A = isize::MIN, + /// B = isize::MAX, + /// } + /// + /// assert_eq!(isize::MIN, Foo::A.into()); + /// assert_eq!(isize::MAX, Foo::B.into()); + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(isize)] + /// #[repr(usize)] + /// enum Foo { + /// A = (isize::MAX as usize) + 1 + /// } + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(i32)] + /// #[repr(i64)] + /// enum Foo { + /// A = (i32::MIN as i64) - 1, + /// } + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(i32)] + /// #[repr(i64)] + /// enum Foo { + /// A = (i32::MAX as i64) + 1, + /// } + /// ``` + mod overflow_assert_works_on_signed_int {} + + /// ``` + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(usize)] + /// #[repr(usize)] + /// enum Foo { + /// A = usize::MIN, + /// B = usize::MAX, + /// } + /// + /// assert_eq!(usize::MIN, Foo::A.into()); + /// assert_eq!(usize::MAX, Foo::B.into()); + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(usize)] + /// #[repr(isize)] + /// enum Foo { + /// A = -1, + /// } + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(u32)] + /// #[repr(i64)] + /// enum Foo { + /// A = (u32::MIN as i64) - 1, + /// } + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(u32)] + /// #[repr(i64)] + /// enum Foo { + /// A = (u32::MAX as i64) + 1, + /// } + /// ``` + mod overflow_assert_works_on_unsigned_int {} + + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(Bounded<i8, 7>, i8, i16, i32, i64)] + /// #[repr(i8)] + /// enum Foo { + /// // `i8::MAX` cannot be represented with `Bounded<i8, 7>`. + /// A = i8::MAX, + /// } + /// ``` + /// + /// ```compile_fail + /// use kernel::macros::Into; + /// + /// #[derive(Into)] + /// #[into(i8, i16, i32, i64, Bounded<i8, 7>)] + /// #[repr(i8)] + /// enum Foo { + /// // `i8::MAX` cannot be represented with `Bounded<i8, 7>`. + /// A = i8::MAX, + /// } + /// ``` + mod any_into_target_overflow_is_rejected {} +} -- 2.52.0
