rustc_resolve/
errors.rs

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    // #[primary_span]
252    #[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}