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