compiler/rustc_expand/src/errors.rs

   1 use rustc_ast::ast;
   2 use rustc_macros::Diagnostic;
   3 use rustc_session::Limit;
   4 use rustc_span::edition::Edition;
   5 use rustc_span::symbol::{Ident, MacroRulesNormalizedIdent};
   6 use rustc_span::{Span, Symbol};
   7 use std::borrow::Cow;
   8
   9 #[derive(Diagnostic)]
  10 #[diag(expand_expr_repeat_no_syntax_vars)]
  11 pub(crate) struct NoSyntaxVarsExprRepeat {
  12     #[primary_span]
  13     pub span: Span,
  14 }
  15
  16 #[derive(Diagnostic)]
  17 #[diag(expand_must_repeat_once)]
  18 pub(crate) struct MustRepeatOnce {
  19     #[primary_span]
  20     pub span: Span,
  21 }
  22
  23 #[derive(Diagnostic)]
  24 #[diag(expand_count_repetition_misplaced)]
  25 pub(crate) struct CountRepetitionMisplaced {
  26     #[primary_span]
  27     pub span: Span,
  28 }
  29
  30 #[derive(Diagnostic)]
  31 #[diag(expand_meta_var_expr_unrecognized_var)]
  32 pub(crate) struct MetaVarExprUnrecognizedVar {
  33     #[primary_span]
  34     pub span: Span,
  35     pub key: MacroRulesNormalizedIdent,
  36 }
  37
  38 #[derive(Diagnostic)]
  39 #[diag(expand_var_still_repeating)]
  40 pub(crate) struct VarStillRepeating {
  41     #[primary_span]
  42     pub span: Span,
  43     pub ident: MacroRulesNormalizedIdent,
  44 }
  45
  46 #[derive(Diagnostic)]
  47 #[diag(expand_meta_var_dif_seq_matchers)]
  48 pub(crate) struct MetaVarsDifSeqMatchers {
  49     #[primary_span]
  50     pub span: Span,
  51     pub msg: String,
  52 }
  53
  54 #[derive(Diagnostic)]
  55 #[diag(expand_resolve_relative_path)]
  56 pub(crate) struct ResolveRelativePath {
  57     #[primary_span]
  58     pub span: Span,
  59     pub path: String,
  60 }
  61
  62 #[derive(Diagnostic)]
  63 #[diag(expand_macro_const_stability)]
  64 pub(crate) struct MacroConstStability {
  65     #[primary_span]
  66     #[label]
  67     pub span: Span,
  68     #[label(label2)]
  69     pub head_span: Span,
  70 }
  71
  72 #[derive(Diagnostic)]
  73 #[diag(expand_macro_body_stability)]
  74 pub(crate) struct MacroBodyStability {
  75     #[primary_span]
  76     #[label]
  77     pub span: Span,
  78     #[label(label2)]
  79     pub head_span: Span,
  80 }
  81
  82 #[derive(Diagnostic)]
  83 #[diag(expand_attr_no_arguments)]
  84 pub(crate) struct AttrNoArguments {
  85     #[primary_span]
  86     pub span: Span,
  87 }
  88
  89 #[derive(Diagnostic)]
  90 #[diag(expand_not_a_meta_item)]
  91 pub(crate) struct NotAMetaItem {
  92     #[primary_span]
  93     pub span: Span,
  94 }
  95
  96 #[derive(Diagnostic)]
  97 #[diag(expand_only_one_word)]
  98 pub(crate) struct OnlyOneWord {
  99     #[primary_span]
 100     pub span: Span,
 101 }
 102
 103 #[derive(Diagnostic)]
 104 #[diag(expand_cannot_be_name_of_macro)]
 105 pub(crate) struct CannotBeNameOfMacro<'a> {
 106     #[primary_span]
 107     pub span: Span,
 108     pub trait_ident: Ident,
 109     pub macro_type: &'a str,
 110 }
 111
 112 #[derive(Diagnostic)]
 113 #[diag(expand_arg_not_attributes)]
 114 pub(crate) struct ArgumentNotAttributes {
 115     #[primary_span]
 116     pub span: Span,
 117 }
 118
 119 #[derive(Diagnostic)]
 120 #[diag(expand_attributes_wrong_form)]
 121 pub(crate) struct AttributesWrongForm {
 122     #[primary_span]
 123     pub span: Span,
 124 }
 125
 126 #[derive(Diagnostic)]
 127 #[diag(expand_attribute_meta_item)]
 128 pub(crate) struct AttributeMetaItem {
 129     #[primary_span]
 130     pub span: Span,
 131 }
 132
 133 #[derive(Diagnostic)]
 134 #[diag(expand_attribute_single_word)]
 135 pub(crate) struct AttributeSingleWord {
 136     #[primary_span]
 137     pub span: Span,
 138 }
 139
 140 #[derive(Diagnostic)]
 141 #[diag(expand_helper_attribute_name_invalid)]
 142 pub(crate) struct HelperAttributeNameInvalid {
 143     #[primary_span]
 144     pub span: Span,
 145     pub name: Ident,
 146 }
 147
 148 #[derive(Diagnostic)]
 149 #[diag(expand_expected_comma_in_list)]
 150 pub(crate) struct ExpectedCommaInList {
 151     #[primary_span]
 152     pub span: Span,
 153 }
 154
 155 #[derive(Diagnostic)]
 156 #[diag(expand_only_one_argument)]
 157 pub(crate) struct OnlyOneArgument<'a> {
 158     #[primary_span]
 159     pub span: Span,
 160     pub name: &'a str,
 161 }
 162
 163 #[derive(Diagnostic)]
 164 #[diag(expand_takes_no_arguments)]
 165 pub(crate) struct TakesNoArguments<'a> {
 166     #[primary_span]
 167     pub span: Span,
 168     pub name: &'a str,
 169 }
 170
 171 #[derive(Diagnostic)]
 172 #[diag(expand_feature_included_in_edition, code = "E0705")]
 173 pub(crate) struct FeatureIncludedInEdition {
 174     #[primary_span]
 175     pub span: Span,
 176     pub feature: Symbol,
 177     pub edition: Edition,
 178 }
 179
 180 #[derive(Diagnostic)]
 181 #[diag(expand_feature_removed, code = "E0557")]
 182 pub(crate) struct FeatureRemoved<'a> {
 183     #[primary_span]
 184     #[label]
 185     pub span: Span,
 186     #[subdiagnostic]
 187     pub reason: Option<FeatureRemovedReason<'a>>,
 188 }
 189
 190 #[derive(Subdiagnostic)]
 191 #[note(reason)]
 192 pub(crate) struct FeatureRemovedReason<'a> {
 193     pub reason: &'a str,
 194 }
 195
 196 #[derive(Diagnostic)]
 197 #[diag(expand_feature_not_allowed, code = "E0725")]
 198 pub(crate) struct FeatureNotAllowed {
 199     #[primary_span]
 200     pub span: Span,
 201     pub name: Symbol,
 202 }
 203
 204 #[derive(Diagnostic)]
 205 #[diag(expand_recursion_limit_reached)]
 206 #[help]
 207 pub(crate) struct RecursionLimitReached<'a> {
 208     #[primary_span]
 209     pub span: Span,
 210     pub descr: String,
 211     pub suggested_limit: Limit,
 212     pub crate_name: &'a str,
 213 }
 214
 215 #[derive(Diagnostic)]
 216 #[diag(expand_malformed_feature_attribute, code = "E0556")]
 217 pub(crate) struct MalformedFeatureAttribute {
 218     #[primary_span]
 219     pub span: Span,
 220     #[subdiagnostic]
 221     pub help: MalformedFeatureAttributeHelp,
 222 }
 223
 224 #[derive(Subdiagnostic)]
 225 pub(crate) enum MalformedFeatureAttributeHelp {
 226     #[label(expected)]
 227     Label {
 228         #[primary_span]
 229         span: Span,
 230     },
 231     #[suggestion(expected, code = "{suggestion}", applicability = "maybe-incorrect")]
 232     Suggestion {
 233         #[primary_span]
 234         span: Span,
 235         suggestion: Symbol,
 236     },
 237 }
 238
 239 #[derive(Diagnostic)]
 240 #[diag(expand_remove_expr_not_supported)]
 241 pub(crate) struct RemoveExprNotSupported {
 242     #[primary_span]
 243     pub span: Span,
 244 }
 245
 246 #[derive(Diagnostic)]
 247 pub(crate) enum InvalidCfg {
 248     #[diag(expand_invalid_cfg_no_parens)]
 249     NotFollowedByParens {
 250         #[primary_span]
 251         #[suggestion(
 252             expand_invalid_cfg_expected_syntax,
 253             code = "cfg(/* predicate */)",
 254             applicability = "has-placeholders"
 255         )]
 256         span: Span,
 257     },
 258     #[diag(expand_invalid_cfg_no_predicate)]
 259     NoPredicate {
 260         #[primary_span]
 261         #[suggestion(
 262             expand_invalid_cfg_expected_syntax,
 263             code = "cfg(/* predicate */)",
 264             applicability = "has-placeholders"
 265         )]
 266         span: Span,
 267     },
 268     #[diag(expand_invalid_cfg_multiple_predicates)]
 269     MultiplePredicates {
 270         #[primary_span]
 271         span: Span,
 272     },
 273     #[diag(expand_invalid_cfg_predicate_literal)]
 274     PredicateLiteral {
 275         #[primary_span]
 276         span: Span,
 277     },
 278 }
 279
 280 #[derive(Diagnostic)]
 281 #[diag(expand_wrong_fragment_kind)]
 282 pub(crate) struct WrongFragmentKind<'a> {
 283     #[primary_span]
 284     pub span: Span,
 285     pub kind: &'a str,
 286     pub name: &'a ast::Path,
 287 }
 288
 289 #[derive(Diagnostic)]
 290 #[diag(expand_unsupported_key_value)]
 291 pub(crate) struct UnsupportedKeyValue {
 292     #[primary_span]
 293     pub span: Span,
 294 }
 295
 296 #[derive(Diagnostic)]
 297 #[diag(expand_incomplete_parse)]
 298 #[note]
 299 pub(crate) struct IncompleteParse<'a> {
 300     #[primary_span]
 301     pub span: Span,
 302     pub token: Cow<'a, str>,
 303     #[label]
 304     pub label_span: Span,
 305     pub macro_path: &'a ast::Path,
 306     pub kind_name: &'a str,
 307
 308     #[suggestion(
 309         suggestion_add_semi,
 310         style = "verbose",
 311         code = ";",
 312         applicability = "maybe-incorrect"
 313     )]
 314     pub add_semicolon: Option<Span>,
 315 }
 316
 317 #[derive(Diagnostic)]
 318 #[diag(expand_remove_node_not_supported)]
 319 pub(crate) struct RemoveNodeNotSupported {
 320     #[primary_span]
 321     pub span: Span,
 322     pub descr: &'static str,
 323 }
 324
 325 #[derive(Diagnostic)]
 326 #[diag(expand_module_circular)]
 327 pub(crate) struct ModuleCircular {
 328     #[primary_span]
 329     pub span: Span,
 330     pub modules: String,
 331 }
 332
 333 #[derive(Diagnostic)]
 334 #[diag(expand_module_in_block)]
 335 pub(crate) struct ModuleInBlock {
 336     #[primary_span]
 337     pub span: Span,
 338     #[subdiagnostic]
 339     pub name: Option<ModuleInBlockName>,
 340 }
 341
 342 #[derive(Subdiagnostic)]
 343 #[note(note)]
 344 pub(crate) struct ModuleInBlockName {
 345     #[primary_span]
 346     pub span: Span,
 347     pub name: Ident,
 348 }
 349
 350 #[derive(Diagnostic)]
 351 #[diag(expand_module_file_not_found, code = "E0583")]
 352 #[help]
 353 pub(crate) struct ModuleFileNotFound {
 354     #[primary_span]
 355     pub span: Span,
 356     pub name: Ident,
 357     pub default_path: String,
 358     pub secondary_path: String,
 359 }
 360
 361 #[derive(Diagnostic)]
 362 #[diag(expand_module_multiple_candidates, code = "E0761")]
 363 #[help]
 364 pub(crate) struct ModuleMultipleCandidates {
 365     #[primary_span]
 366     pub span: Span,
 367     pub name: Ident,
 368     pub default_path: String,
 369     pub secondary_path: String,
 370 }
 371
 372 #[derive(Diagnostic)]
 373 #[diag(expand_trace_macro)]
 374 pub struct TraceMacro {
 375     #[primary_span]
 376     pub span: Span,
 377 }