compiler/rustc_ast_lowering/src/errors.rs

   1 use rustc_errors::{fluent, AddToDiagnostic, Applicability, Diagnostic, DiagnosticArgFromDisplay};
   2 use rustc_macros::{Diagnostic, Subdiagnostic};
   3 use rustc_span::{symbol::Ident, Span, Symbol};
   4
   5 #[derive(Diagnostic, Clone, Copy)]
   6 #[diag(ast_lowering::generic_type_with_parentheses, code = "E0214")]
   7 pub struct GenericTypeWithParentheses {
   8     #[primary_span]
   9     #[label]
  10     pub span: Span,
  11     #[subdiagnostic]
  12     pub sub: Option<UseAngleBrackets>,
  13 }
  14
  15 #[derive(Clone, Copy)]
  16 pub struct UseAngleBrackets {
  17     pub open_param: Span,
  18     pub close_param: Span,
  19 }
  20
  21 impl AddToDiagnostic for UseAngleBrackets {
  22     fn add_to_diagnostic(self, diag: &mut Diagnostic) {
  23         diag.multipart_suggestion(
  24             fluent::ast_lowering::use_angle_brackets,
  25             vec![(self.open_param, String::from("<")), (self.close_param, String::from(">"))],
  26             Applicability::MaybeIncorrect,
  27         );
  28     }
  29 }
  30
  31 #[derive(Diagnostic)]
  32 #[diag(ast_lowering::invalid_abi, code = "E0703")]
  33 #[note]
  34 pub struct InvalidAbi {
  35     #[primary_span]
  36     #[label]
  37     pub span: Span,
  38     pub abi: Symbol,
  39     pub command: String,
  40     #[subdiagnostic]
  41     pub suggestion: Option<InvalidAbiSuggestion>,
  42 }
  43
  44 #[derive(Subdiagnostic)]
  45 #[suggestion(
  46     ast_lowering::invalid_abi_suggestion,
  47     code = "{suggestion}",
  48     applicability = "maybe-incorrect"
  49 )]
  50 pub struct InvalidAbiSuggestion {
  51     #[primary_span]
  52     pub span: Span,
  53     pub suggestion: String,
  54 }
  55
  56 #[derive(Diagnostic, Clone, Copy)]
  57 #[diag(ast_lowering::assoc_ty_parentheses)]
  58 pub struct AssocTyParentheses {
  59     #[primary_span]
  60     pub span: Span,
  61     #[subdiagnostic]
  62     pub sub: AssocTyParenthesesSub,
  63 }
  64
  65 #[derive(Clone, Copy)]
  66 pub enum AssocTyParenthesesSub {
  67     Empty { parentheses_span: Span },
  68     NotEmpty { open_param: Span, close_param: Span },
  69 }
  70
  71 impl AddToDiagnostic for AssocTyParenthesesSub {
  72     fn add_to_diagnostic(self, diag: &mut Diagnostic) {
  73         match self {
  74             Self::Empty { parentheses_span } => diag.multipart_suggestion(
  75                 fluent::ast_lowering::remove_parentheses,
  76                 vec![(parentheses_span, String::new())],
  77                 Applicability::MaybeIncorrect,
  78             ),
  79             Self::NotEmpty { open_param, close_param } => diag.multipart_suggestion(
  80                 fluent::ast_lowering::use_angle_brackets,
  81                 vec![(open_param, String::from("<")), (close_param, String::from(">"))],
  82                 Applicability::MaybeIncorrect,
  83             ),
  84         };
  85     }
  86 }
  87
  88 #[derive(Diagnostic)]
  89 #[diag(ast_lowering::misplaced_impl_trait, code = "E0562")]
  90 pub struct MisplacedImplTrait<'a> {
  91     #[primary_span]
  92     pub span: Span,
  93     pub position: DiagnosticArgFromDisplay<'a>,
  94 }
  95
  96 #[derive(Diagnostic, Clone, Copy)]
  97 #[diag(ast_lowering::rustc_box_attribute_error)]
  98 pub struct RustcBoxAttributeError {
  99     #[primary_span]
 100     pub span: Span,
 101 }
 102
 103 #[derive(Diagnostic, Clone, Copy)]
 104 #[diag(ast_lowering::underscore_expr_lhs_assign)]
 105 pub struct UnderscoreExprLhsAssign {
 106     #[primary_span]
 107     #[label]
 108     pub span: Span,
 109 }
 110
 111 #[derive(Diagnostic, Clone, Copy)]
 112 #[diag(ast_lowering::base_expression_double_dot)]
 113 pub struct BaseExpressionDoubleDot {
 114     #[primary_span]
 115     #[label]
 116     pub span: Span,
 117 }
 118
 119 #[derive(Diagnostic, Clone, Copy)]
 120 #[diag(ast_lowering::await_only_in_async_fn_and_blocks, code = "E0728")]
 121 pub struct AwaitOnlyInAsyncFnAndBlocks {
 122     #[primary_span]
 123     #[label]
 124     pub dot_await_span: Span,
 125     #[label(ast_lowering::this_not_async)]
 126     pub item_span: Option<Span>,
 127 }
 128
 129 #[derive(Diagnostic, Clone, Copy)]
 130 #[diag(ast_lowering::generator_too_many_parameters, code = "E0628")]
 131 pub struct GeneratorTooManyParameters {
 132     #[primary_span]
 133     pub fn_decl_span: Span,
 134 }
 135
 136 #[derive(Diagnostic, Clone, Copy)]
 137 #[diag(ast_lowering::closure_cannot_be_static, code = "E0697")]
 138 pub struct ClosureCannotBeStatic {
 139     #[primary_span]
 140     pub fn_decl_span: Span,
 141 }
 142
 143 #[derive(Diagnostic, Clone, Copy)]
 144 #[help]
 145 #[diag(ast_lowering::async_non_move_closure_not_supported, code = "E0708")]
 146 pub struct AsyncNonMoveClosureNotSupported {
 147     #[primary_span]
 148     pub fn_decl_span: Span,
 149 }
 150
 151 #[derive(Diagnostic, Clone, Copy)]
 152 #[diag(ast_lowering::functional_record_update_destructuring_assignment)]
 153 pub struct FunctionalRecordUpdateDestructuringAssignemnt {
 154     #[primary_span]
 155     #[suggestion(code = "", applicability = "machine-applicable")]
 156     pub span: Span,
 157 }
 158
 159 #[derive(Diagnostic, Clone, Copy)]
 160 #[diag(ast_lowering::async_generators_not_supported, code = "E0727")]
 161 pub struct AsyncGeneratorsNotSupported {
 162     #[primary_span]
 163     pub span: Span,
 164 }
 165
 166 #[derive(Diagnostic, Clone, Copy)]
 167 #[diag(ast_lowering::inline_asm_unsupported_target, code = "E0472")]
 168 pub struct InlineAsmUnsupportedTarget {
 169     #[primary_span]
 170     pub span: Span,
 171 }
 172
 173 #[derive(Diagnostic, Clone, Copy)]
 174 #[diag(ast_lowering::att_syntax_only_x86)]
 175 pub struct AttSyntaxOnlyX86 {
 176     #[primary_span]
 177     pub span: Span,
 178 }
 179
 180 #[derive(Diagnostic, Clone, Copy)]
 181 #[diag(ast_lowering::abi_specified_multiple_times)]
 182 pub struct AbiSpecifiedMultipleTimes {
 183     #[primary_span]
 184     pub abi_span: Span,
 185     pub prev_name: Symbol,
 186     #[label]
 187     pub prev_span: Span,
 188     #[note]
 189     pub equivalent: Option<()>,
 190 }
 191
 192 #[derive(Diagnostic, Clone, Copy)]
 193 #[diag(ast_lowering::clobber_abi_not_supported)]
 194 pub struct ClobberAbiNotSupported {
 195     #[primary_span]
 196     pub abi_span: Span,
 197 }
 198
 199 #[derive(Diagnostic)]
 200 #[note]
 201 #[diag(ast_lowering::invalid_abi_clobber_abi)]
 202 pub struct InvalidAbiClobberAbi {
 203     #[primary_span]
 204     pub abi_span: Span,
 205     pub supported_abis: String,
 206 }
 207
 208 #[derive(Diagnostic, Clone, Copy)]
 209 #[diag(ast_lowering::invalid_register)]
 210 pub struct InvalidRegister<'a> {
 211     #[primary_span]
 212     pub op_span: Span,
 213     pub reg: Symbol,
 214     pub error: &'a str,
 215 }
 216
 217 #[derive(Diagnostic, Clone, Copy)]
 218 #[diag(ast_lowering::invalid_register_class)]
 219 pub struct InvalidRegisterClass<'a> {
 220     #[primary_span]
 221     pub op_span: Span,
 222     pub reg_class: Symbol,
 223     pub error: &'a str,
 224 }
 225
 226 #[derive(Diagnostic)]
 227 #[diag(ast_lowering::invalid_asm_template_modifier_reg_class)]
 228 pub struct InvalidAsmTemplateModifierRegClass {
 229     #[primary_span]
 230     #[label(ast_lowering::template_modifier)]
 231     pub placeholder_span: Span,
 232     #[label(ast_lowering::argument)]
 233     pub op_span: Span,
 234     #[subdiagnostic]
 235     pub sub: InvalidAsmTemplateModifierRegClassSub,
 236 }
 237
 238 #[derive(Subdiagnostic)]
 239 pub enum InvalidAsmTemplateModifierRegClassSub {
 240     #[note(ast_lowering::support_modifiers)]
 241     SupportModifier { class_name: Symbol, modifiers: String },
 242     #[note(ast_lowering::does_not_support_modifiers)]
 243     DoesNotSupportModifier { class_name: Symbol },
 244 }
 245
 246 #[derive(Diagnostic, Clone, Copy)]
 247 #[diag(ast_lowering::invalid_asm_template_modifier_const)]
 248 pub struct InvalidAsmTemplateModifierConst {
 249     #[primary_span]
 250     #[label(ast_lowering::template_modifier)]
 251     pub placeholder_span: Span,
 252     #[label(ast_lowering::argument)]
 253     pub op_span: Span,
 254 }
 255
 256 #[derive(Diagnostic, Clone, Copy)]
 257 #[diag(ast_lowering::invalid_asm_template_modifier_sym)]
 258 pub struct InvalidAsmTemplateModifierSym {
 259     #[primary_span]
 260     #[label(ast_lowering::template_modifier)]
 261     pub placeholder_span: Span,
 262     #[label(ast_lowering::argument)]
 263     pub op_span: Span,
 264 }
 265
 266 #[derive(Diagnostic, Clone, Copy)]
 267 #[diag(ast_lowering::register_class_only_clobber)]
 268 pub struct RegisterClassOnlyClobber {
 269     #[primary_span]
 270     pub op_span: Span,
 271     pub reg_class_name: Symbol,
 272 }
 273
 274 #[derive(Diagnostic, Clone, Copy)]
 275 #[diag(ast_lowering::register_conflict)]
 276 pub struct RegisterConflict<'a> {
 277     #[primary_span]
 278     #[label(ast_lowering::register1)]
 279     pub op_span1: Span,
 280     #[label(ast_lowering::register2)]
 281     pub op_span2: Span,
 282     pub reg1_name: &'a str,
 283     pub reg2_name: &'a str,
 284     #[help]
 285     pub in_out: Option<Span>,
 286 }
 287
 288 #[derive(Diagnostic, Clone, Copy)]
 289 #[help]
 290 #[diag(ast_lowering::sub_tuple_binding)]
 291 pub struct SubTupleBinding<'a> {
 292     #[primary_span]
 293     #[label]
 294     #[suggestion_verbose(
 295         ast_lowering::sub_tuple_binding_suggestion,
 296         code = "..",
 297         applicability = "maybe-incorrect"
 298     )]
 299     pub span: Span,
 300     pub ident: Ident,
 301     pub ident_name: Symbol,
 302     pub ctx: &'a str,
 303 }
 304
 305 #[derive(Diagnostic, Clone, Copy)]
 306 #[diag(ast_lowering::extra_double_dot)]
 307 pub struct ExtraDoubleDot<'a> {
 308     #[primary_span]
 309     #[label]
 310     pub span: Span,
 311     #[label(ast_lowering::previously_used_here)]
 312     pub prev_span: Span,
 313     pub ctx: &'a str,
 314 }
 315
 316 #[derive(Diagnostic, Clone, Copy)]
 317 #[note]
 318 #[diag(ast_lowering::misplaced_double_dot)]
 319 pub struct MisplacedDoubleDot {
 320     #[primary_span]
 321     pub span: Span,
 322 }
 323
 324 #[derive(Diagnostic, Clone, Copy)]
 325 #[diag(ast_lowering::misplaced_relax_trait_bound)]
 326 pub struct MisplacedRelaxTraitBound {
 327     #[primary_span]
 328     pub span: Span,
 329 }
 330
 331 #[derive(Diagnostic, Clone, Copy)]
 332 #[diag(ast_lowering::not_supported_for_lifetime_binder_async_closure)]
 333 pub struct NotSupportedForLifetimeBinderAsyncClosure {
 334     #[primary_span]
 335     pub span: Span,
 336 }
 337
 338 #[derive(Diagnostic, Clone, Copy)]
 339 #[diag(ast_lowering::arbitrary_expression_in_pattern)]
 340 pub struct ArbitraryExpressionInPattern {
 341     #[primary_span]
 342     pub span: Span,
 343 }
 344
 345 #[derive(Diagnostic, Clone, Copy)]
 346 #[diag(ast_lowering::inclusive_range_with_no_end)]
 347 pub struct InclusiveRangeWithNoEnd {
 348     #[primary_span]
 349     pub span: Span,
 350 }
 351
 352 #[derive(Diagnostic, Clone, Copy)]
 353 #[diag(ast_lowering::trait_fn_async, code = "E0706")]
 354 #[note]
 355 #[note(ast_lowering::note2)]
 356 pub struct TraitFnAsync {
 357     #[primary_span]
 358     pub fn_span: Span,
 359     #[label]
 360     pub span: Span,
 361 }