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 #[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}