rustc_resolve/diagnostics/

mod.rs

use rustc_errors::codes::*;
use rustc_errors::formatting::DiagMessageAddArg;
use rustc_errors::{
    Applicability, Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, ElidedLifetimeInPathSubdiag,
    EmissionGuarantee, IntoDiagArg, Level, MultiSpan, Subdiagnostic, msg,
};
use rustc_macros::{Diagnostic, Subdiagnostic};
use rustc_span::{Ident, Span, Spanned, Symbol};

use crate::Res;
use crate::late::{PatternSource, ResolvingRestrictionKind};

pub(crate) mod impls;

#[derive(Diagnostic)]
#[diag("can't use {$is_self ->
        [true] `Self`
        *[false] generic parameters
    } from outer item", code = E0401)]
#[note(
    "nested items are independent from their parent item for everything except for privacy and name resolution"
)]
pub(crate) struct GenericParamsFromOuterItem {
    #[primary_span]
    #[label(
        "use of {$is_self ->
            [true] `Self`
            *[false] generic parameter
        } from outer item"
    )]
    pub(crate) span: Span,
    #[subdiagnostic]
    pub(crate) label: Option<GenericParamsFromOuterItemLabel>,
    #[subdiagnostic]
    pub(crate) refer_to_type_directly: Option<UseTypeDirectly>,
    #[subdiagnostic]
    pub(crate) use_let: Option<GenericParamsFromOuterItemUseLet>,
    #[subdiagnostic]
    pub(crate) sugg: Option<GenericParamsFromOuterItemSugg>,
    #[subdiagnostic]
    pub(crate) static_or_const: Option<GenericParamsFromOuterItemStaticOrConst>,
    pub(crate) is_self: bool,
    #[subdiagnostic]
    pub(crate) item: Option<GenericParamsFromOuterItemInnerItem>,
}

#[derive(Subdiagnostic)]
#[label(
    "{$is_self ->
        [true] `Self`
        *[false] generic parameter
    } used in this inner {$descr}"
)]
pub(crate) struct GenericParamsFromOuterItemInnerItem {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) descr: String,
    pub(crate) is_self: bool,
}

#[derive(Subdiagnostic)]
pub(crate) enum GenericParamsFromOuterItemStaticOrConst {
    #[note("a `static` is a separate item from the item that contains it")]
    Static,
    #[note("a `const` is a separate item from the item that contains it")]
    Const,
}

#[derive(Subdiagnostic)]
pub(crate) enum GenericParamsFromOuterItemLabel {
    #[label("can't use `Self` here")]
    SelfTyParam(#[primary_span] Span),
    #[label("`Self` type implicitly declared here, by this `impl`")]
    SelfTyAlias(#[primary_span] Span),
    #[label("type parameter from outer item")]
    TyParam(#[primary_span] Span),
    #[label("const parameter from outer item")]
    ConstParam(#[primary_span] Span),
}

#[derive(Subdiagnostic)]
#[suggestion(
    "try introducing a local generic parameter here",
    code = "{snippet}",
    applicability = "maybe-incorrect",
    style = "verbose"
)]
pub(crate) struct GenericParamsFromOuterItemSugg {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) snippet: String,
}

#[derive(Subdiagnostic)]
#[suggestion(
    "try using a local `let` binding instead",
    code = "let",
    applicability = "maybe-incorrect",
    style = "verbose"
)]
pub(crate) struct GenericParamsFromOuterItemUseLet {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Subdiagnostic)]
#[suggestion(
    "refer to the type directly here instead",
    code = "{snippet}",
    applicability = "maybe-incorrect",
    style = "verbose"
)]
pub(crate) struct UseTypeDirectly {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) snippet: String,
}

#[derive(Diagnostic)]
#[diag("the name `{$name}` is already used for a generic parameter in this item's generic parameters", code = E0403)]
pub(crate) struct NameAlreadyUsedInParameterList {
    #[primary_span]
    #[label("already used")]
    pub(crate) span: Span,
    #[label("first use of `{$name}`")]
    pub(crate) first_use_span: Span,
    pub(crate) name: Ident,
}

#[derive(Diagnostic)]
#[diag("method `{$method}` is not a member of trait `{$trait_}`", code = E0407)]
pub(crate) struct MethodNotMemberOfTrait {
    #[primary_span]
    #[label("not a member of trait `{$trait_}`")]
    pub(crate) span: Span,
    pub(crate) method: Ident,
    pub(crate) trait_: String,
    #[subdiagnostic]
    pub(crate) sub: Option<AssociatedFnWithSimilarNameExists>,
}

#[derive(Subdiagnostic)]
#[suggestion(
    "there is an associated function with a similar name",
    code = "{candidate}",
    applicability = "maybe-incorrect"
)]
pub(crate) struct AssociatedFnWithSimilarNameExists {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) candidate: Symbol,
}

#[derive(Diagnostic)]
#[diag("type `{$type_}` is not a member of trait `{$trait_}`", code = E0437)]
pub(crate) struct TypeNotMemberOfTrait {
    #[primary_span]
    #[label("not a member of trait `{$trait_}`")]
    pub(crate) span: Span,
    pub(crate) type_: Ident,
    pub(crate) trait_: String,
    #[subdiagnostic]
    pub(crate) sub: Option<AssociatedTypeWithSimilarNameExists>,
}

#[derive(Subdiagnostic)]
#[suggestion(
    "there is an associated type with a similar name",
    code = "{candidate}",
    applicability = "maybe-incorrect"
)]
pub(crate) struct AssociatedTypeWithSimilarNameExists {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) candidate: Symbol,
}

#[derive(Diagnostic)]
#[diag("const `{$const_}` is not a member of trait `{$trait_}`", code = E0438)]
pub(crate) struct ConstNotMemberOfTrait {
    #[primary_span]
    #[label("not a member of trait `{$trait_}`")]
    pub(crate) span: Span,
    pub(crate) const_: Ident,
    pub(crate) trait_: String,
    #[subdiagnostic]
    pub(crate) sub: Option<AssociatedConstWithSimilarNameExists>,
}

#[derive(Subdiagnostic)]
#[suggestion(
    "there is an associated constant with a similar name",
    code = "{candidate}",
    applicability = "maybe-incorrect"
)]
pub(crate) struct AssociatedConstWithSimilarNameExists {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) candidate: Symbol,
}

#[derive(Diagnostic)]
#[diag("variable `{$variable_name}` is bound inconsistently across alternatives separated by `|`", code = E0409)]
pub(crate) struct VariableBoundWithDifferentMode {
    #[primary_span]
    #[label("bound in different ways")]
    pub(crate) span: Span,
    #[label("first binding")]
    pub(crate) first_binding_span: Span,
    pub(crate) variable_name: Ident,
}

#[derive(Diagnostic)]
#[diag("identifier `{$identifier}` is bound more than once in this parameter list", code = E0415)]
pub(crate) struct IdentifierBoundMoreThanOnceInParameterList {
    #[primary_span]
    #[label("used as parameter more than once")]
    pub(crate) span: Span,
    pub(crate) identifier: Ident,
}

#[derive(Diagnostic)]
#[diag("identifier `{$identifier}` is bound more than once in the same pattern", code = E0416)]
pub(crate) struct IdentifierBoundMoreThanOnceInSamePattern {
    #[primary_span]
    #[label("used in a pattern more than once")]
    pub(crate) span: Span,
    pub(crate) identifier: Ident,
}

#[derive(Diagnostic)]
#[diag("use of undeclared label `{$name}`", code = E0426)]
pub(crate) struct UndeclaredLabel {
    #[primary_span]
    #[label("undeclared label `{$name}`")]
    pub(crate) span: Span,
    pub(crate) name: Symbol,
    #[subdiagnostic]
    pub(crate) sub_reachable: Option<LabelWithSimilarNameReachable>,
    #[subdiagnostic]
    pub(crate) sub_reachable_suggestion: Option<TryUsingSimilarlyNamedLabel>,
    #[subdiagnostic]
    pub(crate) sub_unreachable: Option<UnreachableLabelWithSimilarNameExists>,
}

#[derive(Subdiagnostic)]
#[label("a label with a similar name is reachable")]
pub(crate) struct LabelWithSimilarNameReachable(#[primary_span] pub(crate) Span);

#[derive(Subdiagnostic)]
#[suggestion(
    "try using similarly named label",
    code = "{ident_name}",
    applicability = "maybe-incorrect"
)]
pub(crate) struct TryUsingSimilarlyNamedLabel {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) ident_name: Symbol,
}

#[derive(Subdiagnostic)]
#[label("a label with a similar name exists but is unreachable")]
pub(crate) struct UnreachableLabelWithSimilarNameExists {
    #[primary_span]
    pub(crate) ident_span: Span,
}

#[derive(Diagnostic)]
#[diag("can't capture dynamic environment in a fn item", code = E0434)]
#[help("use the `|| {\"{\"} ... {\"}\"}` closure form instead")]
pub(crate) struct CannotCaptureDynamicEnvironmentInFnItem {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag("attempt to use a non-constant value in a constant", code = E0435)]
pub(crate) struct AttemptToUseNonConstantValueInConstant<'a> {
    #[primary_span]
    pub(crate) span: Span,
    #[subdiagnostic]
    pub(crate) with: Option<AttemptToUseNonConstantValueInConstantWithSuggestion<'a>>,
    #[subdiagnostic]
    pub(crate) with_label: Option<AttemptToUseNonConstantValueInConstantLabelWithSuggestion>,
    #[subdiagnostic]
    pub(crate) without: Option<AttemptToUseNonConstantValueInConstantWithoutSuggestion<'a>>,
}

#[derive(Subdiagnostic)]
#[multipart_suggestion(
    "consider using `{$suggestion}` instead of `{$current}`",
    style = "verbose",
    applicability = "has-placeholders"
)]
pub(crate) struct AttemptToUseNonConstantValueInConstantWithSuggestion<'a> {
    // #[primary_span]
    #[suggestion_part(code = "{suggestion} ")]
    pub(crate) span: Span,
    pub(crate) suggestion: &'a str,
    #[suggestion_part(code = ": /* Type */")]
    pub(crate) type_span: Option<Span>,
    pub(crate) current: &'a str,
}

#[derive(Subdiagnostic)]
#[label("non-constant value")]
pub(crate) struct AttemptToUseNonConstantValueInConstantLabelWithSuggestion {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Subdiagnostic)]
#[label("this would need to be a `{$suggestion}`")]
pub(crate) struct AttemptToUseNonConstantValueInConstantWithoutSuggestion<'a> {
    #[primary_span]
    pub(crate) ident_span: Span,
    pub(crate) suggestion: &'a str,
}

#[derive(Diagnostic)]
#[diag("{$shadowing_binding}s cannot shadow {$shadowed_binding}s", code = E0530)]
pub(crate) struct BindingShadowsSomethingUnacceptable<'a> {
    #[primary_span]
    #[label("cannot be named the same as {$article} {$shadowed_binding}")]
    pub(crate) span: Span,
    pub(crate) shadowing_binding: PatternSource,
    pub(crate) shadowed_binding: Res,
    pub(crate) article: &'a str,
    #[subdiagnostic]
    pub(crate) sub_suggestion: Option<BindingShadowsSomethingUnacceptableSuggestion>,
    #[label("the {$shadowed_binding} `{$name}` is {$participle} here")]
    pub(crate) shadowed_binding_span: Span,
    pub(crate) participle: &'a str,
    pub(crate) name: Symbol,
}

#[derive(Subdiagnostic)]
#[suggestion(
    "try specify the pattern arguments",
    code = "{name}(..)",
    applicability = "unspecified"
)]
pub(crate) struct BindingShadowsSomethingUnacceptableSuggestion {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) name: Symbol,
}

#[derive(Diagnostic)]
#[diag("generic parameter defaults cannot reference parameters before they are declared", code = E0128)]
pub(crate) struct ForwardDeclaredGenericParam {
    #[primary_span]
    #[label("cannot reference `{$param}` before it is declared")]
    pub(crate) span: Span,
    pub(crate) param: Symbol,
}

#[derive(Diagnostic)]
#[diag("const parameter types cannot reference parameters before they are declared")]
pub(crate) struct ForwardDeclaredGenericInConstParamTy {
    #[primary_span]
    #[label("const parameter type cannot reference `{$param}` before it is declared")]
    pub(crate) span: Span,
    pub(crate) param: Symbol,
}

#[derive(Diagnostic)]
#[diag("the type of const parameters must not depend on other generic parameters", code = E0770)]
pub(crate) struct ParamInTyOfConstParam {
    #[primary_span]
    #[label("the type must not depend on the parameter `{$name}`")]
    pub(crate) span: Span,
    pub(crate) name: Symbol,
}

#[derive(Diagnostic)]
#[diag("generic parameters cannot use `Self` in their defaults", code = E0735)]
pub(crate) struct SelfInGenericParamDefault {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag("cannot use `Self` in const parameter type")]
pub(crate) struct SelfInConstGenericTy {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag(
    "{$is_gca ->
    [true] generic parameters in const blocks are not allowed; use a named `const` item instead
    *[false] generic parameters may not be used in const operations
}"
)]
pub(crate) struct ParamInNonTrivialAnonConst {
    #[primary_span]
    #[label("cannot perform const operation using `{$name}`")]
    pub(crate) span: Span,
    pub(crate) name: Symbol,
    #[subdiagnostic]
    pub(crate) param_kind: ParamKindInNonTrivialAnonConst,
    #[help("add `#![feature(generic_const_exprs)]` to allow generic const expressions")]
    pub(crate) help: bool,
    pub(crate) is_gca: bool,
    #[help(
        "consider factoring the expression into a `type const` item and use it as the const argument instead"
    )]
    pub(crate) help_gca: bool,
    #[help(
        "alternatively, you can use `#![feature(generic_const_args)]` and extract the expression into a `type const` item"
    )]
    pub(crate) help_suggest_gca: bool,
}

#[derive(Debug)]
#[derive(Subdiagnostic)]
pub(crate) enum ParamKindInNonTrivialAnonConst {
    #[note("type parameters may not be used in const expressions")]
    Type,
    #[help("const parameters may only be used as standalone arguments here, i.e. `{$name}`")]
    Const { name: Symbol },
    #[note("lifetime parameters may not be used in const expressions")]
    Lifetime,
}

#[derive(Diagnostic)]
#[diag("use of unreachable label `{$name}`", code = E0767)]
#[note("labels are unreachable through functions, closures, async blocks and modules")]
pub(crate) struct UnreachableLabel {
    #[primary_span]
    #[label("unreachable label `{$name}`")]
    pub(crate) span: Span,
    pub(crate) name: Symbol,
    #[label("unreachable label defined here")]
    pub(crate) definition_span: Span,
    #[subdiagnostic]
    pub(crate) sub_suggestion: Option<UnreachableLabelSubSuggestion>,
    #[subdiagnostic]
    pub(crate) sub_suggestion_label: Option<UnreachableLabelSubLabel>,
    #[subdiagnostic]
    pub(crate) sub_unreachable_label: Option<UnreachableLabelSubLabelUnreachable>,
}

#[derive(Subdiagnostic)]
#[suggestion(
    "try using similarly named label",
    code = "{ident_name}",
    applicability = "maybe-incorrect"
)]
pub(crate) struct UnreachableLabelSubSuggestion {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) ident_name: Symbol,
}

#[derive(Subdiagnostic)]
#[label("a label with a similar name is reachable")]
pub(crate) struct UnreachableLabelSubLabel {
    #[primary_span]
    pub(crate) ident_span: Span,
}

#[derive(Subdiagnostic)]
#[label("a label with a similar name exists but is also unreachable")]
pub(crate) struct UnreachableLabelSubLabelUnreachable {
    #[primary_span]
    pub(crate) ident_span: Span,
}

#[derive(Diagnostic)]
#[diag("invalid `sym` operand")]
#[help("`sym` operands must refer to either a function or a static")]
pub(crate) struct InvalidAsmSym {
    #[primary_span]
    #[label("is a local variable")]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag("attempt to use a non-constant value in a constant")]
pub(crate) struct LowercaseSelf {
    #[primary_span]
    #[suggestion(
        "try using `Self`",
        code = "Self",
        applicability = "maybe-incorrect",
        style = "short"
    )]
    pub(crate) span: Span,
}

#[derive(Debug)]
#[derive(Diagnostic)]
#[diag("never patterns cannot contain variable bindings")]
pub(crate) struct BindingInNeverPattern {
    #[primary_span]
    #[suggestion(
        "use a wildcard `_` instead",
        code = "_",
        applicability = "machine-applicable",
        style = "short"
    )]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag("duplicate definitions with name `{$name}`:", code = E0201)]
pub(crate) struct TraitImplDuplicate {
    #[primary_span]
    #[label("duplicate definition")]
    pub(crate) span: Span,
    #[label("previous definition here")]
    pub(crate) old_span: Span,
    #[label("item in trait")]
    pub(crate) trait_item_span: Span,
    pub(crate) name: Ident,
}

#[derive(Diagnostic)]
#[diag("relative paths are not supported in visibilities in 2018 edition or later")]
pub(crate) struct Relative2018 {
    #[primary_span]
    pub(crate) span: Span,
    #[suggestion("try", code = "crate::{path_str}", applicability = "maybe-incorrect")]
    pub(crate) path_span: Span,
    pub(crate) path_str: String,
}

#[derive(Diagnostic)]
#[diag("visibilities can only be restricted to ancestor modules", code = E0742)]
pub(crate) struct AncestorOnly(#[primary_span] pub(crate) Span);

#[derive(Diagnostic)]
#[diag("expected module, found {$res} `{$path_str}`", code = E0577)]
pub(crate) struct ExpectedModuleFound {
    #[primary_span]
    #[label("not a module")]
    pub(crate) span: Span,
    pub(crate) res: Res,
    pub(crate) path_str: String,
}

#[derive(Diagnostic)]
#[diag("cannot determine resolution for the visibility", code = E0578)]
pub(crate) struct Indeterminate(#[primary_span] pub(crate) Span);

#[derive(Diagnostic)]
#[diag(
    "{$kind ->
    [impl] trait implementation
    *[mut] field mutation
} can only be restricted to ancestor modules"
)]
pub(crate) struct RestrictionAncestorOnly {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) kind: ResolvingRestrictionKind,
}

#[derive(Diagnostic)]
#[diag("cannot use a tool module through an import")]
pub(crate) struct ToolModuleImported {
    #[primary_span]
    pub(crate) span: Span,
    #[note("the tool module imported here")]
    pub(crate) import: Span,
}

#[derive(Diagnostic)]
#[diag("visibility must resolve to a module")]
pub(crate) struct ModuleOnly(#[primary_span] pub(crate) Span);

#[derive(Diagnostic)]
#[diag("expected {$expected}, found {$found} `{$macro_path}`")]
pub(crate) struct MacroExpectedFound<'a> {
    #[primary_span]
    #[label("not {$article} {$expected}")]
    pub(crate) span: Span,
    pub(crate) found: &'a str,
    pub(crate) article: &'static str,
    pub(crate) expected: &'a str,
    pub(crate) macro_path: &'a str,
    #[subdiagnostic]
    pub(crate) remove_surrounding_derive: Option<RemoveSurroundingDerive>,
    #[subdiagnostic]
    pub(crate) add_as_non_derive: Option<AddAsNonDerive<'a>>,
}

#[derive(Subdiagnostic)]
#[help("remove from the surrounding `derive()`")]
pub(crate) struct RemoveSurroundingDerive {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Subdiagnostic)]
#[help(
    "
    add as non-Derive macro
    `#[{$macro_path}]`"
)]
pub(crate) struct AddAsNonDerive<'a> {
    pub(crate) macro_path: &'a str,
}

#[derive(Diagnostic)]
#[diag("can't use a procedural macro from the same crate that defines it")]
pub(crate) struct ProcMacroSameCrate {
    #[primary_span]
    pub(crate) span: Span,
    #[help("you can define integration tests in a directory named `tests`")]
    pub(crate) is_test: bool,
}

#[derive(Diagnostic)]
#[diag("cannot find {$ns_descr} `{$ident}` in this scope")]
pub(crate) struct ProcMacroDeriveResolutionFallback {
    #[label("names from parent modules are not accessible without an explicit import")]
    pub span: Span,
    pub ns_descr: &'static str,
    pub ident: Symbol,
}

#[derive(Diagnostic)]
#[diag(
    "macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths"
)]
pub(crate) struct MacroExpandedMacroExportsAccessedByAbsolutePaths {
    #[note("the macro is defined here")]
    pub definition: Span,
}

#[derive(Diagnostic)]
#[diag("`#[macro_use]` is not supported on `extern crate self`")]
pub(crate) struct MacroUseExternCrateSelf {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag("not sure whether the path is accessible or not")]
#[note("the type may have associated items, but we are currently not checking them")]
pub(crate) struct CfgAccessibleUnsure {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Debug)]
#[derive(Diagnostic)]
#[diag("generic parameters may not be used in enum discriminant values")]
pub(crate) struct ParamInEnumDiscriminant {
    #[primary_span]
    #[label("cannot perform const operation using `{$name}`")]
    pub(crate) span: Span,
    pub(crate) name: Symbol,
    #[subdiagnostic]
    pub(crate) param_kind: ParamKindInEnumDiscriminant,
}

#[derive(Debug)]
#[derive(Subdiagnostic)]
pub(crate) enum ParamKindInEnumDiscriminant {
    #[note("type parameters may not be used in enum discriminant values")]
    Type,
    #[note("const parameters may not be used in enum discriminant values")]
    Const,
    #[note("lifetime parameters may not be used in enum discriminant values")]
    Lifetime,
}

#[derive(Subdiagnostic)]
#[label("you can use `as` to change the binding name of the import")]
pub(crate) struct ChangeImportBinding {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Subdiagnostic)]
#[suggestion(
    "you can use `as` to change the binding name of the import",
    code = "{suggestion}",
    applicability = "maybe-incorrect"
)]
pub(crate) struct ChangeImportBindingSuggestion {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) suggestion: String,
}

#[derive(Diagnostic)]
#[diag("imports cannot refer to {$what}")]
pub(crate) struct ImportsCannotReferTo<'a> {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) what: &'a str,
}

#[derive(Diagnostic)]
#[diag("cannot find {$expected} `{$ident}` in this scope")]
pub(crate) struct CannotFindIdentInThisScope<'a> {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) expected: &'a str,
    pub(crate) ident: Ident,
}

#[derive(Subdiagnostic)]
#[note("unsafe traits like `{$ident}` should be implemented explicitly")]
pub(crate) struct ExplicitUnsafeTraits {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) ident: Ident,
}

#[derive(Subdiagnostic)]
#[note("a macro with the same name exists, but it appears later")]
pub(crate) struct MacroDefinedLater {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Subdiagnostic)]
#[label("consider moving the definition of `{$ident}` before this call")]
pub(crate) struct MacroSuggMovePosition {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) ident: Ident,
}

#[derive(Subdiagnostic)]
pub(crate) enum MacroRulesNot {
    #[label("`{$ident}` exists, but has no rules for function-like invocation")]
    Func {
        #[primary_span]
        span: Span,
        ident: Ident,
    },
    #[label("`{$ident}` exists, but has no `attr` rules")]
    Attr {
        #[primary_span]
        span: Span,
        ident: Ident,
    },
    #[label("`{$ident}` exists, but has no `derive` rules")]
    Derive {
        #[primary_span]
        span: Span,
        ident: Ident,
    },
}

#[derive(Subdiagnostic)]
#[note("maybe you have forgotten to define a name for this `macro_rules!`")]
pub(crate) struct MaybeMissingMacroRulesName {
    #[primary_span]
    pub(crate) spans: MultiSpan,
}

#[derive(Subdiagnostic)]
#[help("have you added the `#[macro_use]` on the module/import?")]
pub(crate) struct AddedMacroUse;

#[derive(Subdiagnostic)]
#[suggestion("consider adding a derive", code = "{suggestion}", applicability = "maybe-incorrect")]
pub(crate) struct ConsiderAddingADerive {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) suggestion: String,
}

#[derive(Diagnostic)]
#[diag("cannot determine resolution for the import")]
pub(crate) struct CannotDetermineImportResolution {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag("cannot determine resolution for the {$kind} `{$path}`")]
#[note("import resolution is stuck, try simplifying macro imports")]
pub(crate) struct CannotDetermineMacroResolution {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) kind: &'static str,
    pub(crate) path: String,
}

#[derive(Diagnostic)]
#[diag("`{$ident}` is private, and cannot be re-exported", code = E0364)]
pub(crate) struct CannotBeReexportedPrivate {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) ident: Ident,
}

#[derive(Diagnostic)]
#[diag("`{$ident}` is only public within the crate, and cannot be re-exported outside", code = E0364)]
pub(crate) struct CannotBeReexportedCratePublic {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) ident: Ident,
}

#[derive(Diagnostic)]
#[diag("`{$ident}` is private, and cannot be re-exported", code = E0365)]
#[note("consider declaring type or module `{$ident}` with `pub`")]
pub(crate) struct CannotBeReexportedPrivateNS {
    #[primary_span]
    #[label("re-export of private `{$ident}`")]
    pub(crate) span: Span,
    pub(crate) ident: Ident,
}

#[derive(Diagnostic)]
#[diag("`{$ident}` is only public within the crate, and cannot be re-exported outside", code = E0365)]
#[note("consider declaring type or module `{$ident}` with `pub`")]
pub(crate) struct CannotBeReexportedCratePublicNS {
    #[primary_span]
    #[label("re-export of crate public `{$ident}`")]
    pub(crate) span: Span,
    pub(crate) ident: Ident,
}

#[derive(Diagnostic)]
#[diag("extern crate `{$ident}` is private and cannot be re-exported", code = E0365)]
pub(crate) struct PrivateExternCrateReexport {
    pub ident: Ident,
    #[suggestion(
        "consider making the `extern crate` item publicly accessible",
        code = "pub ",
        style = "verbose",
        applicability = "maybe-incorrect"
    )]
    pub sugg: Span,
}

#[derive(Subdiagnostic)]
#[help("consider adding a `#[macro_export]` to the macro in the imported module")]
pub(crate) struct ConsiderAddingMacroExport {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Subdiagnostic)]
#[suggestion(
    "in case you want to use the macro within this crate only, reduce the visibility to `pub(crate)`",
    code = "pub(crate)",
    applicability = "maybe-incorrect"
)]
pub(crate) struct ConsiderMarkingAsPubCrate {
    #[primary_span]
    pub(crate) vis_span: Span,
}

#[derive(Subdiagnostic)]
#[note("consider marking `{$ident}` as `pub` in the imported module")]
pub(crate) struct ConsiderMarkingAsPub {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) ident: Ident,
}

#[derive(Diagnostic)]
#[diag("cannot glob-import all possible crates")]
pub(crate) struct CannotGlobImportAllCrates {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Subdiagnostic)]
#[suggestion(
    "you might have meant to write a const parameter here",
    code = "const ",
    style = "verbose"
)]
pub(crate) struct UnexpectedResChangeTyToConstParamSugg {
    #[primary_span]
    pub span: Span,
    #[applicability]
    pub applicability: Applicability,
}

#[derive(Subdiagnostic)]
#[suggestion(
    "you might have meant to introduce a const parameter `{$item_name}` on the {$item_location}",
    code = "{snippet}",
    applicability = "machine-applicable",
    style = "verbose"
)]
pub(crate) struct UnexpectedMissingConstParameter {
    #[primary_span]
    pub span: Span,
    pub snippet: String,
    pub item_name: String,
    pub item_location: String,
}

#[derive(Subdiagnostic)]
#[multipart_suggestion(
    "you might have meant to write a const parameter here",
    applicability = "has-placeholders",
    style = "verbose"
)]
pub(crate) struct UnexpectedResChangeTyParamToConstParamSugg {
    #[suggestion_part(code = "const ")]
    pub before: Span,
    #[suggestion_part(code = ": /* Type */")]
    pub after: Span,
}

#[derive(Subdiagnostic)]
#[suggestion(
    "if you meant to collect the rest of the slice in `{$ident}`, use the at operator",
    code = "{snippet}",
    applicability = "maybe-incorrect",
    style = "verbose"
)]
pub(crate) struct UnexpectedResUseAtOpInSlicePatWithRangeSugg {
    #[primary_span]
    pub span: Span,
    pub ident: Ident,
    pub snippet: String,
}

#[derive(Diagnostic)]
#[diag("an `extern crate` loading macros must be at the crate root", code = E0468)]
pub(crate) struct ExternCrateLoadingMacroNotAtCrateRoot {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag("`extern crate self;` requires renaming")]
pub(crate) struct ExternCrateSelfRequiresRenaming {
    #[primary_span]
    #[suggestion(
        "rename the `self` crate to be able to import it",
        code = "extern crate self as name;",
        applicability = "has-placeholders"
    )]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag("`{$name}` is already in scope")]
#[note("macro-expanded `#[macro_use]`s may not shadow existing macros (see RFC 1560)")]
pub(crate) struct MacroUseNameAlreadyInUse {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) name: Symbol,
}

#[derive(Diagnostic)]
#[diag("imported macro not found", code = E0469)]
pub(crate) struct ImportedMacroNotFound {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag("`#[macro_escape]` is a deprecated synonym for `#[macro_use]`")]
pub(crate) struct MacroExternDeprecated {
    #[primary_span]
    pub(crate) span: Span,
    #[help("try an outer attribute: `#[macro_use]`")]
    pub inner_attribute: bool,
}

#[derive(Diagnostic)]
#[diag("arguments to `macro_use` are not allowed here")]
pub(crate) struct ArgumentsMacroUseNotAllowed {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Subdiagnostic)]
#[multipart_suggestion(
    "try renaming it with a name",
    applicability = "maybe-incorrect",
    style = "verbose"
)]
pub(crate) struct UnnamedImportSugg {
    #[suggestion_part(code = "{ident} as name")]
    pub(crate) span: Span,
    pub(crate) ident: Ident,
}

#[derive(Diagnostic)]
#[diag("imports need to be explicitly named")]
pub(crate) struct UnnamedImport {
    #[primary_span]
    pub(crate) span: Span,
    #[subdiagnostic]
    pub(crate) sugg: UnnamedImportSugg,
}

#[derive(Diagnostic)]
#[diag("macro-expanded `extern crate` items cannot shadow names passed with `--extern`")]
pub(crate) struct MacroExpandedExternCrateCannotShadowExternArguments {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag("`&` without an explicit lifetime name cannot be used here", code = E0637)]
pub(crate) struct ElidedAnonymousLifetimeReportError {
    #[primary_span]
    #[label("explicit lifetime name needed here")]
    pub(crate) span: Span,
    #[subdiagnostic]
    pub(crate) suggestion: Option<ElidedAnonymousLifetimeReportErrorSuggestion>,
}

#[derive(Diagnostic)]
#[diag(
    "associated type `Iterator::Item` is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type"
)]
pub(crate) struct LendingIteratorReportError {
    #[primary_span]
    pub(crate) lifetime: Span,
    #[note(
        "you can't create an `Iterator` that borrows each `Item` from itself, but you can instead create a new type that borrows your existing type and implement `Iterator` for that new type"
    )]
    pub(crate) ty: Span,
}

#[derive(Diagnostic)]
#[diag("missing lifetime in associated type")]
pub(crate) struct AnonymousLifetimeNonGatReportError {
    #[primary_span]
    #[label("this lifetime must come from the implemented type")]
    pub(crate) lifetime: Span,
    #[note(
        "in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type"
    )]
    pub(crate) decl: MultiSpan,
}

#[derive(Subdiagnostic)]
#[multipart_suggestion(
    "consider introducing a higher-ranked lifetime here",
    applicability = "machine-applicable"
)]
pub(crate) struct ElidedAnonymousLifetimeReportErrorSuggestion {
    #[suggestion_part(code = "for<'a> ")]
    pub(crate) lo: Span,
    #[suggestion_part(code = "'a ")]
    pub(crate) hi: Span,
}

#[derive(Diagnostic)]
#[diag("`'_` cannot be used here", code = E0637)]
pub(crate) struct ExplicitAnonymousLifetimeReportError {
    #[primary_span]
    #[label("`'_` is a reserved lifetime name")]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag("implicit elided lifetime not allowed here", code = E0726)]
pub(crate) struct ImplicitElidedLifetimeNotAllowedHere {
    #[primary_span]
    pub(crate) span: Span,
    #[subdiagnostic]
    pub(crate) subdiag: ElidedLifetimeInPathSubdiag,
}

#[derive(Diagnostic)]
#[diag("`'_` cannot be used here", code = E0637)]
#[help("use another lifetime specifier")]
pub(crate) struct UnderscoreLifetimeIsReserved {
    #[primary_span]
    #[label("`'_` is a reserved lifetime name")]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag("invalid lifetime parameter name: `{$lifetime}`", code = E0262)]
pub(crate) struct StaticLifetimeIsReserved {
    #[primary_span]
    #[label("'static is a reserved lifetime name")]
    pub(crate) span: Span,
    pub(crate) lifetime: Ident,
}

#[derive(Diagnostic)]
#[diag("variable `{$name}` is not bound in all patterns", code = E0408)]
pub(crate) struct VariableIsNotBoundInAllPatterns {
    #[primary_span]
    pub(crate) multispan: MultiSpan,
    pub(crate) name: Ident,
}

#[derive(Subdiagnostic, Debug, Clone)]
#[label("pattern doesn't bind `{$name}`")]
pub(crate) struct PatternDoesntBindName {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) name: Ident,
}

#[derive(Subdiagnostic, Debug, Clone)]
#[label("variable not in all patterns")]
pub(crate) struct VariableNotInAllPatterns {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Subdiagnostic)]
#[multipart_suggestion(
    "you might have meant to use the similarly named previously used binding `{$typo}`",
    applicability = "maybe-incorrect",
    style = "verbose"
)]
pub(crate) struct PatternBindingTypo {
    #[suggestion_part(code = "{typo}")]
    pub(crate) spans: Vec<Span>,
    pub(crate) typo: Symbol,
}

#[derive(Diagnostic)]
#[diag("the name `{$name}` is defined multiple times")]
#[note("`{$name}` must be defined only once in the {$descr} namespace of this {$container}")]
pub(crate) struct NameDefinedMultipleTime {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) name: Symbol,
    pub(crate) descr: &'static str,
    pub(crate) container: &'static str,
    #[subdiagnostic]
    pub(crate) label: NameDefinedMultipleTimeLabel,
    #[subdiagnostic]
    pub(crate) old_binding_label: Option<NameDefinedMultipleTimeOldBindingLabel>,
}

#[derive(Subdiagnostic)]
pub(crate) enum NameDefinedMultipleTimeLabel {
    #[label("`{$name}` reimported here")]
    Reimported {
        #[primary_span]
        span: Span,
        name: Symbol,
    },
    #[label("`{$name}` redefined here")]
    Redefined {
        #[primary_span]
        span: Span,
        name: Symbol,
    },
}

#[derive(Subdiagnostic)]
pub(crate) enum NameDefinedMultipleTimeOldBindingLabel {
    #[label("previous import of the {$old_kind} `{$name}` here")]
    Import {
        #[primary_span]
        span: Span,
        old_kind: &'static str,
        name: Symbol,
    },
    #[label("previous definition of the {$old_kind} `{$name}` here")]
    Definition {
        #[primary_span]
        span: Span,
        old_kind: &'static str,
        name: Symbol,
    },
}

#[derive(Diagnostic)]
#[diag("{$ident_descr} `{$ident}` is private", code = E0603)]
pub(crate) struct IsPrivate<'a> {
    #[primary_span]
    #[label("private {$ident_descr}")]
    pub(crate) span: Span,
    pub(crate) ident_descr: &'a str,
    pub(crate) ident: Ident,
}

#[derive(Diagnostic)]
#[diag("generic arguments in macro path")]
pub(crate) struct GenericArgumentsInMacroPath {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag("attributes starting with `rustc` are reserved for use by the `rustc` compiler")]
pub(crate) struct AttributesStartingWithRustcAreReserved {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag(
    "attributes containing a segment starting with `rustc` are reserved for use by the `rustc` compiler"
)]
pub(crate) struct AttributesContainingRustcAreReserved {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Diagnostic)]
#[diag("cannot use {$article} {$descr} through an import")]
pub(crate) struct CannotUseThroughAnImport {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) article: &'static str,
    pub(crate) descr: &'static str,
    #[note("the {$descr} imported here")]
    pub(crate) binding_span: Option<Span>,
}

#[derive(Diagnostic)]
#[diag("name `{$ident}` is reserved in attribute namespace")]
pub(crate) struct NameReservedInAttributeNamespace {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) ident: Symbol,
}

#[derive(Diagnostic)]
#[diag("cannot find a built-in macro with name `{$ident}`")]
pub(crate) struct CannotFindBuiltinMacroWithName {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) ident: Ident,
}

#[derive(Diagnostic)]
#[diag("tool `{$tool}` was already registered")]
pub(crate) struct ToolWasAlreadyRegistered {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) tool: Ident,
    #[label("already registered here")]
    pub(crate) old_ident_span: Span,
}

#[derive(Subdiagnostic)]
pub(crate) enum DefinedHere {
    #[label("similarly named {$candidate_descr} `{$candidate}` defined here")]
    SimilarlyNamed {
        #[primary_span]
        span: Span,
        candidate_descr: &'static str,
        candidate: Symbol,
    },
    #[label("{$candidate_descr} `{$candidate}` defined here")]
    SingleItem {
        #[primary_span]
        span: Span,
        candidate_descr: &'static str,
        candidate: Symbol,
    },
}

#[derive(Subdiagnostic)]
#[label("{$outer_ident_descr} `{$outer_ident}` is not publicly re-exported")]
pub(crate) struct OuterIdentIsNotPubliclyReexported {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) outer_ident_descr: &'static str,
    pub(crate) outer_ident: Ident,
}

#[derive(Subdiagnostic)]
#[label("a constructor is private if any of the fields is private")]
pub(crate) struct ConstructorPrivateIfAnyFieldPrivate {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Subdiagnostic)]
#[multipart_suggestion(
    "{ $number_of_fields ->
        [one] consider making the field publicly accessible
        *[other] consider making the fields publicly accessible
    }",
    applicability = "maybe-incorrect",
    style = "verbose"
)]
pub(crate) struct ConsiderMakingTheFieldPublic {
    #[suggestion_part(code = "pub ")]
    pub(crate) spans: Vec<Span>,
    pub(crate) number_of_fields: usize,
}

#[derive(Subdiagnostic)]
pub(crate) enum ImportIdent {
    #[suggestion(
        "import `{$ident}` through the re-export",
        code = "{path}",
        applicability = "machine-applicable",
        style = "verbose"
    )]
    ThroughReExport {
        #[primary_span]
        span: Span,
        ident: Ident,
        path: String,
    },
    #[suggestion(
        "import `{$ident}` directly",
        code = "{path}",
        applicability = "machine-applicable",
        style = "verbose"
    )]
    Directly {
        #[primary_span]
        span: Span,
        ident: Ident,
        path: String,
    },
}

#[derive(Subdiagnostic)]
#[note(
    "{$first ->
        [true] {$dots ->
            [true] the {$binding_descr} `{$binding_name}` is defined here...
            *[false] the {$binding_descr} `{$binding_name}` is defined here
        }
        *[false] {$dots ->
            [true] ...and refers to the {$binding_descr} `{$binding_name}` which is defined here...
            *[false] ...and refers to the {$binding_descr} `{$binding_name}` which is defined here
        }
    }"
)]
pub(crate) struct NoteAndRefersToTheItemDefinedHere<'a> {
    #[primary_span]
    pub(crate) span: MultiSpan,
    pub(crate) binding_descr: &'a str,
    pub(crate) binding_name: Ident,
    pub(crate) first: bool,
    pub(crate) dots: bool,
}

#[derive(Subdiagnostic)]
#[suggestion("remove unnecessary import", code = "", applicability = "maybe-incorrect")]
pub(crate) struct RemoveUnnecessaryImport {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Subdiagnostic)]
#[suggestion(
    "remove unnecessary import",
    code = "",
    applicability = "maybe-incorrect",
    style = "tool-only"
)]
pub(crate) struct ToolOnlyRemoveUnnecessaryImport {
    #[primary_span]
    pub(crate) span: Span,
}

#[derive(Subdiagnostic)]
#[note("`{$imported_ident}` is imported here, but it is {$imported_ident_desc}")]
pub(crate) struct IdentImporterHereButItIsDesc<'a> {
    #[primary_span]
    pub(crate) span: Span,
    pub(crate) imported_ident: Ident,
    pub(crate) imported_ident_desc: &'a str,
}

#[derive(Subdiagnostic)]
#[note("`{$imported_ident}` is in scope, but it is {$imported_ident_desc}")]
pub(crate) struct IdentInScopeButItIsDesc<'a> {
    pub(crate) imported_ident: Ident,
    pub(crate) imported_ident_desc: &'a str,
}

pub(crate) struct FoundItemConfigureOut {
    pub(crate) span: Span,
    pub(crate) item_was: ItemWas,
}

pub(crate) enum ItemWas {
    BehindFeature { feature: Symbol, span: Span },
    CfgOut { span: Span },
}

impl Subdiagnostic for FoundItemConfigureOut {
    fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
        let mut multispan: MultiSpan = self.span.into();
        match self.item_was {
            ItemWas::BehindFeature { feature, span } => {
                let value = feature.into_diag_arg(&mut None);
                let msg = msg!("the item is gated behind the `{$feature}` feature")
                    .arg("feature", value)
                    .format();
                multispan.push_span_label(span, msg);
            }
            ItemWas::CfgOut { span } => {
                multispan.push_span_label(span, msg!("the item is gated here"));
            }
        }
        diag.span_note(multispan, msg!("found an item that was configured out"));
    }
}

#[derive(Diagnostic)]
#[diag("item `{$name}` is an associated {$kind}, which doesn't match its trait `{$trait_path}`")]
pub(crate) struct TraitImplMismatch {
    #[primary_span]
    #[label("does not match trait")]
    pub(crate) span: Span,
    pub(crate) name: Ident,
    pub(crate) kind: &'static str,
    pub(crate) trait_path: String,
    #[label("item in trait")]
    pub(crate) trait_item_span: Span,
}

#[derive(Diagnostic)]
#[diag("derive helper attribute is used before it is introduced")]
pub(crate) struct LegacyDeriveHelpers {
    #[label("the attribute is introduced here")]
    pub span: Span,
}

#[derive(Diagnostic)]
#[diag("unused extern crate")]
pub(crate) struct UnusedExternCrate {
    #[label("unused")]
    pub span: Span,
    #[suggestion(
        "remove the unused `extern crate`",
        code = "",
        applicability = "machine-applicable",
        style = "verbose"
    )]
    pub removal_span: Span,
}

#[derive(Diagnostic)]
#[diag("{$kind} `{$name}` from private dependency '{$krate}' is re-exported")]
pub(crate) struct ReexportPrivateDependency {
    pub name: Symbol,
    pub kind: &'static str,
    pub krate: Symbol,
}

#[derive(Diagnostic)]
#[diag("unused label")]
pub(crate) struct UnusedLabel;

#[derive(Diagnostic)]
#[diag("unused `#[macro_use]` import")]
pub(crate) struct UnusedMacroUse;

#[derive(Diagnostic)]
#[diag("applying the `#[macro_use]` attribute to an `extern crate` item is deprecated")]
#[help("remove it and import macros at use sites with a `use` item instead")]
pub(crate) struct MacroUseDeprecated;

#[derive(Diagnostic)]
#[diag("macro `{$ident}` is private")]
pub(crate) struct MacroIsPrivate {
    pub ident: Ident,
}

#[derive(Diagnostic)]
#[diag("unused macro definition: `{$name}`")]
pub(crate) struct UnusedMacroDefinition {
    pub name: Symbol,
}

#[derive(Diagnostic)]
#[diag("rule #{$n} of macro `{$name}` is never used")]
pub(crate) struct MacroRuleNeverUsed {
    pub n: usize,
    pub name: Symbol,
}

#[derive(Diagnostic)]
#[diag("`extern crate` is not idiomatic in the new edition")]
pub(crate) struct ExternCrateNotIdiomatic {
    #[suggestion(
        "convert it to a `use`",
        style = "verbose",
        code = "{code}",
        applicability = "machine-applicable"
    )]
    pub span: Span,
    pub code: &'static str,
}

#[derive(Diagnostic)]
#[diag("cannot find macro `{$path}` in the current scope when looking from {$location}")]
#[help("import `macro_rules` with `use` to make it callable above its definition")]
pub(crate) struct OutOfScopeMacroCalls {
    #[label("not found from {$location}")]
    pub span: Span,
    pub path: String,
    pub location: String,
}

#[derive(Diagnostic)]
#[diag(
    "glob import doesn't reexport anything with visibility `{$import_vis}` because no imported item is public enough"
)]
pub(crate) struct RedundantImportVisibility {
    #[note("the most public imported item is `{$max_vis}`")]
    pub span: Span,
    #[help("reduce the glob import's visibility or increase visibility of imported items")]
    pub help: (),
    pub import_vis: String,
    pub max_vis: String,
}

#[derive(Diagnostic)]
#[diag("unknown diagnostic attribute")]
pub(crate) struct UnknownDiagnosticAttribute {
    #[subdiagnostic]
    pub help: Option<UnknownDiagnosticAttributeHelp>,
}

#[derive(Subdiagnostic)]
pub(crate) enum UnknownDiagnosticAttributeHelp {
    #[suggestion(
        "an attribute with a similar name exists",
        style = "verbose",
        code = "{typo_name}",
        applicability = "machine-applicable"
    )]
    Typo {
        #[primary_span]
        span: Span,
        typo_name: Symbol,
    },
    #[help("add `#![feature({$feature})]` to the crate attributes to enable")]
    UseFeature { feature: Symbol },
}

// FIXME: Make this properly translatable.
pub(crate) struct Ambiguity {
    pub ident: Ident,
    pub ambig_vis: Option<String>,
    pub kind: &'static str,
    pub help: Option<&'static [&'static str]>,
    pub b1_note: Spanned<String>,
    pub b1_help_msgs: Vec<String>,
    pub b2_note: Spanned<String>,
    pub b2_help_msgs: Vec<String>,
    /// If false, then it's a lint, if true, then it's an error with the `E0659` error code.
    pub is_error: bool,
}

impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for Ambiguity {
    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
        let Self {
            ident,
            ambig_vis,
            kind,
            help,
            b1_note,
            b1_help_msgs,
            b2_note,
            b2_help_msgs,
            is_error,
        } = self;

        let mut diag = Diag::new(dcx, level, "").with_span(ident.span);
        if is_error {
            diag.code(E0659);
        }
        if let Some(ambig_vis) = ambig_vis {
            diag.primary_message(format!("ambiguous import visibility: {ambig_vis}"));
        } else {
            diag.primary_message(format!("`{}` is ambiguous", ident));
            diag.span_label(ident.span, "ambiguous name");
        }
        diag.note(format!("ambiguous because of {}", kind));
        diag.span_note(b1_note.span, b1_note.node);
        if let Some(help) = help {
            for help in help {
                diag.help(*help);
            }
        }
        for help_msg in b1_help_msgs {
            diag.help(help_msg);
        }
        diag.span_note(b2_note.span, b2_note.node);
        for help_msg in b2_help_msgs {
            diag.help(help_msg);
        }
        diag
    }
}

#[derive(Diagnostic)]
#[diag("lifetime parameter `{$ident}` never used")]
pub(crate) struct UnusedLifetime {
    #[suggestion("elide the unused lifetime", code = "", applicability = "machine-applicable")]
    pub deletion_span: Option<Span>,

    pub ident: Ident,
}

#[derive(Diagnostic)]
#[diag("ambiguous glob re-exports")]
pub(crate) struct AmbiguousGlobReexports {
    #[label("the name `{$name}` in the {$namespace} namespace is first re-exported here")]
    pub first_reexport: Span,
    #[label("but the name `{$name}` in the {$namespace} namespace is also re-exported here")]
    pub duplicate_reexport: Span,

    pub name: String,
    pub namespace: String,
}

#[derive(Diagnostic)]
#[diag("private item shadows public glob re-export")]
pub(crate) struct HiddenGlobReexports {
    #[note(
        "the name `{$name}` in the {$namespace} namespace is supposed to be publicly re-exported here"
    )]
    pub glob_reexport: Span,
    #[note("but the private item here shadows it")]
    pub private_item: Span,

    pub name: String,
    pub namespace: String,
}

#[derive(Diagnostic)]
#[diag("the item `{$ident}` is imported redundantly")]
pub(crate) struct RedundantImport {
    #[subdiagnostic]
    pub subs: Vec<RedundantImportSub>,
    pub ident: Ident,
}

#[derive(Subdiagnostic)]
pub(crate) enum RedundantImportSub {
    #[label("the item `{$ident}` is already imported here")]
    ImportedHere {
        #[primary_span]
        span: Span,
        ident: Ident,
    },
    #[label("the item `{$ident}` is already defined here")]
    DefinedHere {
        #[primary_span]
        span: Span,
        ident: Ident,
    },
    #[label("the item `{$ident}` is already imported by the extern prelude")]
    ImportedPrelude {
        #[primary_span]
        span: Span,
        ident: Ident,
    },
    #[label("the item `{$ident}` is already defined by the extern prelude")]
    DefinedPrelude {
        #[primary_span]
        span: Span,
        ident: Ident,
    },
}

#[derive(Diagnostic)]
#[diag("unnecessary qualification")]
pub(crate) struct UnusedQualifications {
    #[suggestion(
        "remove the unnecessary path segments",
        style = "verbose",
        code = "",
        applicability = "machine-applicable"
    )]
    pub removal_span: Span,
}

#[derive(Diagnostic)]
#[diag("lifetime parameter `{$ident}` only used once")]
pub(crate) struct SingleUseLifetime {
    #[label("this lifetime...")]
    pub param_span: Span,
    #[label("...is used only here")]
    pub use_span: Span,
    #[subdiagnostic]
    pub suggestion: Option<SingleUseLifetimeSugg>,

    pub ident: Ident,
}

#[derive(Subdiagnostic)]
#[multipart_suggestion("elide the single-use lifetime", applicability = "machine-applicable")]
pub(crate) struct SingleUseLifetimeSugg {
    #[suggestion_part(code = "")]
    pub deletion_span: Option<Span>,
    #[suggestion_part(code = "{replace_lt}")]
    pub use_span: Span,

    pub replace_lt: String,
}

#[derive(Diagnostic)]
#[diag(
    "absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition"
)]
pub(crate) struct AbsPathWithModule {
    #[subdiagnostic]
    pub sugg: AbsPathWithModuleSugg,
}

#[derive(Subdiagnostic)]
#[suggestion("use `crate`", code = "{replacement}")]
pub(crate) struct AbsPathWithModuleSugg {
    #[primary_span]
    pub span: Span,
    #[applicability]
    pub applicability: Applicability,
    pub replacement: String,
}

#[derive(Diagnostic)]
#[diag("hidden lifetime parameters in types are deprecated")]
pub(crate) struct ElidedLifetimesInPaths {
    #[subdiagnostic]
    pub subdiag: rustc_errors::ElidedLifetimeInPathSubdiag,
}

#[derive(Diagnostic)]
#[diag(
    "{$num_snippets ->
        [one] unused import: {$span_snippets}
        *[other] unused imports: {$span_snippets}
    }"
)]
pub(crate) struct UnusedImports {
    #[subdiagnostic]
    pub sugg: Option<UnusedImportsSugg>,
    #[help("if this is a test module, consider adding a `#[cfg(test)]` to the containing module")]
    pub test_module_span: Option<Span>,

    pub span_snippets: DiagArgValue,
    pub num_snippets: usize,
}

#[derive(Subdiagnostic)]
pub(crate) enum UnusedImportsSugg {
    #[suggestion(
        "remove the whole `use` item",
        applicability = "machine-applicable",
        code = "",
        style = "tool-only"
    )]
    RemoveWholeUse {
        #[primary_span]
        span: Span,
    },
    #[multipart_suggestion(
        "{$num_to_remove ->
            [one] remove the unused import
            *[other] remove the unused imports
        }",
        applicability = "machine-applicable",
        style = "tool-only"
    )]
    RemoveImports {
        #[suggestion_part(code = "")]
        remove_spans: Vec<Span>,
        num_to_remove: usize,
    },
}