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

rustc_mir_build/
errors.rs
