]>
Commit | Line | Data |
---|---|---|
f2b60f7d FG |
1 | infer_opaque_hidden_type = |
2 | opaque type's hidden type cannot be another opaque type from the same scope | |
3 | .label = one of the two opaque types used here has to be outside its defining scope | |
4 | .opaque_type = opaque type whose hidden type is being assigned | |
5 | .hidden_type = opaque type being used as hidden type | |
6 | ||
7 | infer_type_annotations_needed = {$source_kind -> | |
8 | [closure] type annotations needed for the closure `{$source_name}` | |
9 | [normal] type annotations needed for `{$source_name}` | |
10 | *[other] type annotations needed | |
11 | } | |
12 | .label = type must be known at this point | |
13 | ||
14 | infer_label_bad = {$bad_kind -> | |
15 | *[other] cannot infer type | |
16 | [more_info] cannot infer {$prefix_kind -> | |
17 | *[type] type for {$prefix} | |
18 | [const_with_param] the value of const parameter | |
19 | [const] the value of the constant | |
20 | } `{$name}`{$has_parent -> | |
21 | [true] {" "}declared on the {$parent_prefix} `{$parent_name}` | |
22 | *[false] {""} | |
23 | } | |
24 | } | |
25 | ||
26 | infer_source_kind_subdiag_let = {$kind -> | |
27 | [with_pattern] consider giving `{$name}` an explicit type | |
28 | [closure] consider giving this closure parameter an explicit type | |
29 | *[other] consider giving this pattern a type | |
30 | }{$x_kind -> | |
31 | [has_name] , where the {$prefix_kind -> | |
32 | *[type] type for {$prefix} | |
33 | [const_with_param] the value of const parameter | |
34 | [const] the value of the constant | |
35 | } `{$arg_name}` is specified | |
36 | [underscore] , where the placeholders `_` are specified | |
37 | *[empty] {""} | |
38 | } | |
39 | ||
40 | infer_source_kind_subdiag_generic_label = | |
41 | cannot infer {$is_type -> | |
42 | [true] type | |
43 | *[false] the value | |
44 | } of the {$is_type -> | |
45 | [true] type | |
46 | *[false] const | |
47 | } {$parent_exists -> | |
48 | [true] parameter `{$param_name}` declared on the {$parent_prefix} `{$parent_name}` | |
49 | *[false] parameter {$param_name} | |
50 | } | |
51 | ||
52 | infer_source_kind_subdiag_generic_suggestion = | |
53 | consider specifying the generic {$arg_count -> | |
54 | [one] argument | |
55 | *[other] arguments | |
56 | } | |
57 | ||
58 | infer_source_kind_fully_qualified = | |
59 | try using a fully qualified path to specify the expected types | |
60 | ||
61 | infer_source_kind_closure_return = | |
62 | try giving this closure an explicit return type | |
63 | ||
64 | # generator_kind may need to be translated | |
65 | infer_need_type_info_in_generator = | |
66 | type inside {$generator_kind -> | |
67 | [async_block] `async` block | |
68 | [async_closure] `async` closure | |
69 | [async_fn] `async fn` body | |
70 | *[generator] generator | |
71 | } must be known in this context | |
72 | ||
73 | ||
74 | infer_subtype = ...so that the {$requirement -> | |
75 | [method_compat] method type is compatible with trait | |
76 | [type_compat] associated type is compatible with trait | |
77 | [const_compat] const is compatible with trait | |
78 | [expr_assignable] expression is assignable | |
79 | [if_else_different] `if` and `else` have incompatible types | |
80 | [no_else] `if` missing an `else` returns `()` | |
81 | [fn_main_correct_type] `main` function has the correct type | |
82 | [fn_start_correct_type] #[start]` function has the correct type | |
83 | [intristic_correct_type] intrinsic has the correct type | |
84 | [method_correct_type] method receiver has the correct type | |
85 | *[other] types are compatible | |
86 | } | |
87 | infer_subtype_2 = ...so that {$requirement -> | |
88 | [method_compat] method type is compatible with trait | |
89 | [type_compat] associated type is compatible with trait | |
90 | [const_compat] const is compatible with trait | |
91 | [expr_assignable] expression is assignable | |
92 | [if_else_different] `if` and `else` have incompatible types | |
93 | [no_else] `if` missing an `else` returns `()` | |
94 | [fn_main_correct_type] `main` function has the correct type | |
95 | [fn_start_correct_type] #[start]` function has the correct type | |
96 | [intristic_correct_type] intrinsic has the correct type | |
97 | [method_correct_type] method receiver has the correct type | |
98 | *[other] types are compatible | |
99 | } | |
100 | ||
101 | infer_reborrow = ...so that reference does not outlive borrowed content | |
102 | infer_reborrow_upvar = ...so that closure can access `{$name}` | |
103 | infer_relate_object_bound = ...so that it can be closed over into an object | |
f2b60f7d FG |
104 | infer_reference_outlives_referent = ...so that the reference type `{$name}` does not outlive the data it points at |
105 | infer_relate_param_bound = ...so that the type `{$name}` will meet its required lifetime bounds{$continues -> | |
106 | [true] ... | |
107 | *[false] {""} | |
108 | } | |
109 | infer_relate_param_bound_2 = ...that is required by this bound | |
110 | infer_relate_region_param_bound = ...so that the declared lifetime parameter bounds are satisfied | |
111 | infer_compare_impl_item_obligation = ...so that the definition in impl matches the definition from the trait | |
112 | infer_ascribe_user_type_prove_predicate = ...so that the where clause holds | |
113 | ||
114 | infer_nothing = {""} | |
115 | ||
116 | infer_lifetime_mismatch = lifetime mismatch | |
117 | ||
118 | infer_declared_different = this parameter and the return type are declared with different lifetimes... | |
119 | infer_data_returned = ...but data{$label_var1_exists -> | |
120 | [true] {" "}from `{$label_var1}` | |
121 | *[false] {""} | |
122 | } is returned here | |
123 | ||
124 | infer_data_lifetime_flow = ...but data with one lifetime flows into the other here | |
125 | infer_declared_multiple = this type is declared with multiple lifetimes... | |
126 | infer_types_declared_different = these two types are declared with different lifetimes... | |
127 | infer_data_flows = ...but data{$label_var1_exists -> | |
487cf647 | 128 | [true] {" "}from `{$label_var1}` |
f2b60f7d FG |
129 | *[false] -> {""} |
130 | } flows{$label_var2_exists -> | |
487cf647 | 131 | [true] {" "}into `{$label_var2}` |
f2b60f7d FG |
132 | *[false] -> {""} |
133 | } here | |
134 | ||
135 | infer_lifetime_param_suggestion = consider introducing a named lifetime parameter{$is_impl -> | |
136 | [true] {" "}and update trait if needed | |
137 | *[false] {""} | |
138 | } | |
139 | infer_lifetime_param_suggestion_elided = each elided lifetime in input position becomes a distinct lifetime | |
140 | ||
141 | infer_region_explanation = {$pref_kind -> | |
142 | *[should_not_happen] [{$pref_kind}] | |
143 | [empty] {""} | |
144 | }{$pref_kind -> | |
145 | [empty] {""} | |
146 | *[other] {" "} | |
147 | }{$desc_kind -> | |
148 | *[should_not_happen] [{$desc_kind}] | |
149 | [restatic] the static lifetime | |
150 | [reempty] the empty lifetime | |
151 | [reemptyuni] the empty lifetime in universe {$desc_arg} | |
152 | [revar] lifetime {$desc_arg} | |
153 | ||
154 | [as_defined] the lifetime `{$desc_arg}` as defined here | |
155 | [as_defined_anon] the anonymous lifetime as defined here | |
156 | [defined_here] the anonymous lifetime defined here | |
157 | [anon_num_here] the anonymous lifetime #{$desc_num_arg} defined here | |
158 | [defined_here_reg] the lifetime `{$desc_arg}` as defined here | |
159 | }{$suff_kind -> | |
160 | *[should_not_happen] [{$suff_kind}] | |
161 | [empty]{""} | |
162 | [continues] ... | |
163 | } | |
164 | ||
165 | infer_mismatched_static_lifetime = incompatible lifetime on type | |
2b03887a FG |
166 | infer_does_not_outlive_static_from_impl = ...does not necessarily outlive the static lifetime introduced by the compatible `impl` |
167 | infer_implicit_static_lifetime_note = this has an implicit `'static` lifetime requirement | |
168 | infer_implicit_static_lifetime_suggestion = consider relaxing the implicit `'static` requirement | |
f2b60f7d FG |
169 | infer_msl_introduces_static = introduces a `'static` lifetime requirement |
170 | infer_msl_unmet_req = because this has an unmet lifetime requirement | |
171 | infer_msl_trait_note = this has an implicit `'static` lifetime requirement | |
172 | infer_msl_trait_sugg = consider relaxing the implicit `'static` requirement | |
487cf647 | 173 | infer_suggest_add_let_for_letchains = consider adding `let` |
9c376795 FG |
174 | |
175 | infer_explicit_lifetime_required_with_ident = explicit lifetime required in the type of `{$simple_ident}` | |
176 | .label = lifetime `{$named}` required | |
177 | ||
178 | infer_explicit_lifetime_required_with_param_type = explicit lifetime required in parameter type | |
179 | .label = lifetime `{$named}` required | |
180 | ||
181 | infer_explicit_lifetime_required_sugg_with_ident = add explicit lifetime `{$named}` to the type of `{$simple_ident}` | |
182 | ||
183 | infer_explicit_lifetime_required_sugg_with_param_type = add explicit lifetime `{$named}` to type | |
184 | ||
185 | infer_actual_impl_expl_expected_signature_two = {$leading_ellipsis -> | |
186 | [true] ... | |
187 | *[false] {""} | |
188 | }closure with signature `{$ty_or_sig}` must implement `{$trait_path}`, for any two lifetimes `'{$lifetime_1}` and `'{$lifetime_2}`... | |
189 | infer_actual_impl_expl_expected_signature_any = {$leading_ellipsis -> | |
190 | [true] ... | |
191 | *[false] {""} | |
192 | }closure with signature `{$ty_or_sig}` must implement `{$trait_path}`, for any lifetime `'{$lifetime_1}`... | |
193 | infer_actual_impl_expl_expected_signature_some = {$leading_ellipsis -> | |
194 | [true] ... | |
195 | *[false] {""} | |
196 | }closure with signature `{$ty_or_sig}` must implement `{$trait_path}`, for some specific lifetime `'{$lifetime_1}`... | |
197 | infer_actual_impl_expl_expected_signature_nothing = {$leading_ellipsis -> | |
198 | [true] ... | |
199 | *[false] {""} | |
200 | }closure with signature `{$ty_or_sig}` must implement `{$trait_path}` | |
201 | infer_actual_impl_expl_expected_passive_two = {$leading_ellipsis -> | |
202 | [true] ... | |
203 | *[false] {""} | |
204 | }`{$trait_path}` would have to be implemented for the type `{$ty_or_sig}`, for any two lifetimes `'{$lifetime_1}` and `'{$lifetime_2}`... | |
205 | infer_actual_impl_expl_expected_passive_any = {$leading_ellipsis -> | |
206 | [true] ... | |
207 | *[false] {""} | |
208 | }`{$trait_path}` would have to be implemented for the type `{$ty_or_sig}`, for any lifetime `'{$lifetime_1}`... | |
209 | infer_actual_impl_expl_expected_passive_some = {$leading_ellipsis -> | |
210 | [true] ... | |
211 | *[false] {""} | |
212 | }`{$trait_path}` would have to be implemented for the type `{$ty_or_sig}`, for some specific lifetime `'{$lifetime_1}`... | |
213 | infer_actual_impl_expl_expected_passive_nothing = {$leading_ellipsis -> | |
214 | [true] ... | |
215 | *[false] {""} | |
216 | }`{$trait_path}` would have to be implemented for the type `{$ty_or_sig}` | |
217 | infer_actual_impl_expl_expected_other_two = {$leading_ellipsis -> | |
218 | [true] ... | |
219 | *[false] {""} | |
220 | }`{$ty_or_sig}` must implement `{$trait_path}`, for any two lifetimes `'{$lifetime_1}` and `'{$lifetime_2}`... | |
221 | infer_actual_impl_expl_expected_other_any = {$leading_ellipsis -> | |
222 | [true] ... | |
223 | *[false] {""} | |
224 | }`{$ty_or_sig}` must implement `{$trait_path}`, for any lifetime `'{$lifetime_1}`... | |
225 | infer_actual_impl_expl_expected_other_some = {$leading_ellipsis -> | |
226 | [true] ... | |
227 | *[false] {""} | |
228 | }`{$ty_or_sig}` must implement `{$trait_path}`, for some specific lifetime `'{$lifetime_1}`... | |
229 | infer_actual_impl_expl_expected_other_nothing = {$leading_ellipsis -> | |
230 | [true] ... | |
231 | *[false] {""} | |
232 | }`{$ty_or_sig}` must implement `{$trait_path}` | |
233 | ||
234 | infer_actual_impl_expl_but_actually_implements_trait = ...but it actually implements `{$trait_path}`{$has_lifetime -> | |
235 | [true] , for some specific lifetime `'{$lifetime}` | |
236 | *[false] {""} | |
237 | } | |
238 | infer_actual_impl_expl_but_actually_implemented_for_ty = ...but `{$trait_path}` is actually implemented for the type `{$ty}`{$has_lifetime -> | |
239 | [true] , for some specific lifetime `'{$lifetime}` | |
240 | *[false] {""} | |
241 | } | |
242 | infer_actual_impl_expl_but_actually_ty_implements = ...but `{$ty}` actually implements `{$trait_path}`{$has_lifetime -> | |
243 | [true] , for some specific lifetime `'{$lifetime}` | |
244 | *[false] {""} | |
245 | } | |
246 | ||
247 | infer_trait_placeholder_mismatch = implementation of `{$trait_def_id}` is not general enough | |
248 | .label_satisfy = doesn't satisfy where-clause | |
249 | .label_where = due to a where-clause on `{$def_id}`... | |
250 | .label_dup = implementation of `{$trait_def_id}` is not general enough | |
251 | ||
252 | infer_trait_impl_diff = `impl` item signature doesn't match `trait` item signature | |
253 | .found = found `{$found}` | |
254 | .expected = expected `{$expected}` | |
255 | .expected_found = expected signature `{$expected}` | |
256 | {" "}found signature `{$found}` | |
257 | ||
258 | infer_tid_rel_help = verify the lifetime relationships in the `trait` and `impl` between the `self` argument, the other inputs and its output | |
259 | infer_tid_consider_borrowing = consider borrowing this type parameter in the trait | |
260 | infer_tid_param_help = the lifetime requirements from the `impl` do not correspond to the requirements in the `trait` | |
261 | ||
262 | infer_dtcs_has_lifetime_req_label = this has an implicit `'static` lifetime requirement | |
263 | infer_dtcs_introduces_requirement = calling this method introduces the `impl`'s 'static` requirement | |
264 | infer_dtcs_has_req_note = the used `impl` has a `'static` requirement | |
265 | infer_dtcs_suggestion = consider relaxing the implicit `'static` requirement | |
266 | ||
267 | infer_but_calling_introduces = {$has_param_name -> | |
268 | [true] `{$param_name}` | |
269 | *[false] `fn` parameter | |
270 | } has {$lifetime_kind -> | |
271 | [named] lifetime `{$lifetime}` | |
272 | *[anon] an anonymous lifetime `'_` | |
273 | } but calling `{assoc_item}` introduces an implicit `'static` lifetime requirement | |
274 | .label1 = {$has_lifetime -> | |
275 | [named] lifetime `{$lifetime}` | |
276 | *[anon] an anonymous lifetime `'_` | |
277 | } | |
278 | .label2 = ...is used and required to live as long as `'static` here because of an implicit lifetime bound on the {$has_impl_path -> | |
279 | [named] `impl` of `{$impl_path}` | |
280 | *[anon] inherent `impl` | |
281 | } | |
282 | ||
283 | infer_but_needs_to_satisfy = {$has_param_name -> | |
284 | [true] `{$param_name}` | |
285 | *[false] `fn` parameter | |
286 | } has {$has_lifetime -> | |
287 | [named] lifetime `{$lifetime}` | |
288 | *[anon] an anonymous lifetime `'_` | |
289 | } but it needs to satisfy a `'static` lifetime requirement | |
290 | .influencer = this data with {$has_lifetime -> | |
291 | [named] lifetime `{$lifetime}` | |
292 | *[anon] an anonymous lifetime `'_` | |
293 | }... | |
294 | .require = {$spans_empty -> | |
295 | *[true] ...is used and required to live as long as `'static` here | |
296 | [false] ...and is required to live as long as `'static` here | |
297 | } | |
298 | .used_here = ...is used here... | |
299 | .introduced_by_bound = 'static` lifetime requirement introduced by this bound | |
300 | ||
301 | infer_more_targeted = {$has_param_name -> | |
302 | [true] `{$param_name}` | |
303 | *[false] `fn` parameter | |
304 | } has {$has_lifetime -> | |
305 | [named] lifetime `{$lifetime}` | |
306 | *[anon] an anonymous lifetime `'_` | |
307 | } but calling `{$ident}` introduces an implicit `'static` lifetime requirement | |
308 | ||
309 | infer_ril_introduced_here = `'static` requirement introduced here | |
310 | infer_ril_introduced_by = requirement introduced by this return type | |
311 | infer_ril_because_of = because of this returned expression | |
312 | infer_ril_static_introduced_by = "`'static` lifetime requirement introduced by the return type |