mirror of
https://github.com/rust-lang/rust.git
synced 2024-11-23 07:14:28 +00:00
cf09cba20c
Previously we would only mention that the item was gated out, and opportunisitically mention the feature flag name when possible. We now point to the place where the item was gated, which can be behind layers of macro indirection, or in different modules.
```
error[E0433]: failed to resolve: could not find `doesnt_exist` in `inner`
--> $DIR/diagnostics-cross-crate.rs:18:23
|
LL | cfged_out::inner::doesnt_exist::hello();
| ^^^^^^^^^^^^ could not find `doesnt_exist` in `inner`
|
note: found an item that was configured out
--> $DIR/auxiliary/cfged_out.rs:6:13
|
LL | pub mod doesnt_exist {
| ^^^^^^^^^^^^
note: the item is gated here
--> $DIR/auxiliary/cfged_out.rs:5:5
|
LL | #[cfg(FALSE)]
| ^^^^^^^^^^^^^
```
480 lines
17 KiB
Plaintext
480 lines
17 KiB
Plaintext
resolve_accessible_unsure = not sure whether the path is accessible or not
|
|
.note = the type may have associated items, but we are currently not checking them
|
|
|
|
resolve_add_as_non_derive =
|
|
add as non-Derive macro
|
|
`#[{$macro_path}]`
|
|
|
|
resolve_added_macro_use =
|
|
have you added the `#[macro_use]` on the module/import?
|
|
|
|
resolve_ancestor_only =
|
|
visibilities can only be restricted to ancestor modules
|
|
|
|
resolve_anonymous_livetime_non_gat_report_error =
|
|
in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
|
|
.label = this lifetime must come from the implemented type
|
|
|
|
resolve_arguments_macro_use_not_allowed = arguments to `macro_use` are not allowed here
|
|
|
|
resolve_associated_const_with_similar_name_exists =
|
|
there is an associated constant with a similar name
|
|
|
|
resolve_associated_fn_with_similar_name_exists =
|
|
there is an associated function with a similar name
|
|
|
|
resolve_associated_type_with_similar_name_exists =
|
|
there is an associated type with a similar name
|
|
|
|
resolve_attempt_to_define_builtin_macro_twice =
|
|
attempted to define built-in macro more than once
|
|
.note = previously defined here
|
|
|
|
resolve_attempt_to_use_non_constant_value_in_constant =
|
|
attempt to use a non-constant value in a constant
|
|
|
|
resolve_attempt_to_use_non_constant_value_in_constant_label_with_suggestion =
|
|
non-constant value
|
|
|
|
resolve_attempt_to_use_non_constant_value_in_constant_with_suggestion =
|
|
consider using `{$suggestion}` instead of `{$current}`
|
|
|
|
resolve_attempt_to_use_non_constant_value_in_constant_without_suggestion =
|
|
this would need to be a `{$suggestion}`
|
|
|
|
resolve_attributes_starting_with_rustc_are_reserved =
|
|
attributes starting with `rustc` are reserved for use by the `rustc` compiler
|
|
|
|
resolve_bad_macro_import = bad macro import
|
|
|
|
resolve_binding_in_never_pattern =
|
|
never patterns cannot contain variable bindings
|
|
.suggestion = use a wildcard `_` instead
|
|
|
|
resolve_binding_shadows_something_unacceptable =
|
|
{$shadowing_binding}s cannot shadow {$shadowed_binding}s
|
|
.label = cannot be named the same as {$article} {$shadowed_binding}
|
|
.label_shadowed_binding = the {$shadowed_binding} `{$name}` is {$participle} here
|
|
|
|
resolve_binding_shadows_something_unacceptable_suggestion =
|
|
try specify the pattern arguments
|
|
|
|
resolve_cannot_be_reexported_crate_public =
|
|
`{$ident}` is only public within the crate, and cannot be re-exported outside
|
|
|
|
resolve_cannot_be_reexported_private =
|
|
`{$ident}` is private, and cannot be re-exported
|
|
|
|
resolve_cannot_capture_dynamic_environment_in_fn_item =
|
|
can't capture dynamic environment in a fn item
|
|
.help = use the `|| {"{"} ... {"}"}` closure form instead
|
|
|
|
resolve_cannot_determine_import_resolution =
|
|
cannot determine resolution for the import
|
|
.note = import resolution is stuck, try simplifying other imports
|
|
|
|
resolve_cannot_determine_macro_resolution =
|
|
cannot determine resolution for the {$kind} `{$path}`
|
|
.note = import resolution is stuck, try simplifying macro imports
|
|
|
|
resolve_cannot_find_builtin_macro_with_name =
|
|
cannot find a built-in macro with name `{$ident}`
|
|
|
|
resolve_cannot_find_ident_in_this_scope =
|
|
cannot find {$expected} `{$ident}` in this scope
|
|
|
|
resolve_cannot_glob_import_possible_crates =
|
|
cannot glob-import all possible crates
|
|
|
|
resolve_cannot_use_through_an_import =
|
|
cannot use {$article} {$descr} through an import
|
|
.note = the {$descr} imported here
|
|
|
|
resolve_change_import_binding =
|
|
you can use `as` to change the binding name of the import
|
|
|
|
resolve_consider_adding_a_derive =
|
|
consider adding a derive
|
|
|
|
resolve_consider_adding_macro_export =
|
|
consider adding a `#[macro_export]` to the macro in the imported module
|
|
|
|
resolve_consider_declaring_with_pub =
|
|
consider declaring type or module `{$ident}` with `pub`
|
|
|
|
resolve_consider_making_the_field_public =
|
|
{ $number_of_fields ->
|
|
[one] consider making the field publicly accessible
|
|
*[other] consider making the fields publicly accessible
|
|
}
|
|
|
|
resolve_consider_marking_as_pub =
|
|
consider marking `{$ident}` as `pub` in the imported module
|
|
|
|
resolve_consider_move_macro_position =
|
|
consider moving the definition of `{$ident}` before this call
|
|
|
|
|
|
resolve_const_not_member_of_trait =
|
|
const `{$const_}` is not a member of trait `{$trait_}`
|
|
.label = not a member of trait `{$trait_}`
|
|
|
|
resolve_const_param_in_enum_discriminant =
|
|
const parameters may not be used in enum discriminant values
|
|
|
|
resolve_const_param_in_non_trivial_anon_const =
|
|
const parameters may only be used as standalone arguments, i.e. `{$name}`
|
|
|
|
resolve_const_param_in_ty_of_const_param =
|
|
const parameters may not be used in the type of const parameters
|
|
|
|
resolve_constructor_private_if_any_field_private =
|
|
a constructor is private if any of the fields is private
|
|
|
|
resolve_elided_anonymous_lifetime_report_error =
|
|
`&` without an explicit lifetime name cannot be used here
|
|
.label = explicit lifetime name needed here
|
|
|
|
resolve_elided_anonymous_lifetime_report_error_suggestion =
|
|
consider introducing a higher-ranked lifetime here
|
|
|
|
resolve_expected_module_found =
|
|
expected module, found {$res} `{$path_str}`
|
|
.label = not a module
|
|
|
|
resolve_explicit_anonymous_lifetime_report_error =
|
|
`'_` cannot be used here
|
|
.label = `'_` is a reserved lifetime name
|
|
|
|
resolve_explicit_unsafe_traits =
|
|
unsafe traits like `{$ident}` should be implemented explicitly
|
|
|
|
resolve_extern_crate_loading_macro_not_at_crate_root =
|
|
an `extern crate` loading macros must be at the crate root
|
|
|
|
resolve_extern_crate_self_requires_renaming =
|
|
`extern crate self;` requires renaming
|
|
.suggestion = rename the `self` crate to be able to import it
|
|
|
|
resolve_forward_declared_generic_param =
|
|
generic parameters with a default cannot use forward declared identifiers
|
|
.label = defaulted generic parameters cannot be forward declared
|
|
|
|
resolve_found_an_item_configured_out =
|
|
found an item that was configured out
|
|
|
|
resolve_generic_arguments_in_macro_path =
|
|
generic arguments in macro path
|
|
|
|
resolve_generic_params_from_outer_item =
|
|
can't use {$is_self ->
|
|
[true] `Self`
|
|
*[false] generic parameters
|
|
} from outer item
|
|
.label = use of {$is_self ->
|
|
[true] `Self`
|
|
*[false] generic parameter
|
|
} from outer item
|
|
.refer_to_type_directly = refer to the type directly here instead
|
|
.suggestion = try introducing a local generic parameter here
|
|
|
|
resolve_generic_params_from_outer_item_const = a `const` is a separate item from the item that contains it
|
|
|
|
resolve_generic_params_from_outer_item_const_param = const parameter from outer item
|
|
|
|
resolve_generic_params_from_outer_item_self_ty_alias = `Self` type implicitly declared here, by this `impl`
|
|
|
|
resolve_generic_params_from_outer_item_self_ty_param = can't use `Self` here
|
|
|
|
resolve_generic_params_from_outer_item_static = a `static` is a separate item from the item that contains it
|
|
|
|
resolve_generic_params_from_outer_item_ty_param = type parameter from outer item
|
|
|
|
resolve_ident_bound_more_than_once_in_parameter_list =
|
|
identifier `{$identifier}` is bound more than once in this parameter list
|
|
.label = used as parameter more than once
|
|
|
|
resolve_ident_bound_more_than_once_in_same_pattern =
|
|
identifier `{$identifier}` is bound more than once in the same pattern
|
|
.label = used in a pattern more than once
|
|
|
|
resolve_ident_imported_here_but_it_is_desc =
|
|
`{$imported_ident}` is imported here, but it is {$imported_ident_desc}
|
|
|
|
resolve_ident_in_scope_but_it_is_desc =
|
|
`{$imported_ident}` is in scope, but it is {$imported_ident_desc}
|
|
|
|
resolve_implicit_elided_lifetimes_not_allowed_here = implicit elided lifetime not allowed here
|
|
|
|
resolve_imported_crate = `$crate` may not be imported
|
|
|
|
resolve_imported_macro_not_found = imported macro not found
|
|
|
|
resolve_imports_cannot_refer_to =
|
|
imports cannot refer to {$what}
|
|
|
|
resolve_indeterminate =
|
|
cannot determine resolution for the visibility
|
|
|
|
resolve_invalid_asm_sym =
|
|
invalid `sym` operand
|
|
.label = is a local variable
|
|
.help = `sym` operands must refer to either a function or a static
|
|
|
|
resolve_is_not_directly_importable =
|
|
`{$target}` is not directly importable
|
|
.label = cannot be imported directly
|
|
|
|
resolve_is_private =
|
|
{$ident_descr} `{$ident}` is private
|
|
.label = private {$ident_descr}
|
|
|
|
resolve_item_was_behind_feature =
|
|
the item is gated behind the `{$feature}` feature
|
|
|
|
resolve_item_was_cfg_out = the item is gated here
|
|
|
|
resolve_items_in_traits_are_not_importable =
|
|
items in traits are not importable
|
|
|
|
resolve_label_with_similar_name_reachable =
|
|
a label with a similar name is reachable
|
|
|
|
resolve_lending_iterator_report_error =
|
|
associated type `Iterator::Item` is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
|
|
.note = you can't create an `Iterator` that borrows each `Item` from itself, but you can instead create a new type that borrows your existing type and implement `Iterator` for that new type
|
|
|
|
resolve_lifetime_param_in_enum_discriminant =
|
|
lifetime parameters may not be used in enum discriminant values
|
|
|
|
resolve_lifetime_param_in_non_trivial_anon_const =
|
|
lifetime parameters may not be used in const expressions
|
|
|
|
resolve_lifetime_param_in_ty_of_const_param =
|
|
lifetime parameters may not be used in the type of const parameters
|
|
|
|
resolve_lowercase_self =
|
|
attempt to use a non-constant value in a constant
|
|
.suggestion = try using `Self`
|
|
|
|
resolve_macro_defined_later =
|
|
a macro with the same name exists, but it appears later at here
|
|
|
|
resolve_macro_expanded_extern_crate_cannot_shadow_extern_arguments =
|
|
macro-expanded `extern crate` items cannot shadow names passed with `--extern`
|
|
|
|
resolve_macro_expected_found =
|
|
expected {$expected}, found {$found} `{$macro_path}`
|
|
.label = not {$article} {$expected}
|
|
|
|
resolve_macro_extern_deprecated =
|
|
`#[macro_escape]` is a deprecated synonym for `#[macro_use]`
|
|
.help = try an outer attribute: `#[macro_use]`
|
|
|
|
resolve_macro_use_extern_crate_self = `#[macro_use]` is not supported on `extern crate self`
|
|
|
|
resolve_macro_use_name_already_in_use =
|
|
`{$name}` is already in scope
|
|
.note = macro-expanded `#[macro_use]`s may not shadow existing macros (see RFC 1560)
|
|
|
|
resolve_method_not_member_of_trait =
|
|
method `{$method}` is not a member of trait `{$trait_}`
|
|
.label = not a member of trait `{$trait_}`
|
|
|
|
resolve_missing_macro_rules_name = maybe you have forgotten to define a name for this `macro_rules!`
|
|
|
|
resolve_module_only =
|
|
visibility must resolve to a module
|
|
|
|
resolve_name_defined_multiple_time =
|
|
the name `{$name}` is defined multiple times
|
|
.note = `{$name}` must be defined only once in the {$descr} namespace of this {$container}
|
|
|
|
resolve_name_defined_multiple_time_old_binding_definition =
|
|
previous definition of the {$old_kind} `{$name}` here
|
|
|
|
resolve_name_defined_multiple_time_old_binding_import =
|
|
previous import of the {$old_kind} `{$name}` here
|
|
|
|
resolve_name_defined_multiple_time_redefined =
|
|
`{$name}` redefined here
|
|
|
|
resolve_name_defined_multiple_time_reimported =
|
|
`{$name}` reimported here
|
|
|
|
resolve_name_is_already_used_as_generic_parameter =
|
|
the name `{$name}` is already used for a generic parameter in this item's generic parameters
|
|
.label = already used
|
|
.first_use_of_name = first use of `{$name}`
|
|
|
|
resolve_name_reserved_in_attribute_namespace =
|
|
name `{$ident}` is reserved in attribute namespace
|
|
|
|
resolve_note_and_refers_to_the_item_defined_here =
|
|
{$first ->
|
|
[true] {$dots ->
|
|
[true] the {$binding_descr} `{$binding_name}` is defined here...
|
|
*[false] the {$binding_descr} `{$binding_name}` is defined here
|
|
}
|
|
*[false] {$dots ->
|
|
[true] ...and refers to the {$binding_descr} `{$binding_name}` which is defined here...
|
|
*[false] ...and refers to the {$binding_descr} `{$binding_name}` which is defined here
|
|
}
|
|
}
|
|
|
|
resolve_outer_ident_is_not_publicly_reexported =
|
|
{$outer_ident_descr} `{$outer_ident}` is not publicly re-exported
|
|
|
|
resolve_param_in_enum_discriminant =
|
|
generic parameters may not be used in enum discriminant values
|
|
.label = cannot perform const operation using `{$name}`
|
|
|
|
resolve_param_in_non_trivial_anon_const =
|
|
generic parameters may not be used in const operations
|
|
.label = cannot perform const operation using `{$name}`
|
|
|
|
resolve_param_in_non_trivial_anon_const_help =
|
|
add `#![feature(generic_const_exprs)]` to allow generic const expressions
|
|
|
|
resolve_param_in_ty_of_const_param =
|
|
the type of const parameters must not depend on other generic parameters
|
|
.label = the type must not depend on the parameter `{$name}`
|
|
|
|
resolve_pattern_doesnt_bind_name = pattern doesn't bind `{$name}`
|
|
|
|
resolve_proc_macro_same_crate = can't use a procedural macro from the same crate that defines it
|
|
.help = you can define integration tests in a directory named `tests`
|
|
|
|
resolve_reexport_of_crate_public =
|
|
re-export of crate public `{$ident}`
|
|
|
|
resolve_reexport_of_private =
|
|
re-export of private `{$ident}`
|
|
|
|
resolve_relative_2018 =
|
|
relative paths are not supported in visibilities in 2018 edition or later
|
|
.suggestion = try
|
|
|
|
resolve_remove_surrounding_derive =
|
|
remove from the surrounding `derive()`
|
|
|
|
resolve_remove_unnecessary_import = remove unnecessary import
|
|
|
|
resolve_self_import_can_only_appear_once_in_the_list =
|
|
`self` import can only appear once in an import list
|
|
.label = can only appear once in an import list
|
|
|
|
resolve_self_import_only_in_import_list_with_non_empty_prefix =
|
|
`self` import can only appear in an import list with a non-empty prefix
|
|
.label = can only appear in an import list with a non-empty prefix
|
|
|
|
resolve_self_imports_only_allowed_within =
|
|
`self` imports are only allowed within a {"{"} {"}"} list
|
|
|
|
resolve_self_imports_only_allowed_within_multipart_suggestion =
|
|
alternatively, use the multi-path `use` syntax to import `self`
|
|
|
|
resolve_self_imports_only_allowed_within_suggestion =
|
|
consider importing the module directly
|
|
|
|
resolve_self_in_generic_param_default =
|
|
generic parameters cannot use `Self` in their defaults
|
|
.label = `Self` in generic parameter default
|
|
|
|
resolve_similarly_named_defined_here =
|
|
similarly named {$candidate_descr} `{$candidate}` defined here
|
|
|
|
resolve_single_item_defined_here =
|
|
{$candidate_descr} `{$candidate}` defined here
|
|
|
|
resolve_static_lifetime_is_reserved = invalid lifetime parameter name: `{$lifetime}`
|
|
.label = 'static is a reserved lifetime name
|
|
|
|
resolve_suggestion_import_ident_directly =
|
|
import `{$ident}` directly
|
|
|
|
resolve_suggestion_import_ident_through_reexport =
|
|
import `{$ident}` through the re-export
|
|
|
|
resolve_tool_module_imported =
|
|
cannot use a tool module through an import
|
|
.note = the tool module imported here
|
|
|
|
resolve_tool_only_accepts_identifiers =
|
|
`{$tool}` only accepts identifiers
|
|
.label = not an identifier
|
|
|
|
resolve_tool_was_already_registered =
|
|
tool `{$tool}` was already registered
|
|
.label = already registered here
|
|
|
|
resolve_trait_impl_duplicate =
|
|
duplicate definitions with name `{$name}`:
|
|
.label = duplicate definition
|
|
.old_span_label = previous definition here
|
|
.trait_item_span = item in trait
|
|
|
|
resolve_trait_impl_mismatch =
|
|
item `{$name}` is an associated {$kind}, which doesn't match its trait `{$trait_path}`
|
|
.label = does not match trait
|
|
.trait_impl_mismatch_label_item = item in trait
|
|
resolve_try_using_similarly_named_label =
|
|
try using similarly named label
|
|
|
|
resolve_type_not_member_of_trait =
|
|
type `{$type_}` is not a member of trait `{$trait_}`
|
|
.label = not a member of trait `{$trait_}`
|
|
|
|
resolve_type_param_in_enum_discriminant =
|
|
type parameters may not be used in enum discriminant values
|
|
|
|
resolve_type_param_in_non_trivial_anon_const =
|
|
type parameters may not be used in const expressions
|
|
|
|
resolve_type_param_in_ty_of_const_param =
|
|
type parameters may not be used in the type of const parameters
|
|
|
|
resolve_undeclared_label =
|
|
use of undeclared label `{$name}`
|
|
.label = undeclared label `{$name}`
|
|
|
|
resolve_underscore_lifetime_is_reserved = `'_` cannot be used here
|
|
.label = `'_` is a reserved lifetime name
|
|
|
|
resolve_unexpected_res_change_ty_to_const_param_sugg =
|
|
you might have meant to write a const parameter here
|
|
|
|
resolve_unexpected_res_use_at_op_in_slice_pat_with_range_sugg =
|
|
if you meant to collect the rest of the slice in `{$ident}`, use the at operator
|
|
|
|
resolve_unnamed_crate_root_import =
|
|
crate root imports need to be explicitly named: `use crate as name;`
|
|
|
|
resolve_unreachable_label =
|
|
use of unreachable label `{$name}`
|
|
.label = unreachable label `{$name}`
|
|
.label_definition_span = unreachable label defined here
|
|
.note = labels are unreachable through functions, closures, async blocks and modules
|
|
|
|
resolve_unreachable_label_similar_name_reachable =
|
|
a label with a similar name is reachable
|
|
|
|
resolve_unreachable_label_similar_name_unreachable =
|
|
a label with a similar name exists but is also unreachable
|
|
|
|
resolve_unreachable_label_suggestion_use_similarly_named =
|
|
try using similarly named label
|
|
|
|
resolve_unreachable_label_with_similar_name_exists =
|
|
a label with a similar name exists but is unreachable
|
|
|
|
resolve_variable_bound_with_different_mode =
|
|
variable `{$variable_name}` is bound inconsistently across alternatives separated by `|`
|
|
.label = bound in different ways
|
|
.first_binding_span = first binding
|
|
|
|
resolve_variable_is_not_bound_in_all_patterns =
|
|
variable `{$name}` is not bound in all patterns
|
|
|
|
resolve_variable_not_in_all_patterns = variable not in all patterns
|