fork/rust
git clone https://git.julia.blue/fork/rust
3bcad65fbf6
master
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