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