rustc_mir_build/
errors.rs

Help
1use rustc_data_structures::fx::FxIndexMap;
2use rustc_errors::codes::*;
3use rustc_errors::{
4    Applicability, Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level,
5    MultiSpan, SubdiagMessageOp, 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_with<G: EmissionGuarantee, F: SubdiagMessageOp<G>>(
550        self,
551        diag: &mut Diag<'_, G>,
552        _f: &F,
553    ) {
554        diag.span_note(self.signature_span, fluent::mir_build_unsafe_fn_safe_body);
555        let body_start = self.body_span.shrink_to_lo();
556        let body_end = self.body_span.shrink_to_hi();
557        diag.tool_only_multipart_suggestion(
558            fluent::mir_build_wrap_suggestion,
559            vec![(body_start, "{ unsafe ".into()), (body_end, "}".into())],
560            Applicability::MachineApplicable,
561        );
562    }
563}
564
565#[derive(LintDiagnostic)]
566#[diag(mir_build_unused_unsafe)]
567pub(crate) struct UnusedUnsafe {
568    #[label]
569    pub(crate) span: Span,
570    #[subdiagnostic]
571    pub(crate) enclosing: Option<UnusedUnsafeEnclosing>,
572}
573
574#[derive(Subdiagnostic)]
575pub(crate) enum UnusedUnsafeEnclosing {
576    #[label(mir_build_unused_unsafe_enclosing_block_label)]
577    Block {
578        #[primary_span]
579        span: Span,
580    },
581}
582
583pub(crate) struct NonExhaustivePatternsTypeNotEmpty<'p, 'tcx, 'm> {
584    pub(crate) cx: &'m RustcPatCtxt<'p, 'tcx>,
585    pub(crate) scrut_span: Span,
586    pub(crate) braces_span: Option<Span>,
587    pub(crate) ty: Ty<'tcx>,
588}
589
590impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for NonExhaustivePatternsTypeNotEmpty<'_, '_, '_> {
591    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
592        let mut diag =
593            Diag::new(dcx, level, fluent::mir_build_non_exhaustive_patterns_type_not_empty);
594        diag.span(self.scrut_span);
595        diag.code(E0004);
596        let peeled_ty = self.ty.peel_refs();
597        diag.arg("ty", self.ty);
598        diag.arg("peeled_ty", peeled_ty);
599
600        if let ty::Adt(def, _) = peeled_ty.kind() {
601            let def_span = self
602                .cx
603                .tcx
604                .hir()
605                .get_if_local(def.did())
606                .and_then(|node| node.ident())
607                .map(|ident| ident.span)
608                .unwrap_or_else(|| self.cx.tcx.def_span(def.did()));
609
610            // workaround to make test pass
611            let mut span: MultiSpan = def_span.into();
612            span.push_span_label(def_span, "");
613
614            diag.span_note(span, fluent::mir_build_def_note);
615        }
616
617        let is_variant_list_non_exhaustive = matches!(self.ty.kind(),
618            ty::Adt(def, _) if def.is_variant_list_non_exhaustive() && !def.did().is_local());
619        if is_variant_list_non_exhaustive {
620            diag.note(fluent::mir_build_non_exhaustive_type_note);
621        } else {
622            diag.note(fluent::mir_build_type_note);
623        }
624
625        if let ty::Ref(_, sub_ty, _) = self.ty.kind() {
626            if !sub_ty.is_inhabited_from(self.cx.tcx, self.cx.module, self.cx.typing_env) {
627                diag.note(fluent::mir_build_reference_note);
628            }
629        }
630
631        let sm = self.cx.tcx.sess.source_map();
632        if let Some(braces_span) = self.braces_span {
633            // Get the span for the empty match body `{}`.
634            let (indentation, more) = if let Some(snippet) = sm.indentation_before(self.scrut_span)
635            {
636                (format!("\n{snippet}"), "    ")
637            } else {
638                (" ".to_string(), "")
639            };
640            diag.span_suggestion_verbose(
641                braces_span,
642                fluent::mir_build_suggestion,
643                format!(" {{{indentation}{more}_ => todo!(),{indentation}}}"),
644                Applicability::HasPlaceholders,
645            );
646        } else {
647            diag.help(fluent::mir_build_help);
648        }
649
650        diag
651    }
652}
653
654#[derive(Subdiagnostic)]
655#[note(mir_build_non_exhaustive_match_all_arms_guarded)]
656pub(crate) struct NonExhaustiveMatchAllArmsGuarded;
657
658#[derive(Diagnostic)]
659#[diag(mir_build_static_in_pattern, code = E0158)]
660pub(crate) struct StaticInPattern {
661    #[primary_span]
662    #[label]
663    pub(crate) span: Span,
664    #[label(mir_build_static_in_pattern_def)]
665    pub(crate) static_span: Span,
666}
667
668#[derive(Diagnostic)]
669#[diag(mir_build_const_param_in_pattern, code = E0158)]
670pub(crate) struct ConstParamInPattern {
671    #[primary_span]
672    #[label]
673    pub(crate) span: Span,
674    #[label(mir_build_const_param_in_pattern_def)]
675    pub(crate) const_span: Span,
676}
677
678#[derive(Diagnostic)]
679#[diag(mir_build_non_const_path, code = E0080)]
680pub(crate) struct NonConstPath {
681    #[primary_span]
682    #[label]
683    pub(crate) span: Span,
684}
685
686#[derive(LintDiagnostic)]
687#[diag(mir_build_unreachable_pattern)]
688pub(crate) struct UnreachablePattern<'tcx> {
689    #[label]
690    pub(crate) span: Option<Span>,
691    #[label(mir_build_unreachable_matches_no_values)]
692    pub(crate) matches_no_values: Option<Span>,
693    pub(crate) matches_no_values_ty: Ty<'tcx>,
694    #[note(mir_build_unreachable_uninhabited_note)]
695    pub(crate) uninhabited_note: Option<()>,
696    #[label(mir_build_unreachable_covered_by_catchall)]
697    pub(crate) covered_by_catchall: Option<Span>,
698    #[subdiagnostic]
699    pub(crate) wanted_constant: Option<WantedConstant>,
700    #[note(mir_build_unreachable_pattern_const_reexport_accessible)]
701    pub(crate) accessible_constant: Option<Span>,
702    #[note(mir_build_unreachable_pattern_const_inaccessible)]
703    pub(crate) inaccessible_constant: Option<Span>,
704    #[note(mir_build_unreachable_pattern_let_binding)]
705    pub(crate) pattern_let_binding: Option<Span>,
706    #[label(mir_build_unreachable_covered_by_one)]
707    pub(crate) covered_by_one: Option<Span>,
708    #[note(mir_build_unreachable_covered_by_many)]
709    pub(crate) covered_by_many: Option<MultiSpan>,
710    pub(crate) covered_by_many_n_more_count: usize,
711    #[suggestion(code = "", applicability = "machine-applicable")]
712    pub(crate) suggest_remove: Option<Span>,
713}
714
715#[derive(Subdiagnostic)]
716#[suggestion(
717    mir_build_unreachable_pattern_wanted_const,
718    code = "{const_path}",
719    applicability = "machine-applicable"
720)]
721pub(crate) struct WantedConstant {
722    #[primary_span]
723    pub(crate) span: Span,
724    pub(crate) is_typo: bool,
725    pub(crate) const_name: String,
726    pub(crate) const_path: String,
727}
728
729#[derive(Diagnostic)]
730#[diag(mir_build_const_pattern_depends_on_generic_parameter, code = E0158)]
731pub(crate) struct ConstPatternDependsOnGenericParameter {
732    #[primary_span]
733    #[label]
734    pub(crate) span: Span,
735}
736
737#[derive(Diagnostic)]
738#[diag(mir_build_could_not_eval_const_pattern)]
739pub(crate) struct CouldNotEvalConstPattern {
740    #[primary_span]
741    #[label]
742    pub(crate) span: Span,
743}
744
745#[derive(Diagnostic)]
746#[diag(mir_build_lower_range_bound_must_be_less_than_or_equal_to_upper, code = E0030)]
747pub(crate) struct LowerRangeBoundMustBeLessThanOrEqualToUpper {
748    #[primary_span]
749    #[label]
750    pub(crate) span: Span,
751    #[note(mir_build_teach_note)]
752    pub(crate) teach: bool,
753}
754
755#[derive(Diagnostic)]
756#[diag(mir_build_literal_in_range_out_of_bounds)]
757pub(crate) struct LiteralOutOfRange<'tcx> {
758    #[primary_span]
759    #[label]
760    pub(crate) span: Span,
761    pub(crate) ty: Ty<'tcx>,
762    pub(crate) min: i128,
763    pub(crate) max: u128,
764}
765
766#[derive(Diagnostic)]
767#[diag(mir_build_lower_range_bound_must_be_less_than_upper, code = E0579)]
768pub(crate) struct LowerRangeBoundMustBeLessThanUpper {
769    #[primary_span]
770    pub(crate) span: Span,
771}
772
773#[derive(LintDiagnostic)]
774#[diag(mir_build_leading_irrefutable_let_patterns)]
775#[note]
776#[help]
777pub(crate) struct LeadingIrrefutableLetPatterns {
778    pub(crate) count: usize,
779}
780
781#[derive(LintDiagnostic)]
782#[diag(mir_build_trailing_irrefutable_let_patterns)]
783#[note]
784#[help]
785pub(crate) struct TrailingIrrefutableLetPatterns {
786    pub(crate) count: usize,
787}
788
789#[derive(LintDiagnostic)]
790#[diag(mir_build_bindings_with_variant_name, code = E0170)]
791pub(crate) struct BindingsWithVariantName {
792    #[suggestion(code = "{ty_path}::{name}", applicability = "machine-applicable")]
793    pub(crate) suggestion: Option<Span>,
794    pub(crate) ty_path: String,
795    pub(crate) name: Ident,
796}
797
798#[derive(LintDiagnostic)]
799#[diag(mir_build_irrefutable_let_patterns_if_let)]
800#[note]
801#[help]
802pub(crate) struct IrrefutableLetPatternsIfLet {
803    pub(crate) count: usize,
804}
805
806#[derive(LintDiagnostic)]
807#[diag(mir_build_irrefutable_let_patterns_if_let_guard)]
808#[note]
809#[help]
810pub(crate) struct IrrefutableLetPatternsIfLetGuard {
811    pub(crate) count: usize,
812}
813
814#[derive(LintDiagnostic)]
815#[diag(mir_build_irrefutable_let_patterns_let_else)]
816#[note]
817#[help]
818pub(crate) struct IrrefutableLetPatternsLetElse {
819    pub(crate) count: usize,
820}
821
822#[derive(LintDiagnostic)]
823#[diag(mir_build_irrefutable_let_patterns_while_let)]
824#[note]
825#[help]
826pub(crate) struct IrrefutableLetPatternsWhileLet {
827    pub(crate) count: usize,
828}
829
830#[derive(Diagnostic)]
831#[diag(mir_build_borrow_of_moved_value)]
832pub(crate) struct BorrowOfMovedValue {
833    #[primary_span]
834    #[label]
835    #[label(mir_build_occurs_because_label)]
836    pub(crate) binding_span: Span,
837    #[label(mir_build_value_borrowed_label)]
838    pub(crate) conflicts_ref: Vec<Span>,
839    pub(crate) name: Ident,
840    pub(crate) ty: String,
841    #[suggestion(code = "ref ", applicability = "machine-applicable")]
842    pub(crate) suggest_borrowing: Option<Span>,
843}
844
845#[derive(Diagnostic)]
846#[diag(mir_build_multiple_mut_borrows)]
847pub(crate) struct MultipleMutBorrows {
848    #[primary_span]
849    pub(crate) span: Span,
850    #[subdiagnostic]
851    pub(crate) occurrences: Vec<Conflict>,
852}
853
854#[derive(Diagnostic)]
855#[diag(mir_build_already_borrowed)]
856pub(crate) struct AlreadyBorrowed {
857    #[primary_span]
858    pub(crate) span: Span,
859    #[subdiagnostic]
860    pub(crate) occurrences: Vec<Conflict>,
861}
862
863#[derive(Diagnostic)]
864#[diag(mir_build_already_mut_borrowed)]
865pub(crate) struct AlreadyMutBorrowed {
866    #[primary_span]
867    pub(crate) span: Span,
868    #[subdiagnostic]
869    pub(crate) occurrences: Vec<Conflict>,
870}
871
872#[derive(Diagnostic)]
873#[diag(mir_build_moved_while_borrowed)]
874pub(crate) struct MovedWhileBorrowed {
875    #[primary_span]
876    pub(crate) span: Span,
877    #[subdiagnostic]
878    pub(crate) occurrences: Vec<Conflict>,
879}
880
881#[derive(Subdiagnostic)]
882pub(crate) enum Conflict {
883    #[label(mir_build_mutable_borrow)]
884    Mut {
885        #[primary_span]
886        span: Span,
887        name: Symbol,
888    },
889    #[label(mir_build_borrow)]
890    Ref {
891        #[primary_span]
892        span: Span,
893        name: Symbol,
894    },
895    #[label(mir_build_moved)]
896    Moved {
897        #[primary_span]
898        span: Span,
899        name: Symbol,
900    },
901}
902
903#[derive(Diagnostic)]
904#[diag(mir_build_union_pattern)]
905pub(crate) struct UnionPattern {
906    #[primary_span]
907    #[label]
908    pub(crate) span: Span,
909}
910
911#[derive(Diagnostic)]
912#[diag(mir_build_type_not_structural)]
913pub(crate) struct TypeNotStructural<'tcx> {
914    #[primary_span]
915    #[label]
916    pub(crate) span: Span,
917    #[label(mir_build_type_not_structural_def)]
918    pub(crate) ty_def_span: Span,
919    pub(crate) ty: Ty<'tcx>,
920    #[note(mir_build_type_not_structural_tip)]
921    pub(crate) manual_partialeq_impl_span: Option<Span>,
922    #[note(mir_build_type_not_structural_more_info)]
923    pub(crate) manual_partialeq_impl_note: bool,
924}
925
926#[derive(Diagnostic)]
927#[diag(mir_build_non_partial_eq_match)]
928#[note(mir_build_type_not_structural_more_info)]
929pub(crate) struct TypeNotPartialEq<'tcx> {
930    #[primary_span]
931    #[label]
932    pub(crate) span: Span,
933    pub(crate) ty: Ty<'tcx>,
934}
935
936#[derive(Diagnostic)]
937#[diag(mir_build_invalid_pattern)]
938pub(crate) struct InvalidPattern<'tcx> {
939    #[primary_span]
940    #[label]
941    pub(crate) span: Span,
942    pub(crate) non_sm_ty: Ty<'tcx>,
943    pub(crate) prefix: String,
944}
945
946#[derive(Diagnostic)]
947#[diag(mir_build_unsized_pattern)]
948pub(crate) struct UnsizedPattern<'tcx> {
949    #[primary_span]
950    pub(crate) span: Span,
951    pub(crate) non_sm_ty: Ty<'tcx>,
952}
953
954#[derive(Diagnostic)]
955#[diag(mir_build_nan_pattern)]
956#[note]
957#[help]
958pub(crate) struct NaNPattern {
959    #[primary_span]
960    #[label]
961    pub(crate) span: Span,
962}
963
964#[derive(Diagnostic)]
965#[diag(mir_build_pointer_pattern)]
966#[note]
967pub(crate) struct PointerPattern {
968    #[primary_span]
969    #[label]
970    pub(crate) span: Span,
971}
972
973#[derive(Diagnostic)]
974#[diag(mir_build_non_empty_never_pattern)]
975#[note]
976pub(crate) struct NonEmptyNeverPattern<'tcx> {
977    #[primary_span]
978    #[label]
979    pub(crate) span: Span,
980    pub(crate) ty: Ty<'tcx>,
981}
982
983#[derive(Diagnostic)]
984#[diag(mir_build_exceeds_mcdc_condition_limit)]
985pub(crate) struct MCDCExceedsConditionLimit {
986    #[primary_span]
987    pub(crate) span: Span,
988    pub(crate) num_conditions: usize,
989    pub(crate) max_conditions: usize,
990}
991
992#[derive(Diagnostic)]
993#[diag(mir_build_pattern_not_covered, code = E0005)]
994pub(crate) struct PatternNotCovered<'s, 'tcx> {
995    #[primary_span]
996    pub(crate) span: Span,
997    pub(crate) origin: &'s str,
998    #[subdiagnostic]
999    pub(crate) uncovered: Uncovered,
1000    #[subdiagnostic]
1001    pub(crate) inform: Option<Inform>,
1002    #[label(mir_build_confused)]
1003    pub(crate) interpreted_as_const: Option<Span>,
1004    #[subdiagnostic]
1005    pub(crate) interpreted_as_const_sugg: Option<InterpretedAsConst>,
1006    #[subdiagnostic]
1007    pub(crate) adt_defined_here: Option<AdtDefinedHere<'tcx>>,
1008    #[note(mir_build_privately_uninhabited)]
1009    pub(crate) witness_1_is_privately_uninhabited: bool,
1010    #[note(mir_build_pattern_ty)]
1011    pub(crate) _p: (),
1012    pub(crate) pattern_ty: Ty<'tcx>,
1013    #[subdiagnostic]
1014    pub(crate) let_suggestion: Option<SuggestLet>,
1015    #[subdiagnostic]
1016    pub(crate) misc_suggestion: Option<MiscPatternSuggestion>,
1017}
1018
1019#[derive(Subdiagnostic)]
1020#[note(mir_build_inform_irrefutable)]
1021#[note(mir_build_more_information)]
1022pub(crate) struct Inform;
1023
1024pub(crate) struct AdtDefinedHere<'tcx> {
1025    pub(crate) adt_def_span: Span,
1026    pub(crate) ty: Ty<'tcx>,
1027    pub(crate) variants: Vec<Variant>,
1028}
1029
1030pub(crate) struct Variant {
1031    pub(crate) span: Span,
1032}
1033
1034impl<'tcx> Subdiagnostic for AdtDefinedHere<'tcx> {
1035    fn add_to_diag_with<G: EmissionGuarantee, F: SubdiagMessageOp<G>>(
1036        self,
1037        diag: &mut Diag<'_, G>,
1038        _f: &F,
1039    ) {
1040        diag.arg("ty", self.ty);
1041        let mut spans = MultiSpan::from(self.adt_def_span);
1042
1043        for Variant { span } in self.variants {
1044            spans.push_span_label(span, fluent::mir_build_variant_defined_here);
1045        }
1046
1047        diag.span_note(spans, fluent::mir_build_adt_defined_here);
1048    }
1049}
1050
1051#[derive(Subdiagnostic)]
1052#[suggestion(
1053    mir_build_interpreted_as_const,
1054    code = "{variable}_var",
1055    applicability = "maybe-incorrect",
1056    style = "verbose"
1057)]
1058pub(crate) struct InterpretedAsConst {
1059    #[primary_span]
1060    pub(crate) span: Span,
1061    pub(crate) variable: String,
1062}
1063
1064#[derive(Subdiagnostic)]
1065pub(crate) enum SuggestLet {
1066    #[multipart_suggestion(mir_build_suggest_if_let, applicability = "has-placeholders")]
1067    If {
1068        #[suggestion_part(code = "if ")]
1069        start_span: Span,
1070        #[suggestion_part(code = " {{ todo!() }}")]
1071        semi_span: Span,
1072        count: usize,
1073    },
1074    #[suggestion(
1075        mir_build_suggest_let_else,
1076        code = " else {{ todo!() }}",
1077        applicability = "has-placeholders"
1078    )]
1079    Else {
1080        #[primary_span]
1081        end_span: Span,
1082        count: usize,
1083    },
1084}
1085
1086#[derive(Subdiagnostic)]
1087pub(crate) enum MiscPatternSuggestion {
1088    #[suggestion(
1089        mir_build_suggest_attempted_int_lit,
1090        code = "_",
1091        applicability = "maybe-incorrect"
1092    )]
1093    AttemptedIntegerLiteral {
1094        #[primary_span]
1095        start_span: Span,
1096    },
1097}
1098
1099#[derive(LintDiagnostic)]
1100#[diag(mir_build_rust_2024_incompatible_pat)]
1101pub(crate) struct Rust2024IncompatiblePat {
1102    #[subdiagnostic]
1103    pub(crate) sugg: Rust2024IncompatiblePatSugg,
1104    pub(crate) bad_modifiers: bool,
1105    pub(crate) bad_ref_pats: bool,
1106    pub(crate) is_hard_error: bool,
1107}
1108
1109pub(crate) struct Rust2024IncompatiblePatSugg {
1110    /// If true, our suggestion is to elide explicit binding modifiers.
1111    /// If false, our suggestion is to make the pattern fully explicit.
1112    pub(crate) suggest_eliding_modes: bool,
1113    pub(crate) suggestion: Vec<(Span, String)>,
1114    pub(crate) ref_pattern_count: usize,
1115    pub(crate) binding_mode_count: usize,
1116    /// Internal state: the ref-mutability of the default binding mode at the subpattern being
1117    /// lowered, with the span where it was introduced. `None` for a by-value default mode.
1118    pub(crate) default_mode_span: Option<(Span, ty::Mutability)>,
1119    /// Labels for where incompatibility-causing by-ref default binding modes were introduced.
1120    pub(crate) default_mode_labels: FxIndexMap<Span, ty::Mutability>,
1121}
1122
1123impl Subdiagnostic for Rust2024IncompatiblePatSugg {
1124    fn add_to_diag_with<G: EmissionGuarantee, F: SubdiagMessageOp<G>>(
1125        self,
1126        diag: &mut Diag<'_, G>,
1127        _f: &F,
1128    ) {
1129        // Format and emit explanatory notes about default binding modes. Reversing the spans' order
1130        // means if we have nested spans, the innermost ones will be visited first.
1131        for (span, def_br_mutbl) in self.default_mode_labels.into_iter().rev() {
1132            // Don't point to a macro call site.
1133            if !span.from_expansion() {
1134                let note_msg = "matching on a reference type with a non-reference pattern changes the default binding mode";
1135                let label_msg =
1136                    format!("this matches on type `{}_`", def_br_mutbl.ref_prefix_str());
1137                let mut label = MultiSpan::from(span);
1138                label.push_span_label(span, label_msg);
1139                diag.span_note(label, note_msg);
1140            }
1141        }
1142
1143        // Format and emit the suggestion.
1144        let applicability =
1145            if self.suggestion.iter().all(|(span, _)| span.can_be_used_for_suggestions()) {
1146                Applicability::MachineApplicable
1147            } else {
1148                Applicability::MaybeIncorrect
1149            };
1150        let msg = if self.suggest_eliding_modes {
1151            let plural_modes = pluralize!(self.binding_mode_count);
1152            format!("remove the unnecessary binding modifier{plural_modes}")
1153        } else {
1154            let plural_derefs = pluralize!(self.ref_pattern_count);
1155            let and_modes = if self.binding_mode_count > 0 {
1156                format!(" and variable binding mode{}", pluralize!(self.binding_mode_count))
1157            } else {
1158                String::new()
1159            };
1160            format!("make the implied reference pattern{plural_derefs}{and_modes} explicit")
1161        };
1162        // FIXME(dianne): for peace of mind, don't risk emitting a 0-part suggestion (that panics!)
1163        if !self.suggestion.is_empty() {
1164            diag.multipart_suggestion_verbose(msg, self.suggestion, applicability);
1165        }
1166    }
1167}
rustc_mir_build/errors.rs

rustc_mir_build/
errors.rs
