tests/ui/undocumented_unsafe_blocks.rs

   1 // aux-build:proc_macro_unsafe.rs
   2
   3 #![warn(clippy::undocumented_unsafe_blocks)]
   4 #![allow(clippy::let_unit_value)]
   5
   6 extern crate proc_macro_unsafe;
   7
   8 // Valid comments
   9
  10 fn nested_local() {
  11     let _ = {
  12         let _ = {
  13             // SAFETY:
  14             let _ = unsafe {};
  15         };
  16     };
  17 }
  18
  19 fn deep_nest() {
  20     let _ = {
  21         let _ = {
  22             // SAFETY:
  23             let _ = unsafe {};
  24
  25             // Safety:
  26             unsafe {};
  27
  28             let _ = {
  29                 let _ = {
  30                     let _ = {
  31                         let _ = {
  32                             let _ = {
  33                                 // Safety:
  34                                 let _ = unsafe {};
  35
  36                                 // SAFETY:
  37                                 unsafe {};
  38                             };
  39                         };
  40                     };
  41
  42                     // Safety:
  43                     unsafe {};
  44                 };
  45             };
  46         };
  47
  48         // Safety:
  49         unsafe {};
  50     };
  51
  52     // SAFETY:
  53     unsafe {};
  54 }
  55
  56 fn local_tuple_expression() {
  57     // Safety:
  58     let _ = (42, unsafe {});
  59 }
  60
  61 fn line_comment() {
  62     // Safety:
  63     unsafe {}
  64 }
  65
  66 fn line_comment_newlines() {
  67     // SAFETY:
  68
  69     unsafe {}
  70 }
  71
  72 fn line_comment_empty() {
  73     // Safety:
  74     //
  75     //
  76     //
  77     unsafe {}
  78 }
  79
  80 fn line_comment_with_extras() {
  81     // This is a description
  82     // Safety:
  83     unsafe {}
  84 }
  85
  86 fn block_comment() {
  87     /* Safety: */
  88     unsafe {}
  89 }
  90
  91 fn block_comment_newlines() {
  92     /* SAFETY: */
  93
  94     unsafe {}
  95 }
  96
  97 fn block_comment_with_extras() {
  98     /* This is a description
  99      * SAFETY:
 100      */
 101     unsafe {}
 102 }
 103
 104 fn block_comment_terminator_same_line() {
 105     /* This is a description
 106      * Safety: */
 107     unsafe {}
 108 }
 109
 110 fn buried_safety() {
 111     // Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
 112     // incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
 113     // ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
 114     // reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint
 115     // occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est
 116     // laborum. Safety:
 117     // Tellus elementum sagittis vitae et leo duis ut diam quam. Sit amet nulla facilisi
 118     // morbi tempus iaculis urna. Amet luctus venenatis lectus magna. At quis risus sed vulputate odio
 119     // ut. Luctus venenatis lectus magna fringilla urna. Tortor id aliquet lectus proin nibh nisl
 120     // condimentum id venenatis. Vulputate dignissim suspendisse in est ante in nibh mauris cursus.
 121     unsafe {}
 122 }
 123
 124 fn safety_with_prepended_text() {
 125     // This is a test. safety:
 126     unsafe {}
 127 }
 128
 129 fn local_line_comment() {
 130     // Safety:
 131     let _ = unsafe {};
 132 }
 133
 134 fn local_block_comment() {
 135     /* SAFETY: */
 136     let _ = unsafe {};
 137 }
 138
 139 fn comment_array() {
 140     // Safety:
 141     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
 142 }
 143
 144 fn comment_tuple() {
 145     // sAFETY:
 146     let _ = (42, unsafe {}, "test", unsafe {});
 147 }
 148
 149 fn comment_unary() {
 150     // SAFETY:
 151     let _ = *unsafe { &42 };
 152 }
 153
 154 #[allow(clippy::match_single_binding)]
 155 fn comment_match() {
 156     // SAFETY:
 157     let _ = match unsafe {} {
 158         _ => {},
 159     };
 160 }
 161
 162 fn comment_addr_of() {
 163     // Safety:
 164     let _ = &unsafe {};
 165 }
 166
 167 fn comment_repeat() {
 168     // Safety:
 169     let _ = [unsafe {}; 5];
 170 }
 171
 172 fn comment_macro_call() {
 173     macro_rules! t {
 174         ($b:expr) => {
 175             $b
 176         };
 177     }
 178
 179     t!(
 180         // SAFETY:
 181         unsafe {}
 182     );
 183 }
 184
 185 fn comment_macro_def() {
 186     macro_rules! t {
 187         () => {
 188             // Safety:
 189             unsafe {}
 190         };
 191     }
 192
 193     t!();
 194 }
 195
 196 fn non_ascii_comment() {
 197     // ॐ᧻໒ SaFeTy: ௵∰
 198     unsafe {};
 199 }
 200
 201 fn local_commented_block() {
 202     let _ =
 203         // safety:
 204         unsafe {};
 205 }
 206
 207 fn local_nest() {
 208     // safety:
 209     let _ = [(42, unsafe {}, unsafe {}), (52, unsafe {}, unsafe {})];
 210 }
 211
 212 fn in_fn_call(x: *const u32) {
 213     fn f(x: u32) {}
 214
 215     // Safety: reason
 216     f(unsafe { *x });
 217 }
 218
 219 fn multi_in_fn_call(x: *const u32) {
 220     fn f(x: u32, y: u32) {}
 221
 222     // Safety: reason
 223     f(unsafe { *x }, unsafe { *x });
 224 }
 225
 226 fn in_multiline_fn_call(x: *const u32) {
 227     fn f(x: u32, y: u32) {}
 228
 229     f(
 230         // Safety: reason
 231         unsafe { *x },
 232         0,
 233     );
 234 }
 235
 236 fn in_macro_call(x: *const u32) {
 237     // Safety: reason
 238     println!("{}", unsafe { *x });
 239 }
 240
 241 fn in_multiline_macro_call(x: *const u32) {
 242     println!(
 243         "{}",
 244         // Safety: reason
 245         unsafe { *x },
 246     );
 247 }
 248
 249 fn from_proc_macro() {
 250     proc_macro_unsafe::unsafe_block!(token);
 251 }
 252
 253 // Invalid comments
 254
 255 #[rustfmt::skip]
 256 fn inline_block_comment() {
 257     /* Safety: */ unsafe {}
 258 }
 259
 260 fn no_comment() {
 261     unsafe {}
 262 }
 263
 264 fn no_comment_array() {
 265     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
 266 }
 267
 268 fn no_comment_tuple() {
 269     let _ = (42, unsafe {}, "test", unsafe {});
 270 }
 271
 272 fn no_comment_unary() {
 273     let _ = *unsafe { &42 };
 274 }
 275
 276 #[allow(clippy::match_single_binding)]
 277 fn no_comment_match() {
 278     let _ = match unsafe {} {
 279         _ => {},
 280     };
 281 }
 282
 283 fn no_comment_addr_of() {
 284     let _ = &unsafe {};
 285 }
 286
 287 fn no_comment_repeat() {
 288     let _ = [unsafe {}; 5];
 289 }
 290
 291 fn local_no_comment() {
 292     let _ = unsafe {};
 293 }
 294
 295 fn no_comment_macro_call() {
 296     macro_rules! t {
 297         ($b:expr) => {
 298             $b
 299         };
 300     }
 301
 302     t!(unsafe {});
 303 }
 304
 305 fn no_comment_macro_def() {
 306     macro_rules! t {
 307         () => {
 308             unsafe {}
 309         };
 310     }
 311
 312     t!();
 313 }
 314
 315 fn trailing_comment() {
 316     unsafe {} // SAFETY:
 317 }
 318
 319 fn internal_comment() {
 320     unsafe {
 321         // SAFETY:
 322     }
 323 }
 324
 325 fn interference() {
 326     // SAFETY
 327
 328     let _ = 42;
 329
 330     unsafe {};
 331 }
 332
 333 pub fn print_binary_tree() {
 334     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
 335 }
 336
 337 fn main() {}