rustc_mir_build/
errors.rs

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

rustc_mir_build/
errors.rs
