rustc_resolve/
errors.rs

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