fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #103046 - JanBeh:PR_clarify_cmp_terminology, r=workingjubilee3bcad65fbf6

master
18.0 KiB393 linesraw
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