src/tools/clippy/tests/ui/auxiliary/macro_rules.rs

   1 #![allow(dead_code)]
   2
   3 //! Used to test that certain lints don't trigger in imported external macros
   4
   5 #[macro_export]
   6 macro_rules! foofoo {
   7     () => {
   8         loop {}
   9     };
  10 }
  11
  12 #[macro_export]
  13 macro_rules! must_use_unit {
  14     () => {
  15         #[must_use]
  16         fn foo() {}
  17     };
  18 }
  19
  20 #[macro_export]
  21 macro_rules! try_err {
  22     () => {
  23         pub fn try_err_fn() -> Result<i32, i32> {
  24             let err: i32 = 1;
  25             // To avoid warnings during rustfix
  26             if true { Err(err)? } else { Ok(2) }
  27         }
  28     };
  29 }
  30
  31 #[macro_export]
  32 macro_rules! string_add {
  33     () => {
  34         let y = "".to_owned();
  35         let z = y + "...";
  36     };
  37 }
  38
  39 #[macro_export]
  40 macro_rules! take_external {
  41     ($s:expr) => {
  42         std::mem::replace($s, Default::default())
  43     };
  44 }
  45
  46 #[macro_export]
  47 macro_rules! option_env_unwrap_external {
  48     ($env: expr) => {
  49         option_env!($env).unwrap()
  50     };
  51     ($env: expr, $message: expr) => {
  52         option_env!($env).expect($message)
  53     };
  54 }
  55
  56 #[macro_export]
  57 macro_rules! ref_arg_binding {
  58     () => {
  59         let ref _y = 42;
  60     };
  61 }
  62
  63 #[macro_export]
  64 macro_rules! ref_arg_function {
  65     () => {
  66         fn fun_example(ref _x: usize) {}
  67     };
  68 }
  69
  70 #[macro_export]
  71 macro_rules! as_conv_with_arg {
  72     (0u32 as u64) => {
  73         ()
  74     };
  75 }
  76
  77 #[macro_export]
  78 macro_rules! as_conv {
  79     () => {
  80         0u32 as u64
  81     };
  82 }
  83
  84 #[macro_export]
  85 macro_rules! large_enum_variant {
  86     () => {
  87         enum LargeEnumInMacro {
  88             A(i32),
  89             B([i32; 8000]),
  90         }
  91     };
  92 }
  93
  94 #[macro_export]
  95 macro_rules! field_reassign_with_default {
  96     () => {
  97         #[derive(Default)]
  98         struct A {
  99             pub i: i32,
 100             pub j: i64,
 101         }
 102         fn lint() {
 103             let mut a: A = Default::default();
 104             a.i = 42;
 105             a;
 106         }
 107     };
 108 }
 109
 110 #[macro_export]
 111 macro_rules! default_numeric_fallback {
 112     () => {
 113         let x = 22;
 114     };
 115 }
 116
 117 #[macro_export]
 118 macro_rules! mut_mut {
 119     () => {
 120         let mut_mut_ty: &mut &mut u32 = &mut &mut 1u32;
 121     };
 122 }
 123
 124 #[macro_export]
 125 macro_rules! ptr_as_ptr_cast {
 126     ($ptr: ident) => {
 127         $ptr as *const i32
 128     };
 129 }
 130
 131 #[macro_export]
 132 macro_rules! manual_rem_euclid {
 133     () => {
 134         let value: i32 = 5;
 135         let _: i32 = ((value % 4) + 4) % 4;
 136     };
 137 }
 138
 139 #[macro_export]
 140 macro_rules! equatable_if_let {
 141     ($a:ident) => {{ if let 2 = $a {} }};
 142 }
 143
 144 #[macro_export]
 145 macro_rules! almost_complete_range {
 146     () => {
 147         let _ = 'a'..'z';
 148         let _ = 'A'..'Z';
 149         let _ = '0'..'9';
 150     };
 151 }
 152
 153 #[macro_export]
 154 macro_rules! unsafe_macro {
 155     () => {
 156         unsafe {
 157             *core::ptr::null::<()>();
 158             *core::ptr::null::<()>();
 159         }
 160     };
 161 }
 162
 163 #[macro_export]
 164 macro_rules! needless_lifetime {
 165     () => {
 166         fn needless_lifetime<'a>(x: &'a u8) -> &'a u8 {
 167             unimplemented!()
 168         }
 169     };
 170 }