tests/ui/undocumented_unsafe_blocks.rs

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