compiler/rustc_infer/messages.ftl

   1 infer_actual_impl_expl_but_actually_implemented_for_ty = ...but `{$trait_path}` is actually implemented for the type `{$ty}`{$has_lifetime ->
   2     [true] , for some specific lifetime `'{$lifetime}`
   3     *[false] {""}
   4 }
   5 infer_actual_impl_expl_but_actually_implements_trait = ...but it actually implements `{$trait_path}`{$has_lifetime ->
   6     [true] , for some specific lifetime `'{$lifetime}`
   7     *[false] {""}
   8 }
   9 infer_actual_impl_expl_but_actually_ty_implements = ...but `{$ty}` actually implements `{$trait_path}`{$has_lifetime ->
  10     [true] , for some specific lifetime `'{$lifetime}`
  11     *[false] {""}
  12 }
  13
  14 infer_actual_impl_expl_expected_other_any = {$leading_ellipsis ->
  15     [true] ...
  16     *[false] {""}
  17 }`{$ty_or_sig}` must implement `{$trait_path}`, for any lifetime `'{$lifetime_1}`...
  18 infer_actual_impl_expl_expected_other_nothing = {$leading_ellipsis ->
  19     [true] ...
  20     *[false] {""}
  21 }`{$ty_or_sig}` must implement `{$trait_path}`
  22
  23 infer_actual_impl_expl_expected_other_some = {$leading_ellipsis ->
  24     [true] ...
  25     *[false] {""}
  26 }`{$ty_or_sig}` must implement `{$trait_path}`, for some specific lifetime `'{$lifetime_1}`...
  27 infer_actual_impl_expl_expected_other_two = {$leading_ellipsis ->
  28     [true] ...
  29     *[false] {""}
  30 }`{$ty_or_sig}` must implement `{$trait_path}`, for any two lifetimes `'{$lifetime_1}` and `'{$lifetime_2}`...
  31 infer_actual_impl_expl_expected_passive_any = {$leading_ellipsis ->
  32     [true] ...
  33     *[false] {""}
  34 }`{$trait_path}` would have to be implemented for the type `{$ty_or_sig}`, for any lifetime `'{$lifetime_1}`...
  35 infer_actual_impl_expl_expected_passive_nothing = {$leading_ellipsis ->
  36     [true] ...
  37     *[false] {""}
  38 }`{$trait_path}` would have to be implemented for the type `{$ty_or_sig}`
  39 infer_actual_impl_expl_expected_passive_some = {$leading_ellipsis ->
  40     [true] ...
  41     *[false] {""}
  42 }`{$trait_path}` would have to be implemented for the type `{$ty_or_sig}`, for some specific lifetime `'{$lifetime_1}`...
  43 infer_actual_impl_expl_expected_passive_two = {$leading_ellipsis ->
  44     [true] ...
  45     *[false] {""}
  46 }`{$trait_path}` would have to be implemented for the type `{$ty_or_sig}`, for any two lifetimes `'{$lifetime_1}` and `'{$lifetime_2}`...
  47 infer_actual_impl_expl_expected_signature_any = {$leading_ellipsis ->
  48     [true] ...
  49     *[false] {""}
  50 }closure with signature `{$ty_or_sig}` must implement `{$trait_path}`, for any lifetime `'{$lifetime_1}`...
  51 infer_actual_impl_expl_expected_signature_nothing = {$leading_ellipsis ->
  52     [true] ...
  53     *[false] {""}
  54 }closure with signature `{$ty_or_sig}` must implement `{$trait_path}`
  55 infer_actual_impl_expl_expected_signature_some = {$leading_ellipsis ->
  56     [true] ...
  57     *[false] {""}
  58 }closure with signature `{$ty_or_sig}` must implement `{$trait_path}`, for some specific lifetime `'{$lifetime_1}`...
  59 infer_actual_impl_expl_expected_signature_two = {$leading_ellipsis ->
  60     [true] ...
  61     *[false] {""}
  62 }closure with signature `{$ty_or_sig}` must implement `{$trait_path}`, for any two lifetimes `'{$lifetime_1}` and `'{$lifetime_2}`...
  63 infer_ascribe_user_type_prove_predicate = ...so that the where clause holds
  64
  65 infer_await_both_futures = consider `await`ing on both `Future`s
  66 infer_await_future = consider `await`ing on the `Future`
  67 infer_await_note = calling an async function returns a future
  68
  69 infer_but_calling_introduces = {$has_param_name ->
  70     [true] `{$param_name}`
  71     *[false] `fn` parameter
  72 } has {$lifetime_kind ->
  73     [true] lifetime `{$lifetime}`
  74     *[false] an anonymous lifetime `'_`
  75 } but calling `{$assoc_item}` introduces an implicit `'static` lifetime requirement
  76     .label1 = {$has_lifetime ->
  77         [true] lifetime `{$lifetime}`
  78         *[false] an anonymous lifetime `'_`
  79     }
  80     .label2 = ...is used and required to live as long as `'static` here because of an implicit lifetime bound on the {$has_impl_path ->
  81         [true] `impl` of `{$impl_path}`
  82         *[false] inherent `impl`
  83     }
  84
  85 infer_but_needs_to_satisfy = {$has_param_name ->
  86     [true] `{$param_name}`
  87     *[false] `fn` parameter
  88 } has {$has_lifetime ->
  89     [true] lifetime `{$lifetime}`
  90     *[false] an anonymous lifetime `'_`
  91 } but it needs to satisfy a `'static` lifetime requirement
  92     .influencer = this data with {$has_lifetime ->
  93         [true] lifetime `{$lifetime}`
  94         *[false] an anonymous lifetime `'_`
  95     }...
  96     .require = {$spans_empty ->
  97         *[true] ...is used and required to live as long as `'static` here
  98         [false] ...and is required to live as long as `'static` here
  99     }
 100     .used_here = ...is used here...
 101     .introduced_by_bound = `'static` lifetime requirement introduced by this bound
 102
 103 infer_compare_impl_item_obligation = ...so that the definition in impl matches the definition from the trait
 104 infer_consider_specifying_length = consider specifying the actual array length
 105 infer_data_flows = ...but data{$label_var1_exists ->
 106     [true] {" "}from `{$label_var1}`
 107     *[false] -> {""}
 108 } flows{$label_var2_exists ->
 109     [true] {" "}into `{$label_var2}`
 110     *[false] -> {""}
 111 } here
 112
 113 infer_data_lifetime_flow = ...but data with one lifetime flows into the other here
 114 infer_data_returned = ...but data{$label_var1_exists ->
 115     [true] {" "}from `{$label_var1}`
 116     *[false] {""}
 117 } is returned here
 118
 119 infer_declared_different = this parameter and the return type are declared with different lifetimes...
 120 infer_declared_multiple = this type is declared with multiple lifetimes...
 121 infer_does_not_outlive_static_from_impl = ...does not necessarily outlive the static lifetime introduced by the compatible `impl`
 122 infer_dtcs_has_lifetime_req_label = this has an implicit `'static` lifetime requirement
 123 infer_dtcs_has_req_note = the used `impl` has a `'static` requirement
 124 infer_dtcs_introduces_requirement = calling this method introduces the `impl`'s `'static` requirement
 125 infer_dtcs_suggestion = consider relaxing the implicit `'static` requirement
 126
 127 infer_explicit_lifetime_required_sugg_with_ident = add explicit lifetime `{$named}` to the type of `{$simple_ident}`
 128
 129 infer_explicit_lifetime_required_sugg_with_param_type = add explicit lifetime `{$named}` to type
 130
 131 infer_explicit_lifetime_required_with_ident = explicit lifetime required in the type of `{$simple_ident}`
 132     .label = lifetime `{$named}` required
 133
 134 infer_explicit_lifetime_required_with_param_type = explicit lifetime required in parameter type
 135     .label = lifetime `{$named}` required
 136
 137 infer_fn_consider_casting = consider casting the fn item to a fn pointer: `{$casting}`
 138
 139 infer_fn_uniq_types = different fn items have unique types, even if their signatures are the same
 140 infer_fps_cast = consider casting to a fn pointer
 141 infer_fps_cast_both = consider casting both fn items to fn pointers using `as {$expected_sig}`
 142
 143 infer_fps_items_are_distinct = fn items are distinct from fn pointers
 144 infer_fps_remove_ref = consider removing the reference
 145 infer_fps_use_ref = consider using a reference
 146 infer_fulfill_req_lifetime = the type `{$ty}` does not fulfill the required lifetime
 147 infer_implicit_static_lifetime_note = this has an implicit `'static` lifetime requirement
 148 infer_implicit_static_lifetime_suggestion = consider relaxing the implicit `'static` requirement
 149 infer_label_bad = {$bad_kind ->
 150     *[other] cannot infer type
 151     [more_info] cannot infer {$prefix_kind ->
 152         *[type] type for {$prefix}
 153         [const_with_param] the value of const parameter
 154         [const] the value of the constant
 155     } `{$name}`{$has_parent ->
 156         [true] {" "}declared on the {$parent_prefix} `{$parent_name}`
 157         *[false] {""}
 158     }
 159 }
 160
 161 infer_lf_bound_not_satisfied = lifetime bound not satisfied
 162 infer_lifetime_mismatch = lifetime mismatch
 163
 164 infer_lifetime_param_suggestion = consider introducing a named lifetime parameter{$is_impl ->
 165     [true] {" "}and update trait if needed
 166     *[false] {""}
 167 }
 168 infer_lifetime_param_suggestion_elided = each elided lifetime in input position becomes a distinct lifetime
 169
 170 infer_meant_byte_literal = if you meant to write a byte literal, prefix with `b`
 171 infer_meant_char_literal = if you meant to write a `char` literal, use single quotes
 172 infer_meant_str_literal = if you meant to write a `str` literal, use double quotes
 173 infer_mismatched_static_lifetime = incompatible lifetime on type
 174 infer_more_targeted = {$has_param_name ->
 175     [true] `{$param_name}`
 176     *[false] `fn` parameter
 177 } has {$has_lifetime ->
 178     [true] lifetime `{$lifetime}`
 179     *[false] an anonymous lifetime `'_`
 180 } but calling `{$ident}` introduces an implicit `'static` lifetime requirement
 181
 182 infer_msl_introduces_static = introduces a `'static` lifetime requirement
 183 infer_msl_unmet_req = because this has an unmet lifetime requirement
 184 infer_need_type_info_in_coroutine =
 185     type inside {$coroutine_kind ->
 186     [async_block] `async` block
 187     [async_closure] `async` closure
 188     [async_fn] `async fn` body
 189     *[coroutine] coroutine
 190     } must be known in this context
 191
 192
 193 infer_nothing = {""}
 194
 195 infer_oc_cant_coerce = cannot coerce intrinsics to function pointers
 196 infer_oc_closure_selfref = closure/coroutine type that references itself
 197 infer_oc_const_compat = const not compatible with trait
 198 infer_oc_fn_lang_correct_type = {$lang_item_name ->
 199         [panic_impl] `#[panic_handler]`
 200         *[lang_item_name] lang item `{$lang_item_name}`
 201     } function has wrong type
 202 infer_oc_fn_main_correct_type = `main` function has wrong type
 203 infer_oc_fn_start_correct_type = `#[start]` function has wrong type
 204 infer_oc_generic = mismatched types
 205
 206 infer_oc_if_else_different = `if` and `else` have incompatible types
 207 infer_oc_intrinsic_correct_type = intrinsic has wrong type
 208 infer_oc_match_compat = `match` arms have incompatible types
 209 infer_oc_method_compat = method not compatible with trait
 210 infer_oc_method_correct_type = mismatched `self` parameter type
 211 infer_oc_no_diverge = `else` clause of `let...else` does not diverge
 212 infer_oc_no_else = `if` may be missing an `else` clause
 213 infer_oc_try_compat = `?` operator has incompatible types
 214 infer_oc_type_compat = type not compatible with trait
 215 infer_opaque_captures_lifetime = hidden type for `{$opaque_ty}` captures lifetime that does not appear in bounds
 216     .label = opaque type defined here
 217
 218 infer_opaque_hidden_type =
 219     opaque type's hidden type cannot be another opaque type from the same scope
 220     .label = one of the two opaque types used here has to be outside its defining scope
 221     .opaque_type = opaque type whose hidden type is being assigned
 222     .hidden_type = opaque type being used as hidden type
 223
 224 infer_outlives_bound = lifetime of the source pointer does not outlive lifetime bound of the object type
 225 infer_outlives_content = lifetime of reference outlives lifetime of borrowed content...
 226 infer_prlf_defined_with_sub = the lifetime `{$sub_symbol}` defined here...
 227 infer_prlf_defined_without_sub = the lifetime defined here...
 228 infer_prlf_known_limitation = this is a known limitation that will be removed in the future (see issue #100013 <https://github.com/rust-lang/rust/issues/100013> for more information)
 229
 230 infer_prlf_must_outlive_with_sup = ...must outlive the lifetime `{$sup_symbol}` defined here
 231 infer_prlf_must_outlive_without_sup = ...must outlive the lifetime defined here
 232 infer_reborrow = ...so that reference does not outlive borrowed content
 233 infer_ref_longer_than_data = in type `{$ty}`, reference has a longer lifetime than the data it references
 234
 235 infer_reference_outlives_referent = ...so that the reference type `{$name}` does not outlive the data it points at
 236 infer_region_explanation = {$pref_kind ->
 237     *[should_not_happen] [{$pref_kind}]
 238     [ref_valid_for] ...the reference is valid for
 239     [content_valid_for] ...but the borrowed content is only valid for
 240     [type_obj_valid_for] object type is valid for
 241     [source_pointer_valid_for] source pointer is only valid for
 242     [type_satisfy] type must satisfy
 243     [type_outlive] type must outlive
 244     [lf_param_instantiated_with] lifetime parameter instantiated with
 245     [lf_param_must_outlive] but lifetime parameter must outlive
 246     [lf_instantiated_with] lifetime instantiated with
 247     [lf_must_outlive] but lifetime must outlive
 248     [pointer_valid_for] the pointer is valid for
 249     [data_valid_for] but the referenced data is only valid for
 250     [empty] {""}
 251 }{$pref_kind ->
 252     [empty] {""}
 253     *[other] {" "}
 254 }{$desc_kind ->
 255     *[should_not_happen] [{$desc_kind}]
 256     [restatic] the static lifetime
 257     [revar] lifetime {$desc_arg}
 258     [as_defined] the lifetime `{$desc_arg}` as defined here
 259     [as_defined_anon] the anonymous lifetime as defined here
 260     [defined_here] the anonymous lifetime defined here
 261     [defined_here_reg] the lifetime `{$desc_arg}` as defined here
 262 }{$suff_kind ->
 263     *[should_not_happen] [{$suff_kind}]
 264     [empty]{""}
 265     [continues] ...
 266     [req_by_binding] {" "}as required by this binding
 267 }
 268
 269 infer_relate_object_bound = ...so that it can be closed over into an object
 270 infer_relate_param_bound = ...so that the type `{$name}` will meet its required lifetime bounds{$continues ->
 271     [true] ...
 272     *[false] {""}
 273 }
 274 infer_relate_param_bound_2 = ...that is required by this bound
 275 infer_relate_region_param_bound = ...so that the declared lifetime parameter bounds are satisfied
 276 infer_ril_because_of = because of this returned expression
 277 infer_ril_introduced_by = requirement introduced by this return type
 278 infer_ril_introduced_here = `'static` requirement introduced here
 279 infer_ril_static_introduced_by = "`'static` lifetime requirement introduced by the return type
 280
 281 infer_sbfrit_box_return_expr = if you change the return type to expect trait objects, box the returned expressions
 282
 283 infer_sbfrit_change_return_type = you could change the return type to be a boxed trait object
 284 infer_source_kind_closure_return =
 285     try giving this closure an explicit return type
 286
 287 # coroutine_kind  may need to be translated
 288 infer_source_kind_fully_qualified =
 289     try using a fully qualified path to specify the expected types
 290
 291 infer_source_kind_subdiag_generic_label =
 292     cannot infer {$is_type ->
 293     [true] type
 294     *[false] the value
 295     } of the {$is_type ->
 296     [true] type
 297     *[false] const
 298     } {$parent_exists ->
 299     [true] parameter `{$param_name}` declared on the {$parent_prefix} `{$parent_name}`
 300     *[false] parameter {$param_name}
 301     }
 302
 303 infer_source_kind_subdiag_generic_suggestion =
 304     consider specifying the generic {$arg_count ->
 305     [one] argument
 306     *[other] arguments
 307     }
 308
 309 infer_source_kind_subdiag_let = {$kind ->
 310     [with_pattern] consider giving `{$name}` an explicit type
 311     [closure] consider giving this closure parameter an explicit type
 312     *[other] consider giving this pattern a type
 313 }{$x_kind ->
 314     [has_name] , where the {$prefix_kind ->
 315         *[type] type for {$prefix}
 316         [const_with_param] value of const parameter
 317         [const] value of the constant
 318     } `{$arg_name}` is specified
 319     [underscore] , where the placeholders `_` are specified
 320     *[empty] {""}
 321 }
 322
 323 infer_srs_add = consider returning the local binding `{$ident}`
 324 infer_srs_add_one = consider returning one of these bindings
 325
 326 infer_srs_remove = consider removing this semicolon
 327 infer_srs_remove_and_box = consider removing this semicolon and boxing the expressions
 328 infer_stp_wrap_many = try wrapping the pattern in a variant of `{$path}`
 329
 330 infer_stp_wrap_one = try wrapping the pattern in `{$variant}`
 331 infer_subtype = ...so that the {$requirement ->
 332     [method_compat] method type is compatible with trait
 333     [type_compat] associated type is compatible with trait
 334     [const_compat] const is compatible with trait
 335     [expr_assignable] expression is assignable
 336     [if_else_different] `if` and `else` have incompatible types
 337     [no_else] `if` missing an `else` returns `()`
 338     [fn_main_correct_type] `main` function has the correct type
 339     [fn_start_correct_type] `#[start]` function has the correct type
 340     [fn_lang_correct_type] lang item function has the correct type
 341     [intrinsic_correct_type] intrinsic has the correct type
 342     [method_correct_type] method receiver has the correct type
 343     *[other] types are compatible
 344 }
 345 infer_subtype_2 = ...so that {$requirement ->
 346     [method_compat] method type is compatible with trait
 347     [type_compat] associated type is compatible with trait
 348     [const_compat] const is compatible with trait
 349     [expr_assignable] expression is assignable
 350     [if_else_different] `if` and `else` have incompatible types
 351     [no_else] `if` missing an `else` returns `()`
 352     [fn_main_correct_type] `main` function has the correct type
 353     [fn_start_correct_type] `#[start]` function has the correct type
 354     [fn_lang_correct_type] lang item function has the correct type
 355     [intrinsic_correct_type] intrinsic has the correct type
 356     [method_correct_type] method receiver has the correct type
 357     *[other] types are compatible
 358 }
 359
 360 infer_suggest_accessing_field = you might have meant to use field `{$name}` whose type is `{$ty}`
 361
 362 infer_suggest_add_let_for_letchains = consider adding `let`
 363
 364 infer_tid_consider_borrowing = consider borrowing this type parameter in the trait
 365 infer_tid_param_help = the lifetime requirements from the `impl` do not correspond to the requirements in the `trait`
 366
 367 infer_tid_rel_help = verify the lifetime relationships in the `trait` and `impl` between the `self` argument, the other inputs and its output
 368 infer_trait_impl_diff = `impl` item signature doesn't match `trait` item signature
 369     .found = found `{$found}`
 370     .expected = expected `{$expected}`
 371     .expected_found = expected signature `{$expected}`
 372                {"   "}found signature `{$found}`
 373
 374 infer_trait_placeholder_mismatch = implementation of `{$trait_def_id}` is not general enough
 375     .label_satisfy = doesn't satisfy where-clause
 376     .label_where = due to a where-clause on `{$def_id}`...
 377     .label_dup = implementation of `{$trait_def_id}` is not general enough
 378
 379 infer_try_cannot_convert = `?` operator cannot convert from `{$found}` to `{$expected}`
 380
 381 infer_tuple_trailing_comma = use a trailing comma to create a tuple with one element
 382
 383 infer_type_annotations_needed = {$source_kind ->
 384     [closure] type annotations needed for the closure `{$source_name}`
 385     [normal] type annotations needed for `{$source_name}`
 386     *[other] type annotations needed
 387 }
 388     .label = type must be known at this point
 389
 390 infer_types_declared_different = these two types are declared with different lifetimes...
 391 infer_where_copy_predicates = copy the `where` clause predicates from the trait
 392
 393 infer_where_remove = remove the `where` clause