fork/rust
git clone https://git.julia.blue/fork/rust
3bcad65fbf6
master
1infer_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} 5infer_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} 9infer_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 14infer_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}`... 18infer_actual_impl_expl_expected_other_nothing = {$leading_ellipsis -> 19 [true] ... 20 *[false] {""} 21}`{$ty_or_sig}` must implement `{$trait_path}` 22 23infer_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}`... 27infer_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}`... 31infer_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}`... 35infer_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}` 39infer_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}`... 43infer_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}`... 47infer_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}`... 51infer_actual_impl_expl_expected_signature_nothing = {$leading_ellipsis -> 52 [true] ... 53 *[false] {""} 54}closure with signature `{$ty_or_sig}` must implement `{$trait_path}` 55infer_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}`... 59infer_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}`... 63infer_ascribe_user_type_prove_predicate = ...so that the where clause holds 64 65infer_await_both_futures = consider `await`ing on both `Future`s 66infer_await_future = consider `await`ing on the `Future` 67infer_await_note = calling an async function returns a future 68 69infer_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 85infer_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 103infer_compare_impl_item_obligation = ...so that the definition in impl matches the definition from the trait 104infer_consider_specifying_length = consider specifying the actual array length 105infer_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 113infer_data_lifetime_flow = ...but data with one lifetime flows into the other here 114infer_data_returned = ...but data{$label_var1_exists -> 115 [true] {" "}from `{$label_var1}` 116 *[false] {""} 117} is returned here 118 119infer_declared_different = this parameter and the return type are declared with different lifetimes... 120infer_declared_multiple = this type is declared with multiple lifetimes... 121infer_does_not_outlive_static_from_impl = ...does not necessarily outlive the static lifetime introduced by the compatible `impl` 122infer_dtcs_has_lifetime_req_label = this has an implicit `'static` lifetime requirement 123infer_dtcs_has_req_note = the used `impl` has a `'static` requirement 124infer_dtcs_introduces_requirement = calling this method introduces the `impl`'s `'static` requirement 125infer_dtcs_suggestion = consider relaxing the implicit `'static` requirement 126 127infer_explicit_lifetime_required_sugg_with_ident = add explicit lifetime `{$named}` to the type of `{$simple_ident}` 128 129infer_explicit_lifetime_required_sugg_with_param_type = add explicit lifetime `{$named}` to type 130 131infer_explicit_lifetime_required_with_ident = explicit lifetime required in the type of `{$simple_ident}` 132 .label = lifetime `{$named}` required 133 134infer_explicit_lifetime_required_with_param_type = explicit lifetime required in parameter type 135 .label = lifetime `{$named}` required 136 137infer_fn_consider_casting = consider casting the fn item to a fn pointer: `{$casting}` 138 139infer_fn_uniq_types = different fn items have unique types, even if their signatures are the same 140infer_fps_cast = consider casting to a fn pointer 141infer_fps_cast_both = consider casting both fn items to fn pointers using `as {$expected_sig}` 142 143infer_fps_items_are_distinct = fn items are distinct from fn pointers 144infer_fps_remove_ref = consider removing the reference 145infer_fps_use_ref = consider using a reference 146infer_fulfill_req_lifetime = the type `{$ty}` does not fulfill the required lifetime 147infer_implicit_static_lifetime_note = this has an implicit `'static` lifetime requirement 148infer_implicit_static_lifetime_suggestion = consider relaxing the implicit `'static` requirement 149infer_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 161infer_lf_bound_not_satisfied = lifetime bound not satisfied 162infer_lifetime_mismatch = lifetime mismatch 163 164infer_lifetime_param_suggestion = consider introducing a named lifetime parameter{$is_impl -> 165 [true] {" "}and update trait if needed 166 *[false] {""} 167} 168infer_lifetime_param_suggestion_elided = each elided lifetime in input position becomes a distinct lifetime 169 170infer_meant_byte_literal = if you meant to write a byte literal, prefix with `b` 171infer_meant_char_literal = if you meant to write a `char` literal, use single quotes 172infer_meant_str_literal = if you meant to write a `str` literal, use double quotes 173infer_mismatched_static_lifetime = incompatible lifetime on type 174infer_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 182infer_msl_introduces_static = introduces a `'static` lifetime requirement 183infer_msl_unmet_req = because this has an unmet lifetime requirement 184infer_need_type_info_in_generator = 185 type inside {$generator_kind -> 186 [async_block] `async` block 187 [async_closure] `async` closure 188 [async_fn] `async fn` body 189 *[generator] generator 190 } must be known in this context 191 192 193infer_nothing = {""} 194 195infer_oc_cant_coerce = cannot coerce intrinsics to function pointers 196infer_oc_closure_selfref = closure/generator type that references itself 197infer_oc_const_compat = const not compatible with trait 198infer_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 202infer_oc_fn_main_correct_type = `main` function has wrong type 203infer_oc_fn_start_correct_type = `#[start]` function has wrong type 204infer_oc_generic = mismatched types 205 206infer_oc_if_else_different = `if` and `else` have incompatible types 207infer_oc_intrinsic_correct_type = intrinsic has wrong type 208infer_oc_match_compat = `match` arms have incompatible types 209infer_oc_method_compat = method not compatible with trait 210infer_oc_method_correct_type = mismatched `self` parameter type 211infer_oc_no_diverge = `else` clause of `let...else` does not diverge 212infer_oc_no_else = `if` may be missing an `else` clause 213infer_oc_try_compat = `?` operator has incompatible types 214infer_oc_type_compat = type not compatible with trait 215infer_opaque_captures_lifetime = hidden type for `{$opaque_ty}` captures lifetime that does not appear in bounds 216 .label = opaque type defined here 217 218infer_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 224infer_outlives_bound = lifetime of the source pointer does not outlive lifetime bound of the object type 225infer_outlives_content = lifetime of reference outlives lifetime of borrowed content... 226infer_prlf_defined_with_sub = the lifetime `{$sub_symbol}` defined here... 227infer_prlf_defined_without_sub = the lifetime defined here... 228infer_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 230infer_prlf_must_outlive_with_sup = ...must outlive the lifetime `{$sup_symbol}` defined here 231infer_prlf_must_outlive_without_sup = ...must outlive the lifetime defined here 232infer_reborrow = ...so that reference does not outlive borrowed content 233infer_ref_longer_than_data = in type `{$ty}`, reference has a longer lifetime than the data it references 234 235infer_reference_outlives_referent = ...so that the reference type `{$name}` does not outlive the data it points at 236infer_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 269infer_relate_object_bound = ...so that it can be closed over into an object 270infer_relate_param_bound = ...so that the type `{$name}` will meet its required lifetime bounds{$continues -> 271 [true] ... 272 *[false] {""} 273} 274infer_relate_param_bound_2 = ...that is required by this bound 275infer_relate_region_param_bound = ...so that the declared lifetime parameter bounds are satisfied 276infer_ril_because_of = because of this returned expression 277infer_ril_introduced_by = requirement introduced by this return type 278infer_ril_introduced_here = `'static` requirement introduced here 279infer_ril_static_introduced_by = "`'static` lifetime requirement introduced by the return type 280 281infer_sbfrit_box_return_expr = if you change the return type to expect trait objects, box the returned expressions 282 283infer_sbfrit_change_return_type = you could change the return type to be a boxed trait object 284infer_source_kind_closure_return = 285 try giving this closure an explicit return type 286 287# generator_kind may need to be translated 288infer_source_kind_fully_qualified = 289 try using a fully qualified path to specify the expected types 290 291infer_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 303infer_source_kind_subdiag_generic_suggestion = 304 consider specifying the generic {$arg_count -> 305 [one] argument 306 *[other] arguments 307 } 308 309infer_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 323infer_srs_add = consider returning the local binding `{$ident}` 324infer_srs_add_one = consider returning one of these bindings 325 326infer_srs_remove = consider removing this semicolon 327infer_srs_remove_and_box = consider removing this semicolon and boxing the expressions 328infer_stp_wrap_many = try wrapping the pattern in a variant of `{$path}` 329 330infer_stp_wrap_one = try wrapping the pattern in `{$variant}` 331infer_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} 345infer_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 360infer_suggest_accessing_field = you might have meant to use field `{$name}` whose type is `{$ty}` 361 362infer_suggest_add_let_for_letchains = consider adding `let` 363 364infer_tid_consider_borrowing = consider borrowing this type parameter in the trait 365infer_tid_param_help = the lifetime requirements from the `impl` do not correspond to the requirements in the `trait` 366 367infer_tid_rel_help = verify the lifetime relationships in the `trait` and `impl` between the `self` argument, the other inputs and its output 368infer_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 374infer_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 379infer_try_cannot_convert = `?` operator cannot convert from `{$found}` to `{$expected}` 380 381infer_tuple_trailing_comma = use a trailing comma to create a tuple with one element 382 383infer_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 390infer_types_declared_different = these two types are declared with different lifetimes... 391infer_where_copy_predicates = copy the `where` clause predicates from the trait 392 393infer_where_remove = remove the `where` clause