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, LintDiagnostic, 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(LintDiagnostic)]
570#[diag(resolve_proc_macro_derive_resolution_fallback)]
571pub(crate) struct ProcMacroDeriveResolutionFallback {
572    #[label]
573    pub span: Span,
574    pub ns_descr: &'static str,
575    pub ident: Ident,
576}
577
578#[derive(LintDiagnostic)]
579#[diag(resolve_macro_expanded_macro_exports_accessed_by_absolute_paths)]
580pub(crate) struct MacroExpandedMacroExportsAccessedByAbsolutePaths {
581    #[note]
582    pub definition: Span,
583}
584
585#[derive(Diagnostic)]
586#[diag(resolve_imported_crate)]
587pub(crate) struct CrateImported {
588    #[primary_span]
589    pub(crate) span: Span,
590}
591
592#[derive(Diagnostic)]
593#[diag(resolve_macro_use_extern_crate_self)]
594pub(crate) struct MacroUseExternCrateSelf {
595    #[primary_span]
596    pub(crate) span: Span,
597}
598
599#[derive(Diagnostic)]
600#[diag(resolve_accessible_unsure)]
601#[note]
602pub(crate) struct CfgAccessibleUnsure {
603    #[primary_span]
604    pub(crate) span: Span,
605}
606
607#[derive(Debug)]
608#[derive(Diagnostic)]
609#[diag(resolve_param_in_enum_discriminant)]
610pub(crate) struct ParamInEnumDiscriminant {
611    #[primary_span]
612    #[label]
613    pub(crate) span: Span,
614    pub(crate) name: Symbol,
615    #[subdiagnostic]
616    pub(crate) param_kind: ParamKindInEnumDiscriminant,
617}
618
619#[derive(Debug)]
620#[derive(Subdiagnostic)]
621pub(crate) enum ParamKindInEnumDiscriminant {
622    #[note(resolve_type_param_in_enum_discriminant)]
623    Type,
624    #[note(resolve_const_param_in_enum_discriminant)]
625    Const,
626    #[note(resolve_lifetime_param_in_enum_discriminant)]
627    Lifetime,
628}
629
630#[derive(Subdiagnostic)]
631#[label(resolve_change_import_binding)]
632pub(crate) struct ChangeImportBinding {
633    #[primary_span]
634    pub(crate) span: Span,
635}
636
637#[derive(Subdiagnostic)]
638#[suggestion(
639    resolve_change_import_binding,
640    code = "{suggestion}",
641    applicability = "maybe-incorrect"
642)]
643pub(crate) struct ChangeImportBindingSuggestion {
644    #[primary_span]
645    pub(crate) span: Span,
646    pub(crate) suggestion: String,
647}
648
649#[derive(Diagnostic)]
650#[diag(resolve_imports_cannot_refer_to)]
651pub(crate) struct ImportsCannotReferTo<'a> {
652    #[primary_span]
653    pub(crate) span: Span,
654    pub(crate) what: &'a str,
655}
656
657#[derive(Diagnostic)]
658#[diag(resolve_cannot_find_ident_in_this_scope)]
659pub(crate) struct CannotFindIdentInThisScope<'a> {
660    #[primary_span]
661    pub(crate) span: Span,
662    pub(crate) expected: &'a str,
663    pub(crate) ident: Ident,
664}
665
666#[derive(Subdiagnostic)]
667#[note(resolve_explicit_unsafe_traits)]
668pub(crate) struct ExplicitUnsafeTraits {
669    #[primary_span]
670    pub(crate) span: Span,
671    pub(crate) ident: Ident,
672}
673
674#[derive(Subdiagnostic)]
675#[note(resolve_macro_defined_later)]
676pub(crate) struct MacroDefinedLater {
677    #[primary_span]
678    pub(crate) span: Span,
679}
680
681#[derive(Subdiagnostic)]
682#[label(resolve_consider_move_macro_position)]
683pub(crate) struct MacroSuggMovePosition {
684    #[primary_span]
685    pub(crate) span: Span,
686    pub(crate) ident: Ident,
687}
688
689#[derive(Subdiagnostic)]
690pub(crate) enum MacroRulesNot {
691    #[label(resolve_macro_cannot_use_as_fn_like)]
692    Func {
693        #[primary_span]
694        span: Span,
695        ident: Ident,
696    },
697    #[label(resolve_macro_cannot_use_as_attr)]
698    Attr {
699        #[primary_span]
700        span: Span,
701        ident: Ident,
702    },
703    #[label(resolve_macro_cannot_use_as_derive)]
704    Derive {
705        #[primary_span]
706        span: Span,
707        ident: Ident,
708    },
709}
710
711#[derive(Subdiagnostic)]
712#[note(resolve_missing_macro_rules_name)]
713pub(crate) struct MaybeMissingMacroRulesName {
714    #[primary_span]
715    pub(crate) spans: MultiSpan,
716}
717
718#[derive(Subdiagnostic)]
719#[help(resolve_added_macro_use)]
720pub(crate) struct AddedMacroUse;
721
722#[derive(Subdiagnostic)]
723#[suggestion(
724    resolve_consider_adding_a_derive,
725    code = "{suggestion}",
726    applicability = "maybe-incorrect"
727)]
728pub(crate) struct ConsiderAddingADerive {
729    #[primary_span]
730    pub(crate) span: Span,
731    pub(crate) suggestion: String,
732}
733
734#[derive(Diagnostic)]
735#[diag(resolve_cannot_determine_import_resolution)]
736pub(crate) struct CannotDetermineImportResolution {
737    #[primary_span]
738    pub(crate) span: Span,
739}
740
741#[derive(Diagnostic)]
742#[diag(resolve_cannot_determine_macro_resolution)]
743#[note]
744pub(crate) struct CannotDetermineMacroResolution {
745    #[primary_span]
746    pub(crate) span: Span,
747    pub(crate) kind: &'static str,
748    pub(crate) path: String,
749}
750
751#[derive(Diagnostic)]
752#[diag(resolve_cannot_be_reexported_private, code = E0364)]
753pub(crate) struct CannotBeReexportedPrivate {
754    #[primary_span]
755    pub(crate) span: Span,
756    pub(crate) ident: Ident,
757}
758
759#[derive(Diagnostic)]
760#[diag(resolve_cannot_be_reexported_crate_public, code = E0364)]
761pub(crate) struct CannotBeReexportedCratePublic {
762    #[primary_span]
763    pub(crate) span: Span,
764    pub(crate) ident: Ident,
765}
766
767#[derive(Diagnostic)]
768#[diag(resolve_cannot_be_reexported_private, code = E0365)]
769#[note(resolve_consider_declaring_with_pub)]
770pub(crate) struct CannotBeReexportedPrivateNS {
771    #[primary_span]
772    #[label(resolve_reexport_of_private)]
773    pub(crate) span: Span,
774    pub(crate) ident: Ident,
775}
776
777#[derive(Diagnostic)]
778#[diag(resolve_cannot_be_reexported_crate_public, code = E0365)]
779#[note(resolve_consider_declaring_with_pub)]
780pub(crate) struct CannotBeReexportedCratePublicNS {
781    #[primary_span]
782    #[label(resolve_reexport_of_crate_public)]
783    pub(crate) span: Span,
784    pub(crate) ident: Ident,
785}
786
787#[derive(Subdiagnostic)]
788#[help(resolve_consider_adding_macro_export)]
789pub(crate) struct ConsiderAddingMacroExport {
790    #[primary_span]
791    pub(crate) span: Span,
792}
793
794#[derive(Subdiagnostic)]
795#[suggestion(
796    resolve_consider_marking_as_pub_crate,
797    code = "pub(crate)",
798    applicability = "maybe-incorrect"
799)]
800pub(crate) struct ConsiderMarkingAsPubCrate {
801    #[primary_span]
802    pub(crate) vis_span: Span,
803}
804
805#[derive(Subdiagnostic)]
806#[note(resolve_consider_marking_as_pub)]
807pub(crate) struct ConsiderMarkingAsPub {
808    #[primary_span]
809    pub(crate) span: Span,
810    pub(crate) ident: Ident,
811}
812
813#[derive(Diagnostic)]
814#[diag(resolve_cannot_glob_import_possible_crates)]
815pub(crate) struct CannotGlobImportAllCrates {
816    #[primary_span]
817    pub(crate) span: Span,
818}
819
820#[derive(Subdiagnostic)]
821#[suggestion(
822    resolve_unexpected_res_change_ty_to_const_param_sugg,
823    code = "const ",
824    style = "verbose"
825)]
826pub(crate) struct UnexpectedResChangeTyToConstParamSugg {
827    #[primary_span]
828    pub span: Span,
829    #[applicability]
830    pub applicability: Applicability,
831}
832
833#[derive(Subdiagnostic)]
834#[suggestion(
835    resolve_unexpected_res_use_at_op_in_slice_pat_with_range_sugg,
836    code = "{snippet}",
837    applicability = "maybe-incorrect",
838    style = "verbose"
839)]
840pub(crate) struct UnexpectedResUseAtOpInSlicePatWithRangeSugg {
841    #[primary_span]
842    pub span: Span,
843    pub ident: Ident,
844    pub snippet: String,
845}
846
847#[derive(Diagnostic)]
848#[diag(resolve_extern_crate_loading_macro_not_at_crate_root, code = E0468)]
849pub(crate) struct ExternCrateLoadingMacroNotAtCrateRoot {
850    #[primary_span]
851    pub(crate) span: Span,
852}
853
854#[derive(Diagnostic)]
855#[diag(resolve_extern_crate_self_requires_renaming)]
856pub(crate) struct ExternCrateSelfRequiresRenaming {
857    #[primary_span]
858    #[suggestion(code = "extern crate self as name;", applicability = "has-placeholders")]
859    pub(crate) span: Span,
860}
861
862#[derive(Diagnostic)]
863#[diag(resolve_macro_use_name_already_in_use)]
864#[note]
865pub(crate) struct MacroUseNameAlreadyInUse {
866    #[primary_span]
867    pub(crate) span: Span,
868    pub(crate) name: Symbol,
869}
870
871#[derive(Diagnostic)]
872#[diag(resolve_imported_macro_not_found, code = E0469)]
873pub(crate) struct ImportedMacroNotFound {
874    #[primary_span]
875    pub(crate) span: Span,
876}
877
878#[derive(Diagnostic)]
879#[diag(resolve_macro_extern_deprecated)]
880pub(crate) struct MacroExternDeprecated {
881    #[primary_span]
882    pub(crate) span: Span,
883    #[help]
884    pub inner_attribute: bool,
885}
886
887#[derive(Diagnostic)]
888#[diag(resolve_arguments_macro_use_not_allowed)]
889pub(crate) struct ArgumentsMacroUseNotAllowed {
890    #[primary_span]
891    pub(crate) span: Span,
892}
893
894#[derive(Diagnostic)]
895#[diag(resolve_unnamed_crate_root_import)]
896pub(crate) struct UnnamedCrateRootImport {
897    #[primary_span]
898    pub(crate) span: Span,
899}
900
901#[derive(Diagnostic)]
902#[diag(resolve_macro_expanded_extern_crate_cannot_shadow_extern_arguments)]
903pub(crate) struct MacroExpandedExternCrateCannotShadowExternArguments {
904    #[primary_span]
905    pub(crate) span: Span,
906}
907
908#[derive(Diagnostic)]
909#[diag(resolve_elided_anonymous_lifetime_report_error, code = E0637)]
910pub(crate) struct ElidedAnonymousLifetimeReportError {
911    #[primary_span]
912    #[label]
913    pub(crate) span: Span,
914    #[subdiagnostic]
915    pub(crate) suggestion: Option<ElidedAnonymousLifetimeReportErrorSuggestion>,
916}
917
918#[derive(Diagnostic)]
919#[diag(resolve_lending_iterator_report_error)]
920pub(crate) struct LendingIteratorReportError {
921    #[primary_span]
922    pub(crate) lifetime: Span,
923    #[note]
924    pub(crate) ty: Span,
925}
926
927#[derive(Diagnostic)]
928#[diag(resolve_anonymous_lifetime_non_gat_report_error)]
929pub(crate) struct AnonymousLifetimeNonGatReportError {
930    #[primary_span]
931    #[label]
932    pub(crate) lifetime: Span,
933}
934
935#[derive(Subdiagnostic)]
936#[multipart_suggestion(
937    resolve_elided_anonymous_lifetime_report_error_suggestion,
938    applicability = "machine-applicable"
939)]
940pub(crate) struct ElidedAnonymousLifetimeReportErrorSuggestion {
941    #[suggestion_part(code = "for<'a> ")]
942    pub(crate) lo: Span,
943    #[suggestion_part(code = "'a ")]
944    pub(crate) hi: Span,
945}
946
947#[derive(Diagnostic)]
948#[diag(resolve_explicit_anonymous_lifetime_report_error, code = E0637)]
949pub(crate) struct ExplicitAnonymousLifetimeReportError {
950    #[primary_span]
951    #[label]
952    pub(crate) span: Span,
953}
954
955#[derive(Diagnostic)]
956#[diag(resolve_implicit_elided_lifetimes_not_allowed_here, code = E0726)]
957pub(crate) struct ImplicitElidedLifetimeNotAllowedHere {
958    #[primary_span]
959    pub(crate) span: Span,
960    #[subdiagnostic]
961    pub(crate) subdiag: ElidedLifetimeInPathSubdiag,
962}
963
964#[derive(Diagnostic)]
965#[diag(resolve_underscore_lifetime_is_reserved, code = E0637)]
966#[help]
967pub(crate) struct UnderscoreLifetimeIsReserved {
968    #[primary_span]
969    #[label]
970    pub(crate) span: Span,
971}
972
973#[derive(Diagnostic)]
974#[diag(resolve_static_lifetime_is_reserved, code = E0262)]
975pub(crate) struct StaticLifetimeIsReserved {
976    #[primary_span]
977    #[label]
978    pub(crate) span: Span,
979    pub(crate) lifetime: Ident,
980}
981
982#[derive(Diagnostic)]
983#[diag(resolve_variable_is_not_bound_in_all_patterns, code = E0408)]
984pub(crate) struct VariableIsNotBoundInAllPatterns {
985    #[primary_span]
986    pub(crate) multispan: MultiSpan,
987    pub(crate) name: Ident,
988}
989
990#[derive(Subdiagnostic, Debug, Clone)]
991#[label(resolve_pattern_doesnt_bind_name)]
992pub(crate) struct PatternDoesntBindName {
993    #[primary_span]
994    pub(crate) span: Span,
995    pub(crate) name: Ident,
996}
997
998#[derive(Subdiagnostic, Debug, Clone)]
999#[label(resolve_variable_not_in_all_patterns)]
1000pub(crate) struct VariableNotInAllPatterns {
1001    #[primary_span]
1002    pub(crate) span: Span,
1003}
1004
1005#[derive(Subdiagnostic)]
1006#[multipart_suggestion(
1007    resolve_variable_is_a_typo,
1008    applicability = "maybe-incorrect",
1009    style = "verbose"
1010)]
1011pub(crate) struct PatternBindingTypo {
1012    #[suggestion_part(code = "{typo}")]
1013    pub(crate) spans: Vec<Span>,
1014    pub(crate) typo: Symbol,
1015}
1016
1017#[derive(Diagnostic)]
1018#[diag(resolve_name_defined_multiple_time)]
1019#[note]
1020pub(crate) struct NameDefinedMultipleTime {
1021    #[primary_span]
1022    pub(crate) span: Span,
1023    pub(crate) name: Symbol,
1024    pub(crate) descr: &'static str,
1025    pub(crate) container: &'static str,
1026    #[subdiagnostic]
1027    pub(crate) label: NameDefinedMultipleTimeLabel,
1028    #[subdiagnostic]
1029    pub(crate) old_binding_label: Option<NameDefinedMultipleTimeOldBindingLabel>,
1030}
1031
1032#[derive(Subdiagnostic)]
1033pub(crate) enum NameDefinedMultipleTimeLabel {
1034    #[label(resolve_name_defined_multiple_time_reimported)]
1035    Reimported {
1036        #[primary_span]
1037        span: Span,
1038    },
1039    #[label(resolve_name_defined_multiple_time_redefined)]
1040    Redefined {
1041        #[primary_span]
1042        span: Span,
1043    },
1044}
1045
1046#[derive(Subdiagnostic)]
1047pub(crate) enum NameDefinedMultipleTimeOldBindingLabel {
1048    #[label(resolve_name_defined_multiple_time_old_binding_import)]
1049    Import {
1050        #[primary_span]
1051        span: Span,
1052        old_kind: &'static str,
1053    },
1054    #[label(resolve_name_defined_multiple_time_old_binding_definition)]
1055    Definition {
1056        #[primary_span]
1057        span: Span,
1058        old_kind: &'static str,
1059    },
1060}
1061
1062#[derive(Diagnostic)]
1063#[diag(resolve_is_private, code = E0603)]
1064pub(crate) struct IsPrivate<'a> {
1065    #[primary_span]
1066    #[label]
1067    pub(crate) span: Span,
1068    pub(crate) ident_descr: &'a str,
1069    pub(crate) ident: Ident,
1070}
1071
1072#[derive(Diagnostic)]
1073#[diag(resolve_generic_arguments_in_macro_path)]
1074pub(crate) struct GenericArgumentsInMacroPath {
1075    #[primary_span]
1076    pub(crate) span: Span,
1077}
1078
1079#[derive(Diagnostic)]
1080#[diag(resolve_attributes_starting_with_rustc_are_reserved)]
1081pub(crate) struct AttributesStartingWithRustcAreReserved {
1082    #[primary_span]
1083    pub(crate) span: Span,
1084}
1085
1086#[derive(Diagnostic)]
1087#[diag(resolve_cannot_use_through_an_import)]
1088pub(crate) struct CannotUseThroughAnImport {
1089    #[primary_span]
1090    pub(crate) span: Span,
1091    pub(crate) article: &'static str,
1092    pub(crate) descr: &'static str,
1093    #[note]
1094    pub(crate) binding_span: Option<Span>,
1095}
1096
1097#[derive(Diagnostic)]
1098#[diag(resolve_name_reserved_in_attribute_namespace)]
1099pub(crate) struct NameReservedInAttributeNamespace {
1100    #[primary_span]
1101    pub(crate) span: Span,
1102    pub(crate) ident: Ident,
1103}
1104
1105#[derive(Diagnostic)]
1106#[diag(resolve_cannot_find_builtin_macro_with_name)]
1107pub(crate) struct CannotFindBuiltinMacroWithName {
1108    #[primary_span]
1109    pub(crate) span: Span,
1110    pub(crate) ident: Ident,
1111}
1112
1113#[derive(Diagnostic)]
1114#[diag(resolve_tool_was_already_registered)]
1115pub(crate) struct ToolWasAlreadyRegistered {
1116    #[primary_span]
1117    pub(crate) span: Span,
1118    pub(crate) tool: Ident,
1119    #[label]
1120    pub(crate) old_ident_span: Span,
1121}
1122
1123#[derive(Diagnostic)]
1124#[diag(resolve_tool_only_accepts_identifiers)]
1125pub(crate) struct ToolOnlyAcceptsIdentifiers {
1126    #[primary_span]
1127    #[label]
1128    pub(crate) span: Span,
1129    pub(crate) tool: Symbol,
1130}
1131
1132#[derive(Subdiagnostic)]
1133pub(crate) enum DefinedHere {
1134    #[label(resolve_similarly_named_defined_here)]
1135    SimilarlyNamed {
1136        #[primary_span]
1137        span: Span,
1138        candidate_descr: &'static str,
1139        candidate: Symbol,
1140    },
1141    #[label(resolve_single_item_defined_here)]
1142    SingleItem {
1143        #[primary_span]
1144        span: Span,
1145        candidate_descr: &'static str,
1146        candidate: Symbol,
1147    },
1148}
1149
1150#[derive(Subdiagnostic)]
1151#[label(resolve_outer_ident_is_not_publicly_reexported)]
1152pub(crate) struct OuterIdentIsNotPubliclyReexported {
1153    #[primary_span]
1154    pub(crate) span: Span,
1155    pub(crate) outer_ident_descr: &'static str,
1156    pub(crate) outer_ident: Ident,
1157}
1158
1159#[derive(Subdiagnostic)]
1160#[label(resolve_constructor_private_if_any_field_private)]
1161pub(crate) struct ConstructorPrivateIfAnyFieldPrivate {
1162    #[primary_span]
1163    pub(crate) span: Span,
1164}
1165
1166#[derive(Subdiagnostic)]
1167#[multipart_suggestion(
1168    resolve_consider_making_the_field_public,
1169    applicability = "maybe-incorrect",
1170    style = "verbose"
1171)]
1172pub(crate) struct ConsiderMakingTheFieldPublic {
1173    #[suggestion_part(code = "pub ")]
1174    pub(crate) spans: Vec<Span>,
1175    pub(crate) number_of_fields: usize,
1176}
1177
1178#[derive(Subdiagnostic)]
1179pub(crate) enum ImportIdent {
1180    #[suggestion(
1181        resolve_suggestion_import_ident_through_reexport,
1182        code = "{path}",
1183        applicability = "machine-applicable",
1184        style = "verbose"
1185    )]
1186    ThroughReExport {
1187        #[primary_span]
1188        span: Span,
1189        ident: Ident,
1190        path: String,
1191    },
1192    #[suggestion(
1193        resolve_suggestion_import_ident_directly,
1194        code = "{path}",
1195        applicability = "machine-applicable",
1196        style = "verbose"
1197    )]
1198    Directly {
1199        #[primary_span]
1200        span: Span,
1201        ident: Ident,
1202        path: String,
1203    },
1204}
1205
1206#[derive(Subdiagnostic)]
1207#[note(resolve_note_and_refers_to_the_item_defined_here)]
1208pub(crate) struct NoteAndRefersToTheItemDefinedHere<'a> {
1209    #[primary_span]
1210    pub(crate) span: MultiSpan,
1211    pub(crate) binding_descr: &'a str,
1212    pub(crate) binding_name: Ident,
1213    pub(crate) first: bool,
1214    pub(crate) dots: bool,
1215}
1216
1217#[derive(Subdiagnostic)]
1218#[suggestion(resolve_remove_unnecessary_import, code = "", applicability = "maybe-incorrect")]
1219pub(crate) struct RemoveUnnecessaryImport {
1220    #[primary_span]
1221    pub(crate) span: Span,
1222}
1223
1224#[derive(Subdiagnostic)]
1225#[suggestion(
1226    resolve_remove_unnecessary_import,
1227    code = "",
1228    applicability = "maybe-incorrect",
1229    style = "tool-only"
1230)]
1231pub(crate) struct ToolOnlyRemoveUnnecessaryImport {
1232    #[primary_span]
1233    pub(crate) span: Span,
1234}
1235
1236#[derive(Subdiagnostic)]
1237#[note(resolve_ident_imported_here_but_it_is_desc)]
1238pub(crate) struct IdentImporterHereButItIsDesc<'a> {
1239    #[primary_span]
1240    pub(crate) span: Span,
1241    pub(crate) imported_ident: Ident,
1242    pub(crate) imported_ident_desc: &'a str,
1243}
1244
1245#[derive(Subdiagnostic)]
1246#[note(resolve_ident_in_scope_but_it_is_desc)]
1247pub(crate) struct IdentInScopeButItIsDesc<'a> {
1248    pub(crate) imported_ident: Ident,
1249    pub(crate) imported_ident_desc: &'a str,
1250}
1251
1252pub(crate) struct FoundItemConfigureOut {
1253    pub(crate) span: Span,
1254    pub(crate) item_was: ItemWas,
1255}
1256
1257pub(crate) enum ItemWas {
1258    BehindFeature { feature: Symbol, span: Span },
1259    CfgOut { span: Span },
1260}
1261
1262impl Subdiagnostic for FoundItemConfigureOut {
1263    fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
1264        let mut multispan: MultiSpan = self.span.into();
1265        match self.item_was {
1266            ItemWas::BehindFeature { feature, span } => {
1267                let key = "feature".into();
1268                let value = feature.into_diag_arg(&mut None);
1269                let msg = diag.dcx.eagerly_translate_to_string(
1270                    fluent::resolve_item_was_behind_feature,
1271                    [(&key, &value)].into_iter(),
1272                );
1273                multispan.push_span_label(span, msg);
1274            }
1275            ItemWas::CfgOut { span } => {
1276                multispan.push_span_label(span, fluent::resolve_item_was_cfg_out);
1277            }
1278        }
1279        diag.span_note(multispan, fluent::resolve_found_an_item_configured_out);
1280    }
1281}
1282
1283#[derive(Diagnostic)]
1284#[diag(resolve_trait_impl_mismatch)]
1285pub(crate) struct TraitImplMismatch {
1286    #[primary_span]
1287    #[label]
1288    pub(crate) span: Span,
1289    pub(crate) name: Ident,
1290    pub(crate) kind: &'static str,
1291    pub(crate) trait_path: String,
1292    #[label(resolve_trait_impl_mismatch_label_item)]
1293    pub(crate) trait_item_span: Span,
1294}
1295
1296#[derive(LintDiagnostic)]
1297#[diag(resolve_legacy_derive_helpers)]
1298pub(crate) struct LegacyDeriveHelpers {
1299    #[label]
1300    pub span: Span,
1301}
1302
1303#[derive(LintDiagnostic)]
1304#[diag(resolve_unused_extern_crate)]
1305pub(crate) struct UnusedExternCrate {
1306    #[label]
1307    pub span: Span,
1308    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
1309    pub removal_span: Span,
1310}
1311
1312#[derive(LintDiagnostic)]
1313#[diag(resolve_reexport_private_dependency)]
1314pub(crate) struct ReexportPrivateDependency {
1315    pub name: Symbol,
1316    pub kind: &'static str,
1317    pub krate: Symbol,
1318}
1319
1320#[derive(LintDiagnostic)]
1321#[diag(resolve_unused_label)]
1322pub(crate) struct UnusedLabel;
1323
1324#[derive(LintDiagnostic)]
1325#[diag(resolve_unused_macro_use)]
1326pub(crate) struct UnusedMacroUse;
1327
1328#[derive(LintDiagnostic)]
1329#[diag(resolve_macro_use_deprecated)]
1330#[help]
1331pub(crate) struct MacroUseDeprecated;
rustc_resolve/errors.rs

rustc_resolve/
errors.rs
