compiler/rustc_hir_analysis/src/errors.rs

   1 //! Errors emitted by `hir_analysis`.
   2
   3 use rustc_errors::IntoDiagnostic;
   4 use rustc_errors::{error_code, Applicability, DiagnosticBuilder, ErrorGuaranteed, Handler};
   5 use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
   6 use rustc_middle::ty::Ty;
   7 use rustc_span::{symbol::Ident, Span, Symbol};
   8
   9 #[derive(Diagnostic)]
  10 #[diag(hir_analysis::field_multiply_specified_in_initializer, code = "E0062")]
  11 pub struct FieldMultiplySpecifiedInInitializer {
  12     #[primary_span]
  13     #[label]
  14     pub span: Span,
  15     #[label(hir_analysis::previous_use_label)]
  16     pub prev_span: Span,
  17     pub ident: Ident,
  18 }
  19
  20 #[derive(Diagnostic)]
  21 #[diag(hir_analysis::unrecognized_atomic_operation, code = "E0092")]
  22 pub struct UnrecognizedAtomicOperation<'a> {
  23     #[primary_span]
  24     #[label]
  25     pub span: Span,
  26     pub op: &'a str,
  27 }
  28
  29 #[derive(Diagnostic)]
  30 #[diag(hir_analysis::wrong_number_of_generic_arguments_to_intrinsic, code = "E0094")]
  31 pub struct WrongNumberOfGenericArgumentsToIntrinsic<'a> {
  32     #[primary_span]
  33     #[label]
  34     pub span: Span,
  35     pub found: usize,
  36     pub expected: usize,
  37     pub descr: &'a str,
  38 }
  39
  40 #[derive(Diagnostic)]
  41 #[diag(hir_analysis::unrecognized_intrinsic_function, code = "E0093")]
  42 pub struct UnrecognizedIntrinsicFunction {
  43     #[primary_span]
  44     #[label]
  45     pub span: Span,
  46     pub name: Symbol,
  47 }
  48
  49 #[derive(Diagnostic)]
  50 #[diag(hir_analysis::lifetimes_or_bounds_mismatch_on_trait, code = "E0195")]
  51 pub struct LifetimesOrBoundsMismatchOnTrait {
  52     #[primary_span]
  53     #[label]
  54     pub span: Span,
  55     #[label(hir_analysis::generics_label)]
  56     pub generics_span: Option<Span>,
  57     pub item_kind: &'static str,
  58     pub ident: Ident,
  59 }
  60
  61 #[derive(Diagnostic)]
  62 #[diag(hir_analysis::drop_impl_on_wrong_item, code = "E0120")]
  63 pub struct DropImplOnWrongItem {
  64     #[primary_span]
  65     #[label]
  66     pub span: Span,
  67 }
  68
  69 #[derive(Diagnostic)]
  70 #[diag(hir_analysis::field_already_declared, code = "E0124")]
  71 pub struct FieldAlreadyDeclared {
  72     pub field_name: Ident,
  73     #[primary_span]
  74     #[label]
  75     pub span: Span,
  76     #[label(hir_analysis::previous_decl_label)]
  77     pub prev_span: Span,
  78 }
  79
  80 #[derive(Diagnostic)]
  81 #[diag(hir_analysis::copy_impl_on_type_with_dtor, code = "E0184")]
  82 pub struct CopyImplOnTypeWithDtor {
  83     #[primary_span]
  84     #[label]
  85     pub span: Span,
  86 }
  87
  88 #[derive(Diagnostic)]
  89 #[diag(hir_analysis::multiple_relaxed_default_bounds, code = "E0203")]
  90 pub struct MultipleRelaxedDefaultBounds {
  91     #[primary_span]
  92     pub span: Span,
  93 }
  94
  95 #[derive(Diagnostic)]
  96 #[diag(hir_analysis::copy_impl_on_non_adt, code = "E0206")]
  97 pub struct CopyImplOnNonAdt {
  98     #[primary_span]
  99     #[label]
 100     pub span: Span,
 101 }
 102
 103 #[derive(Diagnostic)]
 104 #[diag(hir_analysis::trait_object_declared_with_no_traits, code = "E0224")]
 105 pub struct TraitObjectDeclaredWithNoTraits {
 106     #[primary_span]
 107     pub span: Span,
 108     #[label(hir_analysis::alias_span)]
 109     pub trait_alias_span: Option<Span>,
 110 }
 111
 112 #[derive(Diagnostic)]
 113 #[diag(hir_analysis::ambiguous_lifetime_bound, code = "E0227")]
 114 pub struct AmbiguousLifetimeBound {
 115     #[primary_span]
 116     pub span: Span,
 117 }
 118
 119 #[derive(Diagnostic)]
 120 #[diag(hir_analysis::assoc_type_binding_not_allowed, code = "E0229")]
 121 pub struct AssocTypeBindingNotAllowed {
 122     #[primary_span]
 123     #[label]
 124     pub span: Span,
 125 }
 126
 127 #[derive(Diagnostic)]
 128 #[diag(hir_analysis::functional_record_update_on_non_struct, code = "E0436")]
 129 pub struct FunctionalRecordUpdateOnNonStruct {
 130     #[primary_span]
 131     pub span: Span,
 132 }
 133
 134 #[derive(Diagnostic)]
 135 #[diag(hir_analysis::typeof_reserved_keyword_used, code = "E0516")]
 136 pub struct TypeofReservedKeywordUsed<'tcx> {
 137     pub ty: Ty<'tcx>,
 138     #[primary_span]
 139     #[label]
 140     pub span: Span,
 141     #[suggestion_verbose(code = "{ty}")]
 142     pub opt_sugg: Option<(Span, Applicability)>,
 143 }
 144
 145 #[derive(Diagnostic)]
 146 #[diag(hir_analysis::return_stmt_outside_of_fn_body, code = "E0572")]
 147 pub struct ReturnStmtOutsideOfFnBody {
 148     #[primary_span]
 149     pub span: Span,
 150     #[label(hir_analysis::encl_body_label)]
 151     pub encl_body_span: Option<Span>,
 152     #[label(hir_analysis::encl_fn_label)]
 153     pub encl_fn_span: Option<Span>,
 154 }
 155
 156 #[derive(Diagnostic)]
 157 #[diag(hir_analysis::yield_expr_outside_of_generator, code = "E0627")]
 158 pub struct YieldExprOutsideOfGenerator {
 159     #[primary_span]
 160     pub span: Span,
 161 }
 162
 163 #[derive(Diagnostic)]
 164 #[diag(hir_analysis::struct_expr_non_exhaustive, code = "E0639")]
 165 pub struct StructExprNonExhaustive {
 166     #[primary_span]
 167     pub span: Span,
 168     pub what: &'static str,
 169 }
 170
 171 #[derive(Diagnostic)]
 172 #[diag(hir_analysis::method_call_on_unknown_type, code = "E0699")]
 173 pub struct MethodCallOnUnknownType {
 174     #[primary_span]
 175     pub span: Span,
 176 }
 177
 178 #[derive(Diagnostic)]
 179 #[diag(hir_analysis::value_of_associated_struct_already_specified, code = "E0719")]
 180 pub struct ValueOfAssociatedStructAlreadySpecified {
 181     #[primary_span]
 182     #[label]
 183     pub span: Span,
 184     #[label(hir_analysis::previous_bound_label)]
 185     pub prev_span: Span,
 186     pub item_name: Ident,
 187     pub def_path: String,
 188 }
 189
 190 #[derive(Diagnostic)]
 191 #[diag(hir_analysis::address_of_temporary_taken, code = "E0745")]
 192 pub struct AddressOfTemporaryTaken {
 193     #[primary_span]
 194     #[label]
 195     pub span: Span,
 196 }
 197
 198 #[derive(Subdiagnostic)]
 199 pub enum AddReturnTypeSuggestion {
 200     #[suggestion(
 201         hir_analysis::add_return_type_add,
 202         code = "-> {found} ",
 203         applicability = "machine-applicable"
 204     )]
 205     Add {
 206         #[primary_span]
 207         span: Span,
 208         found: String,
 209     },
 210     #[suggestion(
 211         hir_analysis::add_return_type_missing_here,
 212         code = "-> _ ",
 213         applicability = "has-placeholders"
 214     )]
 215     MissingHere {
 216         #[primary_span]
 217         span: Span,
 218     },
 219 }
 220
 221 #[derive(Subdiagnostic)]
 222 pub enum ExpectedReturnTypeLabel<'tcx> {
 223     #[label(hir_analysis::expected_default_return_type)]
 224     Unit {
 225         #[primary_span]
 226         span: Span,
 227     },
 228     #[label(hir_analysis::expected_return_type)]
 229     Other {
 230         #[primary_span]
 231         span: Span,
 232         expected: Ty<'tcx>,
 233     },
 234 }
 235
 236 #[derive(Diagnostic)]
 237 #[diag(hir_analysis::unconstrained_opaque_type)]
 238 #[note]
 239 pub struct UnconstrainedOpaqueType {
 240     #[primary_span]
 241     pub span: Span,
 242     pub name: Symbol,
 243 }
 244
 245 pub struct MissingTypeParams {
 246     pub span: Span,
 247     pub def_span: Span,
 248     pub span_snippet: Option<String>,
 249     pub missing_type_params: Vec<Symbol>,
 250     pub empty_generic_args: bool,
 251 }
 252
 253 // Manual implementation of `IntoDiagnostic` to be able to call `span_to_snippet`.
 254 impl<'a> IntoDiagnostic<'a> for MissingTypeParams {
 255     fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
 256         let mut err = handler.struct_span_err_with_code(
 257             self.span,
 258             rustc_errors::fluent::hir_analysis::missing_type_params,
 259             error_code!(E0393),
 260         );
 261         err.set_arg("parameterCount", self.missing_type_params.len());
 262         err.set_arg(
 263             "parameters",
 264             self.missing_type_params
 265                 .iter()
 266                 .map(|n| format!("`{}`", n))
 267                 .collect::<Vec<_>>()
 268                 .join(", "),
 269         );
 270
 271         err.span_label(self.def_span, rustc_errors::fluent::hir_analysis::label);
 272
 273         let mut suggested = false;
 274         // Don't suggest setting the type params if there are some already: the order is
 275         // tricky to get right and the user will already know what the syntax is.
 276         if let Some(snippet) = self.span_snippet && self.empty_generic_args {
 277             if snippet.ends_with('>') {
 278                 // The user wrote `Trait<'a, T>` or similar. To provide an accurate suggestion
 279                 // we would have to preserve the right order. For now, as clearly the user is
 280                 // aware of the syntax, we do nothing.
 281             } else {
 282                 // The user wrote `Iterator`, so we don't have a type we can suggest, but at
 283                 // least we can clue them to the correct syntax `Iterator<Type>`.
 284                 err.span_suggestion(
 285                     self.span,
 286                     rustc_errors::fluent::hir_analysis::suggestion,
 287                     format!(
 288                         "{}<{}>",
 289                         snippet,
 290                         self.missing_type_params
 291                             .iter()
 292                             .map(|n| n.to_string())
 293                             .collect::<Vec<_>>()
 294                             .join(", ")
 295                     ),
 296                     Applicability::HasPlaceholders,
 297                 );
 298                 suggested = true;
 299             }
 300         }
 301         if !suggested {
 302             err.span_label(self.span, rustc_errors::fluent::hir_analysis::no_suggestion_label);
 303         }
 304
 305         err.note(rustc_errors::fluent::hir_analysis::note);
 306         err
 307     }
 308 }
 309
 310 #[derive(Diagnostic)]
 311 #[diag(hir_analysis::manual_implementation, code = "E0183")]
 312 #[help]
 313 pub struct ManualImplementation {
 314     #[primary_span]
 315     #[label]
 316     pub span: Span,
 317     pub trait_name: String,
 318 }
 319
 320 #[derive(Diagnostic)]
 321 #[diag(hir_analysis::substs_on_overridden_impl)]
 322 pub struct SubstsOnOverriddenImpl {
 323     #[primary_span]
 324     pub span: Span,
 325 }
 326
 327 #[derive(LintDiagnostic)]
 328 #[diag(hir_analysis::unused_extern_crate)]
 329 pub struct UnusedExternCrate {
 330     #[suggestion(applicability = "machine-applicable", code = "")]
 331     pub span: Span,
 332 }
 333
 334 #[derive(LintDiagnostic)]
 335 #[diag(hir_analysis::extern_crate_not_idiomatic)]
 336 pub struct ExternCrateNotIdiomatic {
 337     #[suggestion_short(applicability = "machine-applicable", code = "{suggestion_code}")]
 338     pub span: Span,
 339     pub msg_code: String,
 340     pub suggestion_code: String,
 341 }
 342
 343 #[derive(Diagnostic)]
 344 #[diag(hir_analysis::expected_used_symbol)]
 345 pub struct ExpectedUsedSymbol {
 346     #[primary_span]
 347     pub span: Span,
 348 }
 349
 350 #[derive(Diagnostic)]
 351 #[diag(hir_analysis::missing_parentheses_in_range, code = "E0689")]
 352 pub struct MissingParentheseInRange {
 353     #[primary_span]
 354     #[label(hir_analysis::missing_parentheses_in_range)]
 355     pub span: Span,
 356     pub ty_str: String,
 357     pub method_name: String,
 358
 359     #[subdiagnostic]
 360     pub add_missing_parentheses: Option<AddMissingParenthesesInRange>,
 361 }
 362
 363 #[derive(Subdiagnostic)]
 364 #[multipart_suggestion_verbose(
 365     hir_analysis::add_missing_parentheses_in_range,
 366     applicability = "maybe-incorrect"
 367 )]
 368 pub struct AddMissingParenthesesInRange {
 369     pub func_name: String,
 370     #[suggestion_part(code = "(")]
 371     pub left: Span,
 372     #[suggestion_part(code = ")")]
 373     pub right: Span,
 374 }