fork/rust

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

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

master
19.5 KiB384 linesraw
1mir_build_adt_defined_here = `{$ty}` defined here
2
3mir_build_already_borrowed = cannot borrow value as mutable because it is also borrowed as immutable
4
5mir_build_already_mut_borrowed = cannot borrow value as immutable because it is also borrowed as mutable
6
7mir_build_assoc_const_in_pattern = associated consts cannot be referenced in patterns
8
9mir_build_bindings_with_variant_name =
10    pattern binding `{$name}` is named the same as one of the variants of the type `{$ty_path}`
11    .suggestion = to match on the variant, qualify the path
12
13mir_build_borrow = value is borrowed by `{$name}` here
14
15mir_build_borrow_of_layout_constrained_field_requires_unsafe =
16    borrow of layout constrained field with interior mutability is unsafe and requires unsafe block
17    .note = references to fields of layout constrained fields lose the constraints. Coupled with interior mutability, the field can be changed to invalid values
18    .label = borrow of layout constrained field with interior mutability
19
20mir_build_borrow_of_layout_constrained_field_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
21    borrow of layout constrained field with interior mutability is unsafe and requires unsafe function or block
22    .note = references to fields of layout constrained fields lose the constraints. Coupled with interior mutability, the field can be changed to invalid values
23    .label = borrow of layout constrained field with interior mutability
24
25mir_build_borrow_of_moved_value = borrow of moved value
26    .label = value moved into `{$name}` here
27    .occurs_because_label = move occurs because `{$name}` has type `{$ty}` which does not implement the `Copy` trait
28    .value_borrowed_label = value borrowed here after move
29    .suggestion = borrow this binding in the pattern to avoid moving the value
30
31mir_build_call_to_fn_with_requires_unsafe =
32    call to function `{$function}` with `#[target_feature]` is unsafe and requires unsafe block
33    .note = can only be called if the required target features are available
34    .label = call to function with `#[target_feature]`
35
36mir_build_call_to_fn_with_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
37    call to function `{$function}` with `#[target_feature]` is unsafe and requires unsafe function or block
38    .note = can only be called if the required target features are available
39    .label = call to function with `#[target_feature]`
40
41mir_build_call_to_unsafe_fn_requires_unsafe =
42    call to unsafe function `{$function}` is unsafe and requires unsafe block
43    .note = consult the function's documentation for information on how to avoid undefined behavior
44    .label = call to unsafe function
45
46mir_build_call_to_unsafe_fn_requires_unsafe_nameless =
47    call to unsafe function is unsafe and requires unsafe block
48    .note = consult the function's documentation for information on how to avoid undefined behavior
49    .label = call to unsafe function
50
51mir_build_call_to_unsafe_fn_requires_unsafe_nameless_unsafe_op_in_unsafe_fn_allowed =
52    call to unsafe function is unsafe and requires unsafe function or block
53    .note = consult the function's documentation for information on how to avoid undefined behavior
54    .label = call to unsafe function
55
56mir_build_call_to_unsafe_fn_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
57    call to unsafe function `{$function}` is unsafe and requires unsafe function or block
58    .note = consult the function's documentation for information on how to avoid undefined behavior
59    .label = call to unsafe function
60
61mir_build_confused = missing patterns are not covered because `{$variable}` is interpreted as a constant pattern, not a new variable
62
63mir_build_const_param_in_pattern = const parameters cannot be referenced in patterns
64
65mir_build_const_pattern_depends_on_generic_parameter =
66    constant pattern depends on a generic parameter
67
68mir_build_could_not_eval_const_pattern = could not evaluate constant pattern
69
70mir_build_deref_raw_pointer_requires_unsafe =
71    dereference of raw pointer is unsafe and requires unsafe block
72    .note = raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
73    .label = dereference of raw pointer
74
75mir_build_deref_raw_pointer_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
76    dereference of raw pointer is unsafe and requires unsafe function or block
77    .note = raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
78    .label = dereference of raw pointer
79
80mir_build_extern_static_requires_unsafe =
81    use of extern static is unsafe and requires unsafe block
82    .note = extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
83    .label = use of extern static
84
85mir_build_extern_static_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
86    use of extern static is unsafe and requires unsafe function or block
87    .note = extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
88    .label = use of extern static
89
90mir_build_float_pattern = floating-point types cannot be used in patterns
91
92mir_build_indirect_structural_match =
93    to use a constant of type `{$non_sm_ty}` in a pattern, `{$non_sm_ty}` must be annotated with `#[derive(PartialEq, Eq)]`
94
95mir_build_inform_irrefutable = `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
96
97mir_build_initializing_type_with_requires_unsafe =
98    initializing type with `rustc_layout_scalar_valid_range` attr is unsafe and requires unsafe block
99    .note = initializing a layout restricted type's field with a value outside the valid range is undefined behavior
100    .label = initializing type with `rustc_layout_scalar_valid_range` attr
101
102mir_build_initializing_type_with_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
103    initializing type with `rustc_layout_scalar_valid_range` attr is unsafe and requires unsafe function or block
104    .note = initializing a layout restricted type's field with a value outside the valid range is undefined behavior
105    .label = initializing type with `rustc_layout_scalar_valid_range` attr
106
107mir_build_inline_assembly_requires_unsafe =
108    use of inline assembly is unsafe and requires unsafe block
109    .note = inline assembly is entirely unchecked and can cause undefined behavior
110    .label = use of inline assembly
111
112mir_build_inline_assembly_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
113    use of inline assembly is unsafe and requires unsafe function or block
114    .note = inline assembly is entirely unchecked and can cause undefined behavior
115    .label = use of inline assembly
116
117mir_build_interpreted_as_const = introduce a variable instead
118
119mir_build_invalid_pattern = `{$non_sm_ty}` cannot be used in patterns
120
121mir_build_irrefutable_let_patterns_if_let = irrefutable `if let` {$count ->
122        [one] pattern
123        *[other] patterns
124    }
125    .note = {$count ->
126        [one] this pattern
127        *[other] these patterns
128    } will always match, so the `if let` is useless
129    .help = consider replacing the `if let` with a `let`
130
131mir_build_irrefutable_let_patterns_if_let_guard = irrefutable `if let` guard {$count ->
132        [one] pattern
133        *[other] patterns
134    }
135    .note = {$count ->
136        [one] this pattern
137        *[other] these patterns
138    } will always match, so the guard is useless
139    .help = consider removing the guard and adding a `let` inside the match arm
140
141mir_build_irrefutable_let_patterns_let_else = irrefutable `let...else` {$count ->
142        [one] pattern
143        *[other] patterns
144    }
145    .note = {$count ->
146        [one] this pattern
147        *[other] these patterns
148    } will always match, so the `else` clause is useless
149    .help = consider removing the `else` clause
150
151mir_build_irrefutable_let_patterns_while_let = irrefutable `while let` {$count ->
152        [one] pattern
153        *[other] patterns
154    }
155    .note = {$count ->
156        [one] this pattern
157        *[other] these patterns
158    } will always match, so the loop will never exit
159    .help = consider instead using a `loop {"{"} ... {"}"}` with a `let` inside it
160
161mir_build_leading_irrefutable_let_patterns = leading irrefutable {$count ->
162        [one] pattern
163        *[other] patterns
164    } in let chain
165    .note = {$count ->
166        [one] this pattern
167        *[other] these patterns
168    } will always match
169    .help = consider moving {$count ->
170        [one] it
171        *[other] them
172    } outside of the construct
173
174mir_build_literal_in_range_out_of_bounds =
175    literal out of range for `{$ty}`
176    .label = this value doesn't fit in `{$ty}` whose maximum value is `{$max}`
177
178mir_build_lower_range_bound_must_be_less_than_or_equal_to_upper =
179    lower range bound must be less than or equal to upper
180    .label = lower bound larger than upper bound
181    .teach_note = When matching against a range, the compiler verifies that the range is non-empty. Range patterns include both end-points, so this is equivalent to requiring the start of the range to be less than or equal to the end of the range.
182
183mir_build_lower_range_bound_must_be_less_than_upper = lower range bound must be less than upper
184
185mir_build_more_information = for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
186
187mir_build_moved = value is moved into `{$name}` here
188
189mir_build_moved_while_borrowed = cannot move out of value because it is borrowed
190
191mir_build_multiple_mut_borrows = cannot borrow value as mutable more than once at a time
192
193mir_build_mutable_borrow = value is mutably borrowed by `{$name}` here
194
195mir_build_mutable_static_requires_unsafe =
196    use of mutable static is unsafe and requires unsafe block
197    .note = mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
198    .label = use of mutable static
199
200mir_build_mutable_static_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
201    use of mutable static is unsafe and requires unsafe function or block
202    .note = mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
203    .label = use of mutable static
204
205mir_build_mutation_of_layout_constrained_field_requires_unsafe =
206    mutation of layout constrained field is unsafe and requires unsafe block
207    .note = mutating layout constrained fields cannot statically be checked for valid values
208    .label = mutation of layout constrained field
209
210mir_build_mutation_of_layout_constrained_field_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
211    mutation of layout constrained field is unsafe and requires unsafe function or block
212    .note = mutating layout constrained fields cannot statically be checked for valid values
213    .label = mutation of layout constrained field
214
215mir_build_non_const_path = runtime values cannot be referenced in patterns
216
217mir_build_non_exhaustive_match_all_arms_guarded =
218    match arms with guards don't count towards exhaustivity
219
220mir_build_non_exhaustive_omitted_pattern = some variants are not matched explicitly
221    .help = ensure that all variants are matched explicitly by adding the suggested match arms
222    .note = the matched value is of type `{$scrut_ty}` and the `non_exhaustive_omitted_patterns` attribute was found
223
224mir_build_non_exhaustive_patterns_type_not_empty = non-exhaustive patterns: type `{$ty}` is non-empty
225    .def_note = `{$peeled_ty}` defined here
226    .type_note = the matched value is of type `{$ty}`
227    .non_exhaustive_type_note = the matched value is of type `{$ty}`, which is marked as non-exhaustive
228    .reference_note = references are always considered inhabited
229    .suggestion = ensure that all possible cases are being handled by adding a match arm with a wildcard pattern as shown
230    .help = ensure that all possible cases are being handled by adding a match arm with a wildcard pattern
231
232mir_build_non_partial_eq_match =
233    to use a constant of type `{$non_peq_ty}` in a pattern, the type must implement `PartialEq`
234
235mir_build_nontrivial_structural_match =
236    to use a constant of type `{$non_sm_ty}` in a pattern, the constant's initializer must be trivial or `{$non_sm_ty}` must be annotated with `#[derive(PartialEq, Eq)]`
237
238mir_build_overlapping_range_endpoints = multiple patterns overlap on their endpoints
239    .range = ... with this range
240    .note = you likely meant to write mutually exclusive ranges
241
242mir_build_pattern_not_covered = refutable pattern in {$origin}
243    .pattern_ty = the matched value is of type `{$pattern_ty}`
244
245mir_build_pointer_pattern = function pointers and unsized pointers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
246
247mir_build_privately_uninhabited = pattern `{$witness_1}` is currently uninhabited, but this variant contains private fields which may become inhabited in the future
248
249mir_build_rustc_box_attribute_error = `#[rustc_box]` attribute used incorrectly
250    .attributes = no other attributes may be applied
251    .not_box = `#[rustc_box]` may only be applied to a `Box::new()` call
252    .missing_box = `#[rustc_box]` requires the `owned_box` lang item
253
254mir_build_static_in_pattern = statics cannot be referenced in patterns
255
256mir_build_suggest_attempted_int_lit = alternatively, you could prepend the pattern with an underscore to define a new named variable; identifiers cannot begin with digits
257
258
259mir_build_suggest_if_let = you might want to use `if let` to ignore the {$count ->
260        [one] variant that isn't
261        *[other] variants that aren't
262    } matched
263
264mir_build_suggest_let_else = you might want to use `let else` to handle the {$count ->
265        [one] variant that isn't
266        *[other] variants that aren't
267    } matched
268
269mir_build_trailing_irrefutable_let_patterns = trailing irrefutable {$count ->
270        [one] pattern
271        *[other] patterns
272    } in let chain
273    .note = {$count ->
274        [one] this pattern
275        *[other] these patterns
276    } will always match
277    .help = consider moving {$count ->
278        [one] it
279        *[other] them
280    } into the body
281
282mir_build_type_not_structural =
283     to use a constant of type `{$non_sm_ty}` in a pattern, `{$non_sm_ty}` must be annotated with `#[derive(PartialEq, Eq)]`
284
285mir_build_type_not_structural_more_info = see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
286
287mir_build_type_not_structural_tip = the traits must be derived, manual `impl`s are not sufficient
288
289mir_build_unconditional_recursion = function cannot return without recursing
290    .label = cannot return without recursing
291    .help = a `loop` may express intention better if this is on purpose
292
293mir_build_unconditional_recursion_call_site_label = recursive call site
294
295mir_build_uncovered = {$count ->
296        [1] pattern `{$witness_1}`
297        [2] patterns `{$witness_1}` and `{$witness_2}`
298        [3] patterns `{$witness_1}`, `{$witness_2}` and `{$witness_3}`
299        *[other] patterns `{$witness_1}`, `{$witness_2}`, `{$witness_3}` and {$remainder} more
300    } not covered
301
302mir_build_union_field_requires_unsafe =
303    access to union field is unsafe and requires unsafe block
304    .note = the field may not be properly initialized: using uninitialized data will cause undefined behavior
305    .label = access to union field
306
307mir_build_union_field_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
308    access to union field is unsafe and requires unsafe function or block
309    .note = the field may not be properly initialized: using uninitialized data will cause undefined behavior
310    .label = access to union field
311
312mir_build_union_pattern = cannot use unions in constant patterns
313
314mir_build_unreachable_pattern = unreachable pattern
315    .label = unreachable pattern
316    .catchall_label = matches any value
317
318mir_build_unsafe_not_inherited = items do not inherit unsafety from separate enclosing items
319
320mir_build_unsafe_op_in_unsafe_fn_borrow_of_layout_constrained_field_requires_unsafe =
321    borrow of layout constrained field with interior mutability is unsafe and requires unsafe block (error E0133)
322    .note = references to fields of layout constrained fields lose the constraints. Coupled with interior mutability, the field can be changed to invalid values
323    .label = borrow of layout constrained field with interior mutability
324
325mir_build_unsafe_op_in_unsafe_fn_call_to_fn_with_requires_unsafe =
326    call to function `{$function}` with `#[target_feature]` is unsafe and requires unsafe block (error E0133)
327    .note = can only be called if the required target features are available
328    .label = call to function with `#[target_feature]`
329
330mir_build_unsafe_op_in_unsafe_fn_call_to_unsafe_fn_requires_unsafe =
331    call to unsafe function `{$function}` is unsafe and requires unsafe block (error E0133)
332    .note = consult the function's documentation for information on how to avoid undefined behavior
333    .label = call to unsafe function
334
335mir_build_unsafe_op_in_unsafe_fn_call_to_unsafe_fn_requires_unsafe_nameless =
336    call to unsafe function is unsafe and requires unsafe block (error E0133)
337    .note = consult the function's documentation for information on how to avoid undefined behavior
338    .label = call to unsafe function
339
340mir_build_unsafe_op_in_unsafe_fn_deref_raw_pointer_requires_unsafe =
341    dereference of raw pointer is unsafe and requires unsafe block (error E0133)
342    .note = raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
343    .label = dereference of raw pointer
344
345mir_build_unsafe_op_in_unsafe_fn_extern_static_requires_unsafe =
346    use of extern static is unsafe and requires unsafe block (error E0133)
347    .note = extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
348    .label = use of extern static
349
350mir_build_unsafe_op_in_unsafe_fn_initializing_type_with_requires_unsafe =
351    initializing type with `rustc_layout_scalar_valid_range` attr is unsafe and requires unsafe
352    block (error E0133)
353    .note = initializing a layout restricted type's field with a value outside the valid range is undefined behavior
354    .label = initializing type with `rustc_layout_scalar_valid_range` attr
355
356mir_build_unsafe_op_in_unsafe_fn_inline_assembly_requires_unsafe =
357    use of inline assembly is unsafe and requires unsafe block (error E0133)
358    .note = inline assembly is entirely unchecked and can cause undefined behavior
359    .label = use of inline assembly
360
361mir_build_unsafe_op_in_unsafe_fn_mutable_static_requires_unsafe =
362    use of mutable static is unsafe and requires unsafe block (error E0133)
363    .note = mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
364    .label = use of mutable static
365
366mir_build_unsafe_op_in_unsafe_fn_mutation_of_layout_constrained_field_requires_unsafe =
367    mutation of layout constrained field is unsafe and requires unsafe block (error E0133)
368    .note = mutating layout constrained fields cannot statically be checked for valid values
369    .label = mutation of layout constrained field
370
371mir_build_unsafe_op_in_unsafe_fn_union_field_requires_unsafe =
372    access to union field is unsafe and requires unsafe block (error E0133)
373    .note = the field may not be properly initialized: using uninitialized data will cause undefined behavior
374    .label = access to union field
375
376mir_build_unsized_pattern = cannot use unsized non-slice type `{$non_sm_ty}` in constant patterns
377
378mir_build_unused_unsafe = unnecessary `unsafe` block
379    .label = unnecessary `unsafe` block
380
381mir_build_unused_unsafe_enclosing_block_label = because it's nested under this `unsafe` block
382mir_build_unused_unsafe_enclosing_fn_label = because it's nested under this `unsafe` fn
383
384mir_build_variant_defined_here = not covered