1use rustc_errors::codes::*;
2use rustc_errors::{
3 Applicability, Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level,
4 MultiSpan, Subdiagnostic,
5};
6use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
7use rustc_middle::ty::{self, Ty};
8use rustc_pattern_analysis::errors::Uncovered;
9use rustc_pattern_analysis::rustc::RustcPatCtxt;
10use rustc_span::{Ident, Span, Symbol};
11
12use crate::fluent_generated as fluent;
13
14#[derive(LintDiagnostic)]
15#[diag(mir_build_call_to_deprecated_safe_fn_requires_unsafe)]
16pub(crate) struct CallToDeprecatedSafeFnRequiresUnsafe {
17 #[label]
18 pub(crate) span: Span,
19 pub(crate) function: String,
20 pub(crate) guarantee: String,
21 #[subdiagnostic]
22 pub(crate) sub: CallToDeprecatedSafeFnRequiresUnsafeSub,
23}
24
25#[derive(Subdiagnostic)]
26#[multipart_suggestion(mir_build_suggestion, applicability = "machine-applicable")]
27pub(crate) struct CallToDeprecatedSafeFnRequiresUnsafeSub {
28 pub(crate) start_of_line_suggestion: String,
29 #[suggestion_part(code = "{start_of_line_suggestion}")]
30 pub(crate) start_of_line: Span,
31 #[suggestion_part(code = "unsafe {{ ")]
32 pub(crate) left: Span,
33 #[suggestion_part(code = " }}")]
34 pub(crate) right: Span,
35}
36
37#[derive(LintDiagnostic)]
38#[diag(mir_build_unsafe_op_in_unsafe_fn_call_to_unsafe_fn_requires_unsafe, code = E0133)]
39#[note]
40pub(crate) struct UnsafeOpInUnsafeFnCallToUnsafeFunctionRequiresUnsafe {
41 #[label]
42 pub(crate) span: Span,
43 pub(crate) function: String,
44 #[subdiagnostic]
45 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
46}
47
48#[derive(LintDiagnostic)]
49#[diag(mir_build_unsafe_op_in_unsafe_fn_call_to_unsafe_fn_requires_unsafe_nameless, code = E0133)]
50#[note]
51pub(crate) struct UnsafeOpInUnsafeFnCallToUnsafeFunctionRequiresUnsafeNameless {
52 #[label]
53 pub(crate) span: Span,
54 #[subdiagnostic]
55 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
56}
57
58#[derive(LintDiagnostic)]
59#[diag(mir_build_unsafe_op_in_unsafe_fn_inline_assembly_requires_unsafe, code = E0133)]
60#[note]
61pub(crate) struct UnsafeOpInUnsafeFnUseOfInlineAssemblyRequiresUnsafe {
62 #[label]
63 pub(crate) span: Span,
64 #[subdiagnostic]
65 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
66}
67
68#[derive(LintDiagnostic)]
69#[diag(mir_build_unsafe_op_in_unsafe_fn_initializing_type_with_requires_unsafe, code = E0133)]
70#[note]
71pub(crate) struct UnsafeOpInUnsafeFnInitializingTypeWithRequiresUnsafe {
72 #[label]
73 pub(crate) span: Span,
74 #[subdiagnostic]
75 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
76}
77
78#[derive(LintDiagnostic)]
79#[diag(mir_build_unsafe_op_in_unsafe_fn_initializing_type_with_unsafe_field_requires_unsafe, code = E0133)]
80#[note]
81pub(crate) struct UnsafeOpInUnsafeFnInitializingTypeWithUnsafeFieldRequiresUnsafe {
82 #[label]
83 pub(crate) span: Span,
84 #[subdiagnostic]
85 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
86}
87
88#[derive(LintDiagnostic)]
89#[diag(mir_build_unsafe_op_in_unsafe_fn_mutable_static_requires_unsafe, code = E0133)]
90#[note]
91pub(crate) struct UnsafeOpInUnsafeFnUseOfMutableStaticRequiresUnsafe {
92 #[label]
93 pub(crate) span: Span,
94 #[subdiagnostic]
95 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
96}
97
98#[derive(LintDiagnostic)]
99#[diag(mir_build_unsafe_op_in_unsafe_fn_extern_static_requires_unsafe, code = E0133)]
100#[note]
101pub(crate) struct UnsafeOpInUnsafeFnUseOfExternStaticRequiresUnsafe {
102 #[label]
103 pub(crate) span: Span,
104 #[subdiagnostic]
105 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
106}
107
108#[derive(LintDiagnostic)]
109#[diag(mir_build_unsafe_op_in_unsafe_fn_unsafe_field_requires_unsafe, code = E0133)]
110#[note]
111pub(crate) struct UnsafeOpInUnsafeFnUseOfUnsafeFieldRequiresUnsafe {
112 #[label]
113 pub(crate) span: Span,
114 #[subdiagnostic]
115 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
116}
117
118#[derive(LintDiagnostic)]
119#[diag(mir_build_unsafe_op_in_unsafe_fn_deref_raw_pointer_requires_unsafe, code = E0133)]
120#[note]
121pub(crate) struct UnsafeOpInUnsafeFnDerefOfRawPointerRequiresUnsafe {
122 #[label]
123 pub(crate) span: Span,
124 #[subdiagnostic]
125 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
126}
127
128#[derive(LintDiagnostic)]
129#[diag(mir_build_unsafe_op_in_unsafe_fn_union_field_requires_unsafe, code = E0133)]
130#[note]
131pub(crate) struct UnsafeOpInUnsafeFnAccessToUnionFieldRequiresUnsafe {
132 #[label]
133 pub(crate) span: Span,
134 #[subdiagnostic]
135 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
136}
137
138#[derive(LintDiagnostic)]
139#[diag(
140 mir_build_unsafe_op_in_unsafe_fn_mutation_of_layout_constrained_field_requires_unsafe,
141 code = E0133
142)]
143#[note]
144pub(crate) struct UnsafeOpInUnsafeFnMutationOfLayoutConstrainedFieldRequiresUnsafe {
145 #[label]
146 pub(crate) span: Span,
147 #[subdiagnostic]
148 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
149}
150
151#[derive(LintDiagnostic)]
152#[diag(
153 mir_build_unsafe_op_in_unsafe_fn_borrow_of_layout_constrained_field_requires_unsafe,
154 code = E0133,
155)]
156pub(crate) struct UnsafeOpInUnsafeFnBorrowOfLayoutConstrainedFieldRequiresUnsafe {
157 #[label]
158 pub(crate) span: Span,
159 #[subdiagnostic]
160 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
161}
162
163#[derive(LintDiagnostic)]
164#[diag(
165 mir_build_unsafe_binder_cast_requires_unsafe,
166 code = E0133,
167)]
168pub(crate) struct UnsafeOpInUnsafeFnUnsafeBinderCastRequiresUnsafe {
169 #[label]
170 pub(crate) span: Span,
171 #[subdiagnostic]
172 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
173}
174
175#[derive(LintDiagnostic)]
176#[diag(mir_build_unsafe_op_in_unsafe_fn_call_to_fn_with_requires_unsafe, code = E0133)]
177#[help]
178pub(crate) struct UnsafeOpInUnsafeFnCallToFunctionWithRequiresUnsafe {
179 #[label]
180 pub(crate) span: Span,
181 pub(crate) function: String,
182 pub(crate) missing_target_features: DiagArgValue,
183 pub(crate) missing_target_features_count: usize,
184 #[note]
185 pub(crate) note: bool,
186 pub(crate) build_target_features: DiagArgValue,
187 pub(crate) build_target_features_count: usize,
188 #[subdiagnostic]
189 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
190}
191
192#[derive(Diagnostic)]
193#[diag(mir_build_call_to_unsafe_fn_requires_unsafe, code = E0133)]
194#[note]
195pub(crate) struct CallToUnsafeFunctionRequiresUnsafe {
196 #[primary_span]
197 #[label]
198 pub(crate) span: Span,
199 pub(crate) function: String,
200 #[subdiagnostic]
201 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
202}
203
204#[derive(Diagnostic)]
205#[diag(mir_build_call_to_unsafe_fn_requires_unsafe_nameless, code = E0133)]
206#[note]
207pub(crate) struct CallToUnsafeFunctionRequiresUnsafeNameless {
208 #[primary_span]
209 #[label]
210 pub(crate) span: Span,
211 #[subdiagnostic]
212 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
213}
214
215#[derive(Diagnostic)]
216#[diag(mir_build_call_to_unsafe_fn_requires_unsafe_unsafe_op_in_unsafe_fn_allowed, code = E0133)]
217#[note]
218pub(crate) struct CallToUnsafeFunctionRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
219 #[primary_span]
220 #[label]
221 pub(crate) span: Span,
222 pub(crate) function: String,
223 #[subdiagnostic]
224 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
225}
226
227#[derive(Diagnostic)]
228#[diag(
229 mir_build_call_to_unsafe_fn_requires_unsafe_nameless_unsafe_op_in_unsafe_fn_allowed,
230 code = E0133
231)]
232#[note]
233pub(crate) struct CallToUnsafeFunctionRequiresUnsafeNamelessUnsafeOpInUnsafeFnAllowed {
234 #[primary_span]
235 #[label]
236 pub(crate) span: Span,
237 #[subdiagnostic]
238 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
239}
240
241#[derive(Diagnostic)]
242#[diag(mir_build_inline_assembly_requires_unsafe, code = E0133)]
243#[note]
244pub(crate) struct UseOfInlineAssemblyRequiresUnsafe {
245 #[primary_span]
246 #[label]
247 pub(crate) span: Span,
248 #[subdiagnostic]
249 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
250}
251
252#[derive(Diagnostic)]
253#[diag(mir_build_inline_assembly_requires_unsafe_unsafe_op_in_unsafe_fn_allowed, code = E0133)]
254#[note]
255pub(crate) struct UseOfInlineAssemblyRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
256 #[primary_span]
257 #[label]
258 pub(crate) span: Span,
259 #[subdiagnostic]
260 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
261}
262
263#[derive(Diagnostic)]
264#[diag(mir_build_initializing_type_with_requires_unsafe, code = E0133)]
265#[note]
266pub(crate) struct InitializingTypeWithRequiresUnsafe {
267 #[primary_span]
268 #[label]
269 pub(crate) span: Span,
270 #[subdiagnostic]
271 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
272}
273
274#[derive(Diagnostic)]
275#[diag(mir_build_initializing_type_with_unsafe_field_requires_unsafe, code = E0133)]
276#[note]
277pub(crate) struct InitializingTypeWithUnsafeFieldRequiresUnsafe {
278 #[primary_span]
279 #[label]
280 pub(crate) span: Span,
281 #[subdiagnostic]
282 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
283}
284
285#[derive(Diagnostic)]
286#[diag(
287 mir_build_initializing_type_with_requires_unsafe_unsafe_op_in_unsafe_fn_allowed,
288 code = E0133
289)]
290#[note]
291pub(crate) struct InitializingTypeWithRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
292 #[primary_span]
293 #[label]
294 pub(crate) span: Span,
295 #[subdiagnostic]
296 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
297}
298
299#[derive(Diagnostic)]
300#[diag(
301 mir_build_initializing_type_with_unsafe_field_requires_unsafe_unsafe_op_in_unsafe_fn_allowed,
302 code = E0133
303)]
304#[note]
305pub(crate) struct InitializingTypeWithUnsafeFieldRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
306 #[primary_span]
307 #[label]
308 pub(crate) span: Span,
309 #[subdiagnostic]
310 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
311}
312
313#[derive(Diagnostic)]
314#[diag(mir_build_mutable_static_requires_unsafe, code = E0133)]
315#[note]
316pub(crate) struct UseOfMutableStaticRequiresUnsafe {
317 #[primary_span]
318 #[label]
319 pub(crate) span: Span,
320 #[subdiagnostic]
321 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
322}
323
324#[derive(Diagnostic)]
325#[diag(mir_build_mutable_static_requires_unsafe_unsafe_op_in_unsafe_fn_allowed, code = E0133)]
326#[note]
327pub(crate) struct UseOfMutableStaticRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
328 #[primary_span]
329 #[label]
330 pub(crate) span: Span,
331 #[subdiagnostic]
332 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
333}
334
335#[derive(Diagnostic)]
336#[diag(mir_build_extern_static_requires_unsafe, code = E0133)]
337#[note]
338pub(crate) struct UseOfExternStaticRequiresUnsafe {
339 #[primary_span]
340 #[label]
341 pub(crate) span: Span,
342 #[subdiagnostic]
343 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
344}
345
346#[derive(Diagnostic)]
347#[diag(mir_build_extern_static_requires_unsafe_unsafe_op_in_unsafe_fn_allowed, code = E0133)]
348#[note]
349pub(crate) struct UseOfExternStaticRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
350 #[primary_span]
351 #[label]
352 pub(crate) span: Span,
353 #[subdiagnostic]
354 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
355}
356
357#[derive(Diagnostic)]
358#[diag(mir_build_unsafe_field_requires_unsafe, code = E0133)]
359#[note]
360pub(crate) struct UseOfUnsafeFieldRequiresUnsafe {
361 #[primary_span]
362 #[label]
363 pub(crate) span: Span,
364 #[subdiagnostic]
365 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
366}
367
368#[derive(Diagnostic)]
369#[diag(mir_build_unsafe_field_requires_unsafe_unsafe_op_in_unsafe_fn_allowed, code = E0133)]
370#[note]
371pub(crate) struct UseOfUnsafeFieldRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
372 #[primary_span]
373 #[label]
374 pub(crate) span: Span,
375 #[subdiagnostic]
376 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
377}
378
379#[derive(Diagnostic)]
380#[diag(mir_build_deref_raw_pointer_requires_unsafe, code = E0133)]
381#[note]
382pub(crate) struct DerefOfRawPointerRequiresUnsafe {
383 #[primary_span]
384 #[label]
385 pub(crate) span: Span,
386 #[subdiagnostic]
387 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
388}
389
390#[derive(Diagnostic)]
391#[diag(mir_build_deref_raw_pointer_requires_unsafe_unsafe_op_in_unsafe_fn_allowed, code = E0133)]
392#[note]
393pub(crate) struct DerefOfRawPointerRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
394 #[primary_span]
395 #[label]
396 pub(crate) span: Span,
397 #[subdiagnostic]
398 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
399}
400
401#[derive(Diagnostic)]
402#[diag(mir_build_union_field_requires_unsafe, code = E0133)]
403#[note]
404pub(crate) struct AccessToUnionFieldRequiresUnsafe {
405 #[primary_span]
406 #[label]
407 pub(crate) span: Span,
408 #[subdiagnostic]
409 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
410}
411
412#[derive(Diagnostic)]
413#[diag(mir_build_union_field_requires_unsafe_unsafe_op_in_unsafe_fn_allowed, code = E0133)]
414#[note]
415pub(crate) struct AccessToUnionFieldRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
416 #[primary_span]
417 #[label]
418 pub(crate) span: Span,
419 #[subdiagnostic]
420 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
421}
422
423#[derive(Diagnostic)]
424#[diag(mir_build_mutation_of_layout_constrained_field_requires_unsafe, code = E0133)]
425#[note]
426pub(crate) struct MutationOfLayoutConstrainedFieldRequiresUnsafe {
427 #[primary_span]
428 #[label]
429 pub(crate) span: Span,
430 #[subdiagnostic]
431 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
432}
433
434#[derive(Diagnostic)]
435#[diag(
436 mir_build_mutation_of_layout_constrained_field_requires_unsafe_unsafe_op_in_unsafe_fn_allowed,
437 code = E0133
438)]
439#[note]
440pub(crate) struct MutationOfLayoutConstrainedFieldRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
441 #[primary_span]
442 #[label]
443 pub(crate) span: Span,
444 #[subdiagnostic]
445 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
446}
447
448#[derive(Diagnostic)]
449#[diag(mir_build_borrow_of_layout_constrained_field_requires_unsafe, code = E0133)]
450#[note]
451pub(crate) struct BorrowOfLayoutConstrainedFieldRequiresUnsafe {
452 #[primary_span]
453 #[label]
454 pub(crate) span: Span,
455 #[subdiagnostic]
456 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
457}
458
459#[derive(Diagnostic)]
460#[diag(
461 mir_build_borrow_of_layout_constrained_field_requires_unsafe_unsafe_op_in_unsafe_fn_allowed,
462 code = E0133
463)]
464#[note]
465pub(crate) struct BorrowOfLayoutConstrainedFieldRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
466 #[primary_span]
467 #[label]
468 pub(crate) span: Span,
469 #[subdiagnostic]
470 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
471}
472
473#[derive(Diagnostic)]
474#[diag(mir_build_call_to_fn_with_requires_unsafe, code = E0133)]
475#[help]
476pub(crate) struct CallToFunctionWithRequiresUnsafe {
477 #[primary_span]
478 #[label]
479 pub(crate) span: Span,
480 pub(crate) function: String,
481 pub(crate) missing_target_features: DiagArgValue,
482 pub(crate) missing_target_features_count: usize,
483 #[note]
484 pub(crate) note: bool,
485 pub(crate) build_target_features: DiagArgValue,
486 pub(crate) build_target_features_count: usize,
487 #[subdiagnostic]
488 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
489}
490
491#[derive(Diagnostic)]
492#[diag(mir_build_call_to_fn_with_requires_unsafe_unsafe_op_in_unsafe_fn_allowed, code = E0133)]
493#[help]
494pub(crate) struct CallToFunctionWithRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
495 #[primary_span]
496 #[label]
497 pub(crate) span: Span,
498 pub(crate) function: String,
499 pub(crate) missing_target_features: DiagArgValue,
500 pub(crate) missing_target_features_count: usize,
501 #[note]
502 pub(crate) note: bool,
503 pub(crate) build_target_features: DiagArgValue,
504 pub(crate) build_target_features_count: usize,
505 #[subdiagnostic]
506 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
507}
508
509#[derive(Diagnostic)]
510#[diag(
511 mir_build_unsafe_binder_cast_requires_unsafe,
512 code = E0133,
513)]
514pub(crate) struct UnsafeBinderCastRequiresUnsafe {
515 #[primary_span]
516 #[label]
517 pub(crate) span: Span,
518 #[subdiagnostic]
519 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
520}
521
522#[derive(Diagnostic)]
523#[diag(
524 mir_build_unsafe_binder_cast_requires_unsafe_unsafe_op_in_unsafe_fn_allowed,
525 code = E0133,
526)]
527pub(crate) struct UnsafeBinderCastRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
528 #[primary_span]
529 #[label]
530 pub(crate) span: Span,
531 #[subdiagnostic]
532 pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
533}
534
535#[derive(Subdiagnostic)]
536#[label(mir_build_unsafe_not_inherited)]
537pub(crate) struct UnsafeNotInheritedNote {
538 #[primary_span]
539 pub(crate) span: Span,
540}
541
542pub(crate) struct UnsafeNotInheritedLintNote {
543 pub(crate) signature_span: Span,
544 pub(crate) body_span: Span,
545}
546
547impl Subdiagnostic for UnsafeNotInheritedLintNote {
548 fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
549 diag.span_note(self.signature_span, fluent::mir_build_unsafe_fn_safe_body);
550 let body_start = self.body_span.shrink_to_lo();
551 let body_end = self.body_span.shrink_to_hi();
552 diag.tool_only_multipart_suggestion(
553 fluent::mir_build_wrap_suggestion,
554 vec![(body_start, "{ unsafe ".into()), (body_end, "}".into())],
555 Applicability::MachineApplicable,
556 );
557 }
558}
559
560#[derive(LintDiagnostic)]
561#[diag(mir_build_unused_unsafe)]
562pub(crate) struct UnusedUnsafe {
563 #[label]
564 pub(crate) span: Span,
565 #[subdiagnostic]
566 pub(crate) enclosing: Option<UnusedUnsafeEnclosing>,
567}
568
569#[derive(Subdiagnostic)]
570pub(crate) enum UnusedUnsafeEnclosing {
571 #[label(mir_build_unused_unsafe_enclosing_block_label)]
572 Block {
573 #[primary_span]
574 span: Span,
575 },
576}
577
578pub(crate) struct NonExhaustivePatternsTypeNotEmpty<'p, 'tcx, 'm> {
579 pub(crate) cx: &'m RustcPatCtxt<'p, 'tcx>,
580 pub(crate) scrut_span: Span,
581 pub(crate) braces_span: Option<Span>,
582 pub(crate) ty: Ty<'tcx>,
583}
584
585impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for NonExhaustivePatternsTypeNotEmpty<'_, '_, '_> {
586 fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
587 let mut diag =
588 Diag::new(dcx, level, fluent::mir_build_non_exhaustive_patterns_type_not_empty);
589 diag.span(self.scrut_span);
590 diag.code(E0004);
591 let peeled_ty = self.ty.peel_refs();
592 diag.arg("ty", self.ty);
593 diag.arg("peeled_ty", peeled_ty);
594
595 if let ty::Adt(def, _) = peeled_ty.kind() {
596 let def_span = self
597 .cx
598 .tcx
599 .hir_get_if_local(def.did())
600 .and_then(|node| node.ident())
601 .map(|ident| ident.span)
602 .unwrap_or_else(|| self.cx.tcx.def_span(def.did()));
603
604 let mut span: MultiSpan = def_span.into();
606 span.push_span_label(def_span, "");
607
608 diag.span_note(span, fluent::mir_build_def_note);
609 }
610
611 let is_non_exhaustive = matches!(self.ty.kind(),
612 ty::Adt(def, _) if def.variant_list_has_applicable_non_exhaustive());
613 if is_non_exhaustive {
614 diag.note(fluent::mir_build_non_exhaustive_type_note);
615 } else {
616 diag.note(fluent::mir_build_type_note);
617 }
618
619 if let ty::Ref(_, sub_ty, _) = self.ty.kind() {
620 if !sub_ty.is_inhabited_from(self.cx.tcx, self.cx.module, self.cx.typing_env) {
621 diag.note(fluent::mir_build_reference_note);
622 }
623 }
624
625 let sm = self.cx.tcx.sess.source_map();
626 if let Some(braces_span) = self.braces_span {
627 let (indentation, more) = if let Some(snippet) = sm.indentation_before(self.scrut_span)
629 {
630 (format!("\n{snippet}"), " ")
631 } else {
632 (" ".to_string(), "")
633 };
634 diag.span_suggestion_verbose(
635 braces_span,
636 fluent::mir_build_suggestion,
637 format!(" {{{indentation}{more}_ => todo!(),{indentation}}}"),
638 Applicability::HasPlaceholders,
639 );
640 } else {
641 diag.help(fluent::mir_build_help);
642 }
643
644 diag
645 }
646}
647
648#[derive(Subdiagnostic)]
649#[note(mir_build_non_exhaustive_match_all_arms_guarded)]
650pub(crate) struct NonExhaustiveMatchAllArmsGuarded;
651
652#[derive(Diagnostic)]
653#[diag(mir_build_static_in_pattern, code = E0158)]
654pub(crate) struct StaticInPattern {
655 #[primary_span]
656 #[label]
657 pub(crate) span: Span,
658 #[label(mir_build_static_in_pattern_def)]
659 pub(crate) static_span: Span,
660}
661
662#[derive(Diagnostic)]
663#[diag(mir_build_const_param_in_pattern, code = E0158)]
664pub(crate) struct ConstParamInPattern {
665 #[primary_span]
666 #[label]
667 pub(crate) span: Span,
668 #[label(mir_build_const_param_in_pattern_def)]
669 pub(crate) const_span: Span,
670}
671
672#[derive(Diagnostic)]
673#[diag(mir_build_non_const_path, code = E0080)]
674pub(crate) struct NonConstPath {
675 #[primary_span]
676 #[label]
677 pub(crate) span: Span,
678}
679
680#[derive(LintDiagnostic)]
681#[diag(mir_build_unreachable_pattern)]
682pub(crate) struct UnreachablePattern<'tcx> {
683 #[label]
684 pub(crate) span: Option<Span>,
685 #[label(mir_build_unreachable_matches_no_values)]
686 pub(crate) matches_no_values: Option<Span>,
687 pub(crate) matches_no_values_ty: Ty<'tcx>,
688 #[note(mir_build_unreachable_uninhabited_note)]
689 pub(crate) uninhabited_note: Option<()>,
690 #[label(mir_build_unreachable_covered_by_catchall)]
691 pub(crate) covered_by_catchall: Option<Span>,
692 #[subdiagnostic]
693 pub(crate) wanted_constant: Option<WantedConstant>,
694 #[note(mir_build_unreachable_pattern_const_reexport_accessible)]
695 pub(crate) accessible_constant: Option<Span>,
696 #[note(mir_build_unreachable_pattern_const_inaccessible)]
697 pub(crate) inaccessible_constant: Option<Span>,
698 #[note(mir_build_unreachable_pattern_let_binding)]
699 pub(crate) pattern_let_binding: Option<Span>,
700 #[label(mir_build_unreachable_covered_by_one)]
701 pub(crate) covered_by_one: Option<Span>,
702 #[note(mir_build_unreachable_covered_by_many)]
703 pub(crate) covered_by_many: Option<MultiSpan>,
704 pub(crate) covered_by_many_n_more_count: usize,
705 #[suggestion(code = "", applicability = "machine-applicable")]
706 pub(crate) suggest_remove: Option<Span>,
707}
708
709#[derive(Subdiagnostic)]
710#[suggestion(
711 mir_build_unreachable_pattern_wanted_const,
712 code = "{const_path}",
713 applicability = "machine-applicable"
714)]
715pub(crate) struct WantedConstant {
716 #[primary_span]
717 pub(crate) span: Span,
718 pub(crate) is_typo: bool,
719 pub(crate) const_name: String,
720 pub(crate) const_path: String,
721}
722
723#[derive(LintDiagnostic)]
724#[diag(mir_build_unreachable_due_to_uninhabited)]
725pub(crate) struct UnreachableDueToUninhabited<'desc, 'tcx> {
726 pub descr: &'desc str,
727 #[label]
728 pub expr: Span,
729 #[label(mir_build_label_orig)]
730 #[note]
731 pub orig: Span,
732 pub ty: Ty<'tcx>,
733}
734
735#[derive(Diagnostic)]
736#[diag(mir_build_const_pattern_depends_on_generic_parameter, code = E0158)]
737pub(crate) struct ConstPatternDependsOnGenericParameter {
738 #[primary_span]
739 #[label]
740 pub(crate) span: Span,
741}
742
743#[derive(Diagnostic)]
744#[diag(mir_build_could_not_eval_const_pattern)]
745pub(crate) struct CouldNotEvalConstPattern {
746 #[primary_span]
747 #[label]
748 pub(crate) span: Span,
749}
750
751#[derive(Diagnostic)]
752#[diag(mir_build_lower_range_bound_must_be_less_than_or_equal_to_upper, code = E0030)]
753pub(crate) struct LowerRangeBoundMustBeLessThanOrEqualToUpper {
754 #[primary_span]
755 #[label]
756 pub(crate) span: Span,
757 #[note(mir_build_teach_note)]
758 pub(crate) teach: bool,
759}
760
761#[derive(Diagnostic)]
762#[diag(mir_build_literal_in_range_out_of_bounds)]
763pub(crate) struct LiteralOutOfRange<'tcx> {
764 #[primary_span]
765 #[label]
766 pub(crate) span: Span,
767 pub(crate) ty: Ty<'tcx>,
768 pub(crate) min: i128,
769 pub(crate) max: u128,
770}
771
772#[derive(Diagnostic)]
773#[diag(mir_build_lower_range_bound_must_be_less_than_upper, code = E0579)]
774pub(crate) struct LowerRangeBoundMustBeLessThanUpper {
775 #[primary_span]
776 pub(crate) span: Span,
777}
778
779#[derive(LintDiagnostic)]
780#[diag(mir_build_leading_irrefutable_let_patterns)]
781#[note]
782#[help]
783pub(crate) struct LeadingIrrefutableLetPatterns {
784 pub(crate) count: usize,
785}
786
787#[derive(LintDiagnostic)]
788#[diag(mir_build_trailing_irrefutable_let_patterns)]
789#[note]
790#[help]
791pub(crate) struct TrailingIrrefutableLetPatterns {
792 pub(crate) count: usize,
793}
794
795#[derive(LintDiagnostic)]
796#[diag(mir_build_bindings_with_variant_name, code = E0170)]
797pub(crate) struct BindingsWithVariantName {
798 #[suggestion(code = "{ty_path}::{name}", applicability = "machine-applicable")]
799 pub(crate) suggestion: Option<Span>,
800 pub(crate) ty_path: String,
801 pub(crate) name: Ident,
802}
803
804#[derive(LintDiagnostic)]
805#[diag(mir_build_irrefutable_let_patterns_if_let)]
806#[note]
807#[help]
808pub(crate) struct IrrefutableLetPatternsIfLet {
809 pub(crate) count: usize,
810}
811
812#[derive(LintDiagnostic)]
813#[diag(mir_build_irrefutable_let_patterns_if_let_guard)]
814#[note]
815#[help]
816pub(crate) struct IrrefutableLetPatternsIfLetGuard {
817 pub(crate) count: usize,
818}
819
820#[derive(LintDiagnostic)]
821#[diag(mir_build_irrefutable_let_patterns_let_else)]
822#[note]
823#[help]
824pub(crate) struct IrrefutableLetPatternsLetElse {
825 pub(crate) count: usize,
826}
827
828#[derive(LintDiagnostic)]
829#[diag(mir_build_irrefutable_let_patterns_while_let)]
830#[note]
831#[help]
832pub(crate) struct IrrefutableLetPatternsWhileLet {
833 pub(crate) count: usize,
834}
835
836#[derive(Diagnostic)]
837#[diag(mir_build_borrow_of_moved_value)]
838pub(crate) struct BorrowOfMovedValue<'tcx> {
839 #[primary_span]
840 #[label]
841 #[label(mir_build_occurs_because_label)]
842 pub(crate) binding_span: Span,
843 #[label(mir_build_value_borrowed_label)]
844 pub(crate) conflicts_ref: Vec<Span>,
845 pub(crate) name: Ident,
846 pub(crate) ty: Ty<'tcx>,
847 #[suggestion(code = "ref ", applicability = "machine-applicable")]
848 pub(crate) suggest_borrowing: Option<Span>,
849}
850
851#[derive(Diagnostic)]
852#[diag(mir_build_multiple_mut_borrows)]
853pub(crate) struct MultipleMutBorrows {
854 #[primary_span]
855 pub(crate) span: Span,
856 #[subdiagnostic]
857 pub(crate) occurrences: Vec<Conflict>,
858}
859
860#[derive(Diagnostic)]
861#[diag(mir_build_already_borrowed)]
862pub(crate) struct AlreadyBorrowed {
863 #[primary_span]
864 pub(crate) span: Span,
865 #[subdiagnostic]
866 pub(crate) occurrences: Vec<Conflict>,
867}
868
869#[derive(Diagnostic)]
870#[diag(mir_build_already_mut_borrowed)]
871pub(crate) struct AlreadyMutBorrowed {
872 #[primary_span]
873 pub(crate) span: Span,
874 #[subdiagnostic]
875 pub(crate) occurrences: Vec<Conflict>,
876}
877
878#[derive(Diagnostic)]
879#[diag(mir_build_moved_while_borrowed)]
880pub(crate) struct MovedWhileBorrowed {
881 #[primary_span]
882 pub(crate) span: Span,
883 #[subdiagnostic]
884 pub(crate) occurrences: Vec<Conflict>,
885}
886
887#[derive(Subdiagnostic)]
888pub(crate) enum Conflict {
889 #[label(mir_build_mutable_borrow)]
890 Mut {
891 #[primary_span]
892 span: Span,
893 name: Symbol,
894 },
895 #[label(mir_build_borrow)]
896 Ref {
897 #[primary_span]
898 span: Span,
899 name: Symbol,
900 },
901 #[label(mir_build_moved)]
902 Moved {
903 #[primary_span]
904 span: Span,
905 name: Symbol,
906 },
907}
908
909#[derive(Diagnostic)]
910#[diag(mir_build_union_pattern)]
911pub(crate) struct UnionPattern {
912 #[primary_span]
913 #[label]
914 pub(crate) span: Span,
915}
916
917#[derive(Diagnostic)]
918#[diag(mir_build_type_not_structural)]
919pub(crate) struct TypeNotStructural<'tcx> {
920 #[primary_span]
921 #[label]
922 pub(crate) span: Span,
923 #[label(mir_build_type_not_structural_def)]
924 pub(crate) ty_def_span: Span,
925 pub(crate) ty: Ty<'tcx>,
926 #[note(mir_build_type_not_structural_tip)]
927 pub(crate) manual_partialeq_impl_span: Option<Span>,
928 #[note(mir_build_type_not_structural_more_info)]
929 pub(crate) manual_partialeq_impl_note: bool,
930}
931
932#[derive(Diagnostic)]
933#[diag(mir_build_non_partial_eq_match)]
934#[note(mir_build_type_not_structural_more_info)]
935pub(crate) struct TypeNotPartialEq<'tcx> {
936 #[primary_span]
937 #[label]
938 pub(crate) span: Span,
939 pub(crate) ty: Ty<'tcx>,
940}
941
942#[derive(Diagnostic)]
943#[diag(mir_build_invalid_pattern)]
944pub(crate) struct InvalidPattern<'tcx> {
945 #[primary_span]
946 #[label]
947 pub(crate) span: Span,
948 pub(crate) non_sm_ty: Ty<'tcx>,
949 pub(crate) prefix: String,
950}
951
952#[derive(Diagnostic)]
953#[diag(mir_build_unsized_pattern)]
954pub(crate) struct UnsizedPattern<'tcx> {
955 #[primary_span]
956 pub(crate) span: Span,
957 pub(crate) non_sm_ty: Ty<'tcx>,
958}
959
960#[derive(Diagnostic)]
961#[diag(mir_build_nan_pattern)]
962#[note]
963#[help]
964pub(crate) struct NaNPattern {
965 #[primary_span]
966 #[label]
967 pub(crate) span: Span,
968}
969
970#[derive(Diagnostic)]
971#[diag(mir_build_pointer_pattern)]
972#[note]
973pub(crate) struct PointerPattern {
974 #[primary_span]
975 #[label]
976 pub(crate) span: Span,
977}
978
979#[derive(Diagnostic)]
980#[diag(mir_build_non_empty_never_pattern)]
981#[note]
982pub(crate) struct NonEmptyNeverPattern<'tcx> {
983 #[primary_span]
984 #[label]
985 pub(crate) span: Span,
986 pub(crate) ty: Ty<'tcx>,
987}
988
989#[derive(Diagnostic)]
990#[diag(mir_build_pattern_not_covered, code = E0005)]
991pub(crate) struct PatternNotCovered<'s, 'tcx> {
992 #[primary_span]
993 pub(crate) span: Span,
994 pub(crate) origin: &'s str,
995 #[subdiagnostic]
996 pub(crate) uncovered: Uncovered,
997 #[subdiagnostic]
998 pub(crate) inform: Option<Inform>,
999 #[subdiagnostic]
1000 pub(crate) interpreted_as_const: Option<InterpretedAsConst>,
1001 #[subdiagnostic]
1002 pub(crate) interpreted_as_const_sugg: Option<InterpretedAsConstSugg>,
1003 #[subdiagnostic]
1004 pub(crate) adt_defined_here: Option<AdtDefinedHere<'tcx>>,
1005 #[note(mir_build_privately_uninhabited)]
1006 pub(crate) witness_1_is_privately_uninhabited: bool,
1007 pub(crate) witness_1: String,
1008 #[note(mir_build_pattern_ty)]
1009 pub(crate) _p: (),
1010 pub(crate) pattern_ty: Ty<'tcx>,
1011 #[subdiagnostic]
1012 pub(crate) let_suggestion: Option<SuggestLet>,
1013 #[subdiagnostic]
1014 pub(crate) misc_suggestion: Option<MiscPatternSuggestion>,
1015}
1016
1017#[derive(Subdiagnostic)]
1018#[note(mir_build_inform_irrefutable)]
1019#[note(mir_build_more_information)]
1020pub(crate) struct Inform;
1021
1022#[derive(Subdiagnostic)]
1023#[label(mir_build_confused)]
1024pub(crate) struct InterpretedAsConst {
1025 #[primary_span]
1026 pub(crate) span: Span,
1027 pub(crate) variable: String,
1028}
1029
1030pub(crate) struct AdtDefinedHere<'tcx> {
1031 pub(crate) adt_def_span: Span,
1032 pub(crate) ty: Ty<'tcx>,
1033 pub(crate) variants: Vec<Variant>,
1034}
1035
1036pub(crate) struct Variant {
1037 pub(crate) span: Span,
1038}
1039
1040impl<'tcx> Subdiagnostic for AdtDefinedHere<'tcx> {
1041 fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
1042 diag.arg("ty", self.ty);
1043 let mut spans = MultiSpan::from(self.adt_def_span);
1044
1045 for Variant { span } in self.variants {
1046 spans.push_span_label(span, fluent::mir_build_variant_defined_here);
1047 }
1048
1049 diag.span_note(spans, fluent::mir_build_adt_defined_here);
1050 }
1051}
1052
1053#[derive(Subdiagnostic)]
1054#[suggestion(
1055 mir_build_interpreted_as_const,
1056 code = "{variable}_var",
1057 applicability = "maybe-incorrect",
1058 style = "verbose"
1059)]
1060pub(crate) struct InterpretedAsConstSugg {
1061 #[primary_span]
1062 pub(crate) span: Span,
1063 pub(crate) variable: String,
1064}
1065
1066#[derive(Subdiagnostic)]
1067pub(crate) enum SuggestLet {
1068 #[multipart_suggestion(mir_build_suggest_if_let, applicability = "has-placeholders")]
1069 If {
1070 #[suggestion_part(code = "if ")]
1071 start_span: Span,
1072 #[suggestion_part(code = " {{ todo!() }}")]
1073 semi_span: Span,
1074 count: usize,
1075 },
1076 #[suggestion(
1077 mir_build_suggest_let_else,
1078 code = " else {{ todo!() }}",
1079 applicability = "has-placeholders"
1080 )]
1081 Else {
1082 #[primary_span]
1083 end_span: Span,
1084 count: usize,
1085 },
1086}
1087
1088#[derive(Subdiagnostic)]
1089pub(crate) enum MiscPatternSuggestion {
1090 #[suggestion(
1091 mir_build_suggest_attempted_int_lit,
1092 code = "_",
1093 applicability = "maybe-incorrect"
1094 )]
1095 AttemptedIntegerLiteral {
1096 #[primary_span]
1097 start_span: Span,
1098 },
1099}
1100
1101#[derive(Diagnostic)]
1102#[diag(mir_build_loop_match_invalid_update)]
1103pub(crate) struct LoopMatchInvalidUpdate {
1104 #[primary_span]
1105 pub lhs: Span,
1106 #[label]
1107 pub scrutinee: Span,
1108}
1109
1110#[derive(Diagnostic)]
1111#[diag(mir_build_loop_match_invalid_match)]
1112#[note]
1113pub(crate) struct LoopMatchInvalidMatch {
1114 #[primary_span]
1115 pub span: Span,
1116}
1117
1118#[derive(Diagnostic)]
1119#[diag(mir_build_loop_match_unsupported_type)]
1120#[note]
1121pub(crate) struct LoopMatchUnsupportedType<'tcx> {
1122 #[primary_span]
1123 pub span: Span,
1124 pub ty: Ty<'tcx>,
1125}
1126
1127#[derive(Diagnostic)]
1128#[diag(mir_build_loop_match_bad_statements)]
1129pub(crate) struct LoopMatchBadStatements {
1130 #[primary_span]
1131 pub span: Span,
1132}
1133
1134#[derive(Diagnostic)]
1135#[diag(mir_build_loop_match_bad_rhs)]
1136pub(crate) struct LoopMatchBadRhs {
1137 #[primary_span]
1138 pub span: Span,
1139}
1140
1141#[derive(Diagnostic)]
1142#[diag(mir_build_loop_match_missing_assignment)]
1143pub(crate) struct LoopMatchMissingAssignment {
1144 #[primary_span]
1145 pub span: Span,
1146}
1147
1148#[derive(Diagnostic)]
1149#[diag(mir_build_loop_match_arm_with_guard)]
1150pub(crate) struct LoopMatchArmWithGuard {
1151 #[primary_span]
1152 pub span: Span,
1153}
1154
1155#[derive(Diagnostic)]
1156#[diag(mir_build_const_continue_not_const)]
1157#[help]
1158pub(crate) struct ConstContinueNotMonomorphicConst {
1159 #[primary_span]
1160 pub span: Span,
1161
1162 #[subdiagnostic]
1163 pub reason: ConstContinueNotMonomorphicConstReason,
1164}
1165
1166#[derive(Subdiagnostic)]
1167pub(crate) enum ConstContinueNotMonomorphicConstReason {
1168 #[label(mir_build_const_continue_not_const_constant_parameter)]
1169 ConstantParameter {
1170 #[primary_span]
1171 span: Span,
1172 },
1173
1174 #[label(mir_build_const_continue_not_const_const_block)]
1175 ConstBlock {
1176 #[primary_span]
1177 span: Span,
1178 },
1179
1180 #[label(mir_build_const_continue_not_const_const_other)]
1181 Other {
1182 #[primary_span]
1183 span: Span,
1184 },
1185}
1186
1187#[derive(Diagnostic)]
1188#[diag(mir_build_const_continue_bad_const)]
1189pub(crate) struct ConstContinueBadConst {
1190 #[primary_span]
1191 #[label]
1192 pub span: Span,
1193}
1194
1195#[derive(Diagnostic)]
1196#[diag(mir_build_const_continue_missing_label_or_value)]
1197pub(crate) struct ConstContinueMissingLabelOrValue {
1198 #[primary_span]
1199 pub span: Span,
1200}
1201
1202#[derive(Diagnostic)]
1203#[diag(mir_build_const_continue_unknown_jump_target)]
1204pub(crate) struct ConstContinueUnknownJumpTarget {
1205 #[primary_span]
1206 pub span: Span,
1207}