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 #[rustfmt::skip]
  93 fn inline_block_comment() {
  94     /* Safety: */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 // Invalid comments
 213
 214 fn no_comment() {
 215     unsafe {}
 216 }
 217
 218 fn no_comment_array() {
 219     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
 220 }
 221
 222 fn no_comment_tuple() {
 223     let _ = (42, unsafe {}, "test", unsafe {});
 224 }
 225
 226 fn no_comment_unary() {
 227     let _ = *unsafe { &42 };
 228 }
 229
 230 #[allow(clippy::match_single_binding)]
 231 fn no_comment_match() {
 232     let _ = match unsafe {} {
 233         _ => {},
 234     };
 235 }
 236
 237 fn no_comment_addr_of() {
 238     let _ = &unsafe {};
 239 }
 240
 241 fn no_comment_repeat() {
 242     let _ = [unsafe {}; 5];
 243 }
 244
 245 fn local_no_comment() {
 246     let _ = unsafe {};
 247 }
 248
 249 fn no_comment_macro_call() {
 250     macro_rules! t {
 251         ($b:expr) => {
 252             $b
 253         };
 254     }
 255
 256     t!(unsafe {});
 257 }
 258
 259 fn no_comment_macro_def() {
 260     macro_rules! t {
 261         () => {
 262             unsafe {}
 263         };
 264     }
 265
 266     t!();
 267 }
 268
 269 fn trailing_comment() {
 270     unsafe {} // Safety:
 271 }
 272
 273 fn internal_comment() {
 274     unsafe {
 275         // Safety:
 276     }
 277 }
 278
 279 fn interference() {
 280     // Safety
 281
 282     let _ = 42;
 283
 284     unsafe {};
 285 }
 286
 287 pub fn print_binary_tree() {
 288     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
 289 }
 290
 291 fn main() {}