compiler/rustc_resolve/src/errors.rs

   1 use rustc_macros::{Diagnostic, Subdiagnostic};
   2 use rustc_span::{
   3     symbol::{Ident, Symbol},
   4     Span,
   5 };
   6
   7 use crate::{late::PatternSource, Res};
   8
   9 #[derive(Diagnostic)]
  10 #[diag(resolve_parent_module_reset_for_binding, code = "E0637")]
  11 pub(crate) struct ParentModuleResetForBinding;
  12
  13 #[derive(Diagnostic)]
  14 #[diag(resolve_ampersand_used_without_explicit_lifetime_name, code = "E0637")]
  15 #[note]
  16 pub(crate) struct AmpersandUsedWithoutExplicitLifetimeName(#[primary_span] pub(crate) Span);
  17
  18 #[derive(Diagnostic)]
  19 #[diag(resolve_underscore_lifetime_name_cannot_be_used_here, code = "E0637")]
  20 #[note]
  21 pub(crate) struct UnderscoreLifetimeNameCannotBeUsedHere(#[primary_span] pub(crate) Span);
  22
  23 #[derive(Diagnostic)]
  24 #[diag(resolve_crate_may_not_be_imported)]
  25 pub(crate) struct CrateMayNotBeImported(#[primary_span] pub(crate) Span);
  26
  27 #[derive(Diagnostic)]
  28 #[diag(resolve_crate_root_imports_must_be_named_explicitly)]
  29 pub(crate) struct CrateRootNamesMustBeNamedExplicitly(#[primary_span] pub(crate) Span);
  30
  31 #[derive(Diagnostic)]
  32 #[diag(resolve_crate_root_imports_must_be_named_explicitly)]
  33 pub(crate) struct ResolutionError(#[primary_span] pub(crate) Span);
  34
  35 #[derive(Diagnostic)]
  36 #[diag(resolve_generic_params_from_outer_item, code = "E0401")]
  37 pub(crate) struct GenericParamsFromOuterItem {
  38     #[primary_span]
  39     #[label]
  40     pub(crate) span: Span,
  41     #[subdiagnostic]
  42     pub(crate) label: Option<GenericParamsFromOuterItemLabel>,
  43     #[label(resolve_refer_to_type_directly)]
  44     pub(crate) refer_to_type_directly: Option<Span>,
  45     #[subdiagnostic]
  46     pub(crate) sugg: Option<GenericParamsFromOuterItemSugg>,
  47 }
  48
  49 #[derive(Subdiagnostic)]
  50 pub(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(resolve_suggestion, code = "{snippet}", applicability = "maybe-incorrect")]
  63 pub(crate) struct GenericParamsFromOuterItemSugg {
  64     #[primary_span]
  65     pub(crate) span: Span,
  66     pub(crate) snippet: String,
  67 }
  68
  69 #[derive(Diagnostic)]
  70 #[diag(resolve_name_is_already_used_as_generic_parameter, code = "E0403")]
  71 pub(crate) struct NameAlreadyUsedInParameterList {
  72     #[primary_span]
  73     #[label]
  74     pub(crate) span: Span,
  75     #[label(resolve_first_use_of_name)]
  76     pub(crate) first_use_span: Span,
  77     pub(crate) name: Symbol,
  78 }
  79
  80 #[derive(Diagnostic)]
  81 #[diag(resolve_method_not_member_of_trait, code = "E0407")]
  82 pub(crate) struct MethodNotMemberOfTrait {
  83     #[primary_span]
  84     #[label]
  85     pub(crate) span: Span,
  86     pub(crate) method: Ident,
  87     pub(crate) trait_: String,
  88     #[subdiagnostic]
  89     pub(crate) sub: Option<AssociatedFnWithSimilarNameExists>,
  90 }
  91
  92 #[derive(Subdiagnostic)]
  93 #[suggestion(
  94     resolve_associated_fn_with_similar_name_exists,
  95     code = "{candidate}",
  96     applicability = "maybe-incorrect"
  97 )]
  98 pub(crate) struct AssociatedFnWithSimilarNameExists {
  99     #[primary_span]
 100     pub(crate) span: Span,
 101     pub(crate) candidate: Symbol,
 102 }
 103
 104 #[derive(Diagnostic)]
 105 #[diag(resolve_type_not_member_of_trait, code = "E0437")]
 106 pub(crate) struct TypeNotMemberOfTrait {
 107     #[primary_span]
 108     #[label]
 109     pub(crate) span: Span,
 110     pub(crate) type_: Ident,
 111     pub(crate) trait_: String,
 112     #[subdiagnostic]
 113     pub(crate) sub: Option<AssociatedTypeWithSimilarNameExists>,
 114 }
 115
 116 #[derive(Subdiagnostic)]
 117 #[suggestion(
 118     resolve_associated_type_with_similar_name_exists,
 119     code = "{candidate}",
 120     applicability = "maybe-incorrect"
 121 )]
 122 pub(crate) struct AssociatedTypeWithSimilarNameExists {
 123     #[primary_span]
 124     pub(crate) span: Span,
 125     pub(crate) candidate: Symbol,
 126 }
 127
 128 #[derive(Diagnostic)]
 129 #[diag(resolve_const_not_member_of_trait, code = "E0438")]
 130 pub(crate) struct ConstNotMemberOfTrait {
 131     #[primary_span]
 132     #[label]
 133     pub(crate) span: Span,
 134     pub(crate) const_: Ident,
 135     pub(crate) trait_: String,
 136     #[subdiagnostic]
 137     pub(crate) sub: Option<AssociatedConstWithSimilarNameExists>,
 138 }
 139
 140 #[derive(Subdiagnostic)]
 141 #[suggestion(
 142     resolve_associated_const_with_similar_name_exists,
 143     code = "{candidate}",
 144     applicability = "maybe-incorrect"
 145 )]
 146 pub(crate) struct AssociatedConstWithSimilarNameExists {
 147     #[primary_span]
 148     pub(crate) span: Span,
 149     pub(crate) candidate: Symbol,
 150 }
 151
 152 #[derive(Diagnostic)]
 153 #[diag(resolve_variable_bound_with_different_mode, code = "E0409")]
 154 pub(crate) struct VariableBoundWithDifferentMode {
 155     #[primary_span]
 156     #[label]
 157     pub(crate) span: Span,
 158     #[label(resolve_first_binding_span)]
 159     pub(crate) first_binding_span: Span,
 160     pub(crate) variable_name: Symbol,
 161 }
 162
 163 #[derive(Diagnostic)]
 164 #[diag(resolve_ident_bound_more_than_once_in_parameter_list, code = "E0415")]
 165 pub(crate) struct IdentifierBoundMoreThanOnceInParameterList {
 166     #[primary_span]
 167     #[label]
 168     pub(crate) span: Span,
 169     pub(crate) identifier: Symbol,
 170 }
 171
 172 #[derive(Diagnostic)]
 173 #[diag(resolve_ident_bound_more_than_once_in_same_pattern, code = "E0416")]
 174 pub(crate) struct IdentifierBoundMoreThanOnceInSamePattern {
 175     #[primary_span]
 176     #[label]
 177     pub(crate) span: Span,
 178     pub(crate) identifier: Symbol,
 179 }
 180
 181 #[derive(Diagnostic)]
 182 #[diag(resolve_undeclared_label, code = "E0426")]
 183 pub(crate) struct UndeclaredLabel {
 184     #[primary_span]
 185     #[label]
 186     pub(crate) span: Span,
 187     pub(crate) name: Symbol,
 188     #[subdiagnostic]
 189     pub(crate) sub_reachable: Option<LabelWithSimilarNameReachable>,
 190     #[subdiagnostic]
 191     pub(crate) sub_reachable_suggestion: Option<TryUsingSimilarlyNamedLabel>,
 192     #[subdiagnostic]
 193     pub(crate) sub_unreachable: Option<UnreachableLabelWithSimilarNameExists>,
 194 }
 195
 196 #[derive(Subdiagnostic)]
 197 #[label(resolve_label_with_similar_name_reachable)]
 198 pub(crate) struct LabelWithSimilarNameReachable(#[primary_span] pub(crate) Span);
 199
 200 #[derive(Subdiagnostic)]
 201 #[suggestion(
 202     resolve_try_using_similarly_named_label,
 203     code = "{ident_name}",
 204     applicability = "maybe-incorrect"
 205 )]
 206 pub(crate) struct TryUsingSimilarlyNamedLabel {
 207     #[primary_span]
 208     pub(crate) span: Span,
 209     pub(crate) ident_name: Symbol,
 210 }
 211
 212 #[derive(Subdiagnostic)]
 213 #[label(resolve_unreachable_label_with_similar_name_exists)]
 214 pub(crate) struct UnreachableLabelWithSimilarNameExists {
 215     #[primary_span]
 216     pub(crate) ident_span: Span,
 217 }
 218
 219 #[derive(Diagnostic)]
 220 #[diag(resolve_self_import_can_only_appear_once_in_the_list, code = "E0430")]
 221 pub(crate) struct SelfImportCanOnlyAppearOnceInTheList {
 222     #[primary_span]
 223     #[label]
 224     pub(crate) span: Span,
 225 }
 226
 227 #[derive(Diagnostic)]
 228 #[diag(resolve_self_import_only_in_import_list_with_non_empty_prefix, code = "E0431")]
 229 pub(crate) struct SelfImportOnlyInImportListWithNonEmptyPrefix {
 230     #[primary_span]
 231     #[label]
 232     pub(crate) span: Span,
 233 }
 234
 235 #[derive(Diagnostic)]
 236 #[diag(resolve_cannot_capture_dynamic_environment_in_fn_item, code = "E0434")]
 237 #[help]
 238 pub(crate) struct CannotCaptureDynamicEnvironmentInFnItem {
 239     #[primary_span]
 240     pub(crate) span: Span,
 241 }
 242
 243 #[derive(Diagnostic)]
 244 #[diag(resolve_attempt_to_use_non_constant_value_in_constant, code = "E0435")]
 245 pub(crate) struct AttemptToUseNonConstantValueInConstant<'a> {
 246     #[primary_span]
 247     pub(crate) span: Span,
 248     #[subdiagnostic]
 249     pub(crate) with: Option<AttemptToUseNonConstantValueInConstantWithSuggestion<'a>>,
 250     #[subdiagnostic]
 251     pub(crate) with_label: Option<AttemptToUseNonConstantValueInConstantLabelWithSuggestion>,
 252     #[subdiagnostic]
 253     pub(crate) without: Option<AttemptToUseNonConstantValueInConstantWithoutSuggestion<'a>>,
 254 }
 255
 256 #[derive(Subdiagnostic)]
 257 #[suggestion(
 258     resolve_attempt_to_use_non_constant_value_in_constant_with_suggestion,
 259     code = "{suggestion} {ident}",
 260     applicability = "maybe-incorrect"
 261 )]
 262 pub(crate) struct AttemptToUseNonConstantValueInConstantWithSuggestion<'a> {
 263     #[primary_span]
 264     pub(crate) span: Span,
 265     pub(crate) ident: Ident,
 266     pub(crate) suggestion: &'a str,
 267     pub(crate) current: &'a str,
 268 }
 269
 270 #[derive(Subdiagnostic)]
 271 #[label(resolve_attempt_to_use_non_constant_value_in_constant_label_with_suggestion)]
 272 pub(crate) struct AttemptToUseNonConstantValueInConstantLabelWithSuggestion {
 273     #[primary_span]
 274     pub(crate) span: Span,
 275 }
 276
 277 #[derive(Subdiagnostic)]
 278 #[label(resolve_attempt_to_use_non_constant_value_in_constant_without_suggestion)]
 279 pub(crate) struct AttemptToUseNonConstantValueInConstantWithoutSuggestion<'a> {
 280     #[primary_span]
 281     pub(crate) ident_span: Span,
 282     pub(crate) suggestion: &'a str,
 283 }
 284
 285 #[derive(Diagnostic)]
 286 #[diag(resolve_self_imports_only_allowed_within, code = "E0429")]
 287 pub(crate) struct SelfImportsOnlyAllowedWithin {
 288     #[primary_span]
 289     pub(crate) span: Span,
 290     #[subdiagnostic]
 291     pub(crate) suggestion: Option<SelfImportsOnlyAllowedWithinSuggestion>,
 292     #[subdiagnostic]
 293     pub(crate) mpart_suggestion: Option<SelfImportsOnlyAllowedWithinMultipartSuggestion>,
 294 }
 295
 296 #[derive(Subdiagnostic)]
 297 #[suggestion(
 298     resolve_self_imports_only_allowed_within_suggestion,
 299     code = "",
 300     applicability = "machine-applicable"
 301 )]
 302 pub(crate) struct SelfImportsOnlyAllowedWithinSuggestion {
 303     #[primary_span]
 304     pub(crate) span: Span,
 305 }
 306
 307 #[derive(Subdiagnostic)]
 308 #[multipart_suggestion(
 309     resolve_self_imports_only_allowed_within_multipart_suggestion,
 310     applicability = "machine-applicable"
 311 )]
 312 pub(crate) struct SelfImportsOnlyAllowedWithinMultipartSuggestion {
 313     #[suggestion_part(code = "{{")]
 314     pub(crate) multipart_start: Span,
 315     #[suggestion_part(code = "}}")]
 316     pub(crate) multipart_end: Span,
 317 }
 318
 319 #[derive(Diagnostic)]
 320 #[diag(resolve_binding_shadows_something_unacceptable, code = "E0530")]
 321 pub(crate) struct BindingShadowsSomethingUnacceptable<'a> {
 322     #[primary_span]
 323     #[label]
 324     pub(crate) span: Span,
 325     pub(crate) shadowing_binding: PatternSource,
 326     pub(crate) shadowed_binding: Res,
 327     pub(crate) article: &'a str,
 328     #[subdiagnostic]
 329     pub(crate) sub_suggestion: Option<BindingShadowsSomethingUnacceptableSuggestion>,
 330     #[label(resolve_label_shadowed_binding)]
 331     pub(crate) shadowed_binding_span: Span,
 332     pub(crate) participle: &'a str,
 333     pub(crate) name: Symbol,
 334 }
 335
 336 #[derive(Subdiagnostic)]
 337 #[suggestion(
 338     resolve_binding_shadows_something_unacceptable_suggestion,
 339     code = "{name}(..)",
 340     applicability = "unspecified"
 341 )]
 342 pub(crate) struct BindingShadowsSomethingUnacceptableSuggestion {
 343     #[primary_span]
 344     pub(crate) span: Span,
 345     pub(crate) name: Symbol,
 346 }
 347
 348 #[derive(Diagnostic)]
 349 #[diag(resolve_forward_declared_generic_param, code = "E0128")]
 350 pub(crate) struct ForwardDeclaredGenericParam {
 351     #[primary_span]
 352     #[label]
 353     pub(crate) span: Span,
 354 }
 355
 356 #[derive(Diagnostic)]
 357 #[diag(resolve_param_in_ty_of_const_param, code = "E0770")]
 358 pub(crate) struct ParamInTyOfConstParam {
 359     #[primary_span]
 360     #[label]
 361     pub(crate) span: Span,
 362     pub(crate) name: Symbol,
 363     #[subdiagnostic]
 364     pub(crate) param_kind: Option<ParamKindInTyOfConstParam>,
 365 }
 366
 367 #[derive(Debug)]
 368 #[derive(Subdiagnostic)]
 369 pub(crate) enum ParamKindInTyOfConstParam {
 370     #[note(resolve_type_param_in_ty_of_const_param)]
 371     Type,
 372     #[note(resolve_const_param_in_ty_of_const_param)]
 373     Const,
 374     #[note(resolve_lifetime_param_in_ty_of_const_param)]
 375     Lifetime,
 376 }
 377
 378 #[derive(Diagnostic)]
 379 #[diag(resolve_self_in_generic_param_default, code = "E0735")]
 380 pub(crate) struct SelfInGenericParamDefault {
 381     #[primary_span]
 382     #[label]
 383     pub(crate) span: Span,
 384 }
 385
 386 #[derive(Diagnostic)]
 387 #[diag(resolve_param_in_non_trivial_anon_const)]
 388 pub(crate) struct ParamInNonTrivialAnonConst {
 389     #[primary_span]
 390     #[label]
 391     pub(crate) span: Span,
 392     pub(crate) name: Symbol,
 393     #[subdiagnostic]
 394     pub(crate) param_kind: ParamKindInNonTrivialAnonConst,
 395     #[subdiagnostic]
 396     pub(crate) help: Option<ParamInNonTrivialAnonConstHelp>,
 397 }
 398
 399 #[derive(Subdiagnostic)]
 400 #[help(resolve_param_in_non_trivial_anon_const_help)]
 401 pub(crate) struct ParamInNonTrivialAnonConstHelp;
 402
 403 #[derive(Debug)]
 404 #[derive(Subdiagnostic)]
 405 pub(crate) enum ParamKindInNonTrivialAnonConst {
 406     #[note(resolve_type_param_in_non_trivial_anon_const)]
 407     Type,
 408     #[help(resolve_const_param_in_non_trivial_anon_const)]
 409     Const { name: Symbol },
 410     #[note(resolve_lifetime_param_in_non_trivial_anon_const)]
 411     Lifetime,
 412 }
 413
 414 #[derive(Diagnostic)]
 415 #[diag(resolve_unreachable_label, code = "E0767")]
 416 #[note]
 417 pub(crate) struct UnreachableLabel {
 418     #[primary_span]
 419     #[label]
 420     pub(crate) span: Span,
 421     pub(crate) name: Symbol,
 422     #[label(resolve_label_definition_span)]
 423     pub(crate) definition_span: Span,
 424     #[subdiagnostic]
 425     pub(crate) sub_suggestion: Option<UnreachableLabelSubSuggestion>,
 426     #[subdiagnostic]
 427     pub(crate) sub_suggestion_label: Option<UnreachableLabelSubLabel>,
 428     #[subdiagnostic]
 429     pub(crate) sub_unreachable_label: Option<UnreachableLabelSubLabelUnreachable>,
 430 }
 431
 432 #[derive(Subdiagnostic)]
 433 #[suggestion(
 434     resolve_unreachable_label_suggestion_use_similarly_named,
 435     code = "{ident_name}",
 436     applicability = "maybe-incorrect"
 437 )]
 438 pub(crate) struct UnreachableLabelSubSuggestion {
 439     #[primary_span]
 440     pub(crate) span: Span,
 441     pub(crate) ident_name: Symbol,
 442 }
 443
 444 #[derive(Subdiagnostic)]
 445 #[label(resolve_unreachable_label_similar_name_reachable)]
 446 pub(crate) struct UnreachableLabelSubLabel {
 447     #[primary_span]
 448     pub(crate) ident_span: Span,
 449 }
 450
 451 #[derive(Subdiagnostic)]
 452 #[label(resolve_unreachable_label_similar_name_unreachable)]
 453 pub(crate) struct UnreachableLabelSubLabelUnreachable {
 454     #[primary_span]
 455     pub(crate) ident_span: Span,
 456 }
 457
 458 #[derive(Diagnostic)]
 459 #[diag(resolve_trait_impl_mismatch, code = "{code}")]
 460 pub(crate) struct TraitImplMismatch {
 461     #[primary_span]
 462     #[label]
 463     pub(crate) span: Span,
 464     pub(crate) name: Symbol,
 465     pub(crate) kind: String,
 466     #[label(resolve_label_trait_item)]
 467     pub(crate) trait_item_span: Span,
 468     pub(crate) trait_path: String,
 469     pub(crate) code: String,
 470 }
 471
 472 #[derive(Diagnostic)]
 473 #[diag(resolve_invalid_asm_sym)]
 474 #[help]
 475 pub(crate) struct InvalidAsmSym {
 476     #[primary_span]
 477     #[label]
 478     pub(crate) span: Span,
 479 }
 480
 481 #[derive(Diagnostic)]
 482 #[diag(resolve_lowercase_self)]
 483 pub(crate) struct LowercaseSelf {
 484     #[primary_span]
 485     #[suggestion(code = "Self", applicability = "maybe-incorrect", style = "short")]
 486     pub(crate) span: Span,
 487 }
 488
 489 #[derive(Diagnostic)]
 490 #[diag(resolve_trait_impl_duplicate, code = "E0201")]
 491 pub(crate) struct TraitImplDuplicate {
 492     #[primary_span]
 493     #[label]
 494     pub(crate) span: Span,
 495     #[label(resolve_old_span_label)]
 496     pub(crate) old_span: Span,
 497     #[label(resolve_trait_item_span)]
 498     pub(crate) trait_item_span: Span,
 499     pub(crate) name: Symbol,
 500 }
 501
 502 #[derive(Diagnostic)]
 503 #[diag(resolve_relative_2018)]
 504 pub(crate) struct Relative2018 {
 505     #[primary_span]
 506     pub(crate) span: Span,
 507     #[suggestion(code = "crate::{path_str}", applicability = "maybe-incorrect")]
 508     pub(crate) path_span: Span,
 509     pub(crate) path_str: String,
 510 }
 511
 512 #[derive(Diagnostic)]
 513 #[diag(resolve_ancestor_only, code = "E0742")]
 514 pub(crate) struct AncestorOnly(#[primary_span] pub(crate) Span);
 515
 516 #[derive(Diagnostic)]
 517 #[diag(resolve_expected_found, code = "E0577")]
 518 pub(crate) struct ExpectedFound {
 519     #[primary_span]
 520     #[label]
 521     pub(crate) span: Span,
 522     pub(crate) res: Res,
 523     pub(crate) path_str: String,
 524 }
 525
 526 #[derive(Diagnostic)]
 527 #[diag(resolve_indeterminate, code = "E0578")]
 528 pub(crate) struct Indeterminate(#[primary_span] pub(crate) Span);
 529
 530 #[derive(Diagnostic)]
 531 #[diag(resolve_tool_module_imported)]
 532 pub(crate) struct ToolModuleImported {
 533     #[primary_span]
 534     pub(crate) span: Span,
 535     #[note]
 536     pub(crate) import: Span,
 537 }
 538
 539 #[derive(Diagnostic)]
 540 #[diag(resolve_module_only)]
 541 pub(crate) struct ModuleOnly(#[primary_span] pub(crate) Span);
 542
 543 #[derive(Diagnostic, Default)]
 544 #[diag(resolve_macro_expected_found)]
 545 pub(crate) struct MacroExpectedFound<'a> {
 546     #[primary_span]
 547     pub(crate) span: Span,
 548     pub(crate) found: &'a str,
 549     pub(crate) expected: &'a str,
 550     pub(crate) macro_path: &'a str,
 551     #[subdiagnostic]
 552     pub(crate) remove_surrounding_derive: Option<RemoveSurroundingDerive>,
 553     #[subdiagnostic]
 554     pub(crate) add_as_non_derive: Option<AddAsNonDerive<'a>>,
 555 }
 556
 557 #[derive(Subdiagnostic)]
 558 #[help(resolve_remove_surrounding_derive)]
 559 pub(crate) struct RemoveSurroundingDerive {
 560     #[primary_span]
 561     pub(crate) span: Span,
 562 }
 563
 564 #[derive(Subdiagnostic)]
 565 #[help(resolve_add_as_non_derive)]
 566 pub(crate) struct AddAsNonDerive<'a> {
 567     pub(crate) macro_path: &'a str,
 568 }
 569
 570 #[derive(Diagnostic)]
 571 #[diag(resolve_proc_macro_same_crate)]
 572 pub(crate) struct ProcMacroSameCrate {
 573     #[primary_span]
 574     pub(crate) span: Span,
 575     #[help]
 576     pub(crate) is_test: bool,
 577 }
 578
 579 #[derive(Diagnostic)]
 580 #[diag(resolve_imported_crate)]
 581 pub(crate) struct CrateImported {
 582     #[primary_span]
 583     pub(crate) span: Span,
 584 }
 585
 586 #[derive(Diagnostic)]
 587 #[diag(resolve_macro_use_extern_crate_self)]
 588 pub(crate) struct MacroUseExternCrateSelf {
 589     #[primary_span]
 590     pub(crate) span: Span,
 591 }
 592
 593 #[derive(Diagnostic)]
 594 #[diag(resolve_accessible_unsure)]
 595 #[note]
 596 pub(crate) struct CfgAccessibleUnsure {
 597     #[primary_span]
 598     pub(crate) span: Span,
 599 }
 600
 601 #[derive(Debug)]
 602 #[derive(Diagnostic)]
 603 #[diag(resolve_param_in_enum_discriminant)]
 604 pub(crate) struct ParamInEnumDiscriminant {
 605     #[primary_span]
 606     #[label]
 607     pub(crate) span: Span,
 608     pub(crate) name: Symbol,
 609     #[subdiagnostic]
 610     pub(crate) param_kind: ParamKindInEnumDiscriminant,
 611 }
 612
 613 #[derive(Debug)]
 614 #[derive(Subdiagnostic)]
 615 pub(crate) enum ParamKindInEnumDiscriminant {
 616     #[note(resolve_type_param_in_enum_discriminant)]
 617     Type,
 618     #[note(resolve_const_param_in_enum_discriminant)]
 619     Const,
 620     #[note(resolve_lifetime_param_in_enum_discriminant)]
 621     Lifetime,
 622 }
 623
 624 #[derive(Subdiagnostic)]
 625 #[label(resolve_change_import_binding)]
 626 pub(crate) struct ChangeImportBinding {
 627     #[primary_span]
 628     pub(crate) span: Span,
 629 }
 630
 631 #[derive(Subdiagnostic)]
 632 #[suggestion(
 633     resolve_change_import_binding,
 634     code = "{suggestion}",
 635     applicability = "maybe-incorrect"
 636 )]
 637 pub(crate) struct ChangeImportBindingSuggestion {
 638     #[primary_span]
 639     pub(crate) span: Span,
 640     pub(crate) suggestion: String,
 641 }
 642
 643 #[derive(Diagnostic)]
 644 #[diag(resolve_imports_cannot_refer_to)]
 645 pub(crate) struct ImportsCannotReferTo<'a> {
 646     #[primary_span]
 647     pub(crate) span: Span,
 648     pub(crate) what: &'a str,
 649 }
 650
 651 #[derive(Diagnostic)]
 652 #[diag(resolve_cannot_find_ident_in_this_scope)]
 653 pub(crate) struct CannotFindIdentInThisScope<'a> {
 654     #[primary_span]
 655     pub(crate) span: Span,
 656     pub(crate) expected: &'a str,
 657     pub(crate) ident: Ident,
 658 }
 659
 660 #[derive(Subdiagnostic)]
 661 #[note(resolve_explicit_unsafe_traits)]
 662 pub(crate) struct ExplicitUnsafeTraits {
 663     #[primary_span]
 664     pub(crate) span: Span,
 665     pub(crate) ident: Ident,
 666 }
 667
 668 #[derive(Subdiagnostic)]
 669 #[note(resolve_missing_macro_rules_name)]
 670 pub(crate) struct MaybeMissingMacroRulesName {
 671     #[primary_span]
 672     pub(crate) span: Span,
 673 }
 674
 675 #[derive(Subdiagnostic)]
 676 #[help(resolve_added_macro_use)]
 677 pub(crate) struct AddedMacroUse;
 678
 679 #[derive(Subdiagnostic)]
 680 #[suggestion(
 681     resolve_consider_adding_a_derive,
 682     code = "{suggestion}",
 683     applicability = "maybe-incorrect"
 684 )]
 685 pub(crate) struct ConsiderAddingADerive {
 686     #[primary_span]
 687     pub(crate) span: Span,
 688     pub(crate) suggestion: String,
 689 }
 690
 691 #[derive(Diagnostic)]
 692 #[diag(resolve_cannot_determine_import_resolution)]
 693 pub(crate) struct CannotDetermineImportResolution {
 694     #[primary_span]
 695     pub(crate) span: Span,
 696 }
 697
 698 #[derive(Diagnostic)]
 699 #[diag(resolve_cannot_determine_macro_resolution)]
 700 #[note]
 701 pub(crate) struct CannotDetermineMacroResolution {
 702     #[primary_span]
 703     pub(crate) span: Span,
 704     pub(crate) kind: &'static str,
 705     pub(crate) path: String,
 706 }
 707
 708 #[derive(Diagnostic)]
 709 #[diag(resolve_cannot_be_reexported_private, code = "E0364")]
 710 pub(crate) struct CannotBeReexportedPrivate {
 711     #[primary_span]
 712     pub(crate) span: Span,
 713     pub(crate) ident: Ident,
 714 }
 715
 716 #[derive(Diagnostic)]
 717 #[diag(resolve_cannot_be_reexported_crate_public, code = "E0364")]
 718 pub(crate) struct CannotBeReexportedCratePublic {
 719     #[primary_span]
 720     pub(crate) span: Span,
 721     pub(crate) ident: Ident,
 722 }
 723
 724 #[derive(Diagnostic)]
 725 #[diag(resolve_cannot_be_reexported_private, code = "E0365")]
 726 #[note(resolve_consider_declaring_with_pub)]
 727 pub(crate) struct CannotBeReexportedPrivateNS {
 728     #[primary_span]
 729     #[label(resolve_reexport_of_private)]
 730     pub(crate) span: Span,
 731     pub(crate) ident: Ident,
 732 }
 733
 734 #[derive(Diagnostic)]
 735 #[diag(resolve_cannot_be_reexported_crate_public, code = "E0365")]
 736 #[note(resolve_consider_declaring_with_pub)]
 737 pub(crate) struct CannotBeReexportedCratePublicNS {
 738     #[primary_span]
 739     #[label(resolve_reexport_of_crate_public)]
 740     pub(crate) span: Span,
 741     pub(crate) ident: Ident,
 742 }
 743
 744 #[derive(Subdiagnostic)]
 745 #[help(resolve_consider_adding_macro_export)]
 746 pub(crate) struct ConsiderAddingMacroExport {
 747     #[primary_span]
 748     pub(crate) span: Span,
 749 }
 750
 751 #[derive(Subdiagnostic)]
 752 #[note(resolve_consider_marking_as_pub)]
 753 pub(crate) struct ConsiderMarkingAsPub {
 754     #[primary_span]
 755     pub(crate) span: Span,
 756     pub(crate) ident: Ident,
 757 }
 758
 759 #[derive(Diagnostic)]
 760 #[diag(resolve_cannot_glob_import_possible_crates)]
 761 pub(crate) struct CannotGlobImportAllCrates {
 762     #[primary_span]
 763     pub(crate) span: Span,
 764 }
 765
 766 #[derive(Diagnostic)]
 767 #[diag(resolve_items_in_traits_are_not_importable)]
 768 pub(crate) struct ItemsInTraitsAreNotImportable {
 769     #[primary_span]
 770     pub(crate) span: Span,
 771 }
 772
 773 #[derive(Diagnostic)]
 774 #[diag(resolve_is_not_directly_importable, code = "E0253")]
 775 pub(crate) struct IsNotDirectlyImportable {
 776     #[primary_span]
 777     #[label]
 778     pub(crate) span: Span,
 779     pub(crate) target: Ident,
 780 }