1use rustc_errors::codes::*;
2use rustc_errors::{
3 Applicability, Diag, ElidedLifetimeInPathSubdiag, EmissionGuarantee, IntoDiagArg, MultiSpan,
4 Subdiagnostic,
5};
6use rustc_macros::{Diagnostic, Subdiagnostic};
7use rustc_span::{Ident, Span, Symbol};
8
9use crate::late::PatternSource;
10use crate::{Res, fluent_generated as fluent};
11
12#[derive(Diagnostic)]
13#[diag(resolve_generic_params_from_outer_item, code = E0401)]
14pub(crate) struct GenericParamsFromOuterItem {
15 #[primary_span]
16 #[label]
17 pub(crate) span: Span,
18 #[subdiagnostic]
19 pub(crate) label: Option<GenericParamsFromOuterItemLabel>,
20 #[label(resolve_refer_to_type_directly)]
21 pub(crate) refer_to_type_directly: Option<Span>,
22 #[subdiagnostic]
23 pub(crate) sugg: Option<GenericParamsFromOuterItemSugg>,
24 #[subdiagnostic]
25 pub(crate) static_or_const: Option<GenericParamsFromOuterItemStaticOrConst>,
26 pub(crate) is_self: bool,
27}
28
29#[derive(Subdiagnostic)]
30pub(crate) enum GenericParamsFromOuterItemStaticOrConst {
31 #[note(resolve_generic_params_from_outer_item_static)]
32 Static,
33 #[note(resolve_generic_params_from_outer_item_const)]
34 Const,
35}
36
37#[derive(Subdiagnostic)]
38pub(crate) enum GenericParamsFromOuterItemLabel {
39 #[label(resolve_generic_params_from_outer_item_self_ty_param)]
40 SelfTyParam(#[primary_span] Span),
41 #[label(resolve_generic_params_from_outer_item_self_ty_alias)]
42 SelfTyAlias(#[primary_span] Span),
43 #[label(resolve_generic_params_from_outer_item_ty_param)]
44 TyParam(#[primary_span] Span),
45 #[label(resolve_generic_params_from_outer_item_const_param)]
46 ConstParam(#[primary_span] Span),
47}
48
49#[derive(Subdiagnostic)]
50#[suggestion(resolve_suggestion, code = "{snippet}", applicability = "maybe-incorrect")]
51pub(crate) struct GenericParamsFromOuterItemSugg {
52 #[primary_span]
53 pub(crate) span: Span,
54 pub(crate) snippet: String,
55}
56
57#[derive(Diagnostic)]
58#[diag(resolve_name_is_already_used_as_generic_parameter, code = E0403)]
59pub(crate) struct NameAlreadyUsedInParameterList {
60 #[primary_span]
61 #[label]
62 pub(crate) span: Span,
63 #[label(resolve_first_use_of_name)]
64 pub(crate) first_use_span: Span,
65 pub(crate) name: Ident,
66}
67
68#[derive(Diagnostic)]
69#[diag(resolve_method_not_member_of_trait, code = E0407)]
70pub(crate) struct MethodNotMemberOfTrait {
71 #[primary_span]
72 #[label]
73 pub(crate) span: Span,
74 pub(crate) method: Ident,
75 pub(crate) trait_: String,
76 #[subdiagnostic]
77 pub(crate) sub: Option<AssociatedFnWithSimilarNameExists>,
78}
79
80#[derive(Subdiagnostic)]
81#[suggestion(
82 resolve_associated_fn_with_similar_name_exists,
83 code = "{candidate}",
84 applicability = "maybe-incorrect"
85)]
86pub(crate) struct AssociatedFnWithSimilarNameExists {
87 #[primary_span]
88 pub(crate) span: Span,
89 pub(crate) candidate: Symbol,
90}
91
92#[derive(Diagnostic)]
93#[diag(resolve_type_not_member_of_trait, code = E0437)]
94pub(crate) struct TypeNotMemberOfTrait {
95 #[primary_span]
96 #[label]
97 pub(crate) span: Span,
98 pub(crate) type_: Ident,
99 pub(crate) trait_: String,
100 #[subdiagnostic]
101 pub(crate) sub: Option<AssociatedTypeWithSimilarNameExists>,
102}
103
104#[derive(Subdiagnostic)]
105#[suggestion(
106 resolve_associated_type_with_similar_name_exists,
107 code = "{candidate}",
108 applicability = "maybe-incorrect"
109)]
110pub(crate) struct AssociatedTypeWithSimilarNameExists {
111 #[primary_span]
112 pub(crate) span: Span,
113 pub(crate) candidate: Symbol,
114}
115
116#[derive(Diagnostic)]
117#[diag(resolve_const_not_member_of_trait, code = E0438)]
118pub(crate) struct ConstNotMemberOfTrait {
119 #[primary_span]
120 #[label]
121 pub(crate) span: Span,
122 pub(crate) const_: Ident,
123 pub(crate) trait_: String,
124 #[subdiagnostic]
125 pub(crate) sub: Option<AssociatedConstWithSimilarNameExists>,
126}
127
128#[derive(Subdiagnostic)]
129#[suggestion(
130 resolve_associated_const_with_similar_name_exists,
131 code = "{candidate}",
132 applicability = "maybe-incorrect"
133)]
134pub(crate) struct AssociatedConstWithSimilarNameExists {
135 #[primary_span]
136 pub(crate) span: Span,
137 pub(crate) candidate: Symbol,
138}
139
140#[derive(Diagnostic)]
141#[diag(resolve_variable_bound_with_different_mode, code = E0409)]
142pub(crate) struct VariableBoundWithDifferentMode {
143 #[primary_span]
144 #[label]
145 pub(crate) span: Span,
146 #[label(resolve_first_binding_span)]
147 pub(crate) first_binding_span: Span,
148 pub(crate) variable_name: Ident,
149}
150
151#[derive(Diagnostic)]
152#[diag(resolve_ident_bound_more_than_once_in_parameter_list, code = E0415)]
153pub(crate) struct IdentifierBoundMoreThanOnceInParameterList {
154 #[primary_span]
155 #[label]
156 pub(crate) span: Span,
157 pub(crate) identifier: Ident,
158}
159
160#[derive(Diagnostic)]
161#[diag(resolve_ident_bound_more_than_once_in_same_pattern, code = E0416)]
162pub(crate) struct IdentifierBoundMoreThanOnceInSamePattern {
163 #[primary_span]
164 #[label]
165 pub(crate) span: Span,
166 pub(crate) identifier: Ident,
167}
168
169#[derive(Diagnostic)]
170#[diag(resolve_undeclared_label, code = E0426)]
171pub(crate) struct UndeclaredLabel {
172 #[primary_span]
173 #[label]
174 pub(crate) span: Span,
175 pub(crate) name: Symbol,
176 #[subdiagnostic]
177 pub(crate) sub_reachable: Option<LabelWithSimilarNameReachable>,
178 #[subdiagnostic]
179 pub(crate) sub_reachable_suggestion: Option<TryUsingSimilarlyNamedLabel>,
180 #[subdiagnostic]
181 pub(crate) sub_unreachable: Option<UnreachableLabelWithSimilarNameExists>,
182}
183
184#[derive(Subdiagnostic)]
185#[label(resolve_label_with_similar_name_reachable)]
186pub(crate) struct LabelWithSimilarNameReachable(#[primary_span] pub(crate) Span);
187
188#[derive(Subdiagnostic)]
189#[suggestion(
190 resolve_try_using_similarly_named_label,
191 code = "{ident_name}",
192 applicability = "maybe-incorrect"
193)]
194pub(crate) struct TryUsingSimilarlyNamedLabel {
195 #[primary_span]
196 pub(crate) span: Span,
197 pub(crate) ident_name: Symbol,
198}
199
200#[derive(Subdiagnostic)]
201#[label(resolve_unreachable_label_with_similar_name_exists)]
202pub(crate) struct UnreachableLabelWithSimilarNameExists {
203 #[primary_span]
204 pub(crate) ident_span: Span,
205}
206
207#[derive(Diagnostic)]
208#[diag(resolve_self_import_can_only_appear_once_in_the_list, code = E0430)]
209pub(crate) struct SelfImportCanOnlyAppearOnceInTheList {
210 #[primary_span]
211 #[label]
212 pub(crate) span: Span,
213}
214
215#[derive(Diagnostic)]
216#[diag(resolve_self_import_only_in_import_list_with_non_empty_prefix, code = E0431)]
217pub(crate) struct SelfImportOnlyInImportListWithNonEmptyPrefix {
218 #[primary_span]
219 #[label]
220 pub(crate) span: Span,
221}
222
223#[derive(Diagnostic)]
224#[diag(resolve_cannot_capture_dynamic_environment_in_fn_item, code = E0434)]
225#[help]
226pub(crate) struct CannotCaptureDynamicEnvironmentInFnItem {
227 #[primary_span]
228 pub(crate) span: Span,
229}
230
231#[derive(Diagnostic)]
232#[diag(resolve_attempt_to_use_non_constant_value_in_constant, code = E0435)]
233pub(crate) struct AttemptToUseNonConstantValueInConstant<'a> {
234 #[primary_span]
235 pub(crate) span: Span,
236 #[subdiagnostic]
237 pub(crate) with: Option<AttemptToUseNonConstantValueInConstantWithSuggestion<'a>>,
238 #[subdiagnostic]
239 pub(crate) with_label: Option<AttemptToUseNonConstantValueInConstantLabelWithSuggestion>,
240 #[subdiagnostic]
241 pub(crate) without: Option<AttemptToUseNonConstantValueInConstantWithoutSuggestion<'a>>,
242}
243
244#[derive(Subdiagnostic)]
245#[multipart_suggestion(
246 resolve_attempt_to_use_non_constant_value_in_constant_with_suggestion,
247 style = "verbose",
248 applicability = "has-placeholders"
249)]
250pub(crate) struct AttemptToUseNonConstantValueInConstantWithSuggestion<'a> {
251 #[suggestion_part(code = "{suggestion} ")]
253 pub(crate) span: Span,
254 pub(crate) suggestion: &'a str,
255 #[suggestion_part(code = ": /* Type */")]
256 pub(crate) type_span: Option<Span>,
257 pub(crate) current: &'a str,
258}
259
260#[derive(Subdiagnostic)]
261#[label(resolve_attempt_to_use_non_constant_value_in_constant_label_with_suggestion)]
262pub(crate) struct AttemptToUseNonConstantValueInConstantLabelWithSuggestion {
263 #[primary_span]
264 pub(crate) span: Span,
265}
266
267#[derive(Subdiagnostic)]
268#[label(resolve_attempt_to_use_non_constant_value_in_constant_without_suggestion)]
269pub(crate) struct AttemptToUseNonConstantValueInConstantWithoutSuggestion<'a> {
270 #[primary_span]
271 pub(crate) ident_span: Span,
272 pub(crate) suggestion: &'a str,
273}
274
275#[derive(Diagnostic)]
276#[diag(resolve_self_imports_only_allowed_within, code = E0429)]
277pub(crate) struct SelfImportsOnlyAllowedWithin {
278 #[primary_span]
279 pub(crate) span: Span,
280 #[subdiagnostic]
281 pub(crate) suggestion: Option<SelfImportsOnlyAllowedWithinSuggestion>,
282 #[subdiagnostic]
283 pub(crate) mpart_suggestion: Option<SelfImportsOnlyAllowedWithinMultipartSuggestion>,
284}
285
286#[derive(Subdiagnostic)]
287#[suggestion(
288 resolve_self_imports_only_allowed_within_suggestion,
289 code = "",
290 applicability = "machine-applicable"
291)]
292pub(crate) struct SelfImportsOnlyAllowedWithinSuggestion {
293 #[primary_span]
294 pub(crate) span: Span,
295}
296
297#[derive(Subdiagnostic)]
298#[multipart_suggestion(
299 resolve_self_imports_only_allowed_within_multipart_suggestion,
300 applicability = "machine-applicable"
301)]
302pub(crate) struct SelfImportsOnlyAllowedWithinMultipartSuggestion {
303 #[suggestion_part(code = "{{")]
304 pub(crate) multipart_start: Span,
305 #[suggestion_part(code = "}}")]
306 pub(crate) multipart_end: Span,
307}
308
309#[derive(Diagnostic)]
310#[diag(resolve_binding_shadows_something_unacceptable, code = E0530)]
311pub(crate) struct BindingShadowsSomethingUnacceptable<'a> {
312 #[primary_span]
313 #[label]
314 pub(crate) span: Span,
315 pub(crate) shadowing_binding: PatternSource,
316 pub(crate) shadowed_binding: Res,
317 pub(crate) article: &'a str,
318 #[subdiagnostic]
319 pub(crate) sub_suggestion: Option<BindingShadowsSomethingUnacceptableSuggestion>,
320 #[label(resolve_label_shadowed_binding)]
321 pub(crate) shadowed_binding_span: Span,
322 pub(crate) participle: &'a str,
323 pub(crate) name: Symbol,
324}
325
326#[derive(Subdiagnostic)]
327#[suggestion(
328 resolve_binding_shadows_something_unacceptable_suggestion,
329 code = "{name}(..)",
330 applicability = "unspecified"
331)]
332pub(crate) struct BindingShadowsSomethingUnacceptableSuggestion {
333 #[primary_span]
334 pub(crate) span: Span,
335 pub(crate) name: Symbol,
336}
337
338#[derive(Diagnostic)]
339#[diag(resolve_forward_declared_generic_param, code = E0128)]
340pub(crate) struct ForwardDeclaredGenericParam {
341 #[primary_span]
342 #[label]
343 pub(crate) span: Span,
344 pub(crate) param: Symbol,
345}
346
347#[derive(Diagnostic)]
348#[diag(resolve_forward_declared_generic_in_const_param_ty)]
349pub(crate) struct ForwardDeclaredGenericInConstParamTy {
350 #[primary_span]
351 #[label]
352 pub(crate) span: Span,
353 pub(crate) param: Symbol,
354}
355
356#[derive(Diagnostic)]
357#[diag(resolve_param_in_ty_of_const_param, code = E0770)]
358pub(crate) struct ParamInTyOfConstParam {
359 #[primary_span]
360 #[label]
361 pub(crate) span: Span,
362 pub(crate) name: Symbol,
363}
364
365#[derive(Diagnostic)]
366#[diag(resolve_self_in_generic_param_default, code = E0735)]
367pub(crate) struct SelfInGenericParamDefault {
368 #[primary_span]
369 pub(crate) span: Span,
370}
371
372#[derive(Diagnostic)]
373#[diag(resolve_self_in_const_generic_ty)]
374pub(crate) struct SelfInConstGenericTy {
375 #[primary_span]
376 pub(crate) span: Span,
377}
378
379#[derive(Diagnostic)]
380#[diag(resolve_param_in_non_trivial_anon_const)]
381pub(crate) struct ParamInNonTrivialAnonConst {
382 #[primary_span]
383 #[label]
384 pub(crate) span: Span,
385 pub(crate) name: Symbol,
386 #[subdiagnostic]
387 pub(crate) param_kind: ParamKindInNonTrivialAnonConst,
388 #[subdiagnostic]
389 pub(crate) help: Option<ParamInNonTrivialAnonConstHelp>,
390}
391
392#[derive(Subdiagnostic)]
393#[help(resolve_param_in_non_trivial_anon_const_help)]
394pub(crate) struct ParamInNonTrivialAnonConstHelp;
395
396#[derive(Debug)]
397#[derive(Subdiagnostic)]
398pub(crate) enum ParamKindInNonTrivialAnonConst {
399 #[note(resolve_type_param_in_non_trivial_anon_const)]
400 Type,
401 #[help(resolve_const_param_in_non_trivial_anon_const)]
402 Const { name: Symbol },
403 #[note(resolve_lifetime_param_in_non_trivial_anon_const)]
404 Lifetime,
405}
406
407#[derive(Diagnostic)]
408#[diag(resolve_unreachable_label, code = E0767)]
409#[note]
410pub(crate) struct UnreachableLabel {
411 #[primary_span]
412 #[label]
413 pub(crate) span: Span,
414 pub(crate) name: Symbol,
415 #[label(resolve_label_definition_span)]
416 pub(crate) definition_span: Span,
417 #[subdiagnostic]
418 pub(crate) sub_suggestion: Option<UnreachableLabelSubSuggestion>,
419 #[subdiagnostic]
420 pub(crate) sub_suggestion_label: Option<UnreachableLabelSubLabel>,
421 #[subdiagnostic]
422 pub(crate) sub_unreachable_label: Option<UnreachableLabelSubLabelUnreachable>,
423}
424
425#[derive(Subdiagnostic)]
426#[suggestion(
427 resolve_unreachable_label_suggestion_use_similarly_named,
428 code = "{ident_name}",
429 applicability = "maybe-incorrect"
430)]
431pub(crate) struct UnreachableLabelSubSuggestion {
432 #[primary_span]
433 pub(crate) span: Span,
434 pub(crate) ident_name: Symbol,
435}
436
437#[derive(Subdiagnostic)]
438#[label(resolve_unreachable_label_similar_name_reachable)]
439pub(crate) struct UnreachableLabelSubLabel {
440 #[primary_span]
441 pub(crate) ident_span: Span,
442}
443
444#[derive(Subdiagnostic)]
445#[label(resolve_unreachable_label_similar_name_unreachable)]
446pub(crate) struct UnreachableLabelSubLabelUnreachable {
447 #[primary_span]
448 pub(crate) ident_span: Span,
449}
450
451#[derive(Diagnostic)]
452#[diag(resolve_invalid_asm_sym)]
453#[help]
454pub(crate) struct InvalidAsmSym {
455 #[primary_span]
456 #[label]
457 pub(crate) span: Span,
458}
459
460#[derive(Diagnostic)]
461#[diag(resolve_lowercase_self)]
462pub(crate) struct LowercaseSelf {
463 #[primary_span]
464 #[suggestion(code = "Self", applicability = "maybe-incorrect", style = "short")]
465 pub(crate) span: Span,
466}
467
468#[derive(Debug)]
469#[derive(Diagnostic)]
470#[diag(resolve_binding_in_never_pattern)]
471pub(crate) struct BindingInNeverPattern {
472 #[primary_span]
473 #[suggestion(code = "_", applicability = "machine-applicable", style = "short")]
474 pub(crate) span: Span,
475}
476
477#[derive(Diagnostic)]
478#[diag(resolve_trait_impl_duplicate, code = E0201)]
479pub(crate) struct TraitImplDuplicate {
480 #[primary_span]
481 #[label]
482 pub(crate) span: Span,
483 #[label(resolve_old_span_label)]
484 pub(crate) old_span: Span,
485 #[label(resolve_trait_item_span)]
486 pub(crate) trait_item_span: Span,
487 pub(crate) name: Ident,
488}
489
490#[derive(Diagnostic)]
491#[diag(resolve_relative_2018)]
492pub(crate) struct Relative2018 {
493 #[primary_span]
494 pub(crate) span: Span,
495 #[suggestion(code = "crate::{path_str}", applicability = "maybe-incorrect")]
496 pub(crate) path_span: Span,
497 pub(crate) path_str: String,
498}
499
500#[derive(Diagnostic)]
501#[diag(resolve_ancestor_only, code = E0742)]
502pub(crate) struct AncestorOnly(#[primary_span] pub(crate) Span);
503
504#[derive(Diagnostic)]
505#[diag(resolve_expected_module_found, code = E0577)]
506pub(crate) struct ExpectedModuleFound {
507 #[primary_span]
508 #[label]
509 pub(crate) span: Span,
510 pub(crate) res: Res,
511 pub(crate) path_str: String,
512}
513
514#[derive(Diagnostic)]
515#[diag(resolve_indeterminate, code = E0578)]
516pub(crate) struct Indeterminate(#[primary_span] pub(crate) Span);
517
518#[derive(Diagnostic)]
519#[diag(resolve_tool_module_imported)]
520pub(crate) struct ToolModuleImported {
521 #[primary_span]
522 pub(crate) span: Span,
523 #[note]
524 pub(crate) import: Span,
525}
526
527#[derive(Diagnostic)]
528#[diag(resolve_module_only)]
529pub(crate) struct ModuleOnly(#[primary_span] pub(crate) Span);
530
531#[derive(Diagnostic)]
532#[diag(resolve_macro_expected_found)]
533pub(crate) struct MacroExpectedFound<'a> {
534 #[primary_span]
535 #[label]
536 pub(crate) span: Span,
537 pub(crate) found: &'a str,
538 pub(crate) article: &'static str,
539 pub(crate) expected: &'a str,
540 pub(crate) macro_path: &'a str,
541 #[subdiagnostic]
542 pub(crate) remove_surrounding_derive: Option<RemoveSurroundingDerive>,
543 #[subdiagnostic]
544 pub(crate) add_as_non_derive: Option<AddAsNonDerive<'a>>,
545}
546
547#[derive(Subdiagnostic)]
548#[help(resolve_remove_surrounding_derive)]
549pub(crate) struct RemoveSurroundingDerive {
550 #[primary_span]
551 pub(crate) span: Span,
552}
553
554#[derive(Subdiagnostic)]
555#[help(resolve_add_as_non_derive)]
556pub(crate) struct AddAsNonDerive<'a> {
557 pub(crate) macro_path: &'a str,
558}
559
560#[derive(Diagnostic)]
561#[diag(resolve_proc_macro_same_crate)]
562pub(crate) struct ProcMacroSameCrate {
563 #[primary_span]
564 pub(crate) span: Span,
565 #[help]
566 pub(crate) is_test: bool,
567}
568
569#[derive(Diagnostic)]
570#[diag(resolve_imported_crate)]
571pub(crate) struct CrateImported {
572 #[primary_span]
573 pub(crate) span: Span,
574}
575
576#[derive(Diagnostic)]
577#[diag(resolve_macro_use_extern_crate_self)]
578pub(crate) struct MacroUseExternCrateSelf {
579 #[primary_span]
580 pub(crate) span: Span,
581}
582
583#[derive(Diagnostic)]
584#[diag(resolve_accessible_unsure)]
585#[note]
586pub(crate) struct CfgAccessibleUnsure {
587 #[primary_span]
588 pub(crate) span: Span,
589}
590
591#[derive(Debug)]
592#[derive(Diagnostic)]
593#[diag(resolve_param_in_enum_discriminant)]
594pub(crate) struct ParamInEnumDiscriminant {
595 #[primary_span]
596 #[label]
597 pub(crate) span: Span,
598 pub(crate) name: Symbol,
599 #[subdiagnostic]
600 pub(crate) param_kind: ParamKindInEnumDiscriminant,
601}
602
603#[derive(Debug)]
604#[derive(Subdiagnostic)]
605pub(crate) enum ParamKindInEnumDiscriminant {
606 #[note(resolve_type_param_in_enum_discriminant)]
607 Type,
608 #[note(resolve_const_param_in_enum_discriminant)]
609 Const,
610 #[note(resolve_lifetime_param_in_enum_discriminant)]
611 Lifetime,
612}
613
614#[derive(Subdiagnostic)]
615#[label(resolve_change_import_binding)]
616pub(crate) struct ChangeImportBinding {
617 #[primary_span]
618 pub(crate) span: Span,
619}
620
621#[derive(Subdiagnostic)]
622#[suggestion(
623 resolve_change_import_binding,
624 code = "{suggestion}",
625 applicability = "maybe-incorrect"
626)]
627pub(crate) struct ChangeImportBindingSuggestion {
628 #[primary_span]
629 pub(crate) span: Span,
630 pub(crate) suggestion: String,
631}
632
633#[derive(Diagnostic)]
634#[diag(resolve_imports_cannot_refer_to)]
635pub(crate) struct ImportsCannotReferTo<'a> {
636 #[primary_span]
637 pub(crate) span: Span,
638 pub(crate) what: &'a str,
639}
640
641#[derive(Diagnostic)]
642#[diag(resolve_cannot_find_ident_in_this_scope)]
643pub(crate) struct CannotFindIdentInThisScope<'a> {
644 #[primary_span]
645 pub(crate) span: Span,
646 pub(crate) expected: &'a str,
647 pub(crate) ident: Ident,
648}
649
650#[derive(Subdiagnostic)]
651#[note(resolve_explicit_unsafe_traits)]
652pub(crate) struct ExplicitUnsafeTraits {
653 #[primary_span]
654 pub(crate) span: Span,
655 pub(crate) ident: Ident,
656}
657
658#[derive(Subdiagnostic)]
659#[note(resolve_macro_defined_later)]
660pub(crate) struct MacroDefinedLater {
661 #[primary_span]
662 pub(crate) span: Span,
663}
664
665#[derive(Subdiagnostic)]
666#[label(resolve_consider_move_macro_position)]
667pub(crate) struct MacroSuggMovePosition {
668 #[primary_span]
669 pub(crate) span: Span,
670 pub(crate) ident: Ident,
671}
672
673#[derive(Subdiagnostic)]
674pub(crate) enum MacroRulesNot {
675 #[label(resolve_macro_cannot_use_as_attr)]
676 Attr {
677 #[primary_span]
678 span: Span,
679 ident: Ident,
680 },
681 #[label(resolve_macro_cannot_use_as_derive)]
682 Derive {
683 #[primary_span]
684 span: Span,
685 ident: Ident,
686 },
687}
688
689#[derive(Subdiagnostic)]
690#[note(resolve_missing_macro_rules_name)]
691pub(crate) struct MaybeMissingMacroRulesName {
692 #[primary_span]
693 pub(crate) spans: MultiSpan,
694}
695
696#[derive(Subdiagnostic)]
697#[help(resolve_added_macro_use)]
698pub(crate) struct AddedMacroUse;
699
700#[derive(Subdiagnostic)]
701#[suggestion(
702 resolve_consider_adding_a_derive,
703 code = "{suggestion}",
704 applicability = "maybe-incorrect"
705)]
706pub(crate) struct ConsiderAddingADerive {
707 #[primary_span]
708 pub(crate) span: Span,
709 pub(crate) suggestion: String,
710}
711
712#[derive(Diagnostic)]
713#[diag(resolve_cannot_determine_import_resolution)]
714pub(crate) struct CannotDetermineImportResolution {
715 #[primary_span]
716 pub(crate) span: Span,
717}
718
719#[derive(Diagnostic)]
720#[diag(resolve_cannot_determine_macro_resolution)]
721#[note]
722pub(crate) struct CannotDetermineMacroResolution {
723 #[primary_span]
724 pub(crate) span: Span,
725 pub(crate) kind: &'static str,
726 pub(crate) path: String,
727}
728
729#[derive(Diagnostic)]
730#[diag(resolve_cannot_be_reexported_private, code = E0364)]
731pub(crate) struct CannotBeReexportedPrivate {
732 #[primary_span]
733 pub(crate) span: Span,
734 pub(crate) ident: Ident,
735}
736
737#[derive(Diagnostic)]
738#[diag(resolve_cannot_be_reexported_crate_public, code = E0364)]
739pub(crate) struct CannotBeReexportedCratePublic {
740 #[primary_span]
741 pub(crate) span: Span,
742 pub(crate) ident: Ident,
743}
744
745#[derive(Diagnostic)]
746#[diag(resolve_cannot_be_reexported_private, code = E0365)]
747#[note(resolve_consider_declaring_with_pub)]
748pub(crate) struct CannotBeReexportedPrivateNS {
749 #[primary_span]
750 #[label(resolve_reexport_of_private)]
751 pub(crate) span: Span,
752 pub(crate) ident: Ident,
753}
754
755#[derive(Diagnostic)]
756#[diag(resolve_cannot_be_reexported_crate_public, code = E0365)]
757#[note(resolve_consider_declaring_with_pub)]
758pub(crate) struct CannotBeReexportedCratePublicNS {
759 #[primary_span]
760 #[label(resolve_reexport_of_crate_public)]
761 pub(crate) span: Span,
762 pub(crate) ident: Ident,
763}
764
765#[derive(Subdiagnostic)]
766#[help(resolve_consider_adding_macro_export)]
767pub(crate) struct ConsiderAddingMacroExport {
768 #[primary_span]
769 pub(crate) span: Span,
770}
771
772#[derive(Subdiagnostic)]
773#[note(resolve_consider_marking_as_pub)]
774pub(crate) struct ConsiderMarkingAsPub {
775 #[primary_span]
776 pub(crate) span: Span,
777 pub(crate) ident: Ident,
778}
779
780#[derive(Diagnostic)]
781#[diag(resolve_cannot_glob_import_possible_crates)]
782pub(crate) struct CannotGlobImportAllCrates {
783 #[primary_span]
784 pub(crate) span: Span,
785}
786
787#[derive(Subdiagnostic)]
788#[suggestion(
789 resolve_unexpected_res_change_ty_to_const_param_sugg,
790 code = "const ",
791 style = "verbose"
792)]
793pub(crate) struct UnexpectedResChangeTyToConstParamSugg {
794 #[primary_span]
795 pub span: Span,
796 #[applicability]
797 pub applicability: Applicability,
798}
799
800#[derive(Subdiagnostic)]
801#[suggestion(
802 resolve_unexpected_res_use_at_op_in_slice_pat_with_range_sugg,
803 code = "{snippet}",
804 applicability = "maybe-incorrect",
805 style = "verbose"
806)]
807pub(crate) struct UnexpectedResUseAtOpInSlicePatWithRangeSugg {
808 #[primary_span]
809 pub span: Span,
810 pub ident: Ident,
811 pub snippet: String,
812}
813
814#[derive(Diagnostic)]
815#[diag(resolve_extern_crate_loading_macro_not_at_crate_root, code = E0468)]
816pub(crate) struct ExternCrateLoadingMacroNotAtCrateRoot {
817 #[primary_span]
818 pub(crate) span: Span,
819}
820
821#[derive(Diagnostic)]
822#[diag(resolve_extern_crate_self_requires_renaming)]
823pub(crate) struct ExternCrateSelfRequiresRenaming {
824 #[primary_span]
825 #[suggestion(code = "extern crate self as name;", applicability = "has-placeholders")]
826 pub(crate) span: Span,
827}
828
829#[derive(Diagnostic)]
830#[diag(resolve_macro_use_name_already_in_use)]
831#[note]
832pub(crate) struct MacroUseNameAlreadyInUse {
833 #[primary_span]
834 pub(crate) span: Span,
835 pub(crate) name: Symbol,
836}
837
838#[derive(Diagnostic)]
839#[diag(resolve_imported_macro_not_found, code = E0469)]
840pub(crate) struct ImportedMacroNotFound {
841 #[primary_span]
842 pub(crate) span: Span,
843}
844
845#[derive(Diagnostic)]
846#[diag(resolve_macro_extern_deprecated)]
847pub(crate) struct MacroExternDeprecated {
848 #[primary_span]
849 pub(crate) span: Span,
850 #[help]
851 pub inner_attribute: bool,
852}
853
854#[derive(Diagnostic)]
855#[diag(resolve_arguments_macro_use_not_allowed)]
856pub(crate) struct ArgumentsMacroUseNotAllowed {
857 #[primary_span]
858 pub(crate) span: Span,
859}
860
861#[derive(Diagnostic)]
862#[diag(resolve_unnamed_crate_root_import)]
863pub(crate) struct UnnamedCrateRootImport {
864 #[primary_span]
865 pub(crate) span: Span,
866}
867
868#[derive(Diagnostic)]
869#[diag(resolve_macro_expanded_extern_crate_cannot_shadow_extern_arguments)]
870pub(crate) struct MacroExpandedExternCrateCannotShadowExternArguments {
871 #[primary_span]
872 pub(crate) span: Span,
873}
874
875#[derive(Diagnostic)]
876#[diag(resolve_elided_anonymous_lifetime_report_error, code = E0637)]
877pub(crate) struct ElidedAnonymousLifetimeReportError {
878 #[primary_span]
879 #[label]
880 pub(crate) span: Span,
881 #[subdiagnostic]
882 pub(crate) suggestion: Option<ElidedAnonymousLifetimeReportErrorSuggestion>,
883}
884
885#[derive(Diagnostic)]
886#[diag(resolve_lending_iterator_report_error)]
887pub(crate) struct LendingIteratorReportError {
888 #[primary_span]
889 pub(crate) lifetime: Span,
890 #[note]
891 pub(crate) ty: Span,
892}
893
894#[derive(Diagnostic)]
895#[diag(resolve_anonymous_lifetime_non_gat_report_error)]
896pub(crate) struct AnonymousLifetimeNonGatReportError {
897 #[primary_span]
898 #[label]
899 pub(crate) lifetime: Span,
900}
901
902#[derive(Subdiagnostic)]
903#[multipart_suggestion(
904 resolve_elided_anonymous_lifetime_report_error_suggestion,
905 applicability = "machine-applicable"
906)]
907pub(crate) struct ElidedAnonymousLifetimeReportErrorSuggestion {
908 #[suggestion_part(code = "for<'a> ")]
909 pub(crate) lo: Span,
910 #[suggestion_part(code = "'a ")]
911 pub(crate) hi: Span,
912}
913
914#[derive(Diagnostic)]
915#[diag(resolve_explicit_anonymous_lifetime_report_error, code = E0637)]
916pub(crate) struct ExplicitAnonymousLifetimeReportError {
917 #[primary_span]
918 #[label]
919 pub(crate) span: Span,
920}
921
922#[derive(Diagnostic)]
923#[diag(resolve_implicit_elided_lifetimes_not_allowed_here, code = E0726)]
924pub(crate) struct ImplicitElidedLifetimeNotAllowedHere {
925 #[primary_span]
926 pub(crate) span: Span,
927 #[subdiagnostic]
928 pub(crate) subdiag: ElidedLifetimeInPathSubdiag,
929}
930
931#[derive(Diagnostic)]
932#[diag(resolve_underscore_lifetime_is_reserved, code = E0637)]
933#[help]
934pub(crate) struct UnderscoreLifetimeIsReserved {
935 #[primary_span]
936 #[label]
937 pub(crate) span: Span,
938}
939
940#[derive(Diagnostic)]
941#[diag(resolve_static_lifetime_is_reserved, code = E0262)]
942pub(crate) struct StaticLifetimeIsReserved {
943 #[primary_span]
944 #[label]
945 pub(crate) span: Span,
946 pub(crate) lifetime: Ident,
947}
948
949#[derive(Diagnostic)]
950#[diag(resolve_variable_is_not_bound_in_all_patterns, code = E0408)]
951pub(crate) struct VariableIsNotBoundInAllPatterns {
952 #[primary_span]
953 pub(crate) multispan: MultiSpan,
954 pub(crate) name: Ident,
955}
956
957#[derive(Subdiagnostic, Debug, Clone)]
958#[label(resolve_pattern_doesnt_bind_name)]
959pub(crate) struct PatternDoesntBindName {
960 #[primary_span]
961 pub(crate) span: Span,
962 pub(crate) name: Ident,
963}
964
965#[derive(Subdiagnostic, Debug, Clone)]
966#[label(resolve_variable_not_in_all_patterns)]
967pub(crate) struct VariableNotInAllPatterns {
968 #[primary_span]
969 pub(crate) span: Span,
970}
971
972#[derive(Diagnostic)]
973#[diag(resolve_name_defined_multiple_time)]
974#[note]
975pub(crate) struct NameDefinedMultipleTime {
976 #[primary_span]
977 pub(crate) span: Span,
978 pub(crate) name: Symbol,
979 pub(crate) descr: &'static str,
980 pub(crate) container: &'static str,
981 #[subdiagnostic]
982 pub(crate) label: NameDefinedMultipleTimeLabel,
983 #[subdiagnostic]
984 pub(crate) old_binding_label: Option<NameDefinedMultipleTimeOldBindingLabel>,
985}
986
987#[derive(Subdiagnostic)]
988pub(crate) enum NameDefinedMultipleTimeLabel {
989 #[label(resolve_name_defined_multiple_time_reimported)]
990 Reimported {
991 #[primary_span]
992 span: Span,
993 },
994 #[label(resolve_name_defined_multiple_time_redefined)]
995 Redefined {
996 #[primary_span]
997 span: Span,
998 },
999}
1000
1001#[derive(Subdiagnostic)]
1002pub(crate) enum NameDefinedMultipleTimeOldBindingLabel {
1003 #[label(resolve_name_defined_multiple_time_old_binding_import)]
1004 Import {
1005 #[primary_span]
1006 span: Span,
1007 old_kind: &'static str,
1008 },
1009 #[label(resolve_name_defined_multiple_time_old_binding_definition)]
1010 Definition {
1011 #[primary_span]
1012 span: Span,
1013 old_kind: &'static str,
1014 },
1015}
1016
1017#[derive(Diagnostic)]
1018#[diag(resolve_is_private, code = E0603)]
1019pub(crate) struct IsPrivate<'a> {
1020 #[primary_span]
1021 #[label]
1022 pub(crate) span: Span,
1023 pub(crate) ident_descr: &'a str,
1024 pub(crate) ident: Ident,
1025}
1026
1027#[derive(Diagnostic)]
1028#[diag(resolve_generic_arguments_in_macro_path)]
1029pub(crate) struct GenericArgumentsInMacroPath {
1030 #[primary_span]
1031 pub(crate) span: Span,
1032}
1033
1034#[derive(Diagnostic)]
1035#[diag(resolve_attributes_starting_with_rustc_are_reserved)]
1036pub(crate) struct AttributesStartingWithRustcAreReserved {
1037 #[primary_span]
1038 pub(crate) span: Span,
1039}
1040
1041#[derive(Diagnostic)]
1042#[diag(resolve_cannot_use_through_an_import)]
1043pub(crate) struct CannotUseThroughAnImport {
1044 #[primary_span]
1045 pub(crate) span: Span,
1046 pub(crate) article: &'static str,
1047 pub(crate) descr: &'static str,
1048 #[note]
1049 pub(crate) binding_span: Option<Span>,
1050}
1051
1052#[derive(Diagnostic)]
1053#[diag(resolve_name_reserved_in_attribute_namespace)]
1054pub(crate) struct NameReservedInAttributeNamespace {
1055 #[primary_span]
1056 pub(crate) span: Span,
1057 pub(crate) ident: Ident,
1058}
1059
1060#[derive(Diagnostic)]
1061#[diag(resolve_cannot_find_builtin_macro_with_name)]
1062pub(crate) struct CannotFindBuiltinMacroWithName {
1063 #[primary_span]
1064 pub(crate) span: Span,
1065 pub(crate) ident: Ident,
1066}
1067
1068#[derive(Diagnostic)]
1069#[diag(resolve_tool_was_already_registered)]
1070pub(crate) struct ToolWasAlreadyRegistered {
1071 #[primary_span]
1072 pub(crate) span: Span,
1073 pub(crate) tool: Ident,
1074 #[label]
1075 pub(crate) old_ident_span: Span,
1076}
1077
1078#[derive(Diagnostic)]
1079#[diag(resolve_tool_only_accepts_identifiers)]
1080pub(crate) struct ToolOnlyAcceptsIdentifiers {
1081 #[primary_span]
1082 #[label]
1083 pub(crate) span: Span,
1084 pub(crate) tool: Symbol,
1085}
1086
1087#[derive(Subdiagnostic)]
1088pub(crate) enum DefinedHere {
1089 #[label(resolve_similarly_named_defined_here)]
1090 SimilarlyNamed {
1091 #[primary_span]
1092 span: Span,
1093 candidate_descr: &'static str,
1094 candidate: Symbol,
1095 },
1096 #[label(resolve_single_item_defined_here)]
1097 SingleItem {
1098 #[primary_span]
1099 span: Span,
1100 candidate_descr: &'static str,
1101 candidate: Symbol,
1102 },
1103}
1104
1105#[derive(Subdiagnostic)]
1106#[label(resolve_outer_ident_is_not_publicly_reexported)]
1107pub(crate) struct OuterIdentIsNotPubliclyReexported {
1108 #[primary_span]
1109 pub(crate) span: Span,
1110 pub(crate) outer_ident_descr: &'static str,
1111 pub(crate) outer_ident: Ident,
1112}
1113
1114#[derive(Subdiagnostic)]
1115#[label(resolve_constructor_private_if_any_field_private)]
1116pub(crate) struct ConstructorPrivateIfAnyFieldPrivate {
1117 #[primary_span]
1118 pub(crate) span: Span,
1119}
1120
1121#[derive(Subdiagnostic)]
1122#[multipart_suggestion(
1123 resolve_consider_making_the_field_public,
1124 applicability = "maybe-incorrect",
1125 style = "verbose"
1126)]
1127pub(crate) struct ConsiderMakingTheFieldPublic {
1128 #[suggestion_part(code = "pub ")]
1129 pub(crate) spans: Vec<Span>,
1130 pub(crate) number_of_fields: usize,
1131}
1132
1133#[derive(Subdiagnostic)]
1134pub(crate) enum ImportIdent {
1135 #[suggestion(
1136 resolve_suggestion_import_ident_through_reexport,
1137 code = "{path}",
1138 applicability = "machine-applicable",
1139 style = "verbose"
1140 )]
1141 ThroughReExport {
1142 #[primary_span]
1143 span: Span,
1144 ident: Ident,
1145 path: String,
1146 },
1147 #[suggestion(
1148 resolve_suggestion_import_ident_directly,
1149 code = "{path}",
1150 applicability = "machine-applicable",
1151 style = "verbose"
1152 )]
1153 Directly {
1154 #[primary_span]
1155 span: Span,
1156 ident: Ident,
1157 path: String,
1158 },
1159}
1160
1161#[derive(Subdiagnostic)]
1162#[note(resolve_note_and_refers_to_the_item_defined_here)]
1163pub(crate) struct NoteAndRefersToTheItemDefinedHere<'a> {
1164 #[primary_span]
1165 pub(crate) span: MultiSpan,
1166 pub(crate) binding_descr: &'a str,
1167 pub(crate) binding_name: Ident,
1168 pub(crate) first: bool,
1169 pub(crate) dots: bool,
1170}
1171
1172#[derive(Subdiagnostic)]
1173#[suggestion(resolve_remove_unnecessary_import, code = "", applicability = "maybe-incorrect")]
1174pub(crate) struct RemoveUnnecessaryImport {
1175 #[primary_span]
1176 pub(crate) span: Span,
1177}
1178
1179#[derive(Subdiagnostic)]
1180#[suggestion(
1181 resolve_remove_unnecessary_import,
1182 code = "",
1183 applicability = "maybe-incorrect",
1184 style = "tool-only"
1185)]
1186pub(crate) struct ToolOnlyRemoveUnnecessaryImport {
1187 #[primary_span]
1188 pub(crate) span: Span,
1189}
1190
1191#[derive(Subdiagnostic)]
1192#[note(resolve_ident_imported_here_but_it_is_desc)]
1193pub(crate) struct IdentImporterHereButItIsDesc<'a> {
1194 #[primary_span]
1195 pub(crate) span: Span,
1196 pub(crate) imported_ident: Ident,
1197 pub(crate) imported_ident_desc: &'a str,
1198}
1199
1200#[derive(Subdiagnostic)]
1201#[note(resolve_ident_in_scope_but_it_is_desc)]
1202pub(crate) struct IdentInScopeButItIsDesc<'a> {
1203 pub(crate) imported_ident: Ident,
1204 pub(crate) imported_ident_desc: &'a str,
1205}
1206
1207pub(crate) struct FoundItemConfigureOut {
1208 pub(crate) span: Span,
1209 pub(crate) item_was: ItemWas,
1210}
1211
1212pub(crate) enum ItemWas {
1213 BehindFeature { feature: Symbol, span: Span },
1214 CfgOut { span: Span },
1215}
1216
1217impl Subdiagnostic for FoundItemConfigureOut {
1218 fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
1219 let mut multispan: MultiSpan = self.span.into();
1220 match self.item_was {
1221 ItemWas::BehindFeature { feature, span } => {
1222 let key = "feature".into();
1223 let value = feature.into_diag_arg(&mut None);
1224 let msg = diag.dcx.eagerly_translate_to_string(
1225 fluent::resolve_item_was_behind_feature,
1226 [(&key, &value)].into_iter(),
1227 );
1228 multispan.push_span_label(span, msg);
1229 }
1230 ItemWas::CfgOut { span } => {
1231 multispan.push_span_label(span, fluent::resolve_item_was_cfg_out);
1232 }
1233 }
1234 diag.span_note(multispan, fluent::resolve_found_an_item_configured_out);
1235 }
1236}
1237
1238#[derive(Diagnostic)]
1239#[diag(resolve_trait_impl_mismatch)]
1240pub(crate) struct TraitImplMismatch {
1241 #[primary_span]
1242 #[label]
1243 pub(crate) span: Span,
1244 pub(crate) name: Ident,
1245 pub(crate) kind: &'static str,
1246 pub(crate) trait_path: String,
1247 #[label(resolve_trait_impl_mismatch_label_item)]
1248 pub(crate) trait_item_span: Span,
1249}