rustc_builtin_macros/
errors.rs

1use rustc_errors::codes::*;
2use rustc_errors::{
3    Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level, MultiSpan, SingleLabelManySpans,
4    Subdiagnostic,
5};
6use rustc_macros::{Diagnostic, Subdiagnostic};
7use rustc_span::{Ident, Span, Symbol};
8
9#[derive(Diagnostic)]
10#[diag(builtin_macros_requires_cfg_pattern)]
11pub(crate) struct RequiresCfgPattern {
12    #[primary_span]
13    #[label]
14    pub(crate) span: Span,
15}
16
17#[derive(Diagnostic)]
18#[diag(builtin_macros_expected_one_cfg_pattern)]
19pub(crate) struct OneCfgPattern {
20    #[primary_span]
21    pub(crate) span: Span,
22}
23
24#[derive(Diagnostic)]
25#[diag(builtin_macros_alloc_error_must_be_fn)]
26pub(crate) struct AllocErrorMustBeFn {
27    #[primary_span]
28    pub(crate) span: Span,
29}
30
31#[derive(Diagnostic)]
32#[diag(builtin_macros_assert_requires_boolean)]
33pub(crate) struct AssertRequiresBoolean {
34    #[primary_span]
35    #[label]
36    pub(crate) span: Span,
37}
38
39#[derive(Diagnostic)]
40#[diag(builtin_macros_assert_requires_expression)]
41pub(crate) struct AssertRequiresExpression {
42    #[primary_span]
43    pub(crate) span: Span,
44    #[suggestion(code = "", applicability = "maybe-incorrect")]
45    pub(crate) token: Span,
46}
47
48#[derive(Diagnostic)]
49#[diag(builtin_macros_assert_missing_comma)]
50pub(crate) struct AssertMissingComma {
51    #[primary_span]
52    pub(crate) span: Span,
53    #[suggestion(code = ", ", applicability = "maybe-incorrect", style = "short")]
54    pub(crate) comma: Span,
55}
56
57#[derive(Diagnostic)]
58pub(crate) enum CfgAccessibleInvalid {
59    #[diag(builtin_macros_cfg_accessible_unspecified_path)]
60    UnspecifiedPath(#[primary_span] Span),
61    #[diag(builtin_macros_cfg_accessible_multiple_paths)]
62    MultiplePaths(#[primary_span] Span),
63    #[diag(builtin_macros_cfg_accessible_literal_path)]
64    LiteralPath(#[primary_span] Span),
65    #[diag(builtin_macros_cfg_accessible_has_args)]
66    HasArguments(#[primary_span] Span),
67}
68
69#[derive(Diagnostic)]
70#[diag(builtin_macros_cfg_accessible_indeterminate)]
71pub(crate) struct CfgAccessibleIndeterminate {
72    #[primary_span]
73    pub(crate) span: Span,
74}
75
76#[derive(Diagnostic)]
77#[diag(builtin_macros_concat_missing_literal)]
78#[note]
79pub(crate) struct ConcatMissingLiteral {
80    #[primary_span]
81    pub(crate) spans: Vec<Span>,
82}
83
84#[derive(Diagnostic)]
85#[diag(builtin_macros_concat_bytestr)]
86pub(crate) struct ConcatBytestr {
87    #[primary_span]
88    pub(crate) span: Span,
89}
90
91#[derive(Diagnostic)]
92#[diag(builtin_macros_concat_c_str_lit)]
93pub(crate) struct ConcatCStrLit {
94    #[primary_span]
95    pub(crate) span: Span,
96}
97
98#[derive(Diagnostic)]
99#[diag(builtin_macros_export_macro_rules)]
100pub(crate) struct ExportMacroRules {
101    #[primary_span]
102    pub(crate) span: Span,
103}
104
105#[derive(Diagnostic)]
106#[diag(builtin_macros_proc_macro)]
107pub(crate) struct ProcMacro {
108    #[primary_span]
109    pub(crate) span: Span,
110}
111
112#[derive(Diagnostic)]
113#[diag(builtin_macros_trace_macros)]
114pub(crate) struct TraceMacros {
115    #[primary_span]
116    pub(crate) span: Span,
117}
118
119#[derive(Diagnostic)]
120#[diag(builtin_macros_bench_sig)]
121pub(crate) struct BenchSig {
122    #[primary_span]
123    pub(crate) span: Span,
124}
125
126#[derive(Diagnostic)]
127#[diag(builtin_macros_alloc_must_statics)]
128pub(crate) struct AllocMustStatics {
129    #[primary_span]
130    pub(crate) span: Span,
131}
132
133pub(crate) use autodiff::*;
134
135mod autodiff {
136    use super::*;
137    #[derive(Diagnostic)]
138    #[diag(builtin_macros_autodiff_missing_config)]
139    pub(crate) struct AutoDiffMissingConfig {
140        #[primary_span]
141        pub(crate) span: Span,
142    }
143    #[derive(Diagnostic)]
144    #[diag(builtin_macros_autodiff_unknown_activity)]
145    pub(crate) struct AutoDiffUnknownActivity {
146        #[primary_span]
147        pub(crate) span: Span,
148        pub(crate) act: String,
149    }
150    #[derive(Diagnostic)]
151    #[diag(builtin_macros_autodiff_ty_activity)]
152    pub(crate) struct AutoDiffInvalidTypeForActivity {
153        #[primary_span]
154        pub(crate) span: Span,
155        pub(crate) act: String,
156    }
157    #[derive(Diagnostic)]
158    #[diag(builtin_macros_autodiff_number_activities)]
159    pub(crate) struct AutoDiffInvalidNumberActivities {
160        #[primary_span]
161        pub(crate) span: Span,
162        pub(crate) expected: usize,
163        pub(crate) found: usize,
164    }
165    #[derive(Diagnostic)]
166    #[diag(builtin_macros_autodiff_mode_activity)]
167    pub(crate) struct AutoDiffInvalidApplicationModeAct {
168        #[primary_span]
169        pub(crate) span: Span,
170        pub(crate) mode: String,
171        pub(crate) act: String,
172    }
173
174    #[derive(Diagnostic)]
175    #[diag(builtin_macros_autodiff_ret_activity)]
176    pub(crate) struct AutoDiffInvalidRetAct {
177        #[primary_span]
178        pub(crate) span: Span,
179        pub(crate) mode: String,
180        pub(crate) act: String,
181    }
182
183    #[derive(Diagnostic)]
184    #[diag(builtin_macros_autodiff_width)]
185    pub(crate) struct AutoDiffInvalidWidth {
186        #[primary_span]
187        pub(crate) span: Span,
188        pub(crate) width: u128,
189    }
190
191    #[derive(Diagnostic)]
192    #[diag(builtin_macros_autodiff)]
193    pub(crate) struct AutoDiffInvalidApplication {
194        #[primary_span]
195        pub(crate) span: Span,
196    }
197}
198
199pub(crate) use ad_fallback::*;
200mod ad_fallback {
201    use super::*;
202    #[derive(Diagnostic)]
203    #[diag(builtin_macros_autodiff_not_build)]
204    pub(crate) struct AutoDiffSupportNotBuild {
205        #[primary_span]
206        pub(crate) span: Span,
207    }
208}
209
210#[derive(Diagnostic)]
211#[diag(builtin_macros_concat_bytes_invalid)]
212pub(crate) struct ConcatBytesInvalid {
213    #[primary_span]
214    pub(crate) span: Span,
215    pub(crate) lit_kind: &'static str,
216    #[subdiagnostic]
217    pub(crate) sugg: Option<ConcatBytesInvalidSuggestion>,
218    #[note(builtin_macros_c_str_note)]
219    pub(crate) cs_note: Option<()>,
220}
221
222#[derive(Subdiagnostic)]
223pub(crate) enum ConcatBytesInvalidSuggestion {
224    #[suggestion(
225        builtin_macros_byte_char,
226        code = "b{snippet}",
227        applicability = "machine-applicable"
228    )]
229    CharLit {
230        #[primary_span]
231        span: Span,
232        snippet: String,
233    },
234    #[suggestion(
235        builtin_macros_byte_str,
236        code = "b{snippet}",
237        applicability = "machine-applicable"
238    )]
239    StrLit {
240        #[primary_span]
241        span: Span,
242        snippet: String,
243    },
244    #[note(builtin_macros_c_str_note)]
245    #[suggestion(builtin_macros_c_str, code = "{as_bstr}", applicability = "machine-applicable")]
246    CStrLit {
247        #[primary_span]
248        span: Span,
249        as_bstr: String,
250    },
251    #[suggestion(
252        builtin_macros_number_array,
253        code = "[{snippet}]",
254        applicability = "machine-applicable"
255    )]
256    IntLit {
257        #[primary_span]
258        span: Span,
259        snippet: String,
260    },
261}
262
263#[derive(Diagnostic)]
264#[diag(builtin_macros_concat_bytes_oob)]
265pub(crate) struct ConcatBytesOob {
266    #[primary_span]
267    pub(crate) span: Span,
268}
269
270#[derive(Diagnostic)]
271#[diag(builtin_macros_concat_bytes_non_u8)]
272pub(crate) struct ConcatBytesNonU8 {
273    #[primary_span]
274    pub(crate) span: Span,
275}
276
277#[derive(Diagnostic)]
278#[diag(builtin_macros_concat_bytes_missing_literal)]
279#[note]
280pub(crate) struct ConcatBytesMissingLiteral {
281    #[primary_span]
282    pub(crate) spans: Vec<Span>,
283}
284
285#[derive(Diagnostic)]
286#[diag(builtin_macros_concat_bytes_array)]
287pub(crate) struct ConcatBytesArray {
288    #[primary_span]
289    pub(crate) span: Span,
290    #[note]
291    #[help]
292    pub(crate) bytestr: bool,
293}
294
295#[derive(Diagnostic)]
296#[diag(builtin_macros_concat_bytes_bad_repeat)]
297pub(crate) struct ConcatBytesBadRepeat {
298    #[primary_span]
299    pub(crate) span: Span,
300}
301
302#[derive(Diagnostic)]
303#[diag(builtin_macros_bad_derive_target, code = E0774)]
304pub(crate) struct BadDeriveTarget {
305    #[primary_span]
306    #[label]
307    pub(crate) span: Span,
308    #[label(builtin_macros_label2)]
309    pub(crate) item: Span,
310}
311
312#[derive(Diagnostic)]
313#[diag(builtin_macros_tests_not_support)]
314pub(crate) struct TestsNotSupport {}
315
316#[derive(Diagnostic)]
317#[diag(builtin_macros_unexpected_lit, code = E0777)]
318pub(crate) struct BadDeriveLit {
319    #[primary_span]
320    #[label]
321    pub(crate) span: Span,
322    #[subdiagnostic]
323    pub help: BadDeriveLitHelp,
324}
325
326#[derive(Subdiagnostic)]
327pub(crate) enum BadDeriveLitHelp {
328    #[help(builtin_macros_str_lit)]
329    StrLit { sym: Symbol },
330    #[help(builtin_macros_other)]
331    Other,
332}
333
334#[derive(Diagnostic)]
335#[diag(builtin_macros_derive_path_args_list)]
336pub(crate) struct DerivePathArgsList {
337    #[suggestion(code = "", applicability = "machine-applicable")]
338    #[primary_span]
339    pub(crate) span: Span,
340}
341
342#[derive(Diagnostic)]
343#[diag(builtin_macros_derive_path_args_value)]
344pub(crate) struct DerivePathArgsValue {
345    #[suggestion(code = "", applicability = "machine-applicable")]
346    #[primary_span]
347    pub(crate) span: Span,
348}
349
350#[derive(Diagnostic)]
351#[diag(builtin_macros_no_default_variant, code = E0665)]
352pub(crate) struct NoDefaultVariant {
353    #[primary_span]
354    pub(crate) span: Span,
355    #[label]
356    pub(crate) item_span: Span,
357    #[subdiagnostic]
358    pub(crate) suggs: Vec<NoDefaultVariantSugg>,
359}
360
361#[derive(Subdiagnostic)]
362#[suggestion(builtin_macros_suggestion, code = "#[default] ", applicability = "maybe-incorrect")]
363pub(crate) struct NoDefaultVariantSugg {
364    #[primary_span]
365    pub(crate) span: Span,
366}
367
368#[derive(Diagnostic)]
369#[diag(builtin_macros_multiple_defaults)]
370#[note]
371pub(crate) struct MultipleDefaults {
372    #[primary_span]
373    pub(crate) span: Span,
374    #[label]
375    pub(crate) first: Span,
376    #[label(builtin_macros_additional)]
377    pub additional: Vec<Span>,
378    #[subdiagnostic]
379    pub suggs: Vec<MultipleDefaultsSugg>,
380}
381
382#[derive(Subdiagnostic)]
383#[multipart_suggestion(
384    builtin_macros_suggestion,
385    applicability = "maybe-incorrect",
386    style = "tool-only"
387)]
388pub(crate) struct MultipleDefaultsSugg {
389    #[suggestion_part(code = "")]
390    pub(crate) spans: Vec<Span>,
391    pub(crate) ident: Ident,
392}
393
394#[derive(Diagnostic)]
395#[diag(builtin_macros_non_unit_default)]
396#[help]
397pub(crate) struct NonUnitDefault {
398    #[primary_span]
399    pub(crate) span: Span,
400    pub(crate) post: &'static str,
401}
402
403#[derive(Diagnostic)]
404#[diag(builtin_macros_non_exhaustive_default)]
405#[help]
406pub(crate) struct NonExhaustiveDefault {
407    #[primary_span]
408    pub(crate) span: Span,
409    #[label]
410    pub(crate) non_exhaustive: Span,
411}
412
413#[derive(Diagnostic)]
414#[diag(builtin_macros_multiple_default_attrs)]
415#[note]
416pub(crate) struct MultipleDefaultAttrs {
417    #[primary_span]
418    pub(crate) span: Span,
419    #[label]
420    pub(crate) first: Span,
421    #[label(builtin_macros_label_again)]
422    pub(crate) first_rest: Span,
423    #[help]
424    pub(crate) rest: MultiSpan,
425    pub(crate) only_one: bool,
426    #[subdiagnostic]
427    pub(crate) sugg: MultipleDefaultAttrsSugg,
428}
429
430#[derive(Subdiagnostic)]
431#[multipart_suggestion(
432    builtin_macros_help,
433    applicability = "machine-applicable",
434    style = "tool-only"
435)]
436pub(crate) struct MultipleDefaultAttrsSugg {
437    #[suggestion_part(code = "")]
438    pub(crate) spans: Vec<Span>,
439}
440
441#[derive(Diagnostic)]
442#[diag(builtin_macros_default_arg)]
443pub(crate) struct DefaultHasArg {
444    #[primary_span]
445    #[suggestion(code = "#[default]", style = "hidden", applicability = "maybe-incorrect")]
446    pub(crate) span: Span,
447}
448
449#[derive(Diagnostic)]
450#[diag(builtin_macros_derive_macro_call)]
451pub(crate) struct DeriveMacroCall {
452    #[primary_span]
453    pub(crate) span: Span,
454}
455
456#[derive(Diagnostic)]
457#[diag(builtin_macros_cannot_derive_union)]
458pub(crate) struct DeriveUnion {
459    #[primary_span]
460    pub(crate) span: Span,
461}
462
463#[derive(Diagnostic)]
464#[diag(builtin_macros_env_takes_args)]
465pub(crate) struct EnvTakesArgs {
466    #[primary_span]
467    pub(crate) span: Span,
468}
469
470pub(crate) struct EnvNotDefinedWithUserMessage {
471    pub(crate) span: Span,
472    pub(crate) msg_from_user: Symbol,
473}
474
475// Hand-written implementation to support custom user messages.
476impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for EnvNotDefinedWithUserMessage {
477    #[track_caller]
478    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
479        #[expect(
480            rustc::untranslatable_diagnostic,
481            reason = "cannot translate user-provided messages"
482        )]
483        let mut diag = Diag::new(dcx, level, self.msg_from_user.to_string());
484        diag.span(self.span);
485        diag
486    }
487}
488
489#[derive(Diagnostic)]
490pub(crate) enum EnvNotDefined<'a> {
491    #[diag(builtin_macros_env_not_defined)]
492    #[help(builtin_macros_cargo)]
493    CargoEnvVar {
494        #[primary_span]
495        span: Span,
496        var: Symbol,
497        var_expr: &'a rustc_ast::Expr,
498    },
499    #[diag(builtin_macros_env_not_defined)]
500    #[help(builtin_macros_custom)]
501    CustomEnvVar {
502        #[primary_span]
503        span: Span,
504        var: Symbol,
505        var_expr: &'a rustc_ast::Expr,
506    },
507}
508
509#[derive(Diagnostic)]
510#[diag(builtin_macros_env_not_unicode)]
511pub(crate) struct EnvNotUnicode {
512    #[primary_span]
513    pub(crate) span: Span,
514    pub(crate) var: Symbol,
515}
516
517#[derive(Diagnostic)]
518#[diag(builtin_macros_format_requires_string)]
519pub(crate) struct FormatRequiresString {
520    #[primary_span]
521    pub(crate) span: Span,
522}
523
524#[derive(Diagnostic)]
525#[diag(builtin_macros_format_duplicate_arg)]
526pub(crate) struct FormatDuplicateArg {
527    #[primary_span]
528    pub(crate) span: Span,
529    #[label(builtin_macros_label1)]
530    pub(crate) prev: Span,
531    #[label(builtin_macros_label2)]
532    pub(crate) duplicate: Span,
533    pub(crate) ident: Ident,
534}
535
536#[derive(Diagnostic)]
537#[diag(builtin_macros_format_positional_after_named)]
538pub(crate) struct PositionalAfterNamed {
539    #[primary_span]
540    #[label]
541    pub(crate) span: Span,
542    #[label(builtin_macros_named_args)]
543    pub(crate) args: Vec<Span>,
544}
545
546#[derive(Diagnostic)]
547#[diag(builtin_macros_format_string_invalid)]
548pub(crate) struct InvalidFormatString {
549    #[primary_span]
550    #[label]
551    pub(crate) span: Span,
552    pub(crate) desc: String,
553    pub(crate) label1: String,
554    #[subdiagnostic]
555    pub(crate) note_: Option<InvalidFormatStringNote>,
556    #[subdiagnostic]
557    pub(crate) label_: Option<InvalidFormatStringLabel>,
558    #[subdiagnostic]
559    pub(crate) sugg_: Option<InvalidFormatStringSuggestion>,
560}
561
562#[derive(Subdiagnostic)]
563#[note(builtin_macros_note)]
564pub(crate) struct InvalidFormatStringNote {
565    pub(crate) note: String,
566}
567
568#[derive(Subdiagnostic)]
569#[label(builtin_macros_second_label)]
570pub(crate) struct InvalidFormatStringLabel {
571    #[primary_span]
572    pub(crate) span: Span,
573    pub(crate) label: String,
574}
575
576#[derive(Subdiagnostic)]
577pub(crate) enum InvalidFormatStringSuggestion {
578    #[multipart_suggestion(
579        builtin_macros_format_use_positional,
580        style = "verbose",
581        applicability = "machine-applicable"
582    )]
583    UsePositional {
584        #[suggestion_part(code = "{len}")]
585        captured: Span,
586        len: String,
587        #[suggestion_part(code = ", {arg}")]
588        span: Span,
589        arg: String,
590    },
591    #[suggestion(
592        builtin_macros_format_remove_raw_ident,
593        code = "",
594        applicability = "machine-applicable"
595    )]
596    RemoveRawIdent {
597        #[primary_span]
598        span: Span,
599    },
600    #[suggestion(
601        builtin_macros_format_reorder_format_parameter,
602        code = "{replacement}",
603        style = "verbose",
604        applicability = "machine-applicable"
605    )]
606    ReorderFormatParameter {
607        #[primary_span]
608        span: Span,
609        replacement: String,
610    },
611}
612
613#[derive(Diagnostic)]
614#[diag(builtin_macros_format_no_arg_named)]
615#[note]
616#[note(builtin_macros_note2)]
617pub(crate) struct FormatNoArgNamed {
618    #[primary_span]
619    pub(crate) span: Span,
620    pub(crate) name: Symbol,
621}
622
623#[derive(Diagnostic)]
624#[diag(builtin_macros_format_unknown_trait)]
625#[note]
626pub(crate) struct FormatUnknownTrait<'a> {
627    #[primary_span]
628    pub(crate) span: Span,
629    pub(crate) ty: &'a str,
630    #[subdiagnostic]
631    pub(crate) suggs: Vec<FormatUnknownTraitSugg>,
632}
633
634#[derive(Subdiagnostic)]
635#[suggestion(
636    builtin_macros_suggestion,
637    code = "{fmt}",
638    style = "tool-only",
639    applicability = "maybe-incorrect"
640)]
641pub(crate) struct FormatUnknownTraitSugg {
642    #[primary_span]
643    pub span: Span,
644    pub fmt: &'static str,
645    pub trait_name: &'static str,
646}
647
648#[derive(Diagnostic)]
649#[diag(builtin_macros_format_unused_arg)]
650pub(crate) struct FormatUnusedArg {
651    #[primary_span]
652    #[label(builtin_macros_format_unused_arg)]
653    pub(crate) span: Span,
654    pub(crate) named: bool,
655}
656
657// Allow the singular form to be a subdiagnostic of the multiple-unused
658// form of diagnostic.
659impl Subdiagnostic for FormatUnusedArg {
660    fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
661        diag.arg("named", self.named);
662        let msg = diag.eagerly_translate(crate::fluent_generated::builtin_macros_format_unused_arg);
663        diag.remove_arg("named");
664        diag.span_label(self.span, msg);
665    }
666}
667
668#[derive(Diagnostic)]
669#[diag(builtin_macros_format_unused_args)]
670pub(crate) struct FormatUnusedArgs {
671    #[primary_span]
672    pub(crate) unused: Vec<Span>,
673    #[label]
674    pub(crate) fmt: Span,
675    #[subdiagnostic]
676    pub(crate) unused_labels: Vec<FormatUnusedArg>,
677}
678
679#[derive(Diagnostic)]
680#[diag(builtin_macros_format_pos_mismatch)]
681pub(crate) struct FormatPositionalMismatch {
682    #[primary_span]
683    pub(crate) span: MultiSpan,
684    pub(crate) n: usize,
685    pub(crate) desc: String,
686    #[subdiagnostic]
687    pub(crate) highlight: SingleLabelManySpans,
688}
689
690#[derive(Diagnostic)]
691#[diag(builtin_macros_format_redundant_args)]
692pub(crate) struct FormatRedundantArgs {
693    #[primary_span]
694    pub(crate) span: MultiSpan,
695    pub(crate) n: usize,
696
697    #[note]
698    pub(crate) note: MultiSpan,
699
700    #[subdiagnostic]
701    pub(crate) sugg: Option<FormatRedundantArgsSugg>,
702}
703
704#[derive(Subdiagnostic)]
705#[multipart_suggestion(builtin_macros_suggestion, applicability = "machine-applicable")]
706pub(crate) struct FormatRedundantArgsSugg {
707    #[suggestion_part(code = "")]
708    pub(crate) spans: Vec<Span>,
709}
710
711#[derive(Diagnostic)]
712#[diag(builtin_macros_test_case_non_item)]
713pub(crate) struct TestCaseNonItem {
714    #[primary_span]
715    pub(crate) span: Span,
716}
717
718#[derive(Diagnostic)]
719#[diag(builtin_macros_test_bad_fn)]
720pub(crate) struct TestBadFn {
721    #[primary_span]
722    pub(crate) span: Span,
723    #[label]
724    pub(crate) cause: Span,
725    pub(crate) kind: &'static str,
726}
727
728#[derive(Diagnostic)]
729#[diag(builtin_macros_asm_explicit_register_name)]
730pub(crate) struct AsmExplicitRegisterName {
731    #[primary_span]
732    pub(crate) span: Span,
733}
734
735#[derive(Diagnostic)]
736#[diag(builtin_macros_asm_mutually_exclusive)]
737pub(crate) struct AsmMutuallyExclusive {
738    #[primary_span]
739    pub(crate) spans: Vec<Span>,
740    pub(crate) opt1: &'static str,
741    pub(crate) opt2: &'static str,
742}
743
744#[derive(Diagnostic)]
745#[diag(builtin_macros_asm_pure_combine)]
746pub(crate) struct AsmPureCombine {
747    #[primary_span]
748    pub(crate) spans: Vec<Span>,
749}
750
751#[derive(Diagnostic)]
752#[diag(builtin_macros_asm_pure_no_output)]
753pub(crate) struct AsmPureNoOutput {
754    #[primary_span]
755    pub(crate) spans: Vec<Span>,
756}
757
758#[derive(Diagnostic)]
759#[diag(builtin_macros_asm_modifier_invalid)]
760pub(crate) struct AsmModifierInvalid {
761    #[primary_span]
762    pub(crate) span: Span,
763}
764
765#[derive(Diagnostic)]
766#[diag(builtin_macros_asm_attribute_not_supported)]
767pub(crate) struct AsmAttributeNotSupported {
768    #[primary_span]
769    pub(crate) span: Span,
770}
771
772#[derive(Diagnostic)]
773#[diag(builtin_macros_asm_duplicate_arg)]
774pub(crate) struct AsmDuplicateArg {
775    #[primary_span]
776    #[label(builtin_macros_arg)]
777    pub(crate) span: Span,
778    #[label]
779    pub(crate) prev: Span,
780    pub(crate) name: Symbol,
781}
782
783#[derive(Diagnostic)]
784#[diag(builtin_macros_asm_pos_after)]
785pub(crate) struct AsmPositionalAfter {
786    #[primary_span]
787    #[label(builtin_macros_pos)]
788    pub(crate) span: Span,
789    #[label(builtin_macros_named)]
790    pub(crate) named: Vec<Span>,
791    #[label(builtin_macros_explicit)]
792    pub(crate) explicit: Vec<Span>,
793}
794
795#[derive(Diagnostic)]
796#[diag(builtin_macros_asm_noreturn)]
797pub(crate) struct AsmNoReturn {
798    #[primary_span]
799    pub(crate) outputs_sp: Vec<Span>,
800}
801
802#[derive(Diagnostic)]
803#[diag(builtin_macros_asm_no_matched_argument_name)]
804pub(crate) struct AsmNoMatchedArgumentName {
805    pub(crate) name: String,
806    #[primary_span]
807    pub(crate) span: Span,
808}
809
810#[derive(Diagnostic)]
811#[diag(builtin_macros_asm_mayunwind)]
812pub(crate) struct AsmMayUnwind {
813    #[primary_span]
814    pub(crate) labels_sp: Vec<Span>,
815}
816
817pub(crate) struct AsmClobberNoReg {
818    pub(crate) spans: Vec<Span>,
819    pub(crate) clobbers: Vec<Span>,
820}
821
822impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AsmClobberNoReg {
823    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
824        // eager translation as `span_labels` takes `AsRef<str>`
825        let lbl1 = dcx.eagerly_translate_to_string(
826            crate::fluent_generated::builtin_macros_asm_clobber_abi,
827            [].into_iter(),
828        );
829        let lbl2 = dcx.eagerly_translate_to_string(
830            crate::fluent_generated::builtin_macros_asm_clobber_outputs,
831            [].into_iter(),
832        );
833        Diag::new(dcx, level, crate::fluent_generated::builtin_macros_asm_clobber_no_reg)
834            .with_span(self.spans.clone())
835            .with_span_labels(self.clobbers, &lbl1)
836            .with_span_labels(self.spans, &lbl2)
837    }
838}
839
840#[derive(Diagnostic)]
841#[diag(builtin_macros_asm_opt_already_provided)]
842pub(crate) struct AsmOptAlreadyprovided {
843    #[primary_span]
844    #[label]
845    pub(crate) span: Span,
846    pub(crate) symbol: Symbol,
847    #[suggestion(code = "", applicability = "machine-applicable", style = "tool-only")]
848    pub(crate) span_with_comma: Span,
849}
850
851#[derive(Diagnostic)]
852#[diag(builtin_macros_asm_unsupported_option)]
853pub(crate) struct AsmUnsupportedOption {
854    #[primary_span]
855    #[label]
856    pub(crate) span: Span,
857    pub(crate) symbol: Symbol,
858    #[suggestion(code = "", applicability = "machine-applicable", style = "tool-only")]
859    pub(crate) span_with_comma: Span,
860    pub(crate) macro_name: &'static str,
861}
862
863#[derive(Diagnostic)]
864#[diag(builtin_macros_asm_unsupported_clobber_abi)]
865pub(crate) struct AsmUnsupportedClobberAbi {
866    #[primary_span]
867    pub(crate) spans: Vec<Span>,
868    pub(crate) macro_name: &'static str,
869}
870
871#[derive(Diagnostic)]
872#[diag(builtin_macros_test_runner_invalid)]
873pub(crate) struct TestRunnerInvalid {
874    #[primary_span]
875    pub(crate) span: Span,
876}
877
878#[derive(Diagnostic)]
879#[diag(builtin_macros_test_runner_nargs)]
880pub(crate) struct TestRunnerNargs {
881    #[primary_span]
882    pub(crate) span: Span,
883}
884
885#[derive(Diagnostic)]
886#[diag(builtin_macros_expected_comma_in_list)]
887pub(crate) struct ExpectedCommaInList {
888    #[primary_span]
889    pub span: Span,
890}
891
892#[derive(Diagnostic)]
893#[diag(builtin_macros_only_one_argument)]
894pub(crate) struct OnlyOneArgument<'a> {
895    #[primary_span]
896    pub span: Span,
897    pub name: &'a str,
898}
899
900#[derive(Diagnostic)]
901#[diag(builtin_macros_takes_no_arguments)]
902pub(crate) struct TakesNoArguments<'a> {
903    #[primary_span]
904    pub span: Span,
905    pub name: &'a str,
906}
907
908#[derive(Diagnostic)]
909#[diag(builtin_macros_proc_macro_attribute_only_be_used_on_bare_functions)]
910pub(crate) struct AttributeOnlyBeUsedOnBareFunctions<'a> {
911    #[primary_span]
912    pub span: Span,
913    pub path: &'a str,
914}
915
916#[derive(Diagnostic)]
917#[diag(builtin_macros_proc_macro_attribute_only_usable_with_crate_type)]
918pub(crate) struct AttributeOnlyUsableWithCrateType<'a> {
919    #[primary_span]
920    pub span: Span,
921    pub path: &'a str,
922}
923
924#[derive(Diagnostic)]
925#[diag(builtin_macros_source_uitls_expected_item)]
926pub(crate) struct ExpectedItem<'a> {
927    #[primary_span]
928    pub span: Span,
929    pub token: &'a str,
930}
931
932#[derive(Diagnostic)]
933#[diag(builtin_macros_naked_functions_testing_attribute, code = E0736)]
934pub(crate) struct NakedFunctionTestingAttribute {
935    #[primary_span]
936    #[label(builtin_macros_naked_attribute)]
937    pub naked_span: Span,
938    #[label]
939    pub testing_span: Span,
940}
941
942#[derive(Diagnostic)]
943#[diag(builtin_macros_non_generic_pointee)]
944pub(crate) struct NonGenericPointee {
945    #[primary_span]
946    pub span: Span,
947}
948
949#[derive(Diagnostic)]
950#[diag(builtin_macros_expected_other)]
951pub(crate) struct AsmExpectedOther {
952    #[primary_span]
953    #[label(builtin_macros_expected_other)]
954    pub(crate) span: Span,
955    pub(crate) is_inline_asm: bool,
956}
rustc_builtin_macros/errors.rs

rustc_builtin_macros/
errors.rs
