Syntax change: unsafe_fn uses => and unsafe_method uses =>@ ... =>

Author: peter-lyons-kehl

README.md

@@ -110,8 +110,8 @@ const unsafe fn unsafe_fn_one_arg(b: bool) -> bool { b }
 const unsafe fn unsafe_fn_two_args(_: bool, u: u8) -> u8 { u }
 
 const _: () = unsafe_fn!(unsafe_fn_no_args);
-const _: bool = unsafe_fn!(unsafe_fn_one_arg, true);
-const _: u8 = unsafe_fn!(unsafe_fn_two_args, true, 0);
+const _: bool = unsafe_fn!(unsafe_fn_one_arg=> true);
+const _: u8 = unsafe_fn!(unsafe_fn_two_args=> true, 0);
 fn main() {}
 ```
 
@@ -122,13 +122,13 @@ fn main() {}
 mod module {
   use crate::prudent::*;
   // Works for Copy types
-  const _: u8 = unsafe_method!(1u8, unchecked_add, 0);
+  const _: u8 = unsafe_method!(1u8 =>@ unchecked_add => 0);
   //const _: u8 = unsafe_method!(({#[forbid(unused)] let v = 1u8; v}), unchecked_add, 0);
   //const _: u8 = unsafe_method!(#[allow_unsafe] 1u8, unchecked_add, 0);
   //const _: u8 = unsafe_method!(#[expect_unsafex] 1u8, unchecked_add, 0);
 
   //const _: u8 = unsafe_method!(({#forbid(unused) let v = 1u8; v}), unchecked_add, 0);
-  const _: u8 = unsafe_method!(~allow_unsafe 1u8, unchecked_add, 0);
+  const _: u8 = unsafe_method!(~allow_unsafe 1u8 =>@ unchecked_add => 0);
   //const _: u8 = unsafe_method!(~expect_unsafe 1u8, unchecked_add, 0);
 }
 fn main() {}
@@ -159,9 +159,9 @@ impl SNonCopy {
 fn main() {
     let s = SNonCopy {};
     // Works for non-Copy types
-    unsafe_method!(s, unsafe_method_no_args);
-    unsafe_method!(s, unsafe_method_one_arg, true);
-    unsafe_method!(s, unsafe_method_two_args, true, false);
+    unsafe_method!(s =>@ unsafe_method_no_args);
+    unsafe_method!(s =>@ unsafe_method_one_arg => true);
+    unsafe_method!(s =>@ unsafe_method_two_args => true, false);
 }
 ```
 
@@ -178,9 +178,9 @@ impl SNonCopy {
 
 fn main() {
     let mut s = SNonCopy {};
-    unsafe_method!(s, unsafe_method_no_args);
-    unsafe_method!(s, unsafe_method_one_arg, true);
-    unsafe_method!(s, unsafe_method_two_args, true, false);
+    unsafe_method!(s =>@ unsafe_method_no_args);
+    unsafe_method!(s =>@ unsafe_method_one_arg => true);
+    unsafe_method!(s =>@ unsafe_method_two_args => true, false);
 }
 ```
 
@@ -197,9 +197,9 @@ fn main() {
             unsafe fn unsafe_method_two_args(self, _: bool, _: bool) {}
         }
 
-        unsafe_method!(SNonCopy {}, unsafe_method_no_args);
-        unsafe_method!(SNonCopy {}, unsafe_method_one_arg, true);
-        unsafe_method!(SNonCopy {}, unsafe_method_two_args, true, false);
+        unsafe_method!(SNonCopy {} =>@ unsafe_method_no_args);
+        unsafe_method!(SNonCopy {} =>@ unsafe_method_one_arg => true);
+        unsafe_method!(SNonCopy {} =>@ unsafe_method_two_args => true, false);
     }
     {
         #[derive(Clone, Copy)]
@@ -209,8 +209,8 @@ fn main() {
         }
 
         let sCopy = SCopy {};
-        unsafe_method!(sCopy, unsafe_method_no_args);
-        unsafe_method!(sCopy, unsafe_method_no_args);
+        unsafe_method!(sCopy =>@ unsafe_method_no_args);
+        unsafe_method!(sCopy =>@ unsafe_method_no_args);
         let _ = sCopy;
     }
 }

src/linted.rs

@@ -29,13 +29,10 @@ pub const PRUDENT_INTERNAL_LINTED_VERSION: &str = "0.0.3-beta";
 ///   `unsafe.`
 /// - Some arguments. The given expression (which evaluates to the function to be called) is
 ///   `unsafe.`
-///
-/// ## Zero arguments
-/// The given expression (which evaluates to the function to be called) is `unsafe.`
 #[doc(hidden)]
 #[macro_export]
 macro_rules! internal_prudent_unsafe_fn {
-    ( $fn:expr $(, $arg:expr)+ ) => {
+    ( $fn:expr => $( $arg:expr ),+ ) => {
 
         // Enclosed in (...) and NOT in {...}. Why? Because the later does NOT work if the result is
         // an array/slice and then it's indexed with array access suffix [usize_idx].
@@ -193,7 +190,18 @@ macro_rules! internal_prudent_unsafe_method {
     (
         $( ~allow_unsafe  $( { $allow_unsafe_empty_indicator:tt  } )? )?
         $( ~expect_unsafe $( { $expect_unsafe_empty_indicator:tt } )? )?
-        $self:expr, $fn:ident $(, $arg:expr )*
+        $self:expr =>@ $fn:ident
+     ) => {
+        unsafe_method!(
+            $( ~allow_unsafe  $( { $allow_unsafe_empty_indicator  } )? )?
+            $( ~expect_unsafe $( { $expect_unsafe_empty_indicator } )? )?
+            $self =>@ $fn =>
+        )
+     };
+    (
+        $( ~allow_unsafe  $( { $allow_unsafe_empty_indicator:tt  } )? )?
+        $( ~expect_unsafe $( { $expect_unsafe_empty_indicator:tt } )? )?
+        $self:expr =>@ $fn:ident => $( $arg:expr ),*
      ) => {
         // See unsafe_fn for why here we enclose in (...) and not in {...}.
         (

src/linted_with_tests.rs

@@ -99,7 +99,7 @@ pub use crate::linted_untested::PRUDENT_INTERNAL_LINTED_VERSION;
 ///
 /// fn main() {
 ///     let mut marray = [true];
-///     unsafe_fn!( return_same_mut_ref, &mut marray )[0] = true;
+///     unsafe_fn!( return_same_mut_ref => &mut marray )[0] = true;
 /// }
 /// ```
 #[doc(inline)]

violations_coverage/unsafe_fn/fn_unused_unsafe/some_args.rs

@@ -4,5 +4,5 @@ use crate::prudent::*;
 fn safe_fn_one_arg(_: bool) {}
 
 fn main() {
-    unsafe_fn!(safe_fn_one_arg, true);
+    unsafe_fn!(safe_fn_one_arg=> true);
 }

violations_coverage/unsafe_fn/sneaked_unsafe/arg.rs

@@ -7,7 +7,7 @@ unsafe fn add_three(left: u64, middle: u64, right: u64) -> u64 {
 
 fn main() {
     unsafe_fn!(
-        add_three,
+        add_three=>
         1,
         {
             let _ = core::str::from_utf8_unchecked(b"G'Day");

violations_coverage/unsafe_fn/sneaked_unsafe/fn_expr_some_args.rs

@@ -10,5 +10,5 @@ unsafe fn get_fn_itself() -> unsafe fn(b: bool) -> bool {
 }
 
 fn main() {
-    unsafe_fn!(get_fn_itself(), true);
+    unsafe_fn!(get_fn_itself() => true);
 }

violations_coverage/unsafe_method/fn_unused_unsafe/some_args.rs

@@ -8,5 +8,5 @@ impl S {
 
 fn main() {
     let s = S;
-    unsafe_method!(s, use_it, true);
+    unsafe_method!(s =>@ use_it => true);
 }

violations_coverage/unsafe_method/fn_unused_unsafe/zero_args.rs

@@ -2,5 +2,5 @@
 use crate::prudent::*;
 
 fn main() {
-    let _ = unsafe_method!("hi", len);
+    let _ = unsafe_method!("hi" =>@ len);
 }

violations_coverage/unsafe_method/sneaked_unsafe/arg.rs

@@ -2,5 +2,5 @@
 use crate::prudent::*;
 
 fn main() {
-    let _ = unsafe_method!(1u8, unchecked_add, 0u8.unchecked_add(0));
+    let _ = unsafe_method!(1u8 =>@ unchecked_add => 0u8.unchecked_add(0));
 }

violations_coverage/unsafe_method/sneaked_unsafe/self_some_args.rs

@@ -2,5 +2,5 @@
 use crate::prudent::*;
 
 fn main() {
-    let _ = unsafe_method!(0u8.unchecked_add(0), unchecked_add, 0);
+    let _ = unsafe_method!(0u8.unchecked_add(0) =>@ unchecked_add => 0);
 }