nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-23 07:14:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #104120 - mejrs:diag, r=davidtwco

Browse Source 
Match and enforce crate and slug names

Some of these were in the wrong place or had a name that didn't match.
This commit is contained in:
bors 2022-11-21 18:36:26 +00:00
commit b7bc90fea3
26 changed files with 819 additions and 737 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
compiler/rustc_error_messages/locales/en-US/borrowck.ftl
View File

@ -24,9 +24,6 @@ borrowck_var_does_not_need_mut =
variable does not need to be mutable
.suggestion = remove this `mut`
borrowck_const_not_used_in_type_alias =
const parameter `{$ct}` is part of concrete type but not used in parameter list for the `impl Trait` type alias
borrowck_var_cannot_escape_closure =
captured variable cannot escape `FnMut` closure body
.note = `FnMut` closures only have access to their captured variables while they are executing...

40
compiler/rustc_error_messages/locales/en-US/hir_analysis.ftl
View File

@ -1,8 +1,3 @@
hir_analysis_field_multiply_specified_in_initializer =
field `{$ident}` specified more than once
.label = used more than once
.previous_use_label = first use of `{$ident}`
hir_analysis_unrecognized_atomic_operation =
unrecognized atomic operation function: `{$op}`
.label = unrecognized atomic operation
@ -54,44 +49,16 @@ hir_analysis_assoc_type_binding_not_allowed =
associated type bindings are not allowed here
.label = associated type not allowed here
hir_analysis_functional_record_update_on_non_struct =
functional record update syntax requires a struct
hir_analysis_typeof_reserved_keyword_used =
`typeof` is a reserved keyword but unimplemented
.suggestion = consider replacing `typeof(...)` with an actual type
.label = reserved keyword
hir_analysis_return_stmt_outside_of_fn_body =
return statement outside of function body
.encl_body_label = the return is part of this body...
.encl_fn_label = ...not the enclosing function body
hir_analysis_yield_expr_outside_of_generator =
yield expression outside of generator literal
hir_analysis_struct_expr_non_exhaustive =
cannot create non-exhaustive {$what} using struct expression
hir_analysis_method_call_on_unknown_type =
the type of this value must be known to call a method on a raw pointer on it
hir_analysis_value_of_associated_struct_already_specified =
the value of the associated type `{$item_name}` (from trait `{$def_path}`) is already specified
.label = re-bound here
.previous_bound_label = `{$item_name}` bound here first
hir_analysis_address_of_temporary_taken = cannot take address of a temporary
.label = temporary value
hir_analysis_add_return_type_add = try adding a return type
hir_analysis_add_return_type_missing_here = a return type might be missing here
hir_analysis_expected_default_return_type = expected `()` because of default return type
hir_analysis_expected_return_type = expected `{$expected}` because of return type
hir_analysis_unconstrained_opaque_type = unconstrained opaque type
.note = `{$name}` must be used in combination with a concrete type within the same {$what}
@ -134,10 +101,6 @@ hir_analysis_extern_crate_not_idiomatic =
hir_analysis_expected_used_symbol = expected `used`, `used(compiler)` or `used(linker)`
hir_analysis_missing_parentheses_in_range = can't call method `{$method_name}` on type `{$ty_str}`
hir_analysis_add_missing_parentheses_in_range = you must surround the range in parentheses to call its `{$func_name}` function
hir_analysis_const_impl_for_non_const_trait =
const `impl` for trait `{$trait_name}` which is not marked with `#[const_trait]`
.suggestion = mark `{$trait_name}` as const
@ -150,6 +113,3 @@ hir_analysis_const_bound_for_non_const_trait =
hir_analysis_self_in_impl_self =
`Self` is not valid in the self type of an impl block
.note = replace `Self` with a different type
hir_analysis_op_trait_generic_params =
`{$method_name}` must not have any generic parameters

40
compiler/rustc_error_messages/locales/en-US/hir_typeck.ftl
View File

@ -6,3 +6,43 @@ hir_typeck_fru_suggestion =
[NONE]{""}
*[other] {" "}from `{$expr}`
}, separate the last named field with a comma
hir_typeck_field_multiply_specified_in_initializer =
field `{$ident}` specified more than once
.label = used more than once
.previous_use_label = first use of `{$ident}`
hir_typeck_return_stmt_outside_of_fn_body =
return statement outside of function body
.encl_body_label = the return is part of this body...
.encl_fn_label = ...not the enclosing function body
hir_typeck_yield_expr_outside_of_generator =
yield expression outside of generator literal
hir_typeck_struct_expr_non_exhaustive =
cannot create non-exhaustive {$what} using struct expression
hir_typeck_method_call_on_unknown_type =
the type of this value must be known to call a method on a raw pointer on it
hir_typeck_functional_record_update_on_non_struct =
functional record update syntax requires a struct
hir_typeck_address_of_temporary_taken = cannot take address of a temporary
.label = temporary value
hir_typeck_add_return_type_add = try adding a return type
hir_typeck_add_return_type_missing_here = a return type might be missing here
hir_typeck_expected_default_return_type = expected `()` because of default return type
hir_typeck_expected_return_type = expected `{$expected}` because of return type
hir_typeck_missing_parentheses_in_range = can't call method `{$method_name}` on type `{$ty_str}`
hir_typeck_add_missing_parentheses_in_range = you must surround the range in parentheses to call its `{$func_name}` function
hir_typeck_op_trait_generic_params =
`{$method_name}` must not have any generic parameters

3
compiler/rustc_error_messages/locales/en-US/middle.ftl
View File

@ -31,3 +31,6 @@ middle_cannot_be_normalized =
middle_strict_coherence_needs_negative_coherence =
to use `strict_coherence` on this trait, the `with_negative_coherence` feature must be enabled
.label = due to this attribute
middle_const_not_used_in_type_alias =
const parameter `{$ct}` is part of concrete type but not used in parameter list for the `impl Trait` type alias

364
compiler/rustc_error_messages/locales/en-US/parse.ftl Normal file
View File

@ -0,0 +1,364 @@
parse_struct_literal_body_without_path =
struct literal body without path
.suggestion = you might have forgotten to add the struct literal inside the block
parse_maybe_report_ambiguous_plus =
ambiguous `+` in a type
.suggestion = use parentheses to disambiguate
parse_maybe_recover_from_bad_type_plus =
expected a path on the left-hand side of `+`, not `{$ty}`
parse_add_paren = try adding parentheses
parse_forgot_paren = perhaps you forgot parentheses?
parse_expect_path = expected a path
parse_maybe_recover_from_bad_qpath_stage_2 =
missing angle brackets in associated item path
.suggestion = try: `{$ty}`
parse_incorrect_semicolon =
expected item, found `;`
.suggestion = remove this semicolon
.help = {$name} declarations are not followed by a semicolon
parse_incorrect_use_of_await =
incorrect use of `await`
.parentheses_suggestion = `await` is not a method call, remove the parentheses
.postfix_suggestion = `await` is a postfix operation
parse_in_in_typo =
expected iterable, found keyword `in`
.suggestion = remove the duplicated `in`
parse_invalid_variable_declaration =
invalid variable declaration
parse_switch_mut_let_order =
switch the order of `mut` and `let`
parse_missing_let_before_mut = missing keyword
parse_use_let_not_auto = write `let` instead of `auto` to introduce a new variable
parse_use_let_not_var = write `let` instead of `var` to introduce a new variable
parse_invalid_comparison_operator = invalid comparison operator `{$invalid}`
.use_instead = `{$invalid}` is not a valid comparison operator, use `{$correct}`
.spaceship_operator_invalid = `<=>` is not a valid comparison operator, use `std::cmp::Ordering`
parse_invalid_logical_operator = `{$incorrect}` is not a logical operator
.note = unlike in e.g., Python and PHP, `&&` and `||` are used for logical operators
.use_amp_amp_for_conjunction = use `&&` to perform logical conjunction
.use_pipe_pipe_for_disjunction = use `||` to perform logical disjunction
parse_tilde_is_not_unary_operator = `~` cannot be used as a unary operator
.suggestion = use `!` to perform bitwise not
parse_unexpected_if_with_if = unexpected `if` in the condition expression
.suggestion = remove the `if`
parse_unexpected_token_after_not = unexpected {$negated_desc} after identifier
parse_unexpected_token_after_not_bitwise = use `!` to perform bitwise not
parse_unexpected_token_after_not_logical = use `!` to perform logical negation
parse_unexpected_token_after_not_default = use `!` to perform logical negation or bitwise not
parse_malformed_loop_label = malformed loop label
.suggestion = use the correct loop label format
parse_lifetime_in_borrow_expression = borrow expressions cannot be annotated with lifetimes
.suggestion = remove the lifetime annotation
.label = annotated with lifetime here
parse_field_expression_with_generic = field expressions cannot have generic arguments
parse_macro_invocation_with_qualified_path = macros cannot use qualified paths
parse_unexpected_token_after_label = expected `while`, `for`, `loop` or `{"{"}` after a label
.suggestion_remove_label = consider removing the label
.suggestion_enclose_in_block = consider enclosing expression in a block
parse_require_colon_after_labeled_expression = labeled expression must be followed by `:`
.note = labels are used before loops and blocks, allowing e.g., `break 'label` to them
.label = the label
.suggestion = add `:` after the label
parse_do_catch_syntax_removed = found removed `do catch` syntax
.note = following RFC #2388, the new non-placeholder syntax is `try`
.suggestion = replace with the new syntax
parse_float_literal_requires_integer_part = float literals must have an integer part
.suggestion = must have an integer part
parse_missing_semicolon_before_array = expected `;`, found `[`
.suggestion = consider adding `;` here
parse_invalid_block_macro_segment = cannot use a `block` macro fragment here
.label = the `block` fragment is within this context
parse_expect_dotdot_not_dotdotdot = expected `..`, found `...`
.suggestion = use `..` to fill in the rest of the fields
parse_if_expression_missing_then_block = this `if` expression is missing a block after the condition
.add_then_block = add a block here
.condition_possibly_unfinished = this binary operation is possibly unfinished
parse_if_expression_missing_condition = missing condition for `if` expression
.condition_label = expected condition here
.block_label = if this block is the condition of the `if` expression, then it must be followed by another block
parse_expected_expression_found_let = expected expression, found `let` statement
parse_expect_eq_instead_of_eqeq = expected `=`, found `==`
.suggestion = consider using `=` here
parse_expected_else_block = expected `{"{"}`, found {$first_tok}
.label = expected an `if` or a block after this `else`
.suggestion = add an `if` if this is the condition of a chained `else if` statement
parse_outer_attribute_not_allowed_on_if_else = outer attributes are not allowed on `if` and `else` branches
.branch_label = the attributes are attached to this branch
.ctx_label = the branch belongs to this `{$ctx}`
.suggestion = remove the attributes
parse_missing_in_in_for_loop = missing `in` in `for` loop
.use_in_not_of = try using `in` here instead
.add_in = try adding `in` here
parse_missing_comma_after_match_arm = expected `,` following `match` arm
.suggestion = missing a comma here to end this `match` arm
parse_catch_after_try = keyword `catch` cannot follow a `try` block
.help = try using `match` on the result of the `try` block instead
parse_comma_after_base_struct = cannot use a comma after the base struct
.note = the base struct must always be the last field
.suggestion = remove this comma
parse_eq_field_init = expected `:`, found `=`
.suggestion = replace equals symbol with a colon
parse_dotdotdot = unexpected token: `...`
.suggest_exclusive_range = use `..` for an exclusive range
.suggest_inclusive_range = or `..=` for an inclusive range
parse_left_arrow_operator = unexpected token: `<-`
.suggestion = if you meant to write a comparison against a negative value, add a space in between `<` and `-`
parse_remove_let = expected pattern, found `let`
.suggestion = remove the unnecessary `let` keyword
parse_use_eq_instead = unexpected `==`
.suggestion = try using `=` instead
parse_use_empty_block_not_semi = expected { "`{}`" }, found `;`
.suggestion = try using { "`{}`" } instead
parse_comparison_interpreted_as_generic =
`<` is interpreted as a start of generic arguments for `{$type}`, not a comparison
.label_args = interpreted as generic arguments
.label_comparison = not interpreted as comparison
.suggestion = try comparing the cast value
parse_shift_interpreted_as_generic =
`<<` is interpreted as a start of generic arguments for `{$type}`, not a shift
.label_args = interpreted as generic arguments
.label_comparison = not interpreted as shift
.suggestion = try shifting the cast value
parse_found_expr_would_be_stmt = expected expression, found `{$token}`
.label = expected expression
parse_leading_plus_not_supported = leading `+` is not supported
.label = unexpected `+`
.suggestion_remove_plus = try removing the `+`
parse_parentheses_with_struct_fields = invalid `struct` delimiters or `fn` call arguments
.suggestion_braces_for_struct = if `{$type}` is a struct, use braces as delimiters
.suggestion_no_fields_for_fn = if `{$type}` is a function, use the arguments directly
parse_labeled_loop_in_break = parentheses are required around this expression to avoid confusion with a labeled break expression
parse_sugg_wrap_expression_in_parentheses = wrap the expression in parentheses
parse_array_brackets_instead_of_braces = this is a block expression, not an array
.suggestion = to make an array, use square brackets instead of curly braces
parse_match_arm_body_without_braces = `match` arm body without braces
.label_statements = {$num_statements ->
[one] this statement is not surrounded by a body
*[other] these statements are not surrounded by a body
}
.label_arrow = while parsing the `match` arm starting here
.suggestion_add_braces = surround the {$num_statements ->
[one] statement
*[other] statements
} with a body
.suggestion_use_comma_not_semicolon = use a comma to end a `match` arm expression
parse_struct_literal_not_allowed_here = struct literals are not allowed here
.suggestion = surround the struct literal with parentheses
parse_invalid_interpolated_expression = invalid interpolated expression
parse_invalid_literal_suffix_on_tuple_index = suffixes on a tuple index are invalid
.label = invalid suffix `{$suffix}`
.tuple_exception_line_1 = `{$suffix}` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
.tuple_exception_line_2 = on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
.tuple_exception_line_3 = see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
parse_non_string_abi_literal = non-string ABI literal
.suggestion = specify the ABI with a string literal
parse_mismatched_closing_delimiter = mismatched closing delimiter: `{$delimiter}`
.label_unmatched = mismatched closing delimiter
.label_opening_candidate = closing delimiter possibly meant for this
.label_unclosed = unclosed delimiter
parse_incorrect_visibility_restriction = incorrect visibility restriction
.help = some possible visibility restrictions are:
`pub(crate)`: visible only on the current crate
`pub(super)`: visible only in the current module's parent
`pub(in path::to::module)`: visible only on the specified path
.suggestion = make this visible only to module `{$inner_str}` with `in`
parse_assignment_else_not_allowed = <assignment> ... else {"{"} ... {"}"} is not allowed
parse_expected_statement_after_outer_attr = expected statement after outer attribute
parse_doc_comment_does_not_document_anything = found a documentation comment that doesn't document anything
.help = doc comments must come before what they document, if a comment was intended use `//`
.suggestion = missing comma here
parse_const_let_mutually_exclusive = `const` and `let` are mutually exclusive
.suggestion = remove `let`
parse_invalid_expression_in_let_else = a `{$operator}` expression cannot be directly assigned in `let...else`
parse_invalid_curly_in_let_else = right curly brace `{"}"}` before `else` in a `let...else` statement not allowed
parse_compound_assignment_expression_in_let = can't reassign to an uninitialized variable
.suggestion = initialize the variable
.help = if you meant to overwrite, remove the `let` binding
parse_suffixed_literal_in_attribute = suffixed literals are not allowed in attributes
.help = instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
parse_invalid_meta_item = expected unsuffixed literal or identifier, found `{$token}`
parse_label_inner_attr_does_not_annotate_this = the inner attribute doesn't annotate this {$item}
parse_sugg_change_inner_attr_to_outer = to annotate the {$item}, change the attribute from inner to outer style
parse_inner_attr_not_permitted_after_outer_doc_comment = an inner attribute is not permitted following an outer doc comment
.label_attr = not permitted following an outer doc comment
.label_prev_doc_comment = previous doc comment
.label_does_not_annotate_this = {parse_label_inner_attr_does_not_annotate_this}
.sugg_change_inner_to_outer = {parse_sugg_change_inner_attr_to_outer}
parse_inner_attr_not_permitted_after_outer_attr = an inner attribute is not permitted following an outer attribute
.label_attr = not permitted following an outer attribute
.label_prev_attr = previous outer attribute
.label_does_not_annotate_this = {parse_label_inner_attr_does_not_annotate_this}
.sugg_change_inner_to_outer = {parse_sugg_change_inner_attr_to_outer}
parse_inner_attr_not_permitted = an inner attribute is not permitted in this context
.label_does_not_annotate_this = {parse_label_inner_attr_does_not_annotate_this}
.sugg_change_inner_to_outer = {parse_sugg_change_inner_attr_to_outer}
parse_inner_attr_explanation = inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
parse_outer_attr_explanation = outer attributes, like `#[test]`, annotate the item following them
parse_inner_doc_comment_not_permitted = expected outer doc comment
.note = inner doc comments like this (starting with `//!` or `/*!`) can only appear before items
.suggestion = you might have meant to write a regular comment
.label_does_not_annotate_this = the inner doc comment doesn't annotate this {$item}
.sugg_change_inner_to_outer = to annotate the {$item}, change the doc comment from inner to outer style
parse_expected_identifier_found_reserved_identifier_str = expected identifier, found reserved identifier `{$token}`
parse_expected_identifier_found_keyword_str = expected identifier, found keyword `{$token}`
parse_expected_identifier_found_reserved_keyword_str = expected identifier, found reserved keyword `{$token}`
parse_expected_identifier_found_doc_comment_str = expected identifier, found doc comment `{$token}`
parse_expected_identifier_found_str = expected identifier, found `{$token}`
parse_expected_identifier_found_reserved_identifier = expected identifier, found reserved identifier
parse_expected_identifier_found_keyword = expected identifier, found keyword
parse_expected_identifier_found_reserved_keyword = expected identifier, found reserved keyword
parse_expected_identifier_found_doc_comment = expected identifier, found doc comment
parse_expected_identifier = expected identifier
parse_sugg_escape_to_use_as_identifier = escape `{$ident_name}` to use it as an identifier
parse_sugg_remove_comma = remove this comma
parse_expected_semi_found_reserved_identifier_str = expected `;`, found reserved identifier `{$token}`
parse_expected_semi_found_keyword_str = expected `;`, found keyword `{$token}`
parse_expected_semi_found_reserved_keyword_str = expected `;`, found reserved keyword `{$token}`
parse_expected_semi_found_doc_comment_str = expected `;`, found doc comment `{$token}`
parse_expected_semi_found_str = expected `;`, found `{$token}`
parse_sugg_change_this_to_semi = change this to `;`
parse_sugg_add_semi = add `;` here
parse_label_unexpected_token = unexpected token
parse_unmatched_angle_brackets = {$num_extra_brackets ->
[one] unmatched angle bracket
*[other] unmatched angle brackets
}
.suggestion = {$num_extra_brackets ->
[one] remove extra angle bracket
*[other] remove extra angle brackets
}
parse_generic_parameters_without_angle_brackets = generic parameters without surrounding angle brackets
.suggestion = surround the type parameters with angle brackets
parse_comparison_operators_cannot_be_chained = comparison operators cannot be chained
.sugg_parentheses_for_function_args = or use `(...)` if you meant to specify fn arguments
.sugg_split_comparison = split the comparison into two
.sugg_parenthesize = parenthesize the comparison
parse_sugg_turbofish_syntax = use `::<...>` instead of `<...>` to specify lifetime, type, or const arguments
parse_question_mark_in_type = invalid `?` in type
.label = `?` is only allowed on expressions, not types
.suggestion = if you meant to express that the type might not contain a value, use the `Option` wrapper type
parse_unexpected_parentheses_in_for_head = unexpected parentheses surrounding `for` loop head
.suggestion = remove parentheses in `for` loop
parse_doc_comment_on_param_type = documentation comments cannot be applied to a function parameter's type
.label = doc comments are not allowed here
parse_attribute_on_param_type = attributes cannot be applied to a function parameter's type
.label = attributes are not allowed here
parse_pattern_method_param_without_body = patterns aren't allowed in methods without bodies
.suggestion = give this argument a name or use an underscore to ignore it
parse_self_param_not_first = unexpected `self` parameter in function
.label = must be the first parameter of an associated function
parse_const_generic_without_braces = expressions must be enclosed in braces to be used as const generic arguments
.suggestion = enclose the `const` expression in braces
parse_unexpected_const_param_declaration = unexpected `const` parameter declaration
.label = expected a `const` expression, not a parameter declaration
.suggestion = `const` parameters must be declared for the `impl`
parse_unexpected_const_in_generic_param = expected lifetime, type, or constant, found keyword `const`
.suggestion = the `const` keyword is only needed in the definition of the type
parse_async_move_order_incorrect = the order of `move` and `async` is incorrect
.suggestion = try switching the order
parse_double_colon_in_bound = expected `:` followed by trait or lifetime
.suggestion = use single colon
parse_fn_ptr_with_generics = function pointer types may not have generic parameters
.suggestion = consider moving the lifetime {$arity ->
[one] parameter
*[other] parameters
} to {$for_param_list_exists ->
[true] the
*[false] a
} `for` parameter list
parse_invalid_identifier_with_leading_number = expected identifier, found number literal
.label = identifiers cannot start with a number

392
compiler/rustc_error_messages/locales/en-US/parser.ftl
View File

@ -1,392 +0,0 @@
parser_struct_literal_body_without_path =
struct literal body without path
.suggestion = you might have forgotten to add the struct literal inside the block
parser_maybe_report_ambiguous_plus =
ambiguous `+` in a type
.suggestion = use parentheses to disambiguate
parser_maybe_recover_from_bad_type_plus =
expected a path on the left-hand side of `+`, not `{$ty}`
parser_add_paren = try adding parentheses
parser_forgot_paren = perhaps you forgot parentheses?
parser_expect_path = expected a path
parser_maybe_recover_from_bad_qpath_stage_2 =
missing angle brackets in associated item path
.suggestion = try: `{$ty}`
parser_incorrect_semicolon =
expected item, found `;`
.suggestion = remove this semicolon
.help = {$name} declarations are not followed by a semicolon
parser_incorrect_use_of_await =
incorrect use of `await`
.parentheses_suggestion = `await` is not a method call, remove the parentheses
.postfix_suggestion = `await` is a postfix operation
parser_in_in_typo =
expected iterable, found keyword `in`
.suggestion = remove the duplicated `in`
parser_invalid_variable_declaration =
invalid variable declaration
parser_switch_mut_let_order =
switch the order of `mut` and `let`
parser_missing_let_before_mut = missing keyword
parser_use_let_not_auto = write `let` instead of `auto` to introduce a new variable
parser_use_let_not_var = write `let` instead of `var` to introduce a new variable
parser_invalid_comparison_operator = invalid comparison operator `{$invalid}`
.use_instead = `{$invalid}` is not a valid comparison operator, use `{$correct}`
.spaceship_operator_invalid = `<=>` is not a valid comparison operator, use `std::cmp::Ordering`
parser_invalid_logical_operator = `{$incorrect}` is not a logical operator
.note = unlike in e.g., Python and PHP, `&&` and `||` are used for logical operators
.use_amp_amp_for_conjunction = use `&&` to perform logical conjunction
.use_pipe_pipe_for_disjunction = use `||` to perform logical disjunction
parser_tilde_is_not_unary_operator = `~` cannot be used as a unary operator
.suggestion = use `!` to perform bitwise not
parser_unexpected_if_with_if = unexpected `if` in the condition expression
.suggestion = remove the `if`
parser_unexpected_token_after_not = unexpected {$negated_desc} after identifier
parser_unexpected_token_after_not_bitwise = use `!` to perform bitwise not
parser_unexpected_token_after_not_logical = use `!` to perform logical negation
parser_unexpected_token_after_not_default = use `!` to perform logical negation or bitwise not
parser_malformed_loop_label = malformed loop label
.suggestion = use the correct loop label format
parser_lifetime_in_borrow_expression = borrow expressions cannot be annotated with lifetimes
.suggestion = remove the lifetime annotation
.label = annotated with lifetime here
parser_field_expression_with_generic = field expressions cannot have generic arguments
parser_macro_invocation_with_qualified_path = macros cannot use qualified paths
parser_unexpected_token_after_label = expected `while`, `for`, `loop` or `{"{"}` after a label
.suggestion_remove_label = consider removing the label
.suggestion_enclose_in_block = consider enclosing expression in a block
parser_require_colon_after_labeled_expression = labeled expression must be followed by `:`
.note = labels are used before loops and blocks, allowing e.g., `break 'label` to them
.label = the label
.suggestion = add `:` after the label
parser_do_catch_syntax_removed = found removed `do catch` syntax
.note = following RFC #2388, the new non-placeholder syntax is `try`
.suggestion = replace with the new syntax
parser_float_literal_requires_integer_part = float literals must have an integer part
.suggestion = must have an integer part
parser_invalid_int_literal_width = invalid width `{$width}` for integer literal
.help = valid widths are 8, 16, 32, 64 and 128
parser_invalid_num_literal_base_prefix = invalid base prefix for number literal
.note = base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase
.suggestion = try making the prefix lowercase
parser_invalid_num_literal_suffix = invalid suffix `{$suffix}` for number literal
.label = invalid suffix `{$suffix}`
.help = the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.)
parser_invalid_float_literal_width = invalid width `{$width}` for float literal
.help = valid widths are 32 and 64
parser_invalid_float_literal_suffix = invalid suffix `{$suffix}` for float literal
.label = invalid suffix `{$suffix}`
.help = valid suffixes are `f32` and `f64`
parser_int_literal_too_large = integer literal is too large
parser_missing_semicolon_before_array = expected `;`, found `[`
.suggestion = consider adding `;` here
parser_invalid_block_macro_segment = cannot use a `block` macro fragment here
.label = the `block` fragment is within this context
parser_expect_dotdot_not_dotdotdot = expected `..`, found `...`
.suggestion = use `..` to fill in the rest of the fields
parser_if_expression_missing_then_block = this `if` expression is missing a block after the condition
.add_then_block = add a block here
.condition_possibly_unfinished = this binary operation is possibly unfinished
parser_if_expression_missing_condition = missing condition for `if` expression
.condition_label = expected condition here
.block_label = if this block is the condition of the `if` expression, then it must be followed by another block
parser_expected_expression_found_let = expected expression, found `let` statement
parser_expect_eq_instead_of_eqeq = expected `=`, found `==`
.suggestion = consider using `=` here
parser_expected_else_block = expected `{"{"}`, found {$first_tok}
.label = expected an `if` or a block after this `else`
.suggestion = add an `if` if this is the condition of a chained `else if` statement
parser_outer_attribute_not_allowed_on_if_else = outer attributes are not allowed on `if` and `else` branches
.branch_label = the attributes are attached to this branch
.ctx_label = the branch belongs to this `{$ctx}`
.suggestion = remove the attributes
parser_missing_in_in_for_loop = missing `in` in `for` loop
.use_in_not_of = try using `in` here instead
.add_in = try adding `in` here
parser_missing_comma_after_match_arm = expected `,` following `match` arm
.suggestion = missing a comma here to end this `match` arm
parser_catch_after_try = keyword `catch` cannot follow a `try` block
.help = try using `match` on the result of the `try` block instead
parser_comma_after_base_struct = cannot use a comma after the base struct
.note = the base struct must always be the last field
.suggestion = remove this comma
parser_eq_field_init = expected `:`, found `=`
.suggestion = replace equals symbol with a colon
parser_dotdotdot = unexpected token: `...`
.suggest_exclusive_range = use `..` for an exclusive range
.suggest_inclusive_range = or `..=` for an inclusive range
parser_left_arrow_operator = unexpected token: `<-`
.suggestion = if you meant to write a comparison against a negative value, add a space in between `<` and `-`
parser_remove_let = expected pattern, found `let`
.suggestion = remove the unnecessary `let` keyword
parser_use_eq_instead = unexpected `==`
.suggestion = try using `=` instead
parser_use_empty_block_not_semi = expected { "`{}`" }, found `;`
.suggestion = try using { "`{}`" } instead
parser_comparison_interpreted_as_generic =
`<` is interpreted as a start of generic arguments for `{$type}`, not a comparison
.label_args = interpreted as generic arguments
.label_comparison = not interpreted as comparison
.suggestion = try comparing the cast value
parser_shift_interpreted_as_generic =
`<<` is interpreted as a start of generic arguments for `{$type}`, not a shift
.label_args = interpreted as generic arguments
.label_comparison = not interpreted as shift
.suggestion = try shifting the cast value
parser_found_expr_would_be_stmt = expected expression, found `{$token}`
.label = expected expression
parser_leading_plus_not_supported = leading `+` is not supported
.label = unexpected `+`
.suggestion_remove_plus = try removing the `+`
parser_parentheses_with_struct_fields = invalid `struct` delimiters or `fn` call arguments
.suggestion_braces_for_struct = if `{$type}` is a struct, use braces as delimiters
.suggestion_no_fields_for_fn = if `{$type}` is a function, use the arguments directly
parser_labeled_loop_in_break = parentheses are required around this expression to avoid confusion with a labeled break expression
parser_sugg_wrap_expression_in_parentheses = wrap the expression in parentheses
parser_array_brackets_instead_of_braces = this is a block expression, not an array
.suggestion = to make an array, use square brackets instead of curly braces
parser_match_arm_body_without_braces = `match` arm body without braces
.label_statements = {$num_statements ->
[one] this statement is not surrounded by a body
*[other] these statements are not surrounded by a body
}
.label_arrow = while parsing the `match` arm starting here
.suggestion_add_braces = surround the {$num_statements ->
[one] statement
*[other] statements
} with a body
.suggestion_use_comma_not_semicolon = use a comma to end a `match` arm expression
parser_struct_literal_not_allowed_here = struct literals are not allowed here
.suggestion = surround the struct literal with parentheses
parser_invalid_interpolated_expression = invalid interpolated expression
parser_hexadecimal_float_literal_not_supported = hexadecimal float literal is not supported
parser_octal_float_literal_not_supported = octal float literal is not supported
parser_binary_float_literal_not_supported = binary float literal is not supported
parser_not_supported = not supported
parser_invalid_literal_suffix = suffixes on {$kind} literals are invalid
.label = invalid suffix `{$suffix}`
parser_invalid_literal_suffix_on_tuple_index = suffixes on a tuple index are invalid
.label = invalid suffix `{$suffix}`
.tuple_exception_line_1 = `{$suffix}` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
.tuple_exception_line_2 = on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
.tuple_exception_line_3 = see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
parser_non_string_abi_literal = non-string ABI literal
.suggestion = specify the ABI with a string literal
parser_mismatched_closing_delimiter = mismatched closing delimiter: `{$delimiter}`
.label_unmatched = mismatched closing delimiter
.label_opening_candidate = closing delimiter possibly meant for this
.label_unclosed = unclosed delimiter
parser_incorrect_visibility_restriction = incorrect visibility restriction
.help = some possible visibility restrictions are:
`pub(crate)`: visible only on the current crate
`pub(super)`: visible only in the current module's parent
`pub(in path::to::module)`: visible only on the specified path
.suggestion = make this visible only to module `{$inner_str}` with `in`
parser_assignment_else_not_allowed = <assignment> ... else {"{"} ... {"}"} is not allowed
parser_expected_statement_after_outer_attr = expected statement after outer attribute
parser_doc_comment_does_not_document_anything = found a documentation comment that doesn't document anything
.help = doc comments must come before what they document, if a comment was intended use `//`
.suggestion = missing comma here
parser_const_let_mutually_exclusive = `const` and `let` are mutually exclusive
.suggestion = remove `let`
parser_invalid_expression_in_let_else = a `{$operator}` expression cannot be directly assigned in `let...else`
parser_invalid_curly_in_let_else = right curly brace `{"}"}` before `else` in a `let...else` statement not allowed
parser_compound_assignment_expression_in_let = can't reassign to an uninitialized variable
.suggestion = initialize the variable
.help = if you meant to overwrite, remove the `let` binding
parser_suffixed_literal_in_attribute = suffixed literals are not allowed in attributes
.help = instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
parser_invalid_meta_item = expected unsuffixed literal or identifier, found `{$token}`
parser_label_inner_attr_does_not_annotate_this = the inner attribute doesn't annotate this {$item}
parser_sugg_change_inner_attr_to_outer = to annotate the {$item}, change the attribute from inner to outer style
parser_inner_attr_not_permitted_after_outer_doc_comment = an inner attribute is not permitted following an outer doc comment
.label_attr = not permitted following an outer doc comment
.label_prev_doc_comment = previous doc comment
.label_does_not_annotate_this = {parser_label_inner_attr_does_not_annotate_this}
.sugg_change_inner_to_outer = {parser_sugg_change_inner_attr_to_outer}
parser_inner_attr_not_permitted_after_outer_attr = an inner attribute is not permitted following an outer attribute
.label_attr = not permitted following an outer attribute
.label_prev_attr = previous outer attribute
.label_does_not_annotate_this = {parser_label_inner_attr_does_not_annotate_this}
.sugg_change_inner_to_outer = {parser_sugg_change_inner_attr_to_outer}
parser_inner_attr_not_permitted = an inner attribute is not permitted in this context
.label_does_not_annotate_this = {parser_label_inner_attr_does_not_annotate_this}
.sugg_change_inner_to_outer = {parser_sugg_change_inner_attr_to_outer}
parser_inner_attr_explanation = inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
parser_outer_attr_explanation = outer attributes, like `#[test]`, annotate the item following them
parser_inner_doc_comment_not_permitted = expected outer doc comment
.note = inner doc comments like this (starting with `//!` or `/*!`) can only appear before items
.suggestion = you might have meant to write a regular comment
.label_does_not_annotate_this = the inner doc comment doesn't annotate this {$item}
.sugg_change_inner_to_outer = to annotate the {$item}, change the doc comment from inner to outer style
parser_expected_identifier_found_reserved_identifier_str = expected identifier, found reserved identifier `{$token}`
parser_expected_identifier_found_keyword_str = expected identifier, found keyword `{$token}`
parser_expected_identifier_found_reserved_keyword_str = expected identifier, found reserved keyword `{$token}`
parser_expected_identifier_found_doc_comment_str = expected identifier, found doc comment `{$token}`
parser_expected_identifier_found_str = expected identifier, found `{$token}`
parser_expected_identifier_found_reserved_identifier = expected identifier, found reserved identifier
parser_expected_identifier_found_keyword = expected identifier, found keyword
parser_expected_identifier_found_reserved_keyword = expected identifier, found reserved keyword
parser_expected_identifier_found_doc_comment = expected identifier, found doc comment
parser_expected_identifier = expected identifier
parser_sugg_escape_to_use_as_identifier = escape `{$ident_name}` to use it as an identifier
parser_sugg_remove_comma = remove this comma
parser_expected_semi_found_reserved_identifier_str = expected `;`, found reserved identifier `{$token}`
parser_expected_semi_found_keyword_str = expected `;`, found keyword `{$token}`
parser_expected_semi_found_reserved_keyword_str = expected `;`, found reserved keyword `{$token}`
parser_expected_semi_found_doc_comment_str = expected `;`, found doc comment `{$token}`
parser_expected_semi_found_str = expected `;`, found `{$token}`
parser_sugg_change_this_to_semi = change this to `;`
parser_sugg_add_semi = add `;` here
parser_label_unexpected_token = unexpected token
parser_unmatched_angle_brackets = {$num_extra_brackets ->
[one] unmatched angle bracket
*[other] unmatched angle brackets
}
.suggestion = {$num_extra_brackets ->
[one] remove extra angle bracket
*[other] remove extra angle brackets
}
parser_generic_parameters_without_angle_brackets = generic parameters without surrounding angle brackets
.suggestion = surround the type parameters with angle brackets
parser_comparison_operators_cannot_be_chained = comparison operators cannot be chained
.sugg_parentheses_for_function_args = or use `(...)` if you meant to specify fn arguments
.sugg_split_comparison = split the comparison into two
.sugg_parenthesize = parenthesize the comparison
parser_sugg_turbofish_syntax = use `::<...>` instead of `<...>` to specify lifetime, type, or const arguments
parser_question_mark_in_type = invalid `?` in type
.label = `?` is only allowed on expressions, not types
.suggestion = if you meant to express that the type might not contain a value, use the `Option` wrapper type
parser_unexpected_parentheses_in_for_head = unexpected parentheses surrounding `for` loop head
.suggestion = remove parentheses in `for` loop
parser_doc_comment_on_param_type = documentation comments cannot be applied to a function parameter's type
.label = doc comments are not allowed here
parser_attribute_on_param_type = attributes cannot be applied to a function parameter's type
.label = attributes are not allowed here
parser_pattern_method_param_without_body = patterns aren't allowed in methods without bodies
.suggestion = give this argument a name or use an underscore to ignore it
parser_self_param_not_first = unexpected `self` parameter in function
.label = must be the first parameter of an associated function
parser_const_generic_without_braces = expressions must be enclosed in braces to be used as const generic arguments
.suggestion = enclose the `const` expression in braces
parser_unexpected_const_param_declaration = unexpected `const` parameter declaration
.label = expected a `const` expression, not a parameter declaration
.suggestion = `const` parameters must be declared for the `impl`
parser_unexpected_const_in_generic_param = expected lifetime, type, or constant, found keyword `const`
.suggestion = the `const` keyword is only needed in the definition of the type
parser_async_move_order_incorrect = the order of `move` and `async` is incorrect
.suggestion = try switching the order
parser_double_colon_in_bound = expected `:` followed by trait or lifetime
.suggestion = use single colon
parser_fn_ptr_with_generics = function pointer types may not have generic parameters
.suggestion = consider moving the lifetime {$arity ->
[one] parameter
*[other] parameters
} to {$for_param_list_exists ->
[true] the
*[false] a
} `for` parameter list
parser_invalid_identifier_with_leading_number = expected identifier, found number literal
.label = identifiers cannot start with a number

28
compiler/rustc_error_messages/locales/en-US/session.ftl
View File

@ -58,3 +58,31 @@ session_expr_parentheses_needed = parentheses are required to parse this as an e
session_skipping_const_checks = skipping const checks
session_unleashed_feature_help_named = skipping check for `{$gate}` feature
session_unleashed_feature_help_unnamed = skipping check that does not even have a feature gate
session_hexadecimal_float_literal_not_supported = hexadecimal float literal is not supported
session_octal_float_literal_not_supported = octal float literal is not supported
session_binary_float_literal_not_supported = binary float literal is not supported
session_not_supported = not supported
session_invalid_literal_suffix = suffixes on {$kind} literals are invalid
.label = invalid suffix `{$suffix}`
session_invalid_num_literal_base_prefix = invalid base prefix for number literal
.note = base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase
.suggestion = try making the prefix lowercase
session_invalid_num_literal_suffix = invalid suffix `{$suffix}` for number literal
.label = invalid suffix `{$suffix}`
.help = the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.)
session_invalid_float_literal_width = invalid width `{$width}` for float literal
.help = valid widths are 32 and 64
session_invalid_float_literal_suffix = invalid suffix `{$suffix}` for float literal
.label = invalid suffix `{$suffix}`
.help = valid suffixes are `f32` and `f64`
session_int_literal_too_large = integer literal is too large
session_invalid_int_literal_width = invalid width `{$width}` for integer literal
.help = valid widths are 8, 16, 32, 64 and 128

2
compiler/rustc_error_messages/src/lib.rs
View File

@ -59,7 +59,7 @@ fluent_messages! {
middle => "../locales/en-US/middle.ftl",
mir_dataflow => "../locales/en-US/mir_dataflow.ftl",
monomorphize => "../locales/en-US/monomorphize.ftl",
parser => "../locales/en-US/parser.ftl",
parse => "../locales/en-US/parse.ftl",
passes => "../locales/en-US/passes.ftl",
plugin_impl => "../locales/en-US/plugin_impl.ftl",
privacy => "../locales/en-US/privacy.ftl",

32
compiler/rustc_hir_typeck/src/errors.rs
View File

@ -1,11 +1,11 @@
//! Errors emitted by `rustc_hir_analysis`.
//! Errors emitted by `rustc_hir_typeck`.
use rustc_errors::{AddToDiagnostic, Applicability, Diagnostic, MultiSpan, SubdiagnosticMessage};
use rustc_macros::{Diagnostic, Subdiagnostic};
use rustc_middle::ty::Ty;
use rustc_span::{symbol::Ident, Span};
#[derive(Diagnostic)]
#[diag(hir_analysis_field_multiply_specified_in_initializer, code = "E0062")]
#[diag(hir_typeck_field_multiply_specified_in_initializer, code = "E0062")]
pub struct FieldMultiplySpecifiedInInitializer {
#[primary_span]
#[label]
@ -16,7 +16,7 @@ pub struct FieldMultiplySpecifiedInInitializer {
}
#[derive(Diagnostic)]
#[diag(hir_analysis_return_stmt_outside_of_fn_body, code = "E0572")]
#[diag(hir_typeck_return_stmt_outside_of_fn_body, code = "E0572")]
pub struct ReturnStmtOutsideOfFnBody {
#[primary_span]
pub span: Span,
@ -27,14 +27,14 @@ pub struct ReturnStmtOutsideOfFnBody {
}
#[derive(Diagnostic)]
#[diag(hir_analysis_yield_expr_outside_of_generator, code = "E0627")]
#[diag(hir_typeck_yield_expr_outside_of_generator, code = "E0627")]
pub struct YieldExprOutsideOfGenerator {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(hir_analysis_struct_expr_non_exhaustive, code = "E0639")]
#[diag(hir_typeck_struct_expr_non_exhaustive, code = "E0639")]
pub struct StructExprNonExhaustive {
#[primary_span]
pub span: Span,
@ -42,21 +42,21 @@ pub struct StructExprNonExhaustive {
}
#[derive(Diagnostic)]
#[diag(hir_analysis_method_call_on_unknown_type, code = "E0699")]
#[diag(hir_typeck_method_call_on_unknown_type, code = "E0699")]
pub struct MethodCallOnUnknownType {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(hir_analysis_functional_record_update_on_non_struct, code = "E0436")]
#[diag(hir_typeck_functional_record_update_on_non_struct, code = "E0436")]
pub struct FunctionalRecordUpdateOnNonStruct {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(hir_analysis_address_of_temporary_taken, code = "E0745")]
#[diag(hir_typeck_address_of_temporary_taken, code = "E0745")]
pub struct AddressOfTemporaryTaken {
#[primary_span]
#[label]
@ -66,7 +66,7 @@ pub struct AddressOfTemporaryTaken {
#[derive(Subdiagnostic)]
pub enum AddReturnTypeSuggestion {
#[suggestion(
hir_analysis_add_return_type_add,
hir_typeck_add_return_type_add,
code = "-> {found} ",
applicability = "machine-applicable"
)]
@ -76,7 +76,7 @@ pub enum AddReturnTypeSuggestion {
found: String,
},
#[suggestion(
hir_analysis_add_return_type_missing_here,
hir_typeck_add_return_type_missing_here,
code = "-> _ ",
applicability = "has-placeholders"
)]
@ -88,12 +88,12 @@ pub enum AddReturnTypeSuggestion {
#[derive(Subdiagnostic)]
pub enum ExpectedReturnTypeLabel<'tcx> {
#[label(hir_analysis_expected_default_return_type)]
#[label(hir_typeck_expected_default_return_type)]
Unit {
#[primary_span]
span: Span,
},
#[label(hir_analysis_expected_return_type)]
#[label(hir_typeck_expected_return_type)]
Other {
#[primary_span]
span: Span,
@ -102,10 +102,10 @@ pub enum ExpectedReturnTypeLabel<'tcx> {
}
#[derive(Diagnostic)]
#[diag(hir_analysis_missing_parentheses_in_range, code = "E0689")]
#[diag(hir_typeck_missing_parentheses_in_range, code = "E0689")]
pub struct MissingParentheseInRange {
#[primary_span]
#[label(hir_analysis_missing_parentheses_in_range)]
#[label(hir_typeck_missing_parentheses_in_range)]
pub span: Span,
pub ty_str: String,
pub method_name: String,
@ -115,7 +115,7 @@ pub struct MissingParentheseInRange {
#[derive(Subdiagnostic)]
#[multipart_suggestion(
hir_analysis_add_missing_parentheses_in_range,
hir_typeck_add_missing_parentheses_in_range,
style = "verbose",
applicability = "maybe-incorrect"
)]
@ -128,7 +128,7 @@ pub struct AddMissingParenthesesInRange {
}
#[derive(Diagnostic)]
#[diag(hir_analysis_op_trait_generic_params)]
#[diag(hir_typeck_op_trait_generic_params)]
pub struct OpMethodGenericParams {
#[primary_span]
pub span: Span,

53
compiler/rustc_macros/src/diagnostics/diagnostic.rs
View File

@ -5,6 +5,7 @@ use crate::diagnostics::error::{span_err, DiagnosticDeriveError};
use crate::diagnostics::utils::SetOnce;
use proc_macro2::TokenStream;
use quote::quote;
use syn::spanned::Spanned;
use synstructure::Structure;
/// The central struct for constructing the `into_diagnostic` method from an annotated struct.
@ -45,6 +46,17 @@ impl<'a> DiagnosticDerive<'a> {
.emit();
return DiagnosticDeriveError::ErrorHandled.to_compile_error();
}
Some(slug) if let Some( Mismatch { slug_name, crate_name, slug_prefix }) = Mismatch::check(slug) => {
span_err(slug.span().unwrap(), "diagnostic slug and crate name do not match")
.note(&format!(
"slug is `{slug_name}` but the crate name is `{crate_name}`"
))
.help(&format!(
"expected a slug starting with `{slug_prefix}_...`"
))
.emit();
return DiagnosticDeriveError::ErrorHandled.to_compile_error();
}
Some(slug) => {
quote! {
let mut #diag = #handler.struct_diagnostic(rustc_errors::fluent::#slug);
@ -128,7 +140,22 @@ impl<'a> LintDiagnosticDerive<'a> {
.emit();
return DiagnosticDeriveError::ErrorHandled.to_compile_error();
}
Some(slug) => quote! { rustc_errors::fluent::#slug.into() },
Some(slug) if let Some( Mismatch { slug_name, crate_name, slug_prefix }) = Mismatch::check(slug) => {
span_err(slug.span().unwrap(), "diagnostic slug and crate name do not match")
.note(&format!(
"slug is `{slug_name}` but the crate name is `{crate_name}`"
))
.help(&format!(
"expected a slug starting with `{slug_prefix}_...`"
))
.emit();
return DiagnosticDeriveError::ErrorHandled.to_compile_error();
}
Some(slug) => {
quote! {
rustc_errors::fluent::#slug.into()
}
}
}
});
@ -151,3 +178,27 @@ impl<'a> LintDiagnosticDerive<'a> {
})
}
}
struct Mismatch {
slug_name: String,
crate_name: String,
slug_prefix: String,
}
impl Mismatch {
/// Checks whether the slug starts with the crate name it's in.
fn check(slug: &syn::Path) -> Option<Mismatch> {
// If this is missing we're probably in a test, so bail.
let crate_name = std::env::var("CARGO_CRATE_NAME").ok()?;
// If we're not in a "rustc_" crate, bail.
let Some(("rustc", slug_prefix)) = crate_name.split_once("_") else { return None };
let slug_name = slug.segments.first()?.ident.to_string();
if !slug_name.starts_with(slug_prefix) {
Some(Mismatch { slug_name, slug_prefix: slug_prefix.to_string(), crate_name })
} else {
None
}
}
}

1
compiler/rustc_macros/src/lib.rs
View File

@ -1,4 +1,5 @@
#![feature(allow_internal_unstable)]
#![feature(if_let_guard)]
#![feature(never_type)]
#![feature(proc_macro_diagnostic)]
#![feature(proc_macro_span)]

8
compiler/rustc_middle/src/error.rs
View File

@ -64,3 +64,11 @@ pub(crate) struct StrictCoherenceNeedsNegativeCoherence {
#[label]
pub attr_span: Option<Span>,
}
#[derive(Diagnostic)]
#[diag(middle_const_not_used_in_type_alias)]
pub(super) struct ConstNotUsedTraitAlias {
pub ct: String,
#[primary_span]
pub span: Span,
}

8
compiler/rustc_middle/src/ty/diagnostics.rs
View File

@ -508,11 +508,3 @@ impl<'tcx> TypeVisitor<'tcx> for IsSuggestableVisitor<'tcx> {
c.super_visit_with(self)
}
}
#[derive(Diagnostic)]
#[diag(borrowck_const_not_used_in_type_alias)]
pub(super) struct ConstNotUsedTraitAlias {
pub ct: String,
#[primary_span]
pub span: Span,
}

9
compiler/rustc_middle/src/ty/opaque_types.rs
View File

@ -1,7 +1,8 @@
use crate::error::ConstNotUsedTraitAlias;
use crate::ty::fold::{TypeFolder, TypeSuperFoldable};
use crate::ty::subst::{GenericArg, GenericArgKind};
use crate::ty::{self, Ty, TyCtxt, TypeFoldable};
use rustc_data_structures::fx::FxHashMap;
use rustc_middle::ty::fold::{TypeFolder, TypeSuperFoldable};
use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable};
use rustc_span::Span;
/// Converts generic params of a TypeFoldable from one
@ -201,7 +202,7 @@ impl<'tcx> TypeFolder<'tcx> for ReverseMapper<'tcx> {
Some(u) => panic!("const mapped to unexpected kind: {:?}", u),
None => {
if !self.ignore_errors {
self.tcx.sess.emit_err(ty::ConstNotUsedTraitAlias {
self.tcx.sess.emit_err(ConstNotUsedTraitAlias {
ct: ct.to_string(),
span: self.span,
});

234
compiler/rustc_parse/src/errors.rs
View File

@ -9,7 +9,7 @@ use rustc_span::{Span, Symbol};
use crate::parser::TokenDescription;
#[derive(Diagnostic)]
#[diag(parser_maybe_report_ambiguous_plus)]
#[diag(parse_maybe_report_ambiguous_plus)]
pub(crate) struct AmbiguousPlus {
pub sum_ty: String,
#[primary_span]
@ -18,7 +18,7 @@ pub(crate) struct AmbiguousPlus {
}
#[derive(Diagnostic)]
#[diag(parser_maybe_recover_from_bad_type_plus, code = "E0178")]
#[diag(parse_maybe_recover_from_bad_type_plus, code = "E0178")]
pub(crate) struct BadTypePlus {
pub ty: String,
#[primary_span]
@ -30,7 +30,7 @@ pub(crate) struct BadTypePlus {
#[derive(Subdiagnostic)]
pub(crate) enum BadTypePlusSub {
#[suggestion(
parser_add_paren,
parse_add_paren,
code = "{sum_with_parens}",
applicability = "machine-applicable"
)]
@ -39,12 +39,12 @@ pub(crate) enum BadTypePlusSub {
#[primary_span]
span: Span,
},
#[label(parser_forgot_paren)]
#[label(parse_forgot_paren)]
ForgotParen {
#[primary_span]
span: Span,
},
#[label(parser_expect_path)]
#[label(parse_expect_path)]
ExpectPath {
#[primary_span]
span: Span,
@ -52,7 +52,7 @@ pub(crate) enum BadTypePlusSub {
}
#[derive(Diagnostic)]
#[diag(parser_maybe_recover_from_bad_qpath_stage_2)]
#[diag(parse_maybe_recover_from_bad_qpath_stage_2)]
pub(crate) struct BadQPathStage2 {
#[primary_span]
#[suggestion(code = "", applicability = "maybe-incorrect")]
@ -61,7 +61,7 @@ pub(crate) struct BadQPathStage2 {
}
#[derive(Diagnostic)]
#[diag(parser_incorrect_semicolon)]
#[diag(parse_incorrect_semicolon)]
pub(crate) struct IncorrectSemicolon<'a> {
#[primary_span]
#[suggestion(style = "short", code = "", applicability = "machine-applicable")]
@ -72,7 +72,7 @@ pub(crate) struct IncorrectSemicolon<'a> {
}
#[derive(Diagnostic)]
#[diag(parser_incorrect_use_of_await)]
#[diag(parse_incorrect_use_of_await)]
pub(crate) struct IncorrectUseOfAwait {
#[primary_span]
#[suggestion(parentheses_suggestion, code = "", applicability = "machine-applicable")]
@ -80,7 +80,7 @@ pub(crate) struct IncorrectUseOfAwait {
}
#[derive(Diagnostic)]
#[diag(parser_incorrect_use_of_await)]
#[diag(parse_incorrect_use_of_await)]
pub(crate) struct IncorrectAwait {
#[primary_span]
pub span: Span,
@ -91,7 +91,7 @@ pub(crate) struct IncorrectAwait {
}
#[derive(Diagnostic)]
#[diag(parser_in_in_typo)]
#[diag(parse_in_in_typo)]
pub(crate) struct InInTypo {
#[primary_span]
pub span: Span,
@ -100,7 +100,7 @@ pub(crate) struct InInTypo {
}
#[derive(Diagnostic)]
#[diag(parser_invalid_variable_declaration)]
#[diag(parse_invalid_variable_declaration)]
pub(crate) struct InvalidVariableDeclaration {
#[primary_span]
pub span: Span,
@ -110,22 +110,22 @@ pub(crate) struct InvalidVariableDeclaration {
#[derive(Subdiagnostic)]
pub(crate) enum InvalidVariableDeclarationSub {
#[suggestion(parser_switch_mut_let_order, applicability = "maybe-incorrect", code = "let mut")]
#[suggestion(parse_switch_mut_let_order, applicability = "maybe-incorrect", code = "let mut")]
SwitchMutLetOrder(#[primary_span] Span),
#[suggestion(
parser_missing_let_before_mut,
parse_missing_let_before_mut,
applicability = "machine-applicable",
code = "let mut"
)]
MissingLet(#[primary_span] Span),
#[suggestion(parser_use_let_not_auto, applicability = "machine-applicable", code = "let")]
#[suggestion(parse_use_let_not_auto, applicability = "machine-applicable", code = "let")]
UseLetNotAuto(#[primary_span] Span),
#[suggestion(parser_use_let_not_var, applicability = "machine-applicable", code = "let")]
#[suggestion(parse_use_let_not_var, applicability = "machine-applicable", code = "let")]
UseLetNotVar(#[primary_span] Span),
}
#[derive(Diagnostic)]
#[diag(parser_invalid_comparison_operator)]
#[diag(parse_invalid_comparison_operator)]
pub(crate) struct InvalidComparisonOperator {
#[primary_span]
pub span: Span,
@ -153,7 +153,7 @@ pub(crate) enum InvalidComparisonOperatorSub {
}
#[derive(Diagnostic)]
#[diag(parser_invalid_logical_operator)]
#[diag(parse_invalid_logical_operator)]
#[note]
pub(crate) struct InvalidLogicalOperator {
#[primary_span]
@ -182,7 +182,7 @@ pub(crate) enum InvalidLogicalOperatorSub {
}
#[derive(Diagnostic)]
#[diag(parser_tilde_is_not_unary_operator)]
#[diag(parse_tilde_is_not_unary_operator)]
pub(crate) struct TildeAsUnaryOperator(
#[primary_span]
#[suggestion(style = "short", applicability = "machine-applicable", code = "!")]
@ -190,7 +190,7 @@ pub(crate) struct TildeAsUnaryOperator(
);
#[derive(Diagnostic)]
#[diag(parser_unexpected_token_after_not)]
#[diag(parse_unexpected_token_after_not)]
pub(crate) struct NotAsNegationOperator {
#[primary_span]
pub negated: Span,
@ -202,7 +202,7 @@ pub(crate) struct NotAsNegationOperator {
#[derive(Subdiagnostic)]
pub enum NotAsNegationOperatorSub {
#[suggestion(
parser_unexpected_token_after_not_default,
parse_unexpected_token_after_not_default,
style = "short",
applicability = "machine-applicable",
code = "!"
@ -210,7 +210,7 @@ pub enum NotAsNegationOperatorSub {
SuggestNotDefault(#[primary_span] Span),
#[suggestion(
parser_unexpected_token_after_not_bitwise,
parse_unexpected_token_after_not_bitwise,
style = "short",
applicability = "machine-applicable",
code = "!"
@ -218,7 +218,7 @@ pub enum NotAsNegationOperatorSub {
SuggestNotBitwise(#[primary_span] Span),
#[suggestion(
parser_unexpected_token_after_not_logical,
parse_unexpected_token_after_not_logical,
style = "short",
applicability = "machine-applicable",
code = "!"
@ -227,7 +227,7 @@ pub enum NotAsNegationOperatorSub {
}
#[derive(Diagnostic)]
#[diag(parser_malformed_loop_label)]
#[diag(parse_malformed_loop_label)]
pub(crate) struct MalformedLoopLabel {
#[primary_span]
#[suggestion(applicability = "machine-applicable", code = "{correct_label}")]
@ -236,7 +236,7 @@ pub(crate) struct MalformedLoopLabel {
}
#[derive(Diagnostic)]
#[diag(parser_lifetime_in_borrow_expression)]
#[diag(parse_lifetime_in_borrow_expression)]
pub(crate) struct LifetimeInBorrowExpression {
#[primary_span]
pub span: Span,
@ -246,18 +246,18 @@ pub(crate) struct LifetimeInBorrowExpression {
}
#[derive(Diagnostic)]
#[diag(parser_field_expression_with_generic)]
#[diag(parse_field_expression_with_generic)]
pub(crate) struct FieldExpressionWithGeneric(#[primary_span] pub Span);
#[derive(Diagnostic)]
#[diag(parser_macro_invocation_with_qualified_path)]
#[diag(parse_macro_invocation_with_qualified_path)]
pub(crate) struct MacroInvocationWithQualifiedPath(#[primary_span] pub Span);
#[derive(Diagnostic)]
#[diag(parser_unexpected_token_after_label)]
#[diag(parse_unexpected_token_after_label)]
pub(crate) struct UnexpectedTokenAfterLabel {
#[primary_span]
#[label(parser_unexpected_token_after_label)]
#[label(parse_unexpected_token_after_label)]
pub span: Span,
#[suggestion(suggestion_remove_label, style = "verbose", code = "")]
pub remove_label: Option<Span>,
@ -275,7 +275,7 @@ pub(crate) struct UnexpectedTokenAfterLabelSugg {
}
#[derive(Diagnostic)]
#[diag(parser_require_colon_after_labeled_expression)]
#[diag(parse_require_colon_after_labeled_expression)]
#[note]
pub(crate) struct RequireColonAfterLabeledExpression {
#[primary_span]
@ -287,7 +287,7 @@ pub(crate) struct RequireColonAfterLabeledExpression {
}
#[derive(Diagnostic)]
#[diag(parser_do_catch_syntax_removed)]
#[diag(parse_do_catch_syntax_removed)]
#[note]
pub(crate) struct DoCatchSyntaxRemoved {
#[primary_span]
@ -296,7 +296,7 @@ pub(crate) struct DoCatchSyntaxRemoved {
}
#[derive(Diagnostic)]
#[diag(parser_float_literal_requires_integer_part)]
#[diag(parse_float_literal_requires_integer_part)]
pub(crate) struct FloatLiteralRequiresIntegerPart {
#[primary_span]
#[suggestion(applicability = "machine-applicable", code = "{correct}")]
@ -305,7 +305,7 @@ pub(crate) struct FloatLiteralRequiresIntegerPart {
}
#[derive(Diagnostic)]
#[diag(parser_missing_semicolon_before_array)]
#[diag(parse_missing_semicolon_before_array)]
pub(crate) struct MissingSemicolonBeforeArray {
#[primary_span]
pub open_delim: Span,
@ -314,7 +314,7 @@ pub(crate) struct MissingSemicolonBeforeArray {
}
#[derive(Diagnostic)]
#[diag(parser_expect_dotdot_not_dotdotdot)]
#[diag(parse_expect_dotdot_not_dotdotdot)]
pub(crate) struct MissingDotDot {
#[primary_span]
pub token_span: Span,
@ -323,7 +323,7 @@ pub(crate) struct MissingDotDot {
}
#[derive(Diagnostic)]
#[diag(parser_invalid_block_macro_segment)]
#[diag(parse_invalid_block_macro_segment)]
pub(crate) struct InvalidBlockMacroSegment {
#[primary_span]
pub span: Span,
@ -332,7 +332,7 @@ pub(crate) struct InvalidBlockMacroSegment {
}
#[derive(Diagnostic)]
#[diag(parser_if_expression_missing_then_block)]
#[diag(parse_if_expression_missing_then_block)]
pub(crate) struct IfExpressionMissingThenBlock {
#[primary_span]
pub if_span: Span,
@ -349,7 +349,7 @@ pub(crate) enum IfExpressionMissingThenBlockSub {
}
#[derive(Diagnostic)]
#[diag(parser_if_expression_missing_condition)]
#[diag(parse_if_expression_missing_condition)]
pub(crate) struct IfExpressionMissingCondition {
#[primary_span]
#[label(condition_label)]
@ -359,14 +359,14 @@ pub(crate) struct IfExpressionMissingCondition {
}
#[derive(Diagnostic)]
#[diag(parser_expected_expression_found_let)]
#[diag(parse_expected_expression_found_let)]
pub(crate) struct ExpectedExpressionFoundLet {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(parser_expect_eq_instead_of_eqeq)]
#[diag(parse_expect_eq_instead_of_eqeq)]
pub(crate) struct ExpectedEqForLetExpr {
#[primary_span]
pub span: Span,
@ -375,7 +375,7 @@ pub(crate) struct ExpectedEqForLetExpr {
}
#[derive(Diagnostic)]
#[diag(parser_expected_else_block)]
#[diag(parse_expected_else_block)]
pub(crate) struct ExpectedElseBlock {
#[primary_span]
pub first_tok_span: Span,
@ -387,7 +387,7 @@ pub(crate) struct ExpectedElseBlock {
}
#[derive(Diagnostic)]
#[diag(parser_outer_attribute_not_allowed_on_if_else)]
#[diag(parse_outer_attribute_not_allowed_on_if_else)]
pub(crate) struct OuterAttributeNotAllowedOnIfElse {
#[primary_span]
pub last: Span,
@ -404,7 +404,7 @@ pub(crate) struct OuterAttributeNotAllowedOnIfElse {
}
#[derive(Diagnostic)]
#[diag(parser_missing_in_in_for_loop)]
#[diag(parse_missing_in_in_for_loop)]
pub(crate) struct MissingInInForLoop {
#[primary_span]
pub span: Span,
@ -422,7 +422,7 @@ pub(crate) enum MissingInInForLoopSub {
}
#[derive(Diagnostic)]
#[diag(parser_missing_comma_after_match_arm)]
#[diag(parse_missing_comma_after_match_arm)]
pub(crate) struct MissingCommaAfterMatchArm {
#[primary_span]
#[suggestion(applicability = "machine-applicable", code = ",")]
@ -430,7 +430,7 @@ pub(crate) struct MissingCommaAfterMatchArm {
}
#[derive(Diagnostic)]
#[diag(parser_catch_after_try)]
#[diag(parse_catch_after_try)]
#[help]
pub(crate) struct CatchAfterTry {
#[primary_span]
@ -438,7 +438,7 @@ pub(crate) struct CatchAfterTry {
}
#[derive(Diagnostic)]
#[diag(parser_comma_after_base_struct)]
#[diag(parse_comma_after_base_struct)]
#[note]
pub(crate) struct CommaAfterBaseStruct {
#[primary_span]
@ -448,7 +448,7 @@ pub(crate) struct CommaAfterBaseStruct {
}
#[derive(Diagnostic)]
#[diag(parser_eq_field_init)]
#[diag(parse_eq_field_init)]
pub(crate) struct EqFieldInit {
#[primary_span]
pub span: Span,
@ -457,7 +457,7 @@ pub(crate) struct EqFieldInit {
}
#[derive(Diagnostic)]
#[diag(parser_dotdotdot)]
#[diag(parse_dotdotdot)]
pub(crate) struct DotDotDot {
#[primary_span]
#[suggestion(suggest_exclusive_range, applicability = "maybe-incorrect", code = "..")]
@ -466,7 +466,7 @@ pub(crate) struct DotDotDot {
}
#[derive(Diagnostic)]
#[diag(parser_left_arrow_operator)]
#[diag(parse_left_arrow_operator)]
pub(crate) struct LeftArrowOperator {
#[primary_span]
#[suggestion(applicability = "maybe-incorrect", code = "< -")]
@ -474,7 +474,7 @@ pub(crate) struct LeftArrowOperator {
}
#[derive(Diagnostic)]
#[diag(parser_remove_let)]
#[diag(parse_remove_let)]
pub(crate) struct RemoveLet {
#[primary_span]
#[suggestion(applicability = "machine-applicable", code = "")]
@ -482,7 +482,7 @@ pub(crate) struct RemoveLet {
}
#[derive(Diagnostic)]
#[diag(parser_use_eq_instead)]
#[diag(parse_use_eq_instead)]
pub(crate) struct UseEqInstead {
#[primary_span]
#[suggestion(style = "short", applicability = "machine-applicable", code = "=")]
@ -490,7 +490,7 @@ pub(crate) struct UseEqInstead {
}
#[derive(Diagnostic)]
#[diag(parser_use_empty_block_not_semi)]
#[diag(parse_use_empty_block_not_semi)]
pub(crate) struct UseEmptyBlockNotSemi {
#[primary_span]
#[suggestion(style = "hidden", applicability = "machine-applicable", code = "{{}}")]
@ -498,7 +498,7 @@ pub(crate) struct UseEmptyBlockNotSemi {
}
#[derive(Diagnostic)]
#[diag(parser_comparison_interpreted_as_generic)]
#[diag(parse_comparison_interpreted_as_generic)]
pub(crate) struct ComparisonInterpretedAsGeneric {
#[primary_span]
#[label(label_comparison)]
@ -511,7 +511,7 @@ pub(crate) struct ComparisonInterpretedAsGeneric {
}
#[derive(Diagnostic)]
#[diag(parser_shift_interpreted_as_generic)]
#[diag(parse_shift_interpreted_as_generic)]
pub(crate) struct ShiftInterpretedAsGeneric {
#[primary_span]
#[label(label_comparison)]
@ -533,7 +533,7 @@ pub(crate) struct ComparisonOrShiftInterpretedAsGenericSugg {
}
#[derive(Diagnostic)]
#[diag(parser_found_expr_would_be_stmt)]
#[diag(parse_found_expr_would_be_stmt)]
pub(crate) struct FoundExprWouldBeStmt {
#[primary_span]
#[label]
@ -544,7 +544,7 @@ pub(crate) struct FoundExprWouldBeStmt {
}
#[derive(Diagnostic)]
#[diag(parser_leading_plus_not_supported)]
#[diag(parse_leading_plus_not_supported)]
pub(crate) struct LeadingPlusNotSupported {
#[primary_span]
#[label]
@ -561,7 +561,7 @@ pub(crate) struct LeadingPlusNotSupported {
}
#[derive(Diagnostic)]
#[diag(parser_parentheses_with_struct_fields)]
#[diag(parse_parentheses_with_struct_fields)]
pub(crate) struct ParenthesesWithStructFields {
#[primary_span]
pub span: Span,
@ -589,7 +589,7 @@ pub(crate) struct NoFieldsForFnCall {
}
#[derive(Diagnostic)]
#[diag(parser_labeled_loop_in_break)]
#[diag(parse_labeled_loop_in_break)]
pub(crate) struct LabeledLoopInBreak {
#[primary_span]
pub span: Span,
@ -599,7 +599,7 @@ pub(crate) struct LabeledLoopInBreak {
#[derive(Subdiagnostic)]
#[multipart_suggestion(
parser_sugg_wrap_expression_in_parentheses,
parse_sugg_wrap_expression_in_parentheses,
applicability = "machine-applicable"
)]
pub(crate) struct WrapExpressionInParentheses {
@ -610,7 +610,7 @@ pub(crate) struct WrapExpressionInParentheses {
}
#[derive(Diagnostic)]
#[diag(parser_array_brackets_instead_of_braces)]
#[diag(parse_array_brackets_instead_of_braces)]
pub(crate) struct ArrayBracketsInsteadOfSpaces {
#[primary_span]
pub span: Span,
@ -628,7 +628,7 @@ pub(crate) struct ArrayBracketsInsteadOfSpacesSugg {
}
#[derive(Diagnostic)]
#[diag(parser_match_arm_body_without_braces)]
#[diag(parse_match_arm_body_without_braces)]
pub(crate) struct MatchArmBodyWithoutBraces {
#[primary_span]
#[label(label_statements)]
@ -661,7 +661,7 @@ pub(crate) enum MatchArmBodyWithoutBracesSugg {
}
#[derive(Diagnostic)]
#[diag(parser_struct_literal_not_allowed_here)]
#[diag(parse_struct_literal_not_allowed_here)]
pub(crate) struct StructLiteralNotAllowedHere {
#[primary_span]
pub span: Span,
@ -679,14 +679,14 @@ pub(crate) struct StructLiteralNotAllowedHereSugg {
}
#[derive(Diagnostic)]
#[diag(parser_invalid_interpolated_expression)]
#[diag(parse_invalid_interpolated_expression)]
pub(crate) struct InvalidInterpolatedExpression {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(parser_invalid_literal_suffix_on_tuple_index)]
#[diag(parse_invalid_literal_suffix_on_tuple_index)]
pub(crate) struct InvalidLiteralSuffixOnTupleIndex {
#[primary_span]
#[label]
@ -699,7 +699,7 @@ pub(crate) struct InvalidLiteralSuffixOnTupleIndex {
}
#[derive(Diagnostic)]
#[diag(parser_non_string_abi_literal)]
#[diag(parse_non_string_abi_literal)]
pub(crate) struct NonStringAbiLiteral {
#[primary_span]
#[suggestion(code = "\"C\"", applicability = "maybe-incorrect")]
@ -707,7 +707,7 @@ pub(crate) struct NonStringAbiLiteral {
}
#[derive(Diagnostic)]
#[diag(parser_mismatched_closing_delimiter)]
#[diag(parse_mismatched_closing_delimiter)]
pub(crate) struct MismatchedClosingDelimiter {
#[primary_span]
pub spans: Vec<Span>,
@ -721,7 +721,7 @@ pub(crate) struct MismatchedClosingDelimiter {
}
#[derive(Diagnostic)]
#[diag(parser_incorrect_visibility_restriction, code = "E0704")]
#[diag(parse_incorrect_visibility_restriction, code = "E0704")]
#[help]
pub(crate) struct IncorrectVisibilityRestriction {
#[primary_span]
@ -731,21 +731,21 @@ pub(crate) struct IncorrectVisibilityRestriction {
}
#[derive(Diagnostic)]
#[diag(parser_assignment_else_not_allowed)]
#[diag(parse_assignment_else_not_allowed)]
pub(crate) struct AssignmentElseNotAllowed {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(parser_expected_statement_after_outer_attr)]
#[diag(parse_expected_statement_after_outer_attr)]
pub(crate) struct ExpectedStatementAfterOuterAttr {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(parser_doc_comment_does_not_document_anything, code = "E0585")]
#[diag(parse_doc_comment_does_not_document_anything, code = "E0585")]
#[help]
pub(crate) struct DocCommentDoesNotDocumentAnything {
#[primary_span]
@ -755,7 +755,7 @@ pub(crate) struct DocCommentDoesNotDocumentAnything {
}
#[derive(Diagnostic)]
#[diag(parser_const_let_mutually_exclusive)]
#[diag(parse_const_let_mutually_exclusive)]
pub(crate) struct ConstLetMutuallyExclusive {
#[primary_span]
#[suggestion(code = "const", applicability = "maybe-incorrect")]
@ -763,7 +763,7 @@ pub(crate) struct ConstLetMutuallyExclusive {
}
#[derive(Diagnostic)]
#[diag(parser_invalid_expression_in_let_else)]
#[diag(parse_invalid_expression_in_let_else)]
pub(crate) struct InvalidExpressionInLetElse {
#[primary_span]
pub span: Span,
@ -773,7 +773,7 @@ pub(crate) struct InvalidExpressionInLetElse {
}
#[derive(Diagnostic)]
#[diag(parser_invalid_curly_in_let_else)]
#[diag(parse_invalid_curly_in_let_else)]
pub(crate) struct InvalidCurlyInLetElse {
#[primary_span]
pub span: Span,
@ -782,7 +782,7 @@ pub(crate) struct InvalidCurlyInLetElse {
}
#[derive(Diagnostic)]
#[diag(parser_compound_assignment_expression_in_let)]
#[diag(parse_compound_assignment_expression_in_let)]
#[help]
pub(crate) struct CompoundAssignmentExpressionInLet {
#[primary_span]
@ -791,7 +791,7 @@ pub(crate) struct CompoundAssignmentExpressionInLet {
}
#[derive(Diagnostic)]
#[diag(parser_suffixed_literal_in_attribute)]
#[diag(parse_suffixed_literal_in_attribute)]
#[help]
pub(crate) struct SuffixedLiteralInAttribute {
#[primary_span]
@ -799,7 +799,7 @@ pub(crate) struct SuffixedLiteralInAttribute {
}
#[derive(Diagnostic)]
#[diag(parser_invalid_meta_item)]
#[diag(parse_invalid_meta_item)]
pub(crate) struct InvalidMetaItem {
#[primary_span]
pub span: Span,
@ -808,7 +808,7 @@ pub(crate) struct InvalidMetaItem {
#[derive(Subdiagnostic)]
#[suggestion(
parser_sugg_escape_to_use_as_identifier,
parse_sugg_escape_to_use_as_identifier,
style = "verbose",
applicability = "maybe-incorrect",
code = "r#"
@ -820,7 +820,7 @@ pub(crate) struct SuggEscapeToUseAsIdentifier {
}
#[derive(Subdiagnostic)]
#[suggestion(parser_sugg_remove_comma, applicability = "machine-applicable", code = "")]
#[suggestion(parse_sugg_remove_comma, applicability = "machine-applicable", code = "")]
pub(crate) struct SuggRemoveComma {
#[primary_span]
pub span: Span,
@ -828,15 +828,15 @@ pub(crate) struct SuggRemoveComma {
#[derive(Subdiagnostic)]
pub(crate) enum ExpectedIdentifierFound {
#[label(parser_expected_identifier_found_reserved_identifier)]
#[label(parse_expected_identifier_found_reserved_identifier)]
ReservedIdentifier(#[primary_span] Span),
#[label(parser_expected_identifier_found_keyword)]
#[label(parse_expected_identifier_found_keyword)]
Keyword(#[primary_span] Span),
#[label(parser_expected_identifier_found_reserved_keyword)]
#[label(parse_expected_identifier_found_reserved_keyword)]
ReservedKeyword(#[primary_span] Span),
#[label(parser_expected_identifier_found_doc_comment)]
#[label(parse_expected_identifier_found_doc_comment)]
DocComment(#[primary_span] Span),
#[label(parser_expected_identifier)]
#[label(parse_expected_identifier)]
Other(#[primary_span] Span),
}
@ -871,16 +871,16 @@ impl<'a, G: EmissionGuarantee> IntoDiagnostic<'a, G> for ExpectedIdentifier {
let mut diag = handler.struct_diagnostic(match token_descr {
Some(TokenDescription::ReservedIdentifier) => {
fluent::parser_expected_identifier_found_reserved_identifier_str
fluent::parse_expected_identifier_found_reserved_identifier_str
}
Some(TokenDescription::Keyword) => fluent::parser_expected_identifier_found_keyword_str,
Some(TokenDescription::Keyword) => fluent::parse_expected_identifier_found_keyword_str,
Some(TokenDescription::ReservedKeyword) => {
fluent::parser_expected_identifier_found_reserved_keyword_str
fluent::parse_expected_identifier_found_reserved_keyword_str
}
Some(TokenDescription::DocComment) => {
fluent::parser_expected_identifier_found_doc_comment_str
fluent::parse_expected_identifier_found_doc_comment_str
}
None => fluent::parser_expected_identifier_found_str,
None => fluent::parse_expected_identifier_found_str,
});
diag.set_span(self.span);
diag.set_arg("token", self.token);
@ -917,22 +917,20 @@ impl<'a, G: EmissionGuarantee> IntoDiagnostic<'a, G> for ExpectedSemi {
let mut diag = handler.struct_diagnostic(match token_descr {
Some(TokenDescription::ReservedIdentifier) => {
fluent::parser_expected_semi_found_reserved_identifier_str
fluent::parse_expected_semi_found_reserved_identifier_str
}
Some(TokenDescription::Keyword) => fluent::parser_expected_semi_found_keyword_str,
Some(TokenDescription::Keyword) => fluent::parse_expected_semi_found_keyword_str,
Some(TokenDescription::ReservedKeyword) => {
fluent::parser_expected_semi_found_reserved_keyword_str
fluent::parse_expected_semi_found_reserved_keyword_str
}
Some(TokenDescription::DocComment) => {
fluent::parser_expected_semi_found_doc_comment_str
}
None => fluent::parser_expected_semi_found_str,
Some(TokenDescription::DocComment) => fluent::parse_expected_semi_found_doc_comment_str,
None => fluent::parse_expected_semi_found_str,
});
diag.set_span(self.span);
diag.set_arg("token", self.token);
if let Some(unexpected_token_label) = self.unexpected_token_label {
diag.span_label(unexpected_token_label, fluent::parser_label_unexpected_token);
diag.span_label(unexpected_token_label, fluent::parse_label_unexpected_token);
}
self.sugg.add_to_diagnostic(&mut diag);
@ -943,14 +941,10 @@ impl<'a, G: EmissionGuarantee> IntoDiagnostic<'a, G> for ExpectedSemi {
#[derive(Subdiagnostic)]
pub(crate) enum ExpectedSemiSugg {
#[suggestion(
parser_sugg_change_this_to_semi,
code = ";",
applicability = "machine-applicable"
)]
#[suggestion(parse_sugg_change_this_to_semi, code = ";", applicability = "machine-applicable")]
ChangeToSemi(#[primary_span] Span),
#[suggestion(
parser_sugg_add_semi,
parse_sugg_add_semi,
style = "short",
code = ";",
applicability = "machine-applicable"
@ -959,7 +953,7 @@ pub(crate) enum ExpectedSemiSugg {
}
#[derive(Diagnostic)]
#[diag(parser_struct_literal_body_without_path)]
#[diag(parse_struct_literal_body_without_path)]
pub(crate) struct StructLiteralBodyWithoutPath {
#[primary_span]
pub span: Span,
@ -977,7 +971,7 @@ pub(crate) struct StructLiteralBodyWithoutPathSugg {
}
#[derive(Diagnostic)]
#[diag(parser_unmatched_angle_brackets)]
#[diag(parse_unmatched_angle_brackets)]
pub(crate) struct UnmatchedAngleBrackets {
#[primary_span]
#[suggestion(code = "", applicability = "machine-applicable")]
@ -986,7 +980,7 @@ pub(crate) struct UnmatchedAngleBrackets {
}
#[derive(Diagnostic)]
#[diag(parser_generic_parameters_without_angle_brackets)]
#[diag(parse_generic_parameters_without_angle_brackets)]
pub(crate) struct GenericParamsWithoutAngleBrackets {
#[primary_span]
pub span: Span,
@ -1004,18 +998,18 @@ pub(crate) struct GenericParamsWithoutAngleBracketsSugg {
}
#[derive(Diagnostic)]
#[diag(parser_comparison_operators_cannot_be_chained)]
#[diag(parse_comparison_operators_cannot_be_chained)]
pub(crate) struct ComparisonOperatorsCannotBeChained {
#[primary_span]
pub span: Vec<Span>,
#[suggestion(
parser_sugg_turbofish_syntax,
parse_sugg_turbofish_syntax,
style = "verbose",
code = "::",
applicability = "maybe-incorrect"
)]
pub suggest_turbofish: Option<Span>,
#[help(parser_sugg_turbofish_syntax)]
#[help(parse_sugg_turbofish_syntax)]
#[help(sugg_parentheses_for_function_args)]
pub help_turbofish: Option<()>,
#[subdiagnostic]
@ -1045,7 +1039,7 @@ pub(crate) enum ComparisonOperatorsCannotBeChainedSugg {
}
#[derive(Diagnostic)]
#[diag(parser_question_mark_in_type)]
#[diag(parse_question_mark_in_type)]
pub(crate) struct QuestionMarkInType {
#[primary_span]
#[label]
@ -1064,7 +1058,7 @@ pub(crate) struct QuestionMarkInTypeSugg {
}
#[derive(Diagnostic)]
#[diag(parser_unexpected_parentheses_in_for_head)]
#[diag(parse_unexpected_parentheses_in_for_head)]
pub(crate) struct ParenthesesInForHead {
#[primary_span]
pub span: Vec<Span>,
@ -1084,7 +1078,7 @@ pub(crate) struct ParenthesesInForHeadSugg {
}
#[derive(Diagnostic)]
#[diag(parser_doc_comment_on_param_type)]
#[diag(parse_doc_comment_on_param_type)]
pub(crate) struct DocCommentOnParamType {
#[primary_span]
#[label]
@ -1092,7 +1086,7 @@ pub(crate) struct DocCommentOnParamType {
}
#[derive(Diagnostic)]
#[diag(parser_attribute_on_param_type)]
#[diag(parse_attribute_on_param_type)]
pub(crate) struct AttributeOnParamType {
#[primary_span]
#[label]
@ -1100,7 +1094,7 @@ pub(crate) struct AttributeOnParamType {
}
#[derive(Diagnostic)]
#[diag(parser_pattern_method_param_without_body, code = "E0642")]
#[diag(parse_pattern_method_param_without_body, code = "E0642")]
pub(crate) struct PatternMethodParamWithoutBody {
#[primary_span]
#[suggestion(code = "_", applicability = "machine-applicable")]
@ -1108,7 +1102,7 @@ pub(crate) struct PatternMethodParamWithoutBody {
}
#[derive(Diagnostic)]
#[diag(parser_self_param_not_first)]
#[diag(parse_self_param_not_first)]
pub(crate) struct SelfParamNotFirst {
#[primary_span]
#[label]
@ -1116,7 +1110,7 @@ pub(crate) struct SelfParamNotFirst {
}
#[derive(Diagnostic)]
#[diag(parser_invalid_identifier_with_leading_number)]
#[diag(parse_invalid_identifier_with_leading_number)]
pub(crate) struct InvalidIdentiferStartsWithNumber {
#[primary_span]
#[label]
@ -1124,7 +1118,7 @@ pub(crate) struct InvalidIdentiferStartsWithNumber {
}
#[derive(Diagnostic)]
#[diag(parser_const_generic_without_braces)]
#[diag(parse_const_generic_without_braces)]
pub(crate) struct ConstGenericWithoutBraces {
#[primary_span]
pub span: Span,
@ -1142,7 +1136,7 @@ pub(crate) struct ConstGenericWithoutBracesSugg {
}
#[derive(Diagnostic)]
#[diag(parser_unexpected_const_param_declaration)]
#[diag(parse_unexpected_const_param_declaration)]
pub(crate) struct UnexpectedConstParamDeclaration {
#[primary_span]
#[label]
@ -1174,7 +1168,7 @@ pub(crate) enum UnexpectedConstParamDeclarationSugg {
}
#[derive(Diagnostic)]
#[diag(parser_unexpected_const_in_generic_param)]
#[diag(parse_unexpected_const_in_generic_param)]
pub(crate) struct UnexpectedConstInGenericParam {
#[primary_span]
pub span: Span,
@ -1183,7 +1177,7 @@ pub(crate) struct UnexpectedConstInGenericParam {
}
#[derive(Diagnostic)]
#[diag(parser_async_move_order_incorrect)]
#[diag(parse_async_move_order_incorrect)]
pub(crate) struct AsyncMoveOrderIncorrect {
#[primary_span]
#[suggestion(style = "verbose", code = "async move", applicability = "maybe-incorrect")]
@ -1191,7 +1185,7 @@ pub(crate) struct AsyncMoveOrderIncorrect {
}
#[derive(Diagnostic)]
#[diag(parser_double_colon_in_bound)]
#[diag(parse_double_colon_in_bound)]
pub(crate) struct DoubleColonInBound {
#[primary_span]
pub span: Span,
@ -1200,7 +1194,7 @@ pub(crate) struct DoubleColonInBound {
}
#[derive(Diagnostic)]
#[diag(parser_fn_ptr_with_generics)]
#[diag(parse_fn_ptr_with_generics)]
pub(crate) struct FnPtrWithGenerics {
#[primary_span]
pub span: Span,
@ -1221,7 +1215,7 @@ pub(crate) struct FnPtrWithGenericsSugg {
}
#[derive(Diagnostic)]
#[diag(parser_unexpected_if_with_if)]
#[diag(parse_unexpected_if_with_if)]
pub(crate) struct UnexpectedIfWithIf(
#[primary_span]
#[suggestion(applicability = "machine-applicable", code = " ", style = "verbose")]

12
compiler/rustc_parse/src/parser/attr.rs
View File

@ -55,7 +55,7 @@ impl<'a> Parser<'a> {
let span = self.token.span;
let mut err = self.sess.span_diagnostic.struct_span_err_with_code(
span,
fluent::parser_inner_doc_comment_not_permitted,
fluent::parse_inner_doc_comment_not_permitted,
error_code!(E0753),
);
if let Some(replacement_span) = self.annotate_following_item_if_applicable(
@ -200,7 +200,7 @@ impl<'a> Parser<'a> {
Some(InnerAttrForbiddenReason::AfterOuterDocComment { prev_doc_comment_span }) => {
let mut diag = self.struct_span_err(
attr_sp,
fluent::parser_inner_attr_not_permitted_after_outer_doc_comment,
fluent::parse_inner_attr_not_permitted_after_outer_doc_comment,
);
diag.span_label(attr_sp, fluent::label_attr)
.span_label(prev_doc_comment_span, fluent::label_prev_doc_comment);
@ -209,18 +209,18 @@ impl<'a> Parser<'a> {
Some(InnerAttrForbiddenReason::AfterOuterAttribute { prev_outer_attr_sp }) => {
let mut diag = self.struct_span_err(
attr_sp,
fluent::parser_inner_attr_not_permitted_after_outer_attr,
fluent::parse_inner_attr_not_permitted_after_outer_attr,
);
diag.span_label(attr_sp, fluent::label_attr)
.span_label(prev_outer_attr_sp, fluent::label_prev_attr);
diag
}
Some(InnerAttrForbiddenReason::InCodeBlock) | None => {
self.struct_span_err(attr_sp, fluent::parser_inner_attr_not_permitted)
self.struct_span_err(attr_sp, fluent::parse_inner_attr_not_permitted)
}
};
diag.note(fluent::parser_inner_attr_explanation);
diag.note(fluent::parse_inner_attr_explanation);
if self
.annotate_following_item_if_applicable(
&mut diag,
@ -229,7 +229,7 @@ impl<'a> Parser<'a> {
)
.is_some()
{
diag.note(fluent::parser_outer_attr_explanation);
diag.note(fluent::parse_outer_attr_explanation);
};
diag.emit();
}

2
compiler/rustc_parse/src/parser/diagnostics.rs
View File

@ -937,7 +937,7 @@ impl<'a> Parser<'a> {
if self.eat(&token::Gt) {
e.span_suggestion_verbose(
binop.span.shrink_to_lo(),
fluent::parser_sugg_turbofish_syntax,
fluent::parse_sugg_turbofish_syntax,
"::",
Applicability::MaybeIncorrect,
)

26
compiler/rustc_session/src/errors.rs
View File

@ -196,7 +196,7 @@ pub enum UnleashedFeatureHelp {
}
#[derive(Diagnostic)]
#[diag(parser_invalid_literal_suffix)]
#[diag(session_invalid_literal_suffix)]
pub(crate) struct InvalidLiteralSuffix {
#[primary_span]
#[label]
@ -207,7 +207,7 @@ pub(crate) struct InvalidLiteralSuffix {
}
#[derive(Diagnostic)]
#[diag(parser_invalid_int_literal_width)]
#[diag(session_invalid_int_literal_width)]
#[help]
pub(crate) struct InvalidIntLiteralWidth {
#[primary_span]
@ -216,7 +216,7 @@ pub(crate) struct InvalidIntLiteralWidth {
}
#[derive(Diagnostic)]
#[diag(parser_invalid_num_literal_base_prefix)]
#[diag(session_invalid_num_literal_base_prefix)]
#[note]
pub(crate) struct InvalidNumLiteralBasePrefix {
#[primary_span]
@ -226,7 +226,7 @@ pub(crate) struct InvalidNumLiteralBasePrefix {
}
#[derive(Diagnostic)]
#[diag(parser_invalid_num_literal_suffix)]
#[diag(session_invalid_num_literal_suffix)]
#[help]
pub(crate) struct InvalidNumLiteralSuffix {
#[primary_span]
@ -236,7 +236,7 @@ pub(crate) struct InvalidNumLiteralSuffix {
}
#[derive(Diagnostic)]
#[diag(parser_invalid_float_literal_width)]
#[diag(session_invalid_float_literal_width)]
#[help]
pub(crate) struct InvalidFloatLiteralWidth {
#[primary_span]
@ -245,7 +245,7 @@ pub(crate) struct InvalidFloatLiteralWidth {
}
#[derive(Diagnostic)]
#[diag(parser_invalid_float_literal_suffix)]
#[diag(session_invalid_float_literal_suffix)]
#[help]
pub(crate) struct InvalidFloatLiteralSuffix {
#[primary_span]
@ -255,33 +255,33 @@ pub(crate) struct InvalidFloatLiteralSuffix {
}
#[derive(Diagnostic)]
#[diag(parser_int_literal_too_large)]
#[diag(session_int_literal_too_large)]
pub(crate) struct IntLiteralTooLarge {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(parser_hexadecimal_float_literal_not_supported)]
#[diag(session_hexadecimal_float_literal_not_supported)]
pub(crate) struct HexadecimalFloatLiteralNotSupported {
#[primary_span]
#[label(parser_not_supported)]
#[label(session_not_supported)]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(parser_octal_float_literal_not_supported)]
#[diag(session_octal_float_literal_not_supported)]
pub(crate) struct OctalFloatLiteralNotSupported {
#[primary_span]
#[label(parser_not_supported)]
#[label(session_not_supported)]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(parser_binary_float_literal_not_supported)]
#[diag(session_binary_float_literal_not_supported)]
pub(crate) struct BinaryFloatLiteralNotSupported {
#[primary_span]
#[label(parser_not_supported)]
#[label(session_not_supported)]
pub span: Span,
}

2
src/test/run-make/translation/broken.ftl
View File

@ -1,3 +1,3 @@
# `foo` isn't provided by this diagnostic so it is expected that the fallback message is used.
parser_struct_literal_body_without_path = this is a {$foo} message
parse_struct_literal_body_without_path = this is a {$foo} message
.suggestion = this is a test suggestion

2
src/test/run-make/translation/missing.ftl
View File

@ -1,3 +1,3 @@
# `parser_struct_literal_body_without_path` isn't provided by this resource at all, so the
# `parse_struct_literal_body_without_path` isn't provided by this resource at all, so the
# fallback should be used.
foo = bar

2
src/test/run-make/translation/working.ftl
View File

@ -1,2 +1,2 @@
parser_struct_literal_body_without_path = this is a test message
parse_struct_literal_body_without_path = this is a test message
.suggestion = this is a test suggestion

2
src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.rs
View File

@ -471,7 +471,7 @@ struct NoApplicability {
}
#[derive(Subdiagnostic)]
#[note(parser_add_paren)]
#[note(parse_add_paren)]
struct Note;
#[derive(Diagnostic)]

24
src/test/ui-fulldeps/session-diagnostic/enforce_slug_naming.rs Normal file
View File

@ -0,0 +1,24 @@
// rustc-env:CARGO_CRATE_NAME=rustc_dummy
#![feature(rustc_private)]
#![crate_type = "lib"]
extern crate rustc_span;
use rustc_span::symbol::Ident;
use rustc_span::Span;
extern crate rustc_macros;
use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
extern crate rustc_middle;
use rustc_middle::ty::Ty;
extern crate rustc_errors;
use rustc_errors::{Applicability, MultiSpan};
extern crate rustc_session;
#[derive(Diagnostic)]
#[diag(compiletest_example, code = "E0123")]
//~^ ERROR diagnostic slug and crate name do not match
struct Hello {}

11
src/test/ui-fulldeps/session-diagnostic/enforce_slug_naming.stderr Normal file
View File

@ -0,0 +1,11 @@
error: diagnostic slug and crate name do not match
--> $DIR/enforce_slug_naming.rs:22:8
|
LL | #[diag(compiletest_example, code = "E0123")]
| ^^^^^^^^^^^^^^^^^^^
|
= note: slug is `compiletest_example` but the crate name is `rustc_dummy`
= help: expected a slug starting with `dummy_...`
error: aborting due to previous error

140
src/test/ui-fulldeps/session-diagnostic/subdiagnostic-derive.rs
View File

@ -20,7 +20,7 @@ use rustc_macros::Subdiagnostic;
use rustc_span::Span;
#[derive(Subdiagnostic)]
#[label(parser_add_paren)]
#[label(parse_add_paren)]
struct A {
#[primary_span]
span: Span,
@ -29,13 +29,13 @@ struct A {
#[derive(Subdiagnostic)]
enum B {
#[label(parser_add_paren)]
#[label(parse_add_paren)]
A {
#[primary_span]
span: Span,
var: String,
},
#[label(parser_add_paren)]
#[label(parse_add_paren)]
B {
#[primary_span]
span: Span,
@ -44,7 +44,7 @@ enum B {
}
#[derive(Subdiagnostic)]
#[label(parser_add_paren)]
#[label(parse_add_paren)]
//~^ ERROR label without `#[primary_span]` field
struct C {
var: String,
@ -138,7 +138,7 @@ struct M {
}
#[derive(Subdiagnostic)]
#[label(parser_add_paren, code = "...")]
#[label(parse_add_paren, code = "...")]
//~^ ERROR `#[label(code = ...)]` is not a valid attribute
struct N {
#[primary_span]
@ -147,7 +147,7 @@ struct N {
}
#[derive(Subdiagnostic)]
#[label(parser_add_paren, applicability = "machine-applicable")]
#[label(parse_add_paren, applicability = "machine-applicable")]
//~^ ERROR `#[label(applicability = ...)]` is not a valid attribute
struct O {
#[primary_span]
@ -160,7 +160,7 @@ struct O {
//~^ ERROR cannot find attribute `foo` in this scope
//~^^ ERROR unsupported type attribute for subdiagnostic enum
enum P {
#[label(parser_add_paren)]
#[label(parse_add_paren)]
A {
#[primary_span]
span: Span,
@ -230,7 +230,7 @@ enum U {
#[derive(Subdiagnostic)]
enum V {
#[label(parser_add_paren)]
#[label(parse_add_paren)]
A {
#[primary_span]
span: Span,
@ -244,7 +244,7 @@ enum V {
}
#[derive(Subdiagnostic)]
#[label(parser_add_paren)]
#[label(parse_add_paren)]
//~^ ERROR label without `#[primary_span]` field
struct W {
#[primary_span]
@ -253,7 +253,7 @@ struct W {
}
#[derive(Subdiagnostic)]
#[label(parser_add_paren)]
#[label(parse_add_paren)]
struct X {
#[primary_span]
span: Span,
@ -263,7 +263,7 @@ struct X {
}
#[derive(Subdiagnostic)]
#[label(parser_add_paren)]
#[label(parse_add_paren)]
struct Y {
#[primary_span]
span: Span,
@ -274,7 +274,7 @@ struct Y {
}
#[derive(Subdiagnostic)]
#[label(parser_add_paren)]
#[label(parse_add_paren)]
struct Z {
#[primary_span]
span: Span,
@ -285,7 +285,7 @@ struct Z {
}
#[derive(Subdiagnostic)]
#[label(parser_add_paren)]
#[label(parse_add_paren)]
struct AA {
#[primary_span]
span: Span,
@ -296,7 +296,7 @@ struct AA {
}
#[derive(Subdiagnostic)]
#[label(parser_add_paren)]
#[label(parse_add_paren)]
struct AB {
#[primary_span]
span: Span,
@ -312,23 +312,23 @@ union AC {
}
#[derive(Subdiagnostic)]
#[label(parser_add_paren)]
#[label(parser_add_paren)]
#[label(parse_add_paren)]
#[label(parse_add_paren)]
struct AD {
#[primary_span]
span: Span,
}
#[derive(Subdiagnostic)]
#[label(parser_add_paren, parser_add_paren)]
//~^ ERROR `#[label(parser_add_paren)]` is not a valid attribute
#[label(parse_add_paren, parse_add_paren)]
//~^ ERROR `#[label(parse_add_paren)]` is not a valid attribute
struct AE {
#[primary_span]
span: Span,
}
#[derive(Subdiagnostic)]
#[label(parser_add_paren)]
#[label(parse_add_paren)]
struct AF {
#[primary_span]
//~^ NOTE previously specified here
@ -346,7 +346,7 @@ struct AG {
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "...")]
#[suggestion(parse_add_paren, code = "...")]
struct AH {
#[primary_span]
span: Span,
@ -357,7 +357,7 @@ struct AH {
#[derive(Subdiagnostic)]
enum AI {
#[suggestion(parser_add_paren, code = "...")]
#[suggestion(parse_add_paren, code = "...")]
A {
#[primary_span]
span: Span,
@ -365,7 +365,7 @@ enum AI {
applicability: Applicability,
var: String,
},
#[suggestion(parser_add_paren, code = "...")]
#[suggestion(parse_add_paren, code = "...")]
B {
#[primary_span]
span: Span,
@ -376,7 +376,7 @@ enum AI {
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "...", code = "...")]
#[suggestion(parse_add_paren, code = "...", code = "...")]
//~^ ERROR specified multiple times
//~^^ NOTE previously specified here
struct AJ {
@ -387,7 +387,7 @@ struct AJ {
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "...")]
#[suggestion(parse_add_paren, code = "...")]
struct AK {
#[primary_span]
span: Span,
@ -400,7 +400,7 @@ struct AK {
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "...")]
#[suggestion(parse_add_paren, code = "...")]
struct AL {
#[primary_span]
span: Span,
@ -410,14 +410,14 @@ struct AL {
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "...")]
#[suggestion(parse_add_paren, code = "...")]
struct AM {
#[primary_span]
span: Span,
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren)]
#[suggestion(parse_add_paren)]
//~^ ERROR suggestion without `code = "..."`
struct AN {
#[primary_span]
@ -427,7 +427,7 @@ struct AN {
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "...", applicability = "foo")]
#[suggestion(parse_add_paren, code = "...", applicability = "foo")]
//~^ ERROR invalid applicability
struct AO {
#[primary_span]
@ -435,24 +435,24 @@ struct AO {
}
#[derive(Subdiagnostic)]
#[help(parser_add_paren)]
#[help(parse_add_paren)]
struct AP {
var: String,
}
#[derive(Subdiagnostic)]
#[note(parser_add_paren)]
#[note(parse_add_paren)]
struct AQ;
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "...")]
#[suggestion(parse_add_paren, code = "...")]
//~^ ERROR suggestion without `#[primary_span]` field
struct AR {
var: String,
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "...", applicability = "machine-applicable")]
#[suggestion(parse_add_paren, code = "...", applicability = "machine-applicable")]
struct AS {
#[primary_span]
span: Span,
@ -462,7 +462,7 @@ struct AS {
#[label]
//~^ ERROR unsupported type attribute for subdiagnostic enum
enum AT {
#[label(parser_add_paren)]
#[label(parse_add_paren)]
A {
#[primary_span]
span: Span,
@ -471,7 +471,7 @@ enum AT {
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "{var}", applicability = "machine-applicable")]
#[suggestion(parse_add_paren, code = "{var}", applicability = "machine-applicable")]
struct AU {
#[primary_span]
span: Span,
@ -479,7 +479,7 @@ struct AU {
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "{var}", applicability = "machine-applicable")]
#[suggestion(parse_add_paren, code = "{var}", applicability = "machine-applicable")]
//~^ ERROR `var` doesn't refer to a field on this type
struct AV {
#[primary_span]
@ -488,7 +488,7 @@ struct AV {
#[derive(Subdiagnostic)]
enum AW {
#[suggestion(parser_add_paren, code = "{var}", applicability = "machine-applicable")]
#[suggestion(parse_add_paren, code = "{var}", applicability = "machine-applicable")]
A {
#[primary_span]
span: Span,
@ -498,7 +498,7 @@ enum AW {
#[derive(Subdiagnostic)]
enum AX {
#[suggestion(parser_add_paren, code = "{var}", applicability = "machine-applicable")]
#[suggestion(parse_add_paren, code = "{var}", applicability = "machine-applicable")]
//~^ ERROR `var` doesn't refer to a field on this type
A {
#[primary_span]
@ -507,18 +507,18 @@ enum AX {
}
#[derive(Subdiagnostic)]
#[warning(parser_add_paren)]
#[warning(parse_add_paren)]
struct AY {}
#[derive(Subdiagnostic)]
#[warning(parser_add_paren)]
#[warning(parse_add_paren)]
struct AZ {
#[primary_span]
span: Span,
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "...")]
#[suggestion(parse_add_paren, code = "...")]
//~^ ERROR suggestion without `#[primary_span]` field
struct BA {
#[suggestion_part]
@ -533,7 +533,7 @@ struct BA {
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(parser_add_paren, code = "...", applicability = "machine-applicable")]
#[multipart_suggestion(parse_add_paren, code = "...", applicability = "machine-applicable")]
//~^ ERROR multipart suggestion without any `#[suggestion_part(...)]` fields
//~| ERROR `#[multipart_suggestion(code = ...)]` is not a valid attribute
struct BBa {
@ -541,7 +541,7 @@ struct BBa {
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(parser_add_paren, applicability = "machine-applicable")]
#[multipart_suggestion(parse_add_paren, applicability = "machine-applicable")]
struct BBb {
#[suggestion_part]
//~^ ERROR `#[suggestion_part(...)]` attribute without `code = "..."`
@ -549,7 +549,7 @@ struct BBb {
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(parser_add_paren, applicability = "machine-applicable")]
#[multipart_suggestion(parse_add_paren, applicability = "machine-applicable")]
struct BBc {
#[suggestion_part()]
//~^ ERROR `#[suggestion_part(...)]` attribute without `code = "..."`
@ -557,7 +557,7 @@ struct BBc {
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(parser_add_paren)]
#[multipart_suggestion(parse_add_paren)]
//~^ ERROR multipart suggestion without any `#[suggestion_part(...)]` fields
struct BC {
#[primary_span]
@ -566,7 +566,7 @@ struct BC {
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(parser_add_paren)]
#[multipart_suggestion(parse_add_paren)]
struct BD {
#[suggestion_part]
//~^ ERROR `#[suggestion_part(...)]` attribute without `code = "..."`
@ -586,7 +586,7 @@ struct BD {
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(parser_add_paren, applicability = "machine-applicable")]
#[multipart_suggestion(parse_add_paren, applicability = "machine-applicable")]
struct BE {
#[suggestion_part(code = "...", code = ",,,")]
//~^ ERROR specified multiple times
@ -595,7 +595,7 @@ struct BE {
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(parser_add_paren, applicability = "machine-applicable")]
#[multipart_suggestion(parse_add_paren, applicability = "machine-applicable")]
struct BF {
#[suggestion_part(code = "(")]
first: Span,
@ -604,7 +604,7 @@ struct BF {
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(parser_add_paren)]
#[multipart_suggestion(parse_add_paren)]
struct BG {
#[applicability]
appl: Applicability,
@ -615,7 +615,7 @@ struct BG {
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(parser_add_paren, applicability = "machine-applicable")]
#[multipart_suggestion(parse_add_paren, applicability = "machine-applicable")]
struct BH {
#[applicability]
//~^ ERROR `#[applicability]` has no effect
@ -627,14 +627,14 @@ struct BH {
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(parser_add_paren, applicability = "machine-applicable")]
#[multipart_suggestion(parse_add_paren, applicability = "machine-applicable")]
struct BI {
#[suggestion_part(code = "")]
spans: Vec<Span>,
}
#[derive(Subdiagnostic)]
#[label(parser_add_paren)]
#[label(parse_add_paren)]
struct BJ {
#[primary_span]
span: Span,
@ -643,7 +643,7 @@ struct BJ {
/// with a doc comment on the type..
#[derive(Subdiagnostic)]
#[label(parser_add_paren)]
#[label(parse_add_paren)]
struct BK {
/// ..and the field
#[primary_span]
@ -654,7 +654,7 @@ struct BK {
#[derive(Subdiagnostic)]
enum BL {
/// ..and the variant..
#[label(parser_add_paren)]
#[label(parse_add_paren)]
Foo {
/// ..and the field
#[primary_span]
@ -663,7 +663,7 @@ enum BL {
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(parser_add_paren)]
#[multipart_suggestion(parse_add_paren)]
struct BM {
#[suggestion_part(code("foo"))]
//~^ ERROR expected exactly one string literal for `code = ...`
@ -672,7 +672,7 @@ struct BM {
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(parser_add_paren)]
#[multipart_suggestion(parse_add_paren)]
struct BN {
#[suggestion_part(code("foo", "bar"))]
//~^ ERROR expected exactly one string literal for `code = ...`
@ -681,7 +681,7 @@ struct BN {
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(parser_add_paren)]
#[multipart_suggestion(parse_add_paren)]
struct BO {
#[suggestion_part(code(3))]
//~^ ERROR expected exactly one string literal for `code = ...`
@ -690,7 +690,7 @@ struct BO {
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(parser_add_paren)]
#[multipart_suggestion(parse_add_paren)]
struct BP {
#[suggestion_part(code())]
//~^ ERROR expected exactly one string literal for `code = ...`
@ -699,7 +699,7 @@ struct BP {
}
#[derive(Subdiagnostic)]
#[multipart_suggestion(parser_add_paren)]
#[multipart_suggestion(parse_add_paren)]
struct BQ {
#[suggestion_part(code = 3)]
//~^ ERROR `code = "..."`/`code(...)` must contain only string literals
@ -708,42 +708,42 @@ struct BQ {
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "")]
#[suggestion(parse_add_paren, code = "")]
struct SuggestionStyleDefault {
#[primary_span]
sub: Span,
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "", style = "short")]
#[suggestion(parse_add_paren, code = "", style = "short")]
struct SuggestionStyleShort {
#[primary_span]
sub: Span,
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "", style = "hidden")]
#[suggestion(parse_add_paren, code = "", style = "hidden")]
struct SuggestionStyleHidden {
#[primary_span]
sub: Span,
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "", style = "verbose")]
#[suggestion(parse_add_paren, code = "", style = "verbose")]
struct SuggestionStyleVerbose {
#[primary_span]
sub: Span,
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "", style = "tool-only")]
#[suggestion(parse_add_paren, code = "", style = "tool-only")]
struct SuggestionStyleToolOnly {
#[primary_span]
sub: Span,
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "", style = "hidden", style = "normal")]
#[suggestion(parse_add_paren, code = "", style = "hidden", style = "normal")]
//~^ ERROR specified multiple times
//~| NOTE previously specified here
struct SuggestionStyleTwice {
@ -752,7 +752,7 @@ struct SuggestionStyleTwice {
}
#[derive(Subdiagnostic)]
#[suggestion_hidden(parser_add_paren, code = "")]
#[suggestion_hidden(parse_add_paren, code = "")]
//~^ ERROR #[suggestion_hidden(...)]` is not a valid attribute
struct SuggestionStyleOldSyntax {
#[primary_span]
@ -760,7 +760,7 @@ struct SuggestionStyleOldSyntax {
}
#[derive(Subdiagnostic)]
#[suggestion_hidden(parser_add_paren, code = "", style = "normal")]
#[suggestion_hidden(parse_add_paren, code = "", style = "normal")]
//~^ ERROR #[suggestion_hidden(...)]` is not a valid attribute
struct SuggestionStyleOldAndNewSyntax {
#[primary_span]
@ -768,7 +768,7 @@ struct SuggestionStyleOldAndNewSyntax {
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "", style = "foo")]
#[suggestion(parse_add_paren, code = "", style = "foo")]
//~^ ERROR invalid suggestion style
struct SuggestionStyleInvalid1 {
#[primary_span]
@ -776,7 +776,7 @@ struct SuggestionStyleInvalid1 {
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "", style = 42)]
#[suggestion(parse_add_paren, code = "", style = 42)]
//~^ ERROR `#[suggestion(style = ...)]` is not a valid attribute
struct SuggestionStyleInvalid2 {
#[primary_span]
@ -784,7 +784,7 @@ struct SuggestionStyleInvalid2 {
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "", style)]
#[suggestion(parse_add_paren, code = "", style)]
//~^ ERROR `#[suggestion(style)]` is not a valid attribute
struct SuggestionStyleInvalid3 {
#[primary_span]
@ -792,7 +792,7 @@ struct SuggestionStyleInvalid3 {
}
#[derive(Subdiagnostic)]
#[suggestion(parser_add_paren, code = "", style("foo"))]
#[suggestion(parse_add_paren, code = "", style("foo"))]
//~^ ERROR `#[suggestion(style(...))]` is not a valid attribute
struct SuggestionStyleInvalid4 {
#[primary_span]

116
src/test/ui-fulldeps/session-diagnostic/subdiagnostic-derive.stderr
View File

@ -1,7 +1,7 @@
error: label without `#[primary_span]` field
--> $DIR/subdiagnostic-derive.rs:47:1
|
LL | / #[label(parser_add_paren)]
LL | / #[label(parse_add_paren)]
LL | |
LL | | struct C {
LL | | var: String,
@ -81,16 +81,16 @@ LL | #[label()]
| ^^^^^^^^^^
error: `#[label(code = ...)]` is not a valid attribute
--> $DIR/subdiagnostic-derive.rs:141:27
--> $DIR/subdiagnostic-derive.rs:141:26
|
LL | #[label(parser_add_paren, code = "...")]
| ^^^^^^^^^^^^
LL | #[label(parse_add_paren, code = "...")]
| ^^^^^^^^^^^^
error: `#[label(applicability = ...)]` is not a valid attribute
--> $DIR/subdiagnostic-derive.rs:150:27
--> $DIR/subdiagnostic-derive.rs:150:26
|
LL | #[label(parser_add_paren, applicability = "machine-applicable")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | #[label(parse_add_paren, applicability = "machine-applicable")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: unsupported type attribute for subdiagnostic enum
--> $DIR/subdiagnostic-derive.rs:159:1
@ -143,7 +143,7 @@ LL | #[primary_span]
error: label without `#[primary_span]` field
--> $DIR/subdiagnostic-derive.rs:247:1
|
LL | / #[label(parser_add_paren)]
LL | / #[label(parse_add_paren)]
LL | |
LL | | struct W {
LL | | #[primary_span]
@ -190,11 +190,11 @@ LL | | b: u64,
LL | | }
| |_^
error: `#[label(parser_add_paren)]` is not a valid attribute
--> $DIR/subdiagnostic-derive.rs:323:27
error: `#[label(parse_add_paren)]` is not a valid attribute
--> $DIR/subdiagnostic-derive.rs:323:26
|
LL | #[label(parser_add_paren, parser_add_paren)]
| ^^^^^^^^^^^^^^^^
LL | #[label(parse_add_paren, parse_add_paren)]
| ^^^^^^^^^^^^^^^
|
= help: a diagnostic slug must be the first argument to the attribute
@ -217,16 +217,16 @@ LL | struct AG {
| ^^
error: specified multiple times
--> $DIR/subdiagnostic-derive.rs:379:46
--> $DIR/subdiagnostic-derive.rs:379:45
|
LL | #[suggestion(parser_add_paren, code = "...", code = "...")]
| ^^^^^^^^^^^^
LL | #[suggestion(parse_add_paren, code = "...", code = "...")]
| ^^^^^^^^^^^^
|
note: previously specified here
--> $DIR/subdiagnostic-derive.rs:379:32
--> $DIR/subdiagnostic-derive.rs:379:31
|
LL | #[suggestion(parser_add_paren, code = "...", code = "...")]
| ^^^^^^^^^^^^
LL | #[suggestion(parse_add_paren, code = "...", code = "...")]
| ^^^^^^^^^^^^
error: specified multiple times
--> $DIR/subdiagnostic-derive.rs:397:5
@ -249,19 +249,19 @@ LL | #[applicability]
error: suggestion without `code = "..."`
--> $DIR/subdiagnostic-derive.rs:420:1
|
LL | #[suggestion(parser_add_paren)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | #[suggestion(parse_add_paren)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: invalid applicability
--> $DIR/subdiagnostic-derive.rs:430:46
--> $DIR/subdiagnostic-derive.rs:430:45
|
LL | #[suggestion(parser_add_paren, code = "...", applicability = "foo")]
| ^^^^^^^^^^^^^^^^^^^^^
LL | #[suggestion(parse_add_paren, code = "...", applicability = "foo")]
| ^^^^^^^^^^^^^^^^^^^^^
error: suggestion without `#[primary_span]` field
--> $DIR/subdiagnostic-derive.rs:448:1
|
LL | / #[suggestion(parser_add_paren, code = "...")]
LL | / #[suggestion(parse_add_paren, code = "...")]
LL | |
LL | | struct AR {
LL | | var: String,
@ -275,16 +275,16 @@ LL | #[label]
| ^^^^^^^^
error: `var` doesn't refer to a field on this type
--> $DIR/subdiagnostic-derive.rs:482:39
--> $DIR/subdiagnostic-derive.rs:482:38
|
LL | #[suggestion(parser_add_paren, code = "{var}", applicability = "machine-applicable")]
| ^^^^^^^
LL | #[suggestion(parse_add_paren, code = "{var}", applicability = "machine-applicable")]
| ^^^^^^^
error: `var` doesn't refer to a field on this type
--> $DIR/subdiagnostic-derive.rs:501:43
--> $DIR/subdiagnostic-derive.rs:501:42
|
LL | #[suggestion(parser_add_paren, code = "{var}", applicability = "machine-applicable")]
| ^^^^^^^
LL | #[suggestion(parse_add_paren, code = "{var}", applicability = "machine-applicable")]
| ^^^^^^^
error: `#[suggestion_part]` is not a valid attribute
--> $DIR/subdiagnostic-derive.rs:524:5
@ -305,7 +305,7 @@ LL | #[suggestion_part(code = "...")]
error: suggestion without `#[primary_span]` field
--> $DIR/subdiagnostic-derive.rs:521:1
|
LL | / #[suggestion(parser_add_paren, code = "...")]
LL | / #[suggestion(parse_add_paren, code = "...")]
LL | |
LL | | struct BA {
LL | | #[suggestion_part]
@ -315,17 +315,17 @@ LL | | }
| |_^
error: `#[multipart_suggestion(code = ...)]` is not a valid attribute
--> $DIR/subdiagnostic-derive.rs:536:42
--> $DIR/subdiagnostic-derive.rs:536:41
|
LL | #[multipart_suggestion(parser_add_paren, code = "...", applicability = "machine-applicable")]
| ^^^^^^^^^^^^
LL | #[multipart_suggestion(parse_add_paren, code = "...", applicability = "machine-applicable")]
| ^^^^^^^^^^^^
|
= help: only `style` and `applicability` are valid nested attributes
error: multipart suggestion without any `#[suggestion_part(...)]` fields
--> $DIR/subdiagnostic-derive.rs:536:1
|
LL | / #[multipart_suggestion(parser_add_paren, code = "...", applicability = "machine-applicable")]
LL | / #[multipart_suggestion(parse_add_paren, code = "...", applicability = "machine-applicable")]
LL | |
LL | |
LL | | struct BBa {
@ -356,7 +356,7 @@ LL | #[primary_span]
error: multipart suggestion without any `#[suggestion_part(...)]` fields
--> $DIR/subdiagnostic-derive.rs:560:1
|
LL | / #[multipart_suggestion(parser_add_paren)]
LL | / #[multipart_suggestion(parse_add_paren)]
LL | |
LL | | struct BC {
LL | | #[primary_span]
@ -446,60 +446,60 @@ LL | #[suggestion_part(code = 3)]
| ^^^^^^^^
error: specified multiple times
--> $DIR/subdiagnostic-derive.rs:746:61
--> $DIR/subdiagnostic-derive.rs:746:60
|
LL | #[suggestion(parser_add_paren, code = "", style = "hidden", style = "normal")]
| ^^^^^^^^^^^^^^^^
LL | #[suggestion(parse_add_paren, code = "", style = "hidden", style = "normal")]
| ^^^^^^^^^^^^^^^^
|
note: previously specified here
--> $DIR/subdiagnostic-derive.rs:746:43
--> $DIR/subdiagnostic-derive.rs:746:42
|
LL | #[suggestion(parser_add_paren, code = "", style = "hidden", style = "normal")]
| ^^^^^^^^^^^^^^^^
LL | #[suggestion(parse_add_paren, code = "", style = "hidden", style = "normal")]
| ^^^^^^^^^^^^^^^^
error: `#[suggestion_hidden(...)]` is not a valid attribute
--> $DIR/subdiagnostic-derive.rs:755:1
|
LL | #[suggestion_hidden(parser_add_paren, code = "")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | #[suggestion_hidden(parse_add_paren, code = "")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: Use `#[suggestion(..., style = "hidden")]` instead
error: `#[suggestion_hidden(...)]` is not a valid attribute
--> $DIR/subdiagnostic-derive.rs:763:1
|
LL | #[suggestion_hidden(parser_add_paren, code = "", style = "normal")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | #[suggestion_hidden(parse_add_paren, code = "", style = "normal")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: Use `#[suggestion(..., style = "hidden")]` instead
error: invalid suggestion style
--> $DIR/subdiagnostic-derive.rs:771:51
--> $DIR/subdiagnostic-derive.rs:771:50
|
LL | #[suggestion(parser_add_paren, code = "", style = "foo")]
| ^^^^^
LL | #[suggestion(parse_add_paren, code = "", style = "foo")]
| ^^^^^
|
= help: valid styles are `normal`, `short`, `hidden`, `verbose` and `tool-only`
error: `#[suggestion(style = ...)]` is not a valid attribute
--> $DIR/subdiagnostic-derive.rs:779:43
--> $DIR/subdiagnostic-derive.rs:779:42
|
LL | #[suggestion(parser_add_paren, code = "", style = 42)]
| ^^^^^^^^^^
LL | #[suggestion(parse_add_paren, code = "", style = 42)]
| ^^^^^^^^^^
error: `#[suggestion(style)]` is not a valid attribute
--> $DIR/subdiagnostic-derive.rs:787:43
--> $DIR/subdiagnostic-derive.rs:787:42
|
LL | #[suggestion(parser_add_paren, code = "", style)]
| ^^^^^
LL | #[suggestion(parse_add_paren, code = "", style)]
| ^^^^^
|
= help: a diagnostic slug must be the first argument to the attribute
error: `#[suggestion(style(...))]` is not a valid attribute
--> $DIR/subdiagnostic-derive.rs:795:43
--> $DIR/subdiagnostic-derive.rs:795:42
|
LL | #[suggestion(parser_add_paren, code = "", style("foo"))]
| ^^^^^^^^^^^^
LL | #[suggestion(parse_add_paren, code = "", style("foo"))]
| ^^^^^^^^^^^^
error: cannot find attribute `foo` in this scope
--> $DIR/subdiagnostic-derive.rs:63:3