fork/rust
git clone https://git.julia.blue/fork/rust
3bcad65fbf6
master
1hir_analysis_ambiguous_lifetime_bound = 2 ambiguous lifetime bound, explicit lifetime bound required 3 4hir_analysis_assoc_bound_on_const = expected associated type, found {$descr} 5 .note = trait bounds not allowed on {$descr} 6 7hir_analysis_assoc_type_binding_not_allowed = 8 associated type bindings are not allowed here 9 .label = associated type not allowed here 10 11hir_analysis_associated_type_trait_uninferred_generic_params = cannot use the associated type of a trait with uninferred generic parameters 12 .suggestion = use a fully qualified path with inferred lifetimes 13 14hir_analysis_associated_type_trait_uninferred_generic_params_multipart_suggestion = use a fully qualified path with explicit lifetimes 15 16hir_analysis_async_trait_impl_should_be_async = 17 method `{$method_name}` should be async because the method from the trait is async 18 .trait_item_label = required because the trait method is async 19 20hir_analysis_auto_deref_reached_recursion_limit = reached the recursion limit while auto-dereferencing `{$ty}` 21 .label = deref recursion limit reached 22 .help = consider increasing the recursion limit by adding a `#![recursion_limit = "{$suggested_limit}"]` attribute to your crate (`{$crate_name}`) 23 24hir_analysis_cannot_capture_late_bound_const = 25 cannot capture late-bound const parameter in {$what} 26 .label = parameter defined here 27 28hir_analysis_cannot_capture_late_bound_lifetime = 29 cannot capture late-bound lifetime in {$what} 30 .label = lifetime defined here 31 32hir_analysis_cannot_capture_late_bound_ty = 33 cannot capture late-bound type parameter in {$what} 34 .label = parameter defined here 35 36hir_analysis_cast_thin_pointer_to_fat_pointer = cannot cast thin pointer `{$expr_ty}` to fat pointer `{$cast_ty}` 37 38hir_analysis_closure_implicit_hrtb = implicit types in closure signatures are forbidden when `for<...>` is present 39 .label = `for<...>` is here 40 41hir_analysis_coerce_unsized_may = the trait `{$trait_name}` may only be implemented for a coercion between structures 42 43hir_analysis_coerce_unsized_multi = implementing the trait `CoerceUnsized` requires multiple coercions 44 .note = `CoerceUnsized` may only be implemented for a coercion between structures with one field being coerced 45 .coercions_note = currently, {$number} fields need coercions: {$coercions} 46 .label = requires multiple coercions 47 48hir_analysis_coercion_between_struct_same_note = expected coercion between the same definition; expected `{$source_path}`, found `{$target_path}` 49 50hir_analysis_coercion_between_struct_single_note = expected a single field to be coerced, none found 51 52hir_analysis_const_bound_for_non_const_trait = 53 ~const can only be applied to `#[const_trait]` traits 54 55hir_analysis_const_impl_for_non_const_trait = 56 const `impl` for trait `{$trait_name}` which is not marked with `#[const_trait]` 57 .suggestion = mark `{$trait_name}` as const 58 .note = marking a trait with `#[const_trait]` ensures all default method bodies are `const` 59 .adding = adding a non-const method body in the future would be a breaking change 60 61hir_analysis_const_param_ty_impl_on_non_adt = 62 the trait `ConstParamTy` may not be implemented for this type 63 .label = type is not a structure or enumeration 64 65hir_analysis_const_specialize = cannot specialize on const impl with non-const impl 66 67hir_analysis_copy_impl_on_non_adt = 68 the trait `Copy` cannot be implemented for this type 69 .label = type is not a structure or enumeration 70 71hir_analysis_copy_impl_on_type_with_dtor = 72 the trait `Copy` cannot be implemented for this type; the type has a destructor 73 .label = `Copy` not allowed on types with destructors 74 75hir_analysis_dispatch_from_dyn_multi = implementing the `DispatchFromDyn` trait requires multiple coercions 76 .note = the trait `DispatchFromDyn` may only be implemented for a coercion between structures with a single field being coerced 77 .coercions_note = currently, {$number} fields need coercions: {$coercions} 78 79hir_analysis_dispatch_from_dyn_repr = structs implementing `DispatchFromDyn` may not have `#[repr(packed)]` or `#[repr(C)]` 80 81hir_analysis_dispatch_from_dyn_zst = the trait `DispatchFromDyn` may only be implemented for structs containing the field being coerced, ZST fields with 1 byte alignment, and nothing else 82 .note = extra field `{$name}` of type `{$ty}` is not allowed 83 84hir_analysis_drop_impl_negative = negative `Drop` impls are not supported 85 86hir_analysis_drop_impl_on_wrong_item = 87 the `Drop` trait may only be implemented for local structs, enums, and unions 88 .label = must be a struct, enum, or union in the current crate 89 90hir_analysis_drop_impl_reservation = reservation `Drop` impls are not supported 91 92hir_analysis_empty_specialization = specialization impl does not specialize any associated items 93 .note = impl is a specialization of this impl 94 95hir_analysis_enum_discriminant_overflowed = enum discriminant overflowed 96 .label = overflowed on value after {$discr} 97 .note = explicitly set `{$item_name} = {$wrapped_discr}` if that is desired outcome 98 99hir_analysis_field_already_declared = 100 field `{$field_name}` is already declared 101 .label = field already declared 102 .previous_decl_label = `{$field_name}` first declared here 103 104hir_analysis_function_not_found_in_trait = function not found in this trait 105 106hir_analysis_function_not_have_default_implementation = function doesn't have a default implementation 107 .note = required by this annotation 108 109hir_analysis_functions_names_duplicated = functions names are duplicated 110 .note = all `#[rustc_must_implement_one_of]` arguments must be unique 111 112hir_analysis_impl_not_marked_default = `{$ident}` specializes an item from a parent `impl`, but that item is not marked `default` 113 .label = cannot specialize default item `{$ident}` 114 .ok_label = parent `impl` is here 115 .note = to specialize, `{$ident}` in the parent `impl` must be marked `default` 116 117hir_analysis_impl_not_marked_default_err = `{$ident}` specializes an item from a parent `impl`, but that item is not marked `default` 118 .note = parent implementation is in crate `{$cname}` 119 120hir_analysis_inherent_dyn = cannot define inherent `impl` for a dyn auto trait 121 .label = impl requires at least one non-auto trait 122 .note = define and implement a new trait or type instead 123 124hir_analysis_inherent_nominal = no nominal type found for inherent implementation 125 .label = impl requires a nominal type 126 .note = either implement a trait on it or create a newtype to wrap it instead 127hir_analysis_inherent_primitive_ty = cannot define inherent `impl` for primitive types 128 .help = consider using an extension trait instead 129 130hir_analysis_inherent_primitive_ty_note = you could also try moving the reference to uses of `{$subty}` (such as `self`) within the implementation 131 132hir_analysis_inherent_ty_outside = cannot define inherent `impl` for a type outside of the crate where the type is defined 133 .help = consider moving this inherent impl into the crate defining the type if possible 134 .span_help = alternatively add `#[rustc_has_incoherent_inherent_impls]` to the type and `#[rustc_allow_incoherent_impl]` to the relevant impl items 135 136hir_analysis_inherent_ty_outside_new = cannot define inherent `impl` for a type outside of the crate where the type is defined 137 .label = impl for type defined outside of crate. 138 .note = define and implement a trait or new type instead 139 140hir_analysis_inherent_ty_outside_primitive = cannot define inherent `impl` for primitive types outside of `core` 141 .help = consider moving this inherent impl into `core` if possible 142 .span_help = alternatively add `#[rustc_allow_incoherent_impl]` to the relevant impl items 143 144hir_analysis_inherent_ty_outside_relevant = cannot define inherent `impl` for a type outside of the crate where the type is defined 145 .help = consider moving this inherent impl into the crate defining the type if possible 146 .span_help = alternatively add `#[rustc_allow_incoherent_impl]` to the relevant impl items 147 148hir_analysis_invalid_union_field = 149 field must implement `Copy` or be wrapped in `ManuallyDrop<...>` to be used in a union 150 .note = union fields must not have drop side-effects, which is currently enforced via either `Copy` or `ManuallyDrop<...>` 151 152hir_analysis_invalid_union_field_sugg = 153 wrap the field type in `ManuallyDrop<...>` 154 155hir_analysis_late_bound_const_in_apit = `impl Trait` can only mention const parameters from an fn or impl 156 .label = const parameter declared here 157 158hir_analysis_late_bound_lifetime_in_apit = `impl Trait` can only mention lifetimes from an fn or impl 159 .label = lifetime declared here 160 161hir_analysis_late_bound_type_in_apit = `impl Trait` can only mention type parameters from an fn or impl 162 .label = type parameter declared here 163 164hir_analysis_lifetimes_or_bounds_mismatch_on_trait = 165 lifetime parameters or bounds on {$item_kind} `{$ident}` do not match the trait declaration 166 .label = lifetimes do not match {$item_kind} in trait 167 .generics_label = lifetimes in impl do not match this {$item_kind} in trait 168 .where_label = this `where` clause might not match the one in the trait 169 .bounds_label = this bound might be missing in the impl 170 171hir_analysis_linkage_type = 172 invalid type for variable with `#[linkage]` attribute 173 174hir_analysis_main_function_async = `main` function is not allowed to be `async` 175 .label = `main` function is not allowed to be `async` 176 177hir_analysis_main_function_generic_parameters = `main` function is not allowed to have generic parameters 178 .label = `main` cannot have generic parameters 179 180hir_analysis_main_function_return_type_generic = `main` function return type is not allowed to have generic parameters 181 182hir_analysis_manual_implementation = 183 manual implementations of `{$trait_name}` are experimental 184 .label = manual implementations of `{$trait_name}` are experimental 185 .help = add `#![feature(unboxed_closures)]` to the crate attributes to enable 186 187hir_analysis_missing_one_of_trait_item = not all trait items implemented, missing one of: `{$missing_items_msg}` 188 .label = missing one of `{$missing_items_msg}` in implementation 189 .note = required because of this annotation 190 191hir_analysis_missing_tilde_const = missing `~const` qualifier for specialization 192 193hir_analysis_missing_trait_item = not all trait items implemented, missing: `{$missing_items_msg}` 194 .label = missing `{$missing_items_msg}` in implementation 195 196hir_analysis_missing_trait_item_label = `{$item}` from trait 197 198hir_analysis_missing_trait_item_suggestion = implement the missing item: `{$snippet}` 199 200hir_analysis_missing_trait_item_unstable = not all trait items implemented, missing: `{$missing_item_name}` 201 .note = default implementation of `{$missing_item_name}` is unstable 202 .some_note = use of unstable library feature '{$feature}': {$reason} 203 .none_note = use of unstable library feature '{$feature}' 204 205hir_analysis_missing_type_params = 206 the type {$parameterCount -> 207 [one] parameter 208 *[other] parameters 209 } {$parameters} must be explicitly specified 210 .label = type {$parameterCount -> 211 [one] parameter 212 *[other] parameters 213 } {$parameters} must be specified for this 214 .suggestion = set the type {$parameterCount -> 215 [one] parameter 216 *[other] parameters 217 } to the desired {$parameterCount -> 218 [one] type 219 *[other] types 220 } 221 .no_suggestion_label = missing {$parameterCount -> 222 [one] reference 223 *[other] references 224 } to {$parameters} 225 .note = because of the default `Self` reference, type parameters must be specified on object types 226 227hir_analysis_multiple_relaxed_default_bounds = 228 type parameter has more than one relaxed default bound, only one is supported 229 230hir_analysis_must_be_name_of_associated_function = must be a name of an associated function 231 232hir_analysis_must_implement_not_function = not a function 233 234hir_analysis_must_implement_not_function_note = all `#[rustc_must_implement_one_of]` arguments must be associated function names 235 236hir_analysis_must_implement_not_function_span_note = required by this annotation 237 238hir_analysis_must_implement_one_of_attribute = the `#[rustc_must_implement_one_of]` attribute must be used with at least 2 args 239 240hir_analysis_paren_sugar_attribute = the `#[rustc_paren_sugar]` attribute is a temporary means of controlling which traits can use parenthetical notation 241 .help = add `#![feature(unboxed_closures)]` to the crate attributes to use it 242 243hir_analysis_parenthesized_fn_trait_expansion = 244 parenthesized trait syntax expands to `{$expanded_type}` 245 246hir_analysis_pass_to_variadic_function = can't pass `{$ty}` to variadic function 247 .suggestion = cast the value to `{$cast_ty}` 248 .help = cast the value to `{$cast_ty}` 249 250hir_analysis_placeholder_not_allowed_item_signatures = the placeholder `_` is not allowed within types on item signatures for {$kind} 251 .label = not allowed in type signatures 252 253hir_analysis_requires_note = the `{$trait_name}` impl for `{$ty}` requires that `{$error_predicate}` 254 255hir_analysis_return_type_notation_conflicting_bound = 256 ambiguous associated function `{$assoc_name}` for `{$ty_name}` 257 .note = `{$assoc_name}` is declared in two supertraits: `{$first_bound}` and `{$second_bound}` 258 259hir_analysis_return_type_notation_equality_bound = 260 return type notation is not allowed to use type equality 261 262hir_analysis_return_type_notation_illegal_param_const = 263 return type notation is not allowed for functions that have const parameters 264 .label = const parameter declared here 265hir_analysis_return_type_notation_illegal_param_type = 266 return type notation is not allowed for functions that have type parameters 267 .label = type parameter declared here 268 269hir_analysis_return_type_notation_missing_method = 270 cannot find associated function `{$assoc_name}` for `{$ty_name}` 271 272hir_analysis_return_type_notation_on_non_rpitit = 273 return type notation used on function that is not `async` and does not return `impl Trait` 274 .note = function returns `{$ty}`, which is not compatible with associated type return bounds 275 .label = this function must be `async` or return `impl Trait` 276 277hir_analysis_rpitit_refined = impl trait in impl method signature does not match trait method signature 278 .suggestion = replace the return type so that it matches the trait 279 .label = return type from trait method defined here 280 .unmatched_bound_label = this bound is stronger than that defined on the trait 281 .note = add `#[allow(refining_impl_trait)]` if it is intended for this to be part of the public API of this crate 282 283hir_analysis_self_in_impl_self = 284 `Self` is not valid in the self type of an impl block 285 .note = replace `Self` with a different type 286 287hir_analysis_simd_ffi_highly_experimental = use of SIMD type{$snip} in FFI is highly experimental and may result in invalid code 288 .help = add `#![feature(simd_ffi)]` to the crate attributes to enable 289 290hir_analysis_specialization_trait = implementing `rustc_specialization_trait` traits is unstable 291 .help = add `#![feature(min_specialization)]` to the crate attributes to enable 292 293hir_analysis_start_function_parameters = `#[start]` function is not allowed to have type parameters 294 .label = `#[start]` function cannot have type parameters 295 296hir_analysis_start_function_where = `#[start]` function is not allowed to have a `where` clause 297 .label = `#[start]` function cannot have a `where` clause 298 299hir_analysis_start_not_async = `#[start]` function is not allowed to be `async` 300 .label = `#[start]` is not allowed to be `async` 301 302hir_analysis_start_not_target_feature = `#[start]` function is not allowed to have `#[target_feature]` 303 .label = `#[start]` function is not allowed to have `#[target_feature]` 304 305hir_analysis_start_not_track_caller = `#[start]` function is not allowed to be `#[track_caller]` 306 .label = `#[start]` function is not allowed to be `#[track_caller]` 307 308hir_analysis_static_specialize = cannot specialize on `'static` lifetime 309 310hir_analysis_substs_on_overridden_impl = could not resolve substs on overridden impl 311 312hir_analysis_tait_forward_compat = item constrains opaque type that is not in its signature 313 .note = this item must mention the opaque type in its signature in order to be able to register hidden types 314 315hir_analysis_target_feature_on_main = `main` function is not allowed to have `#[target_feature]` 316 317hir_analysis_too_large_static = extern static is too large for the current architecture 318 319hir_analysis_track_caller_on_main = `main` function is not allowed to be `#[track_caller]` 320 .suggestion = remove this annotation 321 322hir_analysis_trait_cannot_impl_for_ty = the trait `{$trait_name}` cannot be implemented for this type 323 .label = this field does not implement `{$trait_name}` 324 325hir_analysis_trait_object_declared_with_no_traits = 326 at least one trait is required for an object type 327 .alias_span = this alias does not contain a trait 328 329hir_analysis_transparent_enum_variant = transparent enum needs exactly one variant, but has {$number} 330 .label = needs exactly one variant, but has {$number} 331 .many_label = too many variants in `{$path}` 332 .multi_label = variant here 333 334hir_analysis_transparent_non_zero_sized = transparent {$desc} needs at most one field with non-trivial size or alignment, but has {$field_count} 335 .label = needs at most one field with non-trivial size or alignment, but has {$field_count} 336 .labels = this field has non-zero size or requires alignment 337 338hir_analysis_transparent_non_zero_sized_enum = the variant of a transparent {$desc} needs at most one field with non-trivial size or alignment, but has {$field_count} 339 .label = needs at most one field with non-trivial size or alignment, but has {$field_count} 340 .labels = this field has non-zero size or requires alignment 341 342hir_analysis_typeof_reserved_keyword_used = 343 `typeof` is a reserved keyword but unimplemented 344 .suggestion = consider replacing `typeof(...)` with an actual type 345 .label = reserved keyword 346 347hir_analysis_unconstrained_opaque_type = unconstrained opaque type 348 .note = `{$name}` must be used in combination with a concrete type within the same {$what} 349 350hir_analysis_unrecognized_atomic_operation = 351 unrecognized atomic operation function: `{$op}` 352 .label = unrecognized atomic operation 353 354hir_analysis_unrecognized_intrinsic_function = 355 unrecognized intrinsic function: `{$name}` 356 .label = unrecognized intrinsic 357 358hir_analysis_unused_associated_type_bounds = 359 unnecessary associated type bound for not object safe associated type 360 .note = this associated type has a `where Self: Sized` bound. Thus, while the associated type can be specified, it cannot be used in any way, because trait objects are not `Sized`. 361 .suggestion = remove this bound 362 363hir_analysis_value_of_associated_struct_already_specified = 364 the value of the associated type `{$item_name}` (from trait `{$def_path}`) is already specified 365 .label = re-bound here 366 .previous_bound_label = `{$item_name}` bound here first 367 368hir_analysis_variadic_function_compatible_convention = C-variadic function must have a compatible calling convention, like {$conventions} 369 .label = C-variadic function must have a compatible calling convention 370 371hir_analysis_variances_of = {$variances_of} 372 373hir_analysis_where_clause_on_main = `main` function is not allowed to have a `where` clause 374 .label = `main` cannot have a `where` clause 375 376hir_analysis_wrong_number_of_generic_arguments_to_intrinsic = 377 intrinsic has wrong number of {$descr} parameters: found {$found}, expected {$expected} 378 .label = expected {$expected} {$descr} {$expected -> 379 [one] parameter 380 *[other] parameters 381 }