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
475impl<'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
657impl 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 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}