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#[note(resolve_consider_marking_as_pub)]
780pub(crate) struct ConsiderMarkingAsPub {
781 #[primary_span]
782 pub(crate) span: Span,
783 pub(crate) ident: Ident,
784}
785
786#[derive(Diagnostic)]
787#[diag(resolve_cannot_glob_import_possible_crates)]
788pub(crate) struct CannotGlobImportAllCrates {
789 #[primary_span]
790 pub(crate) span: Span,
791}
792
793#[derive(Subdiagnostic)]
794#[suggestion(
795 resolve_unexpected_res_change_ty_to_const_param_sugg,
796 code = "const ",
797 style = "verbose"
798)]
799pub(crate) struct UnexpectedResChangeTyToConstParamSugg {
800 #[primary_span]
801 pub span: Span,
802 #[applicability]
803 pub applicability: Applicability,
804}
805
806#[derive(Subdiagnostic)]
807#[suggestion(
808 resolve_unexpected_res_use_at_op_in_slice_pat_with_range_sugg,
809 code = "{snippet}",
810 applicability = "maybe-incorrect",
811 style = "verbose"
812)]
813pub(crate) struct UnexpectedResUseAtOpInSlicePatWithRangeSugg {
814 #[primary_span]
815 pub span: Span,
816 pub ident: Ident,
817 pub snippet: String,
818}
819
820#[derive(Diagnostic)]
821#[diag(resolve_extern_crate_loading_macro_not_at_crate_root, code = E0468)]
822pub(crate) struct ExternCrateLoadingMacroNotAtCrateRoot {
823 #[primary_span]
824 pub(crate) span: Span,
825}
826
827#[derive(Diagnostic)]
828#[diag(resolve_extern_crate_self_requires_renaming)]
829pub(crate) struct ExternCrateSelfRequiresRenaming {
830 #[primary_span]
831 #[suggestion(code = "extern crate self as name;", applicability = "has-placeholders")]
832 pub(crate) span: Span,
833}
834
835#[derive(Diagnostic)]
836#[diag(resolve_macro_use_name_already_in_use)]
837#[note]
838pub(crate) struct MacroUseNameAlreadyInUse {
839 #[primary_span]
840 pub(crate) span: Span,
841 pub(crate) name: Symbol,
842}
843
844#[derive(Diagnostic)]
845#[diag(resolve_imported_macro_not_found, code = E0469)]
846pub(crate) struct ImportedMacroNotFound {
847 #[primary_span]
848 pub(crate) span: Span,
849}
850
851#[derive(Diagnostic)]
852#[diag(resolve_macro_extern_deprecated)]
853pub(crate) struct MacroExternDeprecated {
854 #[primary_span]
855 pub(crate) span: Span,
856 #[help]
857 pub inner_attribute: bool,
858}
859
860#[derive(Diagnostic)]
861#[diag(resolve_arguments_macro_use_not_allowed)]
862pub(crate) struct ArgumentsMacroUseNotAllowed {
863 #[primary_span]
864 pub(crate) span: Span,
865}
866
867#[derive(Diagnostic)]
868#[diag(resolve_unnamed_crate_root_import)]
869pub(crate) struct UnnamedCrateRootImport {
870 #[primary_span]
871 pub(crate) span: Span,
872}
873
874#[derive(Diagnostic)]
875#[diag(resolve_macro_expanded_extern_crate_cannot_shadow_extern_arguments)]
876pub(crate) struct MacroExpandedExternCrateCannotShadowExternArguments {
877 #[primary_span]
878 pub(crate) span: Span,
879}
880
881#[derive(Diagnostic)]
882#[diag(resolve_elided_anonymous_lifetime_report_error, code = E0637)]
883pub(crate) struct ElidedAnonymousLifetimeReportError {
884 #[primary_span]
885 #[label]
886 pub(crate) span: Span,
887 #[subdiagnostic]
888 pub(crate) suggestion: Option<ElidedAnonymousLifetimeReportErrorSuggestion>,
889}
890
891#[derive(Diagnostic)]
892#[diag(resolve_lending_iterator_report_error)]
893pub(crate) struct LendingIteratorReportError {
894 #[primary_span]
895 pub(crate) lifetime: Span,
896 #[note]
897 pub(crate) ty: Span,
898}
899
900#[derive(Diagnostic)]
901#[diag(resolve_anonymous_lifetime_non_gat_report_error)]
902pub(crate) struct AnonymousLifetimeNonGatReportError {
903 #[primary_span]
904 #[label]
905 pub(crate) lifetime: Span,
906}
907
908#[derive(Subdiagnostic)]
909#[multipart_suggestion(
910 resolve_elided_anonymous_lifetime_report_error_suggestion,
911 applicability = "machine-applicable"
912)]
913pub(crate) struct ElidedAnonymousLifetimeReportErrorSuggestion {
914 #[suggestion_part(code = "for<'a> ")]
915 pub(crate) lo: Span,
916 #[suggestion_part(code = "'a ")]
917 pub(crate) hi: Span,
918}
919
920#[derive(Diagnostic)]
921#[diag(resolve_explicit_anonymous_lifetime_report_error, code = E0637)]
922pub(crate) struct ExplicitAnonymousLifetimeReportError {
923 #[primary_span]
924 #[label]
925 pub(crate) span: Span,
926}
927
928#[derive(Diagnostic)]
929#[diag(resolve_implicit_elided_lifetimes_not_allowed_here, code = E0726)]
930pub(crate) struct ImplicitElidedLifetimeNotAllowedHere {
931 #[primary_span]
932 pub(crate) span: Span,
933 #[subdiagnostic]
934 pub(crate) subdiag: ElidedLifetimeInPathSubdiag,
935}
936
937#[derive(Diagnostic)]
938#[diag(resolve_underscore_lifetime_is_reserved, code = E0637)]
939#[help]
940pub(crate) struct UnderscoreLifetimeIsReserved {
941 #[primary_span]
942 #[label]
943 pub(crate) span: Span,
944}
945
946#[derive(Diagnostic)]
947#[diag(resolve_static_lifetime_is_reserved, code = E0262)]
948pub(crate) struct StaticLifetimeIsReserved {
949 #[primary_span]
950 #[label]
951 pub(crate) span: Span,
952 pub(crate) lifetime: Ident,
953}
954
955#[derive(Diagnostic)]
956#[diag(resolve_variable_is_not_bound_in_all_patterns, code = E0408)]
957pub(crate) struct VariableIsNotBoundInAllPatterns {
958 #[primary_span]
959 pub(crate) multispan: MultiSpan,
960 pub(crate) name: Ident,
961}
962
963#[derive(Subdiagnostic, Debug, Clone)]
964#[label(resolve_pattern_doesnt_bind_name)]
965pub(crate) struct PatternDoesntBindName {
966 #[primary_span]
967 pub(crate) span: Span,
968 pub(crate) name: Ident,
969}
970
971#[derive(Subdiagnostic, Debug, Clone)]
972#[label(resolve_variable_not_in_all_patterns)]
973pub(crate) struct VariableNotInAllPatterns {
974 #[primary_span]
975 pub(crate) span: Span,
976}
977
978#[derive(Diagnostic)]
979#[diag(resolve_name_defined_multiple_time)]
980#[note]
981pub(crate) struct NameDefinedMultipleTime {
982 #[primary_span]
983 pub(crate) span: Span,
984 pub(crate) name: Symbol,
985 pub(crate) descr: &'static str,
986 pub(crate) container: &'static str,
987 #[subdiagnostic]
988 pub(crate) label: NameDefinedMultipleTimeLabel,
989 #[subdiagnostic]
990 pub(crate) old_binding_label: Option<NameDefinedMultipleTimeOldBindingLabel>,
991}
992
993#[derive(Subdiagnostic)]
994pub(crate) enum NameDefinedMultipleTimeLabel {
995 #[label(resolve_name_defined_multiple_time_reimported)]
996 Reimported {
997 #[primary_span]
998 span: Span,
999 },
1000 #[label(resolve_name_defined_multiple_time_redefined)]
1001 Redefined {
1002 #[primary_span]
1003 span: Span,
1004 },
1005}
1006
1007#[derive(Subdiagnostic)]
1008pub(crate) enum NameDefinedMultipleTimeOldBindingLabel {
1009 #[label(resolve_name_defined_multiple_time_old_binding_import)]
1010 Import {
1011 #[primary_span]
1012 span: Span,
1013 old_kind: &'static str,
1014 },
1015 #[label(resolve_name_defined_multiple_time_old_binding_definition)]
1016 Definition {
1017 #[primary_span]
1018 span: Span,
1019 old_kind: &'static str,
1020 },
1021}
1022
1023#[derive(Diagnostic)]
1024#[diag(resolve_is_private, code = E0603)]
1025pub(crate) struct IsPrivate<'a> {
1026 #[primary_span]
1027 #[label]
1028 pub(crate) span: Span,
1029 pub(crate) ident_descr: &'a str,
1030 pub(crate) ident: Ident,
1031}
1032
1033#[derive(Diagnostic)]
1034#[diag(resolve_generic_arguments_in_macro_path)]
1035pub(crate) struct GenericArgumentsInMacroPath {
1036 #[primary_span]
1037 pub(crate) span: Span,
1038}
1039
1040#[derive(Diagnostic)]
1041#[diag(resolve_attributes_starting_with_rustc_are_reserved)]
1042pub(crate) struct AttributesStartingWithRustcAreReserved {
1043 #[primary_span]
1044 pub(crate) span: Span,
1045}
1046
1047#[derive(Diagnostic)]
1048#[diag(resolve_cannot_use_through_an_import)]
1049pub(crate) struct CannotUseThroughAnImport {
1050 #[primary_span]
1051 pub(crate) span: Span,
1052 pub(crate) article: &'static str,
1053 pub(crate) descr: &'static str,
1054 #[note]
1055 pub(crate) binding_span: Option<Span>,
1056}
1057
1058#[derive(Diagnostic)]
1059#[diag(resolve_name_reserved_in_attribute_namespace)]
1060pub(crate) struct NameReservedInAttributeNamespace {
1061 #[primary_span]
1062 pub(crate) span: Span,
1063 pub(crate) ident: Ident,
1064}
1065
1066#[derive(Diagnostic)]
1067#[diag(resolve_cannot_find_builtin_macro_with_name)]
1068pub(crate) struct CannotFindBuiltinMacroWithName {
1069 #[primary_span]
1070 pub(crate) span: Span,
1071 pub(crate) ident: Ident,
1072}
1073
1074#[derive(Diagnostic)]
1075#[diag(resolve_tool_was_already_registered)]
1076pub(crate) struct ToolWasAlreadyRegistered {
1077 #[primary_span]
1078 pub(crate) span: Span,
1079 pub(crate) tool: Ident,
1080 #[label]
1081 pub(crate) old_ident_span: Span,
1082}
1083
1084#[derive(Diagnostic)]
1085#[diag(resolve_tool_only_accepts_identifiers)]
1086pub(crate) struct ToolOnlyAcceptsIdentifiers {
1087 #[primary_span]
1088 #[label]
1089 pub(crate) span: Span,
1090 pub(crate) tool: Symbol,
1091}
1092
1093#[derive(Subdiagnostic)]
1094pub(crate) enum DefinedHere {
1095 #[label(resolve_similarly_named_defined_here)]
1096 SimilarlyNamed {
1097 #[primary_span]
1098 span: Span,
1099 candidate_descr: &'static str,
1100 candidate: Symbol,
1101 },
1102 #[label(resolve_single_item_defined_here)]
1103 SingleItem {
1104 #[primary_span]
1105 span: Span,
1106 candidate_descr: &'static str,
1107 candidate: Symbol,
1108 },
1109}
1110
1111#[derive(Subdiagnostic)]
1112#[label(resolve_outer_ident_is_not_publicly_reexported)]
1113pub(crate) struct OuterIdentIsNotPubliclyReexported {
1114 #[primary_span]
1115 pub(crate) span: Span,
1116 pub(crate) outer_ident_descr: &'static str,
1117 pub(crate) outer_ident: Ident,
1118}
1119
1120#[derive(Subdiagnostic)]
1121#[label(resolve_constructor_private_if_any_field_private)]
1122pub(crate) struct ConstructorPrivateIfAnyFieldPrivate {
1123 #[primary_span]
1124 pub(crate) span: Span,
1125}
1126
1127#[derive(Subdiagnostic)]
1128#[multipart_suggestion(
1129 resolve_consider_making_the_field_public,
1130 applicability = "maybe-incorrect",
1131 style = "verbose"
1132)]
1133pub(crate) struct ConsiderMakingTheFieldPublic {
1134 #[suggestion_part(code = "pub ")]
1135 pub(crate) spans: Vec<Span>,
1136 pub(crate) number_of_fields: usize,
1137}
1138
1139#[derive(Subdiagnostic)]
1140pub(crate) enum ImportIdent {
1141 #[suggestion(
1142 resolve_suggestion_import_ident_through_reexport,
1143 code = "{path}",
1144 applicability = "machine-applicable",
1145 style = "verbose"
1146 )]
1147 ThroughReExport {
1148 #[primary_span]
1149 span: Span,
1150 ident: Ident,
1151 path: String,
1152 },
1153 #[suggestion(
1154 resolve_suggestion_import_ident_directly,
1155 code = "{path}",
1156 applicability = "machine-applicable",
1157 style = "verbose"
1158 )]
1159 Directly {
1160 #[primary_span]
1161 span: Span,
1162 ident: Ident,
1163 path: String,
1164 },
1165}
1166
1167#[derive(Subdiagnostic)]
1168#[note(resolve_note_and_refers_to_the_item_defined_here)]
1169pub(crate) struct NoteAndRefersToTheItemDefinedHere<'a> {
1170 #[primary_span]
1171 pub(crate) span: MultiSpan,
1172 pub(crate) binding_descr: &'a str,
1173 pub(crate) binding_name: Ident,
1174 pub(crate) first: bool,
1175 pub(crate) dots: bool,
1176}
1177
1178#[derive(Subdiagnostic)]
1179#[suggestion(resolve_remove_unnecessary_import, code = "", applicability = "maybe-incorrect")]
1180pub(crate) struct RemoveUnnecessaryImport {
1181 #[primary_span]
1182 pub(crate) span: Span,
1183}
1184
1185#[derive(Subdiagnostic)]
1186#[suggestion(
1187 resolve_remove_unnecessary_import,
1188 code = "",
1189 applicability = "maybe-incorrect",
1190 style = "tool-only"
1191)]
1192pub(crate) struct ToolOnlyRemoveUnnecessaryImport {
1193 #[primary_span]
1194 pub(crate) span: Span,
1195}
1196
1197#[derive(Subdiagnostic)]
1198#[note(resolve_ident_imported_here_but_it_is_desc)]
1199pub(crate) struct IdentImporterHereButItIsDesc<'a> {
1200 #[primary_span]
1201 pub(crate) span: Span,
1202 pub(crate) imported_ident: Ident,
1203 pub(crate) imported_ident_desc: &'a str,
1204}
1205
1206#[derive(Subdiagnostic)]
1207#[note(resolve_ident_in_scope_but_it_is_desc)]
1208pub(crate) struct IdentInScopeButItIsDesc<'a> {
1209 pub(crate) imported_ident: Ident,
1210 pub(crate) imported_ident_desc: &'a str,
1211}
1212
1213pub(crate) struct FoundItemConfigureOut {
1214 pub(crate) span: Span,
1215 pub(crate) item_was: ItemWas,
1216}
1217
1218pub(crate) enum ItemWas {
1219 BehindFeature { feature: Symbol, span: Span },
1220 CfgOut { span: Span },
1221}
1222
1223impl Subdiagnostic for FoundItemConfigureOut {
1224 fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
1225 let mut multispan: MultiSpan = self.span.into();
1226 match self.item_was {
1227 ItemWas::BehindFeature { feature, span } => {
1228 let key = "feature".into();
1229 let value = feature.into_diag_arg(&mut None);
1230 let msg = diag.dcx.eagerly_translate_to_string(
1231 fluent::resolve_item_was_behind_feature,
1232 [(&key, &value)].into_iter(),
1233 );
1234 multispan.push_span_label(span, msg);
1235 }
1236 ItemWas::CfgOut { span } => {
1237 multispan.push_span_label(span, fluent::resolve_item_was_cfg_out);
1238 }
1239 }
1240 diag.span_note(multispan, fluent::resolve_found_an_item_configured_out);
1241 }
1242}
1243
1244#[derive(Diagnostic)]
1245#[diag(resolve_trait_impl_mismatch)]
1246pub(crate) struct TraitImplMismatch {
1247 #[primary_span]
1248 #[label]
1249 pub(crate) span: Span,
1250 pub(crate) name: Ident,
1251 pub(crate) kind: &'static str,
1252 pub(crate) trait_path: String,
1253 #[label(resolve_trait_impl_mismatch_label_item)]
1254 pub(crate) trait_item_span: Span,
1255}