use alloc::borrow::ToOwned;
use alloc::boxed::Box;
use alloc::format;
use alloc::string::{String, ToString};
use alloc::vec;
use alloc::vec::Vec;
use crate::rustc_abi::ExternAbi;
use crate::rustc_errors::codes::*;
use crate::rustc_errors::{
Applicability, Diag, DiagCtxtHandle, DiagSymbolList, Diagnostic, EmissionGuarantee, Level,
MultiSpan, listify, msg,
};
use rustc_macros::{Diagnostic, Subdiagnostic};
use crate::rustc_middle::ty::{self, Ty};
use crate::rustc_span::{Ident, Span, Symbol};
use crate::rustc_structures::Limit;
pub(crate) mod wrong_number_of_generic_args;
mod precise_captures;
pub(crate) use precise_captures::*;
pub(crate) mod remove_or_use_generic;
#[derive(Diagnostic)]
#[diag("complex const arguments must be placed inside of a `const` block")]
pub(crate) struct ComplexConstArg {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("ambiguous associated {$assoc_kind} `{$assoc_ident}` in bounds of `{$qself}`")]
pub(crate) struct AmbiguousAssocItem<'a> {
#[primary_span]
#[label("ambiguous associated {$assoc_kind} `{$assoc_ident}`")]
pub span: Span,
pub assoc_kind: &'static str,
pub assoc_ident: Ident,
pub qself: &'a str,
}
#[derive(Diagnostic)]
#[diag("expected {$expected}, found {$got}")]
pub(crate) struct AssocKindMismatch {
#[primary_span]
#[label("unexpected {$got}")]
pub span: Span,
pub expected: &'static str,
pub got: &'static str,
#[label("expected a {$expected} because of this associated {$expected}")]
pub expected_because_label: Option<Span>,
pub assoc_kind: &'static str,
#[note("the associated {$assoc_kind} is defined here")]
pub def_span: Span,
#[label("bounds are not allowed on associated constants")]
pub bound_on_assoc_const_label: Option<Span>,
#[subdiagnostic]
pub wrap_in_braces_sugg: Option<AssocKindMismatchWrapInBracesSugg>,
}
#[derive(Subdiagnostic)]
#[multipart_suggestion("consider adding braces here", applicability = "maybe-incorrect")]
pub(crate) struct AssocKindMismatchWrapInBracesSugg {
#[suggestion_part(code = "{{ ")]
pub lo: Span,
#[suggestion_part(code = " }}")]
pub hi: Span,
}
#[derive(Diagnostic)]
#[diag("{$kind} `{$name}` is private", code = E0624)]
pub(crate) struct AssocItemIsPrivate {
#[primary_span]
#[label("private {$kind}")]
pub span: Span,
pub kind: &'static str,
pub name: Ident,
#[label("the {$kind} is defined here")]
pub defined_here_label: Span,
}
#[derive(Diagnostic)]
#[diag("associated {$assoc_kind} `{$assoc_ident}` not found for `{$qself}`", code = E0220)]
pub(crate) struct AssocItemNotFound<'a> {
#[primary_span]
pub span: Span,
pub assoc_ident: Ident,
pub assoc_kind: &'static str,
pub qself: &'a str,
#[subdiagnostic]
pub label: Option<AssocItemNotFoundLabel<'a>>,
#[subdiagnostic]
pub sugg: Option<AssocItemNotFoundSugg<'a>>,
#[label("due to this macro variable")]
pub within_macro_span: Option<Span>,
}
#[derive(Subdiagnostic)]
pub(crate) enum AssocItemNotFoundLabel<'a> {
#[label("associated {$assoc_kind} `{$assoc_ident}` not found")]
NotFound {
#[primary_span]
span: Span,
assoc_ident: Ident,
assoc_kind: &'static str,
},
#[label(
"there is {$identically_named ->
[true] an
*[false] a similarly named
} associated {$assoc_kind} `{$suggested_name}` in the trait `{$trait_name}`"
)]
FoundInOtherTrait {
#[primary_span]
span: Span,
assoc_kind: &'static str,
trait_name: &'a str,
suggested_name: Symbol,
identically_named: bool,
},
}
#[derive(Subdiagnostic)]
pub(crate) enum AssocItemNotFoundSugg<'a> {
#[suggestion(
"there is an associated {$assoc_kind} with a similar name",
code = "{suggested_name}",
applicability = "maybe-incorrect"
)]
Similar {
#[primary_span]
span: Span,
assoc_kind: &'static str,
suggested_name: Symbol,
},
#[suggestion(
"change the associated {$assoc_kind} name to use `{$suggested_name}` from `{$trait_name}`",
code = "{suggested_name}",
style = "verbose",
applicability = "maybe-incorrect"
)]
SimilarInOtherTrait {
#[primary_span]
span: Span,
trait_name: &'a str,
assoc_kind: &'static str,
suggested_name: Symbol,
},
#[multipart_suggestion(
"consider fully qualifying{$identically_named ->
[true] {\"\"}
*[false] {\" \"}and renaming
} the associated {$assoc_kind}",
style = "verbose"
)]
SimilarInOtherTraitQPath {
#[suggestion_part(code = "<")]
lo: Span,
#[suggestion_part(code = " as {trait_ref}>")]
mi: Span,
#[suggestion_part(code = "{suggested_name}")]
hi: Option<Span>,
trait_ref: String,
suggested_name: Symbol,
identically_named: bool,
assoc_kind: &'static str,
#[applicability]
applicability: Applicability,
},
#[suggestion(
"`{$qself}` has the following associated {$assoc_kind}",
code = "{suggested_name}",
applicability = "maybe-incorrect"
)]
Other {
#[primary_span]
span: Span,
qself: &'a str,
assoc_kind: &'static str,
suggested_name: Symbol,
},
}
#[derive(Diagnostic)]
#[diag("intrinsic has wrong number of {$descr} parameters: found {$found}, expected {$expected}", code = E0094)]
pub(crate) struct WrongNumberOfGenericArgumentsToIntrinsic<'a> {
#[primary_span]
#[label(
"expected {$expected} {$descr} {$expected ->
[one] parameter
*[other] parameters
}"
)]
pub span: Span,
pub found: usize,
pub expected: usize,
pub descr: &'a str,
}
#[derive(Diagnostic)]
#[diag("unrecognized intrinsic function: `{$name}`", code = E0093)]
#[help("if you're adding an intrinsic, be sure to update `check_intrinsic_type`")]
pub(crate) struct UnrecognizedIntrinsicFunction {
#[primary_span]
#[label("unrecognized intrinsic")]
pub span: Span,
pub name: Symbol,
}
#[derive(Diagnostic)]
#[diag("lifetime parameters or bounds on {$item_kind} `{$ident}` do not match the trait declaration", code = E0195)]
pub(crate) struct LifetimesOrBoundsMismatchOnTrait {
#[primary_span]
#[label("lifetimes do not match {$item_kind} in trait")]
pub span: Span,
#[label("lifetimes in impl do not match this {$item_kind} in trait")]
pub generics_span: Span,
#[label("this `where` clause might not match the one in the trait")]
pub where_span: Option<Span>,
#[label("this bound might be missing in the impl")]
pub bounds_span: Vec<Span>,
pub item_kind: &'static str,
pub ident: Ident,
}
#[derive(Diagnostic)]
#[diag("the `{$trait_}` trait may only be implemented for local structs, enums, and unions", code = E0120)]
pub(crate) struct DropImplOnWrongItem {
#[primary_span]
#[label("must be a struct, enum, or union in the current crate")]
pub span: Span,
pub trait_: Symbol,
}
#[derive(Diagnostic)]
pub(crate) enum FieldAlreadyDeclared {
#[diag("field `{$field_name}` is already declared", code = E0124)]
NotNested {
field_name: Ident,
#[primary_span]
#[label("field already declared")]
span: Span,
#[label("`{$field_name}` first declared here")]
prev_span: Span,
},
#[diag("field `{$field_name}` is already declared")]
CurrentNested {
field_name: Ident,
#[primary_span]
#[label("field `{$field_name}` declared in this unnamed field")]
span: Span,
#[note("field `{$field_name}` declared here")]
nested_field_span: Span,
#[subdiagnostic]
help: FieldAlreadyDeclaredNestedHelp,
#[label("`{$field_name}` first declared here")]
prev_span: Span,
},
#[diag("field `{$field_name}` is already declared")]
PreviousNested {
field_name: Ident,
#[primary_span]
#[label("field already declared")]
span: Span,
#[label("`{$field_name}` first declared here in this unnamed field")]
prev_span: Span,
#[note("field `{$field_name}` first declared here")]
prev_nested_field_span: Span,
#[subdiagnostic]
prev_help: FieldAlreadyDeclaredNestedHelp,
},
#[diag("field `{$field_name}` is already declared")]
BothNested {
field_name: Ident,
#[primary_span]
#[label("field `{$field_name}` declared in this unnamed field")]
span: Span,
#[note("field `{$field_name}` declared here")]
nested_field_span: Span,
#[subdiagnostic]
help: FieldAlreadyDeclaredNestedHelp,
#[label("`{$field_name}` first declared here in this unnamed field")]
prev_span: Span,
#[note("field `{$field_name}` first declared here")]
prev_nested_field_span: Span,
#[subdiagnostic]
prev_help: FieldAlreadyDeclaredNestedHelp,
},
}
#[derive(Subdiagnostic)]
#[help("fields from the type of this unnamed field are considered fields of the outer type")]
pub(crate) struct FieldAlreadyDeclaredNestedHelp {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("the trait `Copy` cannot be implemented for this type; the type has a destructor", code = E0184)]
pub(crate) struct CopyImplOnTypeWithDtor {
#[primary_span]
#[label("`Copy` not allowed on types with destructors")]
pub span: Span,
#[note("destructor declared here")]
pub impl_: Span,
}
#[derive(Diagnostic)]
#[diag("the trait `Copy` cannot be implemented for this type", code = E0206)]
pub(crate) struct CopyImplOnNonAdt {
#[primary_span]
#[label("type is not a structure or enumeration")]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("the trait `ConstParamTy` may not be implemented for this type")]
pub(crate) struct ConstParamTyImplOnUnsized {
#[primary_span]
#[label("type is not `Sized`")]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("the trait `ConstParamTy` may not be implemented for this type")]
pub(crate) struct ConstParamTyImplOnNonAdt {
#[primary_span]
#[label("type is not a structure or enumeration")]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("the trait `ConstParamTy` may not be implemented for this type")]
pub(crate) struct ConstParamTyImplOnNonExhaustive {
#[primary_span]
#[label("non exhaustive const params are forbidden")]
pub defn_span: Span,
#[label("caused by this attribute")]
pub attr_span: Span,
}
#[derive(Diagnostic)]
#[diag("the trait `ConstParamTy` may not be implemented for this struct")]
pub(crate) struct ConstParamTyFieldVisMismatch {
#[primary_span]
#[label("struct fields are less visible than the struct")]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("at least one trait is required for an object type", code = E0224)]
pub(crate) struct TraitObjectDeclaredWithNoTraits {
#[primary_span]
pub span: Span,
#[label("this alias does not contain a trait")]
pub trait_alias_span: Option<Span>,
}
#[derive(Diagnostic)]
#[diag("ambiguous lifetime bound, explicit lifetime bound required", code = E0227)]
pub(crate) struct AmbiguousLifetimeBound {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("associated item constraints are not allowed here", code = E0229)]
pub(crate) struct AssocItemConstraintsNotAllowedHere {
#[primary_span]
#[label("associated item constraint not allowed here")]
pub span: Span,
#[subdiagnostic]
pub fn_trait_expansion: Option<ParenthesizedFnTraitExpansion>,
}
#[derive(Diagnostic)]
#[diag(
"the type of the associated constant `{$assoc_const}` must not depend on {$param_category ->
[self] `Self`
[synthetic] `impl Trait`
*[normal] generic parameters
}"
)]
pub(crate) struct ParamInTyOfAssocConstBinding<'tcx> {
#[primary_span]
#[label(
"its type must not depend on {$param_category ->
[self] `Self`
[synthetic] `impl Trait`
*[normal] the {$param_def_kind} `{$param_name}`
}"
)]
pub span: Span,
pub assoc_const: Ident,
pub param_name: Symbol,
pub param_def_kind: &'static str,
pub param_category: &'static str,
#[label(
"{$param_category ->
[synthetic] the `impl Trait` is specified here
*[normal] the {$param_def_kind} `{$param_name}` is defined here
}"
)]
pub param_defined_here_label: Option<Span>,
#[subdiagnostic]
pub ty_note: Option<TyOfAssocConstBindingNote<'tcx>>,
}
#[derive(Subdiagnostic, Clone, Copy)]
#[note("`{$assoc_const}` has type `{$ty}`")]
pub(crate) struct TyOfAssocConstBindingNote<'tcx> {
pub assoc_const: Ident,
pub ty: Ty<'tcx>,
}
#[derive(Diagnostic)]
#[diag(
"the type of the associated constant `{$assoc_const}` cannot capture late-bound generic parameters"
)]
pub(crate) struct EscapingBoundVarInTyOfAssocConstBinding<'tcx> {
#[primary_span]
#[label("its type cannot capture the late-bound {$var_def_kind} `{$var_name}`")]
pub span: Span,
pub assoc_const: Ident,
pub var_name: Symbol,
pub var_def_kind: &'static str,
#[label("the late-bound {$var_def_kind} `{$var_name}` is defined here")]
pub var_defined_here_label: Span,
#[subdiagnostic]
pub ty_note: Option<TyOfAssocConstBindingNote<'tcx>>,
}
#[derive(Subdiagnostic)]
#[help("parenthesized trait syntax expands to `{$expanded_type}`")]
pub(crate) struct ParenthesizedFnTraitExpansion {
#[primary_span]
pub span: Span,
pub expanded_type: String,
}
#[derive(Diagnostic)]
#[diag("the value of the associated type `{$item_name}` in trait `{$def_path}` is already specified", code = E0719)]
pub(crate) struct ValueOfAssociatedStructAlreadySpecified {
#[primary_span]
#[label("re-bound here")]
pub span: Span,
#[label("`{$item_name}` bound here first")]
pub prev_span: Span,
pub item_name: Ident,
pub def_path: String,
}
#[derive(Diagnostic)]
#[diag("unconstrained opaque type")]
#[note("`{$name}` must be used in combination with a concrete type within the same {$what}")]
pub(crate) struct UnconstrainedOpaqueType {
#[primary_span]
pub span: Span,
pub name: Ident,
pub what: &'static str,
}
pub(crate) struct MissingGenericParams {
pub span: Span,
pub def_span: Span,
pub span_snippet: Option<String>,
pub missing_generic_params: Vec<(Symbol, ty::GenericParamDefKind)>,
pub empty_generic_args: bool,
}
impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for MissingGenericParams {
#[track_caller]
fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
let mut err = Diag::new(
dcx,
level,
msg!(
"the {$descr} {$parameterCount ->
[one] parameter
*[other] parameters
} {$parameters} must be explicitly specified"
),
);
err.span(self.span);
err.code(E0393);
err.span_label(
self.def_span,
msg!(
"{$descr} {$parameterCount ->
[one] parameter
*[other] parameters
} {$parameters} must be specified for this"
),
);
enum Descr {
Generic,
Type,
Const,
}
let mut descr = None;
for (_, kind) in &self.missing_generic_params {
descr = match (&descr, kind) {
(None, ty::GenericParamDefKind::Type { .. }) => Some(Descr::Type),
(None, ty::GenericParamDefKind::Const { .. }) => Some(Descr::Const),
(Some(Descr::Type), ty::GenericParamDefKind::Const { .. })
| (Some(Descr::Const), ty::GenericParamDefKind::Type { .. }) => {
Some(Descr::Generic)
}
_ => continue,
}
}
err.arg(
"descr",
match descr.unwrap() {
Descr::Generic => "generic",
Descr::Type => "type",
Descr::Const => "const",
},
);
err.arg("parameterCount", self.missing_generic_params.len());
err.arg(
"parameters",
listify(&self.missing_generic_params, |(n, _)| format!("`{n}`")).unwrap(),
);
let mut suggested = false;
if let Some(snippet) = self.span_snippet
&& self.empty_generic_args
{
if snippet.ends_with('>') {
} else {
err.span_suggestion_verbose(
self.span.shrink_to_hi(),
msg!(
"explicitly specify the {$descr} {$parameterCount ->
[one] parameter
*[other] parameters
}"
),
format!(
"<{}>",
self.missing_generic_params
.iter()
.map(|(n, _)| format!("/* {n} */"))
.collect::<Vec<_>>()
.join(", ")
),
Applicability::HasPlaceholders,
);
suggested = true;
}
}
if !suggested {
err.span_label(
self.span,
msg!(
"missing {$parameterCount ->
[one] reference
*[other] references
} to {$parameters}"
),
);
}
err.note(msg!(
"because the parameter {$parameterCount ->
[one] default references
*[other] defaults reference
} `Self`, the {$parameterCount ->
[one] parameter
*[other] parameters
} must be specified on the trait object type"
));
err
}
}
#[derive(Diagnostic)]
#[diag("manual implementations of `{$trait_name}` are experimental", code = E0183)]
#[help("add `#![feature(unboxed_closures)]` to the crate attributes to enable")]
pub(crate) struct ManualImplementation {
#[primary_span]
#[label("manual implementations of `{$trait_name}` are experimental")]
pub span: Span,
pub trait_name: String,
}
#[derive(Diagnostic)]
#[diag("could not resolve generic parameters on overridden impl")]
pub(crate) struct GenericArgsOnOverriddenImpl {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("const `impl` for trait `{$trait_name}` which is not `const`")]
pub(crate) struct ConstImplForNonConstTrait {
#[primary_span]
#[label("this trait is not `const`")]
pub trait_ref_span: Span,
pub trait_name: String,
#[suggestion(
"{$suggestion_pre}mark `{$trait_name}` as `const` to allow it to have `const` implementations",
applicability = "machine-applicable",
code = "const ",
style = "verbose"
)]
pub suggestion: Option<Span>,
pub suggestion_pre: &'static str,
#[note("marking a trait with `const` ensures all default method bodies are `const`")]
pub marking: (),
#[note("adding a non-const method body in the future would be a breaking change")]
pub adding: (),
}
#[derive(Diagnostic)]
#[diag("`{$modifier}` can only be applied to `const` traits")]
pub(crate) struct ConstBoundForNonConstTrait {
#[primary_span]
#[label("can't be applied to `{$trait_name}`")]
pub span: Span,
pub modifier: &'static str,
#[note("`{$trait_name}` can't be used with `{$modifier}` because it isn't `const`")]
pub def_span: Option<Span>,
#[suggestion(
"{$suggestion_pre}mark `{$trait_name}` as `const` to allow it to have `const` implementations",
applicability = "machine-applicable",
code = "const ",
style = "verbose"
)]
pub suggestion: Option<Span>,
pub suggestion_pre: &'static str,
pub trait_name: String,
}
#[derive(Diagnostic)]
#[diag("`Self` is not valid in the self type of an impl block")]
pub(crate) struct SelfInImplSelf {
#[primary_span]
pub span: MultiSpan,
#[note("replace `Self` with a different type")]
pub note: (),
}
#[derive(Diagnostic)]
#[diag("invalid type for variable with `#[linkage]` attribute", code = E0791)]
pub(crate) struct LinkageType {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[help(
"consider increasing the recursion limit by adding a `#![recursion_limit = \"{$suggested_limit}\"]` attribute to your crate (`{$crate_name}`)"
)]
#[diag("reached the recursion limit while auto-dereferencing `{$ty}`", code = E0055)]
pub(crate) struct AutoDerefReachedRecursionLimit<'a> {
#[primary_span]
#[label("deref recursion limit reached")]
pub span: Span,
pub ty: Ty<'a>,
pub suggested_limit: Limit,
pub crate_name: Symbol,
}
#[derive(Diagnostic)]
#[diag("`main` function is not allowed to have a `where` clause", code = E0646)]
pub(crate) struct WhereClauseOnMain {
#[primary_span]
pub span: Span,
#[label("`main` cannot have a `where` clause")]
pub generics_span: Option<Span>,
}
#[derive(Diagnostic)]
#[diag("`main` function is not allowed to be `#[track_caller]`")]
pub(crate) struct TrackCallerOnMain {
#[primary_span]
#[suggestion("remove this annotation", applicability = "maybe-incorrect", code = "")]
pub span: Span,
#[label("`main` function is not allowed to be `#[track_caller]`")]
pub annotated: Span,
}
#[derive(Diagnostic)]
#[diag("`main` function is not allowed to have `#[target_feature]`")]
pub(crate) struct TargetFeatureOnMain {
#[primary_span]
#[label("`main` function is not allowed to have `#[target_feature]`")]
pub main: Span,
}
#[derive(Diagnostic)]
#[diag("`main` function return type is not allowed to have generic parameters", code = E0131)]
pub(crate) struct MainFunctionReturnTypeGeneric {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("`main` function is not allowed to be `async`", code = E0752)]
pub(crate) struct MainFunctionAsync {
#[primary_span]
pub span: Span,
#[label("`main` function is not allowed to be `async`")]
pub asyncness: Option<Span>,
}
#[derive(Diagnostic)]
#[diag("`main` function is not allowed to have generic parameters", code = E0131)]
pub(crate) struct MainFunctionGenericParameters {
#[primary_span]
pub span: Span,
#[label("`main` cannot have generic parameters")]
pub label_span: Option<Span>,
}
#[derive(Diagnostic)]
#[diag("C-variadic functions with the {$convention} calling convention are not supported", code = E0045)]
pub(crate) struct VariadicFunctionCompatibleConvention<'a> {
#[primary_span]
#[label("C-variadic function must have a compatible calling convention")]
pub span: Span,
pub convention: &'a str,
}
#[derive(Diagnostic)]
pub(crate) enum CannotCaptureLateBound {
#[diag("cannot capture late-bound type parameter in {$what}")]
Type {
#[primary_span]
use_span: Span,
#[label("parameter defined here")]
def_span: Span,
what: &'static str,
},
#[diag("cannot capture late-bound const parameter in {$what}")]
Const {
#[primary_span]
use_span: Span,
#[label("parameter defined here")]
def_span: Span,
what: &'static str,
},
#[diag("cannot capture late-bound lifetime in {$what}")]
Lifetime {
#[primary_span]
use_span: Span,
#[label("lifetime defined here")]
def_span: Span,
what: &'static str,
},
}
#[derive(Diagnostic)]
#[diag("{$ty}")]
pub(crate) struct TypeOf<'tcx> {
#[primary_span]
pub span: Span,
pub ty: Ty<'tcx>,
}
#[derive(Diagnostic)]
#[diag("field must implement `Copy` or be wrapped in `ManuallyDrop<...>` to be used in a union", code = E0740)]
pub(crate) struct InvalidUnionField {
#[primary_span]
pub field_span: Span,
#[subdiagnostic]
pub sugg: InvalidUnionFieldSuggestion,
#[note(
"union fields must not have drop side-effects, which is currently enforced via either `Copy` or `ManuallyDrop<...>`"
)]
pub note: (),
}
#[derive(Diagnostic)]
#[diag(
"return type notation used on function that is not `async` and does not return `impl Trait`"
)]
pub(crate) struct ReturnTypeNotationOnNonRpitit<'tcx> {
#[primary_span]
pub span: Span,
pub ty: Ty<'tcx>,
#[label("this function must be `async` or return `impl Trait`")]
pub fn_span: Option<Span>,
#[note("function returns `{$ty}`, which is not compatible with associated type return bounds")]
pub note: (),
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(
"wrap the field type in `ManuallyDrop<...>`",
applicability = "machine-applicable"
)]
pub(crate) struct InvalidUnionFieldSuggestion {
#[suggestion_part(code = "core::mem::ManuallyDrop<")]
pub lo: Span,
#[suggestion_part(code = ">")]
pub hi: Span,
}
#[derive(Diagnostic)]
#[diag("return type notation is not allowed to use type equality")]
pub(crate) struct ReturnTypeNotationEqualityBound {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("the placeholder `_` is not allowed within types on item signatures for {$kind}", code = E0121)]
pub(crate) struct PlaceholderNotAllowedItemSignatures {
#[primary_span]
#[label("not allowed in type signatures")]
pub spans: Vec<Span>,
pub kind: String,
}
#[derive(Diagnostic)]
#[diag("cannot use the {$what} of a trait with uninferred generic parameters", code = E0212)]
pub(crate) struct AssociatedItemTraitUninferredGenericParams {
#[primary_span]
pub span: Span,
#[suggestion(
"use a fully qualified path with inferred lifetimes",
style = "verbose",
applicability = "maybe-incorrect",
code = "{bound}"
)]
pub inferred_sugg: Option<Span>,
pub bound: String,
#[subdiagnostic]
pub mpart_sugg: Option<AssociatedItemTraitUninferredGenericParamsMultipartSuggestion>,
pub what: &'static str,
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(
"use a fully qualified path with explicit lifetimes",
applicability = "maybe-incorrect"
)]
pub(crate) struct AssociatedItemTraitUninferredGenericParamsMultipartSuggestion {
#[suggestion_part(code = "{first}")]
pub fspan: Span,
pub first: String,
#[suggestion_part(code = "{second}")]
pub sspan: Span,
pub second: String,
}
#[derive(Diagnostic)]
#[diag("enum discriminant overflowed", code = E0370)]
#[note("explicitly set `{$item_name} = {$wrapped_discr}` if that is desired outcome")]
pub(crate) struct EnumDiscriminantOverflowed {
#[primary_span]
#[label("overflowed on value after {$discr}")]
pub span: Span,
pub discr: String,
pub item_name: Ident,
pub wrapped_discr: String,
}
#[derive(Diagnostic)]
#[diag("use of SIMD type{$snip} in FFI is highly experimental and may result in invalid code")]
#[help("add `#![feature(simd_ffi)]` to the crate attributes to enable")]
pub(crate) struct SIMDFFIHighlyExperimental {
#[primary_span]
pub span: Span,
pub snip: String,
}
#[derive(Diagnostic)]
pub(crate) enum ImplNotMarkedDefault {
#[diag("`{$ident}` specializes an item from a parent `impl`, but that item is not marked `default`", code = E0520)]
#[note("to specialize, `{$ident}` in the parent `impl` must be marked `default`")]
Ok {
#[primary_span]
#[label("cannot specialize default item `{$ident}`")]
span: Span,
#[label("parent `impl` is here")]
ok_label: Span,
ident: Ident,
},
#[diag("`{$ident}` specializes an item from a parent `impl`, but that item is not marked `default`", code = E0520)]
#[note("parent implementation is in crate `{$cname}`")]
Err {
#[primary_span]
span: Span,
cname: Symbol,
ident: Ident,
},
}
#[derive(Diagnostic)]
#[diag("this item cannot be used as its where bounds are not satisfied for the `Self` type")]
pub(crate) struct UselessImplItem;
#[derive(Diagnostic)]
#[diag("cannot override `{$ident}` because it already has a `final` definition in the trait")]
pub(crate) struct OverridingFinalTraitFunction {
#[primary_span]
pub impl_span: Span,
#[note("`{$ident}` is marked final here")]
pub trait_span: Span,
pub ident: Ident,
}
#[derive(Diagnostic)]
#[diag("not all trait items implemented, missing: `{$missing_items_msg}`", code = E0046)]
pub(crate) struct MissingTraitItem {
#[primary_span]
#[label("missing `{$missing_items_msg}` in implementation")]
pub span: Span,
#[subdiagnostic]
pub missing_trait_item_label: Vec<MissingTraitItemLabel>,
#[subdiagnostic]
pub missing_trait_item: Vec<MissingTraitItemSuggestion>,
#[subdiagnostic]
pub missing_trait_item_none: Vec<MissingTraitItemSuggestionNone>,
#[subdiagnostic]
pub missing_trait_item_unstable: Vec<MissingTraitItemSuggestionUnstable>,
pub missing_items_msg: String,
}
#[derive(Subdiagnostic)]
#[label("`{$item}` from trait")]
pub(crate) struct MissingTraitItemLabel {
#[primary_span]
pub span: Span,
pub item: Symbol,
}
#[derive(Subdiagnostic)]
#[suggestion(
"implement the missing item: `{$snippet}`",
style = "tool-only",
applicability = "has-placeholders",
code = "{code}"
)]
pub(crate) struct MissingTraitItemSuggestion {
#[primary_span]
pub span: Span,
pub code: String,
pub snippet: String,
}
#[derive(Subdiagnostic)]
#[suggestion(
"implement the missing item: `{$snippet}` (unstable, requires feature `{$feature}`)",
style = "hidden",
applicability = "has-placeholders",
code = "{code}"
)]
pub(crate) struct MissingTraitItemSuggestionUnstable {
#[primary_span]
pub span: Span,
pub code: String,
pub snippet: String,
pub feature: Symbol,
}
#[derive(Subdiagnostic)]
#[suggestion(
"implement the missing item: `{$snippet}`",
style = "hidden",
applicability = "has-placeholders",
code = "{code}"
)]
pub(crate) struct MissingTraitItemSuggestionNone {
#[primary_span]
pub span: Span,
pub code: String,
pub snippet: String,
}
#[derive(Diagnostic)]
#[diag("not all trait items implemented, missing one of: `{$missing_items_msg}`", code = E0046)]
pub(crate) struct MissingOneOfTraitItem {
#[primary_span]
#[label("missing one of `{$missing_items_msg}` in implementation")]
pub span: Span,
#[note("required because of this annotation")]
pub note: Option<Span>,
#[subdiagnostic]
pub missing_trait_item_label: Vec<MissingTraitItemLabel>,
#[subdiagnostic]
pub missing_trait_item: Vec<MissingTraitItemSuggestion>,
#[subdiagnostic]
pub missing_trait_item_none: Vec<MissingTraitItemSuggestionNone>,
#[subdiagnostic]
pub missing_trait_item_unstable: Vec<MissingTraitItemSuggestionUnstable>,
pub missing_items_msg: String,
}
#[derive(Diagnostic)]
#[diag("not all trait items implemented, missing: `{$missing_item_name}`", code = E0046)]
#[note("default implementation of `{$missing_item_name}` is unstable")]
pub(crate) struct MissingTraitItemUnstable {
#[primary_span]
pub span: Span,
#[note("use of unstable library feature `{$feature}`: {$reason}")]
pub some_note: bool,
#[note("use of unstable library feature `{$feature}`")]
pub none_note: bool,
pub missing_item_name: Ident,
pub feature: Symbol,
pub reason: String,
}
#[derive(Diagnostic)]
#[diag("transparent enum needs exactly one variant, but has {$number}", code = E0731)]
pub(crate) struct TransparentEnumVariant {
#[primary_span]
#[label("needs exactly one variant, but has {$number}")]
pub span: Span,
#[label("variant here")]
pub spans: Vec<Span>,
#[label("too many variants in `{$path}`")]
pub many: Option<Span>,
pub number: usize,
pub path: String,
}
#[derive(Diagnostic)]
#[diag("extern static is too large for the target architecture")]
pub(crate) struct TooLargeStatic {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("implementing `rustc_specialization_trait` traits is unstable")]
#[help("add `#![feature(min_specialization)]` to the crate attributes to enable")]
pub(crate) struct SpecializationTrait {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("trait cannot be implemented outside `{$restriction_path}`")]
pub(crate) struct ImplOfRestrictedTrait {
#[primary_span]
pub impl_span: Span,
#[note("trait restricted here")]
pub restriction_span: Span,
pub restriction_path: String,
}
#[derive(Diagnostic)]
#[diag("implicit types in closure signatures are forbidden when `for<...>` is present")]
pub(crate) struct ClosureImplicitHrtb {
#[primary_span]
pub spans: Vec<Span>,
#[label("`for<...>` is here")]
pub for_sp: Span,
}
#[derive(Diagnostic)]
#[diag("specialization impl does not specialize any associated items")]
pub(crate) struct EmptySpecialization {
#[primary_span]
pub span: Span,
#[note("impl is a specialization of this impl")]
pub base_impl_span: Span,
}
#[derive(Diagnostic)]
#[diag("cannot specialize on `'static` lifetime")]
pub(crate) struct StaticSpecialize {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("negative `Drop` impls are not supported")]
pub(crate) struct NegativeDropImplPolarity {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
pub(crate) enum ReturnTypeNotationIllegalParam {
#[diag("return type notation is not allowed for functions that have type parameters")]
Type {
#[primary_span]
span: Span,
#[label("type parameter declared here")]
param_span: Span,
},
#[diag("return type notation is not allowed for functions that have const parameters")]
Const {
#[primary_span]
span: Span,
#[label("const parameter declared here")]
param_span: Span,
},
}
#[derive(Diagnostic)]
pub(crate) enum LateBoundInApit {
#[diag("`impl Trait` can only mention type parameters from an fn or impl")]
Type {
#[primary_span]
span: Span,
#[label("type parameter declared here")]
param_span: Span,
},
#[diag("`impl Trait` can only mention const parameters from an fn or impl")]
Const {
#[primary_span]
span: Span,
#[label("const parameter declared here")]
param_span: Span,
},
#[diag("`impl Trait` can only mention lifetimes from an fn or impl")]
Lifetime {
#[primary_span]
span: Span,
#[label("lifetime declared here")]
param_span: Span,
},
}
#[derive(Diagnostic)]
#[diag("unnecessary associated type bound for dyn-incompatible associated type")]
#[note(
"this associated type has a `where Self: Sized` bound, and while the associated type can be specified, it cannot be used because trait objects are never `Sized`"
)]
pub(crate) struct UnusedAssociatedTypeBounds {
#[suggestion("remove this bound", code = "")]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("impl trait in impl method signature does not match trait method signature")]
#[note(
"add `#[allow(refining_impl_trait)]` if it is intended for this to be part of the public API of this crate"
)]
#[note(
"we are soliciting feedback, see issue #121718 <https://github.com/rust-lang/rust/issues/121718> for more information"
)]
pub(crate) struct ReturnPositionImplTraitInTraitRefined {
#[suggestion(
"replace the return type so that it matches the trait",
applicability = "maybe-incorrect",
code = "{pre}{return_ty}{post}"
)]
pub impl_return_span: Span,
#[label("return type from trait method defined here")]
pub trait_return_span: Option<Span>,
#[label("this bound is stronger than that defined on the trait")]
pub unmatched_bound: Option<Span>,
pub pre: &'static str,
pub post: &'static str,
pub return_ty: String,
}
#[derive(Diagnostic)]
#[diag("impl trait in impl method captures fewer lifetimes than in trait")]
#[note(
"add `#[allow(refining_impl_trait)]` if it is intended for this to be part of the public API of this crate"
)]
#[note(
"we are soliciting feedback, see issue #121718 <https://github.com/rust-lang/rust/issues/121718> for more information"
)]
pub(crate) struct ReturnPositionImplTraitInTraitRefinedLifetimes {
#[suggestion(
"modify the `use<..>` bound to capture the same lifetimes that the trait does",
applicability = "maybe-incorrect",
code = "{suggestion}"
)]
pub suggestion_span: Span,
pub suggestion: String,
}
#[derive(Diagnostic)]
#[diag("cannot define inherent `impl` for a type outside of the crate where the type is defined", code = E0390)]
#[help("consider moving this inherent impl into the crate defining the type if possible")]
pub(crate) struct InherentTyOutside {
#[primary_span]
#[help(
"alternatively add `#[rustc_has_incoherent_inherent_impls]` to the type and `#[rustc_allow_incoherent_impl]` to the relevant impl items"
)]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("structs implementing `DispatchFromDyn` may not have `#[repr(packed)]` or `#[repr(C)]`", code = E0378)]
pub(crate) struct DispatchFromDynRepr {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("`derive(CoercePointee)` is only applicable to `struct`, instead of `{$kind}`", code = E0802)]
pub(crate) struct CoercePointeeNotStruct {
#[primary_span]
pub span: Span,
pub kind: String,
}
#[derive(Diagnostic)]
#[diag("`derive(CoercePointee)` is only applicable to `struct`", code = E0802)]
pub(crate) struct CoercePointeeNotConcreteType {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("asserting applicability of `derive(CoercePointee)` on a target data is forbidden", code = E0802)]
pub(crate) struct CoercePointeeNoUserValidityAssertion {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("`derive(CoercePointee)` is only applicable to `struct` with `repr(transparent)` layout", code = E0802)]
pub(crate) struct CoercePointeeNotTransparent {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("`CoercePointee` can only be derived on `struct`s with at least one field", code = E0802)]
pub(crate) struct CoercePointeeNoField {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("cannot define inherent `impl` for a type outside of the crate where the type is defined", code = E0390)]
#[help("consider moving this inherent impl into the crate defining the type if possible")]
pub(crate) struct InherentTyOutsideRelevant {
#[primary_span]
pub span: Span,
#[help("alternatively add `#[rustc_allow_incoherent_impl]` to the relevant impl items")]
pub help_span: Span,
}
#[derive(Diagnostic)]
#[diag("cannot define inherent `impl` for a type outside of the crate where the type is defined", code = E0116)]
#[help(
"consider defining a trait and implementing it for the type or using a newtype wrapper like `struct MyType(ExternalType);` and implement it"
)]
#[note(
"for more details about the orphan rules, see <https://doc.rust-lang.org/reference/items/implementations.html?highlight=orphan#orphan-rules>"
)]
pub(crate) struct InherentTyOutsideNew {
#[primary_span]
#[label("impl for type defined outside of crate")]
pub span: Span,
#[subdiagnostic]
pub note: Option<InherentTyOutsideNewAliasNote>,
}
#[derive(Subdiagnostic)]
#[note("`{$ty_name}` does not define a new type, only an alias of `{$alias_ty_name}` defined here")]
pub(crate) struct InherentTyOutsideNewAliasNote {
#[primary_span]
pub span: Span,
pub ty_name: String,
pub alias_ty_name: String,
}
#[derive(Diagnostic)]
#[diag("cannot define inherent `impl` for primitive types outside of `core`", code = E0390)]
#[help("consider moving this inherent impl into `core` if possible")]
pub(crate) struct InherentTyOutsidePrimitive {
#[primary_span]
pub span: Span,
#[help("alternatively add `#[rustc_allow_incoherent_impl]` to the relevant impl items")]
pub help_span: Span,
}
#[derive(Diagnostic)]
#[diag("cannot define inherent `impl` for primitive types", code = E0390)]
#[help("consider using an extension trait instead")]
pub(crate) struct InherentPrimitiveTy<'a> {
#[primary_span]
pub span: Span,
#[subdiagnostic]
pub note: Option<InherentPrimitiveTyNote<'a>>,
}
#[derive(Subdiagnostic)]
#[note(
"you could also try moving the reference to uses of `{$subty}` (such as `self`) within the implementation"
)]
pub(crate) struct InherentPrimitiveTyNote<'a> {
pub subty: Ty<'a>,
}
#[derive(Diagnostic)]
#[diag("cannot define inherent `impl` for a dyn auto trait", code = E0785)]
#[note("define and implement a new trait or type instead")]
pub(crate) struct InherentDyn {
#[primary_span]
#[label("impl requires at least one non-auto trait")]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("no nominal type found for inherent implementation", code = E0118)]
#[note("either implement a trait on it or create a newtype to wrap it instead")]
pub(crate) struct InherentNominal {
#[primary_span]
#[label("impl requires a nominal type")]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("the trait `DispatchFromDyn` may only be implemented for structs containing the field being coerced, ZST fields with 1 byte alignment that don't mention type/const generics, and nothing else", code = E0378)]
#[note("extra field `{$name}` of type `{$ty}` is not allowed")]
pub(crate) struct DispatchFromDynZST<'a> {
#[primary_span]
pub span: Span,
pub name: Ident,
pub ty: Ty<'a>,
}
#[derive(Diagnostic)]
#[diag("implementing `{$trait_name}` requires a field to be coerced", code = E0374)]
pub(crate) struct CoerceNoField {
#[primary_span]
pub span: Span,
pub trait_name: &'static str,
#[note("expected a single field to be coerced, none found")]
pub note: bool,
}
#[derive(Diagnostic)]
#[diag("implementing `{$trait_name}` does not allow multiple fields to be coerced", code = E0375)]
pub(crate) struct CoerceMulti {
pub trait_name: &'static str,
#[primary_span]
pub span: Span,
pub number: usize,
#[note(
"the trait `{$trait_name}` may only be implemented when a single field is being coerced"
)]
pub fields: MultiSpan,
}
#[derive(Diagnostic)]
#[diag(
"implementing `{$trait_name}` requires that a single lifetime parameter is passed between source and target"
)]
pub(crate) struct CoerceSharedNotSingleLifetimeParam {
#[primary_span]
pub span: Span,
pub trait_name: &'static str,
}
#[derive(Diagnostic)]
#[diag(
"implementing `{$trait_name}` requires exactly one lifetime argument in the reborrowed type"
)]
pub(crate) struct CoerceSharedMulti {
#[primary_span]
pub span: Span,
pub trait_name: &'static str,
}
#[derive(Diagnostic)]
#[diag(
"implementing `{$trait_name}` requires source and target to use the same reborrow lifetime \
argument"
)]
pub(crate) struct CoerceSharedLifetimeMismatch {
#[primary_span]
pub span: Span,
#[label("source reborrow lifetime")]
pub source_lifetime_span: Option<Span>,
#[label("target reborrow lifetime")]
pub target_lifetime_span: Option<Span>,
pub trait_name: &'static str,
}
#[derive(Diagnostic)]
#[diag(
"implementing `{$trait_name}` requires corresponding fields to match, \
be reborrowable with `CoerceShared`, or coerce a mutable reference field \
to a shared reference field"
)]
pub(crate) struct CoerceSharedFieldMismatch<'tcx> {
#[primary_span]
#[label("target field `{$target_name}` has type `{$target_ty}`")]
pub span: Span,
#[label("source field `{$source_name}` has type `{$source_ty}`")]
pub source_span: Span,
#[label("required by this `CoerceShared` implementation")]
pub impl_span: Span,
pub source_name: Symbol,
pub source_ty: Ty<'tcx>,
pub target_name: Symbol,
pub target_ty: Ty<'tcx>,
pub trait_name: &'static str,
}
#[derive(Diagnostic)]
#[diag(
"implementing `{$trait_name}` requires every target field to have a corresponding source field"
)]
pub(crate) struct CoerceSharedMissingField {
#[primary_span]
#[label("target field `{$field_name}` has no corresponding source field")]
pub span: Span,
#[label("source type `{$source_ty_name}` does not contain field `{$field_name}`")]
pub source_ty_span: Span,
pub trait_name: &'static str,
pub source_ty_name: Symbol,
pub field_name: Symbol,
}
#[derive(Diagnostic)]
#[diag(
"implementing `{$trait_name}` requires source fields omitted from the target to be `Copy` or \
`Reborrow`"
)]
pub(crate) struct CoerceSharedOmittedSourceFieldNotCopyOrReborrow<'tcx> {
#[primary_span]
#[label("source field `{$field_name}` has type `{$field_ty}`")]
pub span: Span,
#[label("required by this `CoerceShared` implementation")]
pub impl_span: Span,
pub trait_name: &'static str,
pub field_name: Symbol,
pub field_ty: Ty<'tcx>,
}
#[derive(Diagnostic)]
#[diag(
"implementing `{$trait_name}` requires source and target structs to use the same field style"
)]
pub(crate) struct CoerceSharedFieldStyleMismatch {
#[primary_span]
pub span: Span,
pub trait_name: &'static str,
}
#[derive(Diagnostic)]
#[diag(
"implementing `{$trait_name}` requires all {$role} type fields to be accessible from the impl"
)]
pub(crate) struct CoerceSharedInaccessibleField {
#[primary_span]
pub span: Span,
#[label("{$role} type `{$type_name}` has inaccessible reborrow data fields")]
pub type_span: Span,
pub trait_name: &'static str,
pub role: &'static str,
pub type_name: Symbol,
}
#[derive(Diagnostic)]
#[diag(
"implementing `{$trait_name}` currently requires source and target to have at most one \
non-ZST reborrow data field"
)]
#[note(
"this is a temporary restriction until `CoerceShared` lowering supports non-trivially \
memcpy-compatible field layouts"
)]
pub(crate) struct CoerceSharedMultipleNonZstFields {
#[primary_span]
#[label("in this `CoerceShared` implementation")]
pub span: Span,
#[label("source type has {$source_count} non-ZST reborrow data fields")]
pub source_ty_span: Span,
#[label("target type has {$target_count} non-ZST reborrow data fields")]
pub target_ty_span: Span,
pub trait_name: &'static str,
pub source_count: usize,
pub target_count: usize,
}
#[derive(Diagnostic)]
#[diag("the trait `{$trait_name}` may only be implemented for a coercion between structures", code = E0377)]
pub(crate) struct CoerceUnsizedNonStruct {
#[primary_span]
pub span: Span,
pub trait_name: &'static str,
}
#[derive(Diagnostic)]
#[diag("only pattern types with the same pattern can be coerced between each other")]
pub(crate) struct CoerceSamePatKind {
#[primary_span]
pub span: Span,
pub trait_name: &'static str,
pub pat_a: String,
pub pat_b: String,
}
#[derive(Diagnostic)]
#[diag("the trait `{$trait_name}` may only be implemented for a coercion between structures", code = E0377)]
pub(crate) struct CoerceSameStruct {
#[primary_span]
pub span: Span,
pub trait_name: &'static str,
#[note(
"expected coercion between the same definition; expected `{$source_path}`, found `{$target_path}`"
)]
pub note: bool,
pub source_path: String,
pub target_path: String,
}
#[derive(Diagnostic)]
#[diag(
"for `{$ty}` to have a valid implementation of `{$trait_name}`, it must be possible to coerce the field of type `{$field_ty}`"
)]
pub(crate) struct CoerceFieldValidity<'tcx> {
#[primary_span]
pub span: Span,
pub ty: Ty<'tcx>,
pub trait_name: &'static str,
#[label(
"`{$field_ty}` must be a pointer, reference, or smart pointer that is allowed to be unsized"
)]
pub field_span: Span,
pub field_ty: Ty<'tcx>,
}
#[derive(Diagnostic)]
#[diag("the trait `{$trait_name}` cannot be implemented for this type", code = E0204)]
pub(crate) struct TraitCannotImplForTy {
#[primary_span]
pub span: Span,
pub trait_name: String,
#[label("this field does not implement `{$trait_name}`")]
pub label_spans: Vec<Span>,
#[subdiagnostic]
pub notes: Vec<ImplForTyRequires>,
}
#[derive(Subdiagnostic)]
#[note("the `{$trait_name}` impl for `{$ty}` requires that `{$error_predicate}`")]
pub(crate) struct ImplForTyRequires {
#[primary_span]
pub span: MultiSpan,
pub error_predicate: String,
pub trait_name: String,
pub ty: String,
}
#[derive(Diagnostic)]
#[diag("traits with a default impl, like `{$traits}`, cannot be implemented for {$problematic_kind} `{$self_ty}`", code = E0321)]
#[note(
"a trait object implements `{$traits}` if and only if `{$traits}` is one of the trait object's trait bounds"
)]
pub(crate) struct TraitsWithDefaultImpl<'a> {
#[primary_span]
pub span: Span,
pub traits: String,
pub problematic_kind: &'a str,
pub self_ty: Ty<'a>,
}
#[derive(Diagnostic)]
#[diag("cross-crate traits with a default impl, like `{$traits}`, can only be implemented for a struct/enum type, not `{$self_ty}`", code = E0321)]
pub(crate) struct CrossCrateTraits<'a> {
#[primary_span]
#[label("can't implement cross-crate trait with a default impl for non-struct/enum type")]
pub span: Span,
pub traits: String,
pub self_ty: Ty<'a>,
}
#[derive(Diagnostic)]
#[diag("cross-crate traits with a default impl, like `{$traits}`, can only be implemented for a struct/enum type defined in the current crate", code = E0321)]
pub(crate) struct CrossCrateTraitsDefined {
#[primary_span]
#[label("can't implement cross-crate trait for type in another crate")]
pub span: Span,
pub traits: String,
}
#[derive(Diagnostic)]
#[diag("no variant named `{$ident}` found for enum `{$ty}`", code = E0599)]
pub struct NoVariantNamed<'tcx> {
#[primary_span]
pub span: Span,
pub ident: Ident,
pub ty: Ty<'tcx>,
}
#[derive(Diagnostic)]
#[diag("no field `{$field}` on type `{$ty}`", code = E0609)]
pub struct NoFieldOnType<'tcx> {
#[primary_span]
pub span: Span,
pub ty: Ty<'tcx>,
pub field: Ident,
}
#[derive(Diagnostic)]
pub(crate) enum OnlyCurrentTraits {
#[diag("only traits defined in the current crate can be implemented for types defined outside of the crate", code = E0117)]
Outside {
#[primary_span]
span: Span,
#[note("impl doesn't have any local type before any uncovered type parameters")]
#[note(
"for more information see https://doc.rust-lang.org/reference/items/implementations.html#orphan-rules"
)]
#[note("define and implement a trait or new type instead")]
note: (),
},
#[diag("only traits defined in the current crate can be implemented for primitive types", code = E0117)]
Primitive {
#[primary_span]
span: Span,
#[note("impl doesn't have any local type before any uncovered type parameters")]
#[note(
"for more information see https://doc.rust-lang.org/reference/items/implementations.html#orphan-rules"
)]
#[note("define and implement a trait or new type instead")]
note: (),
},
#[diag("only traits defined in the current crate can be implemented for arbitrary types", code = E0117)]
Arbitrary {
#[primary_span]
span: Span,
#[note("impl doesn't have any local type before any uncovered type parameters")]
#[note(
"for more information see https://doc.rust-lang.org/reference/items/implementations.html#orphan-rules"
)]
#[note("define and implement a trait or new type instead")]
note: (),
},
}
#[derive(Subdiagnostic)]
#[label(
"type alias impl trait is treated as if it were foreign, because its hidden type could be from a foreign crate"
)]
pub(crate) struct OnlyCurrentTraitsOpaque {
#[primary_span]
pub span: Span,
}
#[derive(Subdiagnostic)]
#[label("this is not defined in the current crate because this is a foreign trait")]
pub(crate) struct OnlyCurrentTraitsForeign {
#[primary_span]
pub span: Span,
}
#[derive(Subdiagnostic)]
#[label("this is not defined in the current crate because {$name} are always foreign")]
pub(crate) struct OnlyCurrentTraitsName<'a> {
#[primary_span]
pub span: Span,
pub name: &'a str,
}
#[derive(Subdiagnostic)]
#[label("`{$pointer}` is not defined in the current crate because raw pointers are always foreign")]
pub(crate) struct OnlyCurrentTraitsPointer<'a> {
#[primary_span]
pub span: Span,
pub pointer: Ty<'a>,
}
#[derive(Subdiagnostic)]
#[label("`{$ty}` is not defined in the current crate")]
pub(crate) struct OnlyCurrentTraitsTy<'a> {
#[primary_span]
pub span: Span,
pub ty: Ty<'a>,
}
#[derive(Subdiagnostic)]
#[label("`{$name}` is not defined in the current crate")]
pub(crate) struct OnlyCurrentTraitsAdt {
#[primary_span]
pub span: Span,
pub name: String,
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(
"consider introducing a new wrapper type",
applicability = "maybe-incorrect"
)]
pub(crate) struct OnlyCurrentTraitsPointerSugg<'a> {
#[suggestion_part(code = "WrapperType")]
pub wrapper_span: Span,
#[suggestion_part(code = "struct WrapperType(*{mut_key}{ptr_ty});\n\n")]
pub(crate) struct_span: Span,
pub mut_key: &'a str,
pub ptr_ty: Ty<'a>,
}
#[derive(Diagnostic)]
#[diag("{$descr}")]
pub(crate) struct UnsupportedDelegation<'a> {
#[primary_span]
pub span: Span,
pub descr: &'a str,
#[label("callee defined here")]
pub callee_span: Span,
}
#[derive(Diagnostic)]
#[diag("inferred lifetimes are not allowed in delegations as we need to inherit signature")]
pub(crate) struct ElidedLifetimesAreNotAllowedInDelegations {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("method should be `async` or return a future, but it is synchronous")]
pub(crate) struct MethodShouldReturnFuture {
#[primary_span]
pub span: Span,
pub method_name: Ident,
#[note("this method is `async` so it expects a future to be returned")]
pub trait_item_span: Option<Span>,
}
#[derive(Diagnostic)]
#[diag("{$param_def_kind} `{$param_name}` is never used")]
pub(crate) struct UnusedGenericParameter {
#[primary_span]
#[label("unused {$param_def_kind}")]
pub span: Span,
pub param_name: Ident,
pub param_def_kind: &'static str,
#[label("`{$param_name}` is named here, but is likely unused in the containing type")]
pub usage_spans: Vec<Span>,
#[subdiagnostic]
pub help: UnusedGenericParameterHelp,
#[help(
"if you intended `{$param_name}` to be a const parameter, use `const {$param_name}: /* Type */` instead"
)]
pub const_param_help: bool,
}
#[derive(Diagnostic)]
#[diag("{$param_def_kind} `{$param_name}` is only used recursively")]
pub(crate) struct RecursiveGenericParameter {
#[primary_span]
pub spans: Vec<Span>,
#[label("{$param_def_kind} must be used non-recursively in the definition")]
pub param_span: Span,
pub param_name: Ident,
pub param_def_kind: &'static str,
#[subdiagnostic]
pub help: UnusedGenericParameterHelp,
#[note(
"all type parameters must be used in a non-recursive way in order to constrain their variance"
)]
pub note: (),
}
#[derive(Subdiagnostic)]
pub(crate) enum UnusedGenericParameterHelp {
#[help(
"consider removing `{$param_name}`, referring to it in a field, or using a marker such as `{$phantom_data}`"
)]
Adt { param_name: Ident, phantom_data: String },
#[help("consider removing `{$param_name}` or referring to it in a field")]
AdtNoPhantomData { param_name: Ident },
#[help("consider removing `{$param_name}` or referring to it in the body of the type alias")]
TyAlias { param_name: Ident },
}
#[derive(Diagnostic)]
#[diag(
"the {$param_def_kind} `{$param_name}` is not constrained by the impl trait, self type, or predicates"
)]
pub(crate) struct UnconstrainedGenericParameter {
#[primary_span]
#[label("unconstrained {$param_def_kind}")]
pub span: Span,
pub param_name: Ident,
pub param_def_kind: &'static str,
#[note("expressions using a const parameter must map each value to a distinct output value")]
pub const_param_note: bool,
#[note(
"proving the result of expressions other than the parameter are unique is not supported"
)]
pub const_param_note2: bool,
}
#[derive(Diagnostic)]
#[diag("`impl Trait` cannot capture {$bad_place}", code = E0657)]
pub(crate) struct OpaqueCapturesHigherRankedLifetime {
#[primary_span]
pub span: MultiSpan,
#[label("`impl Trait` implicitly captures all lifetimes in scope")]
pub label: Option<Span>,
#[note("lifetime declared here")]
pub decl_span: MultiSpan,
pub bad_place: &'static str,
}
#[derive(Subdiagnostic)]
pub(crate) enum InvalidReceiverTyHint {
#[note(
"`Weak` does not implement `Receiver` because it has methods that may shadow the referent; consider wrapping your `Weak` in a newtype wrapper for which you implement `Receiver`"
)]
Weak,
#[note(
"`NonNull` does not implement `Receiver` because it has methods that may shadow the referent; consider wrapping your `NonNull` in a newtype wrapper for which you implement `Receiver`"
)]
NonNull,
}
#[derive(Diagnostic)]
#[diag("invalid `self` parameter type: `{$receiver_ty}`", code = E0307)]
#[note("type of `self` must be `Self` or a type that dereferences to it")]
#[help(
"consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)"
)]
pub(crate) struct InvalidReceiverTyNoArbitrarySelfTypes<'tcx> {
#[primary_span]
pub span: Span,
pub receiver_ty: Ty<'tcx>,
}
#[derive(Diagnostic)]
#[diag("invalid `self` parameter type: `{$receiver_ty}`", code = E0307)]
#[note("type of `self` must be `Self` or some type implementing `Receiver`")]
#[help(
"consider changing to `self`, `&self`, `&mut self`, or a type implementing `Receiver` such as `self: Box<Self>`, `self: Rc<Self>`, or `self: Arc<Self>`"
)]
pub(crate) struct InvalidReceiverTy<'tcx> {
#[primary_span]
pub span: Span,
pub receiver_ty: Ty<'tcx>,
#[subdiagnostic]
pub hint: Option<InvalidReceiverTyHint>,
}
#[derive(Diagnostic)]
#[diag("invalid generic `self` parameter type: `{$receiver_ty}`", code = E0801)]
#[note("type of `self` must not be a method generic parameter type")]
#[help(
"use a concrete type such as `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)"
)]
pub(crate) struct InvalidGenericReceiverTy<'tcx> {
#[primary_span]
pub span: Span,
pub receiver_ty: Ty<'tcx>,
}
#[derive(Diagnostic)]
#[diag("arguments for `{$abi}` function too large to pass via registers", code = E0798)]
#[note(
"functions with the `{$abi}` ABI must pass all their arguments via the 4 32-bit argument registers"
)]
pub(crate) struct CmseInputsStackSpill {
#[primary_span]
#[label("does not fit in the available registers")]
pub spans: Vec<Span>,
pub abi: ExternAbi,
}
#[derive(Diagnostic)]
#[diag("return value of `{$abi}` function too large to pass via registers", code = E0798)]
#[note("functions with the `{$abi}` ABI must pass their result via the available return registers")]
#[note(
"the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size"
)]
pub(crate) struct CmseOutputStackSpill {
#[primary_span]
#[label("this type doesn't fit in the available registers")]
pub span: Span,
pub abi: ExternAbi,
}
#[derive(Diagnostic)]
#[diag("generics are not allowed in `extern {$abi}` signatures", code = E0798)]
pub(crate) struct CmseGeneric {
#[primary_span]
pub span: Span,
pub abi: ExternAbi,
}
#[derive(Diagnostic)]
#[diag("`impl Trait` is not allowed in `extern {$abi}` signatures", code = E0798)]
pub(crate) struct CmseImplTrait {
#[primary_span]
pub span: Span,
pub abi: ExternAbi,
}
#[derive(Diagnostic)]
#[diag("return type notation not allowed in this position yet")]
pub(crate) struct BadReturnTypeNotation {
#[primary_span]
pub span: Span,
#[suggestion(
"furthermore, argument types not allowed with return type notation",
applicability = "maybe-incorrect",
code = "(..)",
style = "verbose"
)]
pub suggestion: Option<Span>,
}
#[derive(Diagnostic)]
#[diag("trait item `{$item}` from `{$subtrait}` shadows identically named item from supertrait")]
pub(crate) struct SupertraitItemShadowing {
pub item: Symbol,
pub subtrait: Symbol,
#[subdiagnostic]
pub shadowee: SupertraitItemShadowee,
}
#[derive(Subdiagnostic)]
pub(crate) enum SupertraitItemShadowee {
#[note("item from `{$supertrait}` is shadowed by a subtrait item")]
Labeled {
#[primary_span]
span: Span,
supertrait: Symbol,
},
#[note("items from several supertraits are shadowed: {$traits}")]
Several {
#[primary_span]
spans: MultiSpan,
traits: DiagSymbolList,
},
}
#[derive(Diagnostic)]
#[diag("{$kind} binding in trait object type mentions `Self`")]
pub(crate) struct DynTraitAssocItemBindingMentionsSelf {
#[primary_span]
#[label("contains a mention of `Self`")]
pub span: Span,
pub kind: &'static str,
#[label("this binding mentions `Self`")]
pub binding: Span,
}
#[derive(Diagnostic)]
#[diag("`AsyncDrop` impl without `Drop` impl")]
#[help(
"type implementing `AsyncDrop` trait must also implement `Drop` trait to be used in sync context and unwinds"
)]
pub(crate) struct AsyncDropWithoutSyncDrop {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag("lifetime parameters or bounds of `{$ident}` do not match the declaration")]
pub(crate) struct LifetimesOrBoundsMismatchOnEii {
#[primary_span]
#[label("lifetimes do not match")]
pub span: Span,
#[label("lifetimes in impl do not match this signature")]
pub generics_span: Span,
#[label("this `where` clause might not match the one in the trait")]
pub where_span: Option<Span>,
#[label("this bound might be missing in the impl")]
pub bounds_span: Vec<Span>,
pub ident: Symbol,
}
#[derive(Diagnostic)]
#[diag("`{$impl_name}` cannot have generic parameters other than lifetimes")]
#[help("`#[{$eii_name}]` marks the implementation of an \"externally implementable item\"")]
pub(crate) struct EiiWithGenerics {
#[primary_span]
pub span: Span,
#[label("required by this attribute")]
pub attr: Span,
pub eii_name: Symbol,
pub impl_name: Symbol,
}
#[derive(Diagnostic)]
#[diag("explicit impls for the `Unpin` trait are not permitted for structurally pinned types")]
pub(crate) struct ImplUnpinForPinProjectedType {
#[primary_span]
#[label("impl of `Unpin` not allowed")]
pub span: Span,
#[help("`{$adt_name}` is structurally pinned because it is marked as `#[pin_v2]`")]
pub adt_span: Span,
pub adt_name: Symbol,
}
#[derive(Diagnostic)]
#[diag("`#[{$eii_name}]` must be used on a {$expected_kind}")]
pub(crate) struct EiiDefkindMismatch {
#[primary_span]
pub span: Span,
pub eii_name: Symbol,
pub expected_kind: &'static str,
}
#[derive(Diagnostic)]
#[diag("mutability does not match with the definition of`#[{$eii_name}]`")]
pub(crate) struct EiiDefkindMismatchStaticMutability {
#[primary_span]
pub span: Span,
pub eii_name: Symbol,
}
#[derive(Diagnostic)]
#[diag("safety does not match with the definition of`#[{$eii_name}]`")]
pub(crate) struct EiiDefkindMismatchStaticSafety {
#[primary_span]
pub span: Span,
pub eii_name: Symbol,
}
#[derive(Diagnostic)]
#[diag("conflicting implementations of `Drop::drop` and `Drop::pin_drop`")]
pub(crate) struct ConflictImplDropAndPinDrop {
#[primary_span]
pub span: Span,
#[label("`drop(&mut self)` implemented here")]
pub drop_span: Span,
#[label("`pin_drop(&pin mut self)` implemented here")]
pub pin_drop_span: Span,
}
#[derive(Diagnostic)]
#[diag("`{$adt_name}` must implement `pin_drop`")]
#[help("structurally pinned types must keep `Pin`'s safety contract")]
pub(crate) struct PinV2WithoutPinDrop {
#[primary_span]
#[suggestion(
"implement `pin_drop` instead",
code = "fn pin_drop(&pin mut self)",
applicability = "maybe-incorrect"
)]
pub span: Span,
#[note("`{$adt_name}` is marked `#[pin_v2]` here")]
#[suggestion(
"remove the `#[pin_v2]` attribute if it is not intended for structurally pinning",
code = "",
applicability = "maybe-incorrect"
)]
pub pin_v2_span: Option<Span>,
pub adt_name: Symbol,
}
#[derive(Diagnostic)]
#[diag("`#[pin_v2]` types may not have `#[repr(packed)]`")]
#[note(
"fields of a `#[repr(packed)]` type can be under-aligned, so a structurally pinned field may be moved to a properly aligned location, which `Pin` does not allow"
)]
pub(crate) struct PinV2OnPacked {
#[primary_span]
pub span: Span,
#[note("`{$adt_name}` is marked `#[pin_v2]` here")]
pub pin_v2_span: Option<Span>,
pub adt_name: Symbol,
}
pub(crate) struct UncoveredTyParam<'tcx> {
pub(crate) param: Ident,
pub(crate) local_ty: Option<Ty<'tcx>>,
}
impl<G: EmissionGuarantee> Diagnostic<'_, G> for UncoveredTyParam<'_> {
fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
let Self { param, local_ty } = self;
let mut diag = Diag::new(dcx, level, "")
.with_span(param.span)
.with_span_label(param.span, "uncovered type parameter");
if diag.is_error() {
diag.code(E0210);
}
let note = "\
implementing a foreign trait is only possible if \
at least one of the types for which it is implemented is local";
if let Some(local_ty) = local_ty {
diag.primary_message(format!(
"type parameter `{param}` must be covered by another type when \
it appears before the first local type (`{local_ty}`)"
));
diag.note(format!(
"{note},\nand no uncovered type parameters appear before that first local type"
));
diag.note(
"in this case, 'before' refers to the following order: \
`impl<..> ForeignTrait<T1, ..., Tn> for T0`,\n\
where `T0` is the first and `Tn` is the last",
);
} else {
diag.primary_message(format!(
"type parameter `{param}` must be used as an argument to \
some local type (e.g., `MyStruct<{param}>`)"
));
diag.note(note);
diag.note(
"only traits defined in the current crate can be implemented for a type parameter",
);
}
diag
}
}
#[derive(Diagnostic)]
#[diag("field `{$name}` is already part of the view")]
pub(crate) struct ViewedFieldIsAlreadyPartOfTheView {
#[primary_span]
pub span: Span,
pub name: Symbol,
#[label("field `{$name}` is declared as viewed here")]
pub previous_field_span: Span,
}
#[derive(Diagnostic)]
#[diag("only structs can be viewed")]
pub(crate) struct OnlyStructsCanBeViewedNonAdt<'tcx> {
#[primary_span]
#[label("type `{$ty}` cannot be viewed")]
pub span: Span,
pub ty: Ty<'tcx>,
}
#[derive(Diagnostic)]
#[diag("only structs can be viewed")]
pub(crate) struct OnlyStructsCanBeViewedAdt<'tcx> {
#[primary_span]
#[label("`{$ty}` is {$article} {$kind}, it cannot be viewed")]
pub span: Span,
pub ty: Ty<'tcx>,
pub article: &'static str,
pub kind: &'static str,
}
#[derive(Diagnostic)]
#[diag("the type of const parameters must not depend on other generic parameters", code = E0770)]
pub(crate) struct ParamInTyOfConstParam<'tcx> {
#[primary_span]
#[label("the type `{$ty}` must not depend on other generic parameter")]
pub(crate) span: Span,
pub(crate) ty: Ty<'tcx>,
}