Macros can't hide unsafety because of unused-unsafe

[bblum]

Consider the following.

macro_rules! foo(
        () => {
            unsafe { use std::cast; let () = cast::transmute(()); }
        }   
)
fn main() {
    unsafe { foo!(); }
    foo!();
}

This only does not emit a warning if the first line of code in main is removed. It would be nice to be able to squelch the unused unsafe warning that appears on the first invocation of foo!(), whether automatically or by being able to use #[allow(unused_unsafe)] inside the macro definition.

A workaround is to define a function in the macro that hides the unsafety and to call it.

[treeman]

Still relevant

$ rustc -v
rustc 0.12.0-pre (470dbef29 2014-07-25 09:31:10 +0000)

#![feature(macro_rules)]

macro_rules! foo(
    () => {
        unsafe { use std::mem; let () = mem::transmute(()); }
    }
)
fn main() {
    unsafe { foo!(); }
    foo!();
}

Produces warning: unnecessary unsafe block.

It is possible to avoid the warning with

fn main() {
    #![allow(unused_unsafe)]
    unsafe { foo!(); }
    foo!();
}

But not within the macro definition.

[iliekturtles]

Another workaround is to have multiple match patterns. This pattern may cause confusion since the unsafe at the macro invocation is part of the macro syntax and doesn't guarantee anything about the macro itself.

macro_rules! foo {
    (unsafe $e:expr) => {
        unsafe { foo!($e) }
    };
    ($e:expr) => {{
       use std::mem;
       mem::transmute($e)
    }}
}
#[allow(unused_variables)]
fn main() {
    let x: u32 = unsafe { foo!(1) };
    let y: u32 = foo!(unsafe 1);
}

[mitaa]

This just works now

#![feature(stmt_expr_attributes)]

macro_rules! foo(
        () => {
            #[allow(unused_unsafe)]
            unsafe { use std::mem; let () = mem::transmute(()); }
        }   
);

fn main() {
    unsafe { foo!(); }
    foo!();
}

[leoyvens]

Triage: This is fixed as noted above, stmt_expr_attributes is stable now.