user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rollup merge of #138285 - beetrees:repr128-stable, r=traviscross,bjorn3

Browse source 
Stabilize `repr128`

## Stabilisation report

The `repr128` feature ([tracking issue](https://github.com/rust-lang/rust/issues/56071)) allows the use of `#[repr(u128)]` and `#[repr(i128)]` on enums in the same way that other primitive representations such as `#[repr(u64)]` can be used. For example:

```rust
#[repr(u128)]
enum Foo {
    One = 1,
    Two,
    Big = u128::MAX,
}

#[repr(i128)]
enum Bar {
    HasThing(u16) = 42,
    HasSomethingElse(i64) = u64::MAX as i128 + 1,
    HasNothing,
}
```

This is the final part of adding 128-bit integers to Rust ([RFC 1504](https://rust-lang.github.io/rfcs/1504-int128.html)); all other parts of 128-bit integer support were stabilised in #49101 back in 2018.

From a design perspective, `#[repr(u128)]`/`#[repr(i128)]` function like `#[repr(u64)]`/`#[repr(i64)]` but for 128-bit integers instead of 64-bit integers. The only differences are:

- FFI safety: as `u128`/`i128` are not currently considered FFI safe, neither are `#[repr(u128)]`/`#[repr(i128)]` enums (I discovered this wasn't the case while drafting this stabilisation report, so I have submitted #138282 to fix this).
- Debug info: while none of the major debuggers currently support 128-bit integers, as of LLVM 20 `rustc` will emit valid debuginfo for both DWARF and PDB (PDB makes use of the same natvis that is also used for all enums with fields, whereas DWARF has native support).

Tests for `#[repr(u128)]`/`#[repr(i128)]` enums include:
- [ui/enum-discriminant/repr128.rs](385970f0c1/tests/ui/enum-discriminant/repr128.rs): checks that 128-bit enum discriminants have the correct values.
- [debuginfo/msvc-pretty-enums.rs](385970f0c1/tests/debuginfo/msvc-pretty-enums.rs): checks the PDB debuginfo is correct.
- [run-make/repr128-dwarf](385970f0c1/tests/run-make/repr128-dwarf/rmake.rs): checks the DWARF debuginfo is correct.

Stabilising this feature does not require any changes to the Rust Reference as [the documentation on primitive representations](https://doc.rust-lang.org/nightly/reference/type-layout.html#r-layout.repr.primitive.intro) already includes `u128` and `i128`.

Closes #56071
Closes https://github.com/rust-lang/reference/issues/1368

r? lang

```@rustbot``` label +I-lang-nominated +T-lang
This commit is contained in:
Jacob Pratt 2025-05-29 04:50:46 +02:00 • committed by GitHub
commit 8951c74e2a
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
32 changed files with 143 additions and 277 deletions
Download patch file Download diff file Expand all files Collapse all files

12
compiler/rustc_error_codes/src/error_codes/E0658.md
View file

@ -3,10 +3,7 @@ An unstable feature was used.
Erroneous code example:
```compile_fail,E0658
#[repr(u128)] // error: use of unstable library feature 'repr128'
enum Foo {
Bar(u64),
}
use std::intrinsics; // error: use of unstable library feature `core_intrinsics`
```
If you're using a stable or a beta version of rustc, you won't be able to use
@ -17,12 +14,9 @@ If you're using a nightly version of rustc, just add the corresponding feature
to be able to use it:
```
#![feature(repr128)]
#![feature(core_intrinsics)]
#[repr(u128)] // ok!
enum Foo {
Bar(u64),
}
use std::intrinsics; // ok!
```
[rustup]: https://rust-lang.github.io/rustup/concepts/channels.html

2
compiler/rustc_feature/src/accepted.rs
View file

@ -360,6 +360,8 @@ declare_features! (
(accepted, relaxed_adts, "1.19.0", Some(35626)),
/// Lessens the requirements for structs to implement `Unsize`.
(accepted, relaxed_struct_unsize, "1.58.0", Some(81793)),
/// Allows the `#[repr(i128)]` attribute for enums.
(accepted, repr128, "CURRENT_RUSTC_VERSION", Some(56071)),
/// Allows `repr(align(16))` struct attribute (RFC 1358).
(accepted, repr_align, "1.25.0", Some(33626)),
/// Allows using `#[repr(align(X))]` on enums with equivalent semantics

2
compiler/rustc_feature/src/unstable.rs
View file

@ -621,8 +621,6 @@ declare_features! (
(incomplete, ref_pat_eat_one_layer_2024_structural, "1.81.0", Some(123076)),
/// Allows using the `#[register_tool]` attribute.
(unstable, register_tool, "1.41.0", Some(66079)),
/// Allows the `#[repr(i128)]` attribute for enums.
(incomplete, repr128, "1.16.0", Some(56071)),
/// Allows `repr(simd)` and importing the various simd intrinsics.
(unstable, repr_simd, "1.4.0", Some(27731)),
/// Allows bounding the return type of AFIT/RPITIT.

15
compiler/rustc_hir_analysis/src/check/check.rs
View file

@ -18,7 +18,7 @@ use rustc_middle::middle::resolve_bound_vars::ResolvedArg;
use rustc_middle::middle::stability::EvalResult;
use rustc_middle::ty::error::TypeErrorToStringExt;
use rustc_middle::ty::layout::{LayoutError, MAX_SIMD_LANES};
use rustc_middle::ty::util::{Discr, IntTypeExt};
use rustc_middle::ty::util::Discr;
use rustc_middle::ty::{
AdtDef, BottomUpFolder, GenericArgKind, RegionKind, TypeFoldable, TypeSuperVisitable,
TypeVisitable, TypeVisitableExt, fold_regions,
@ -1385,19 +1385,6 @@ fn check_enum(tcx: TyCtxt<'_>, def_id: LocalDefId) {
);
}
let repr_type_ty = def.repr().discr_type().to_ty(tcx);
if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
if !tcx.features().repr128() {
feature_err(
&tcx.sess,
sym::repr128,
tcx.def_span(def_id),
"repr with 128-bit type is unstable",
)
.emit();
}
}
for v in def.variants() {
if let ty::VariantDiscr::Explicit(discr_def_id) = v.discr {
tcx.ensure_ok().typeck(discr_def_id.expect_local());

18
src/doc/unstable-book/src/language-features/repr128.md
View file

@ -1,18 +0,0 @@
# `repr128`
The tracking issue for this feature is: [#56071]
[#56071]: https://github.com/rust-lang/rust/issues/56071
------------------------
The `repr128` feature adds support for `#[repr(u128)]` on `enum`s.
```rust
#![feature(repr128)]
#[repr(u128)]
enum Foo {
Bar(u64),
}
```

3
src/tools/clippy/tests/ui/auxiliary/proc_macro_attr.rs
View file

@ -1,5 +1,4 @@
#![feature(repr128, proc_macro_hygiene, proc_macro_quote, box_patterns)]
#![allow(incomplete_features)]
#![feature(proc_macro_hygiene, proc_macro_quote, box_patterns)]
#![allow(clippy::useless_conversion, clippy::uninlined_format_args)]
extern crate proc_macro;

3
src/tools/clippy/tests/ui/auxiliary/proc_macro_derive.rs
View file

@ -1,5 +1,4 @@
#![feature(repr128, proc_macro_quote, proc_macro_span)]
#![allow(incomplete_features)]
#![feature(proc_macro_quote, proc_macro_span)]
#![allow(clippy::field_reassign_with_default)]
#![allow(clippy::eq_op)]
#![allow(clippy::literal_string_with_formatting_args)]

2
src/tools/clippy/tests/ui/cast.rs
View file

@ -1,7 +1,5 @@
//@no-rustfix: only some diagnostics have suggestions
#![feature(repr128)]
#![allow(incomplete_features)]
#![warn(
clippy::cast_precision_loss,
clippy::cast_possible_truncation,

184
src/tools/clippy/tests/ui/cast.stderr
View file

@ -1,5 +1,5 @@
error: casting `i32` to `f32` causes a loss of precision (`i32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
--> tests/ui/cast.rs:25:5
--> tests/ui/cast.rs:23:5
|
LL | x0 as f32;
| ^^^^^^^^^
@ -8,37 +8,37 @@ LL | x0 as f32;
= help: to override `-D warnings` add `#[allow(clippy::cast_precision_loss)]`
error: casting `i64` to `f32` causes a loss of precision (`i64` is 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
--> tests/ui/cast.rs:29:5
--> tests/ui/cast.rs:27:5
|
LL | x1 as f32;
| ^^^^^^^^^
error: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
--> tests/ui/cast.rs:32:5
--> tests/ui/cast.rs:30:5
|
LL | x1 as f64;
| ^^^^^^^^^
error: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
--> tests/ui/cast.rs:36:5
--> tests/ui/cast.rs:34:5
|
LL | x2 as f32;
| ^^^^^^^^^
error: casting `u64` to `f32` causes a loss of precision (`u64` is 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
--> tests/ui/cast.rs:40:5
--> tests/ui/cast.rs:38:5
|
LL | x3 as f32;
| ^^^^^^^^^
error: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
--> tests/ui/cast.rs:43:5
--> tests/ui/cast.rs:41:5
|
LL | x3 as f64;
| ^^^^^^^^^
error: casting `f32` to `i32` may truncate the value
--> tests/ui/cast.rs:47:5
--> tests/ui/cast.rs:45:5
|
LL | 1f32 as i32;
| ^^^^^^^^^^^
@ -48,7 +48,7 @@ LL | 1f32 as i32;
= help: to override `-D warnings` add `#[allow(clippy::cast_possible_truncation)]`
error: casting `f32` to `u32` may truncate the value
--> tests/ui/cast.rs:50:5
--> tests/ui/cast.rs:48:5
|
LL | 1f32 as u32;
| ^^^^^^^^^^^
@ -56,7 +56,7 @@ LL | 1f32 as u32;
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
error: casting `f32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:50:5
--> tests/ui/cast.rs:48:5
|
LL | 1f32 as u32;
| ^^^^^^^^^^^
@ -65,7 +65,7 @@ LL | 1f32 as u32;
= help: to override `-D warnings` add `#[allow(clippy::cast_sign_loss)]`
error: casting `f64` to `f32` may truncate the value
--> tests/ui/cast.rs:54:5
--> tests/ui/cast.rs:52:5
|
LL | 1f64 as f32;
| ^^^^^^^^^^^
@ -73,7 +73,7 @@ LL | 1f64 as f32;
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
error: casting `i32` to `i8` may truncate the value
--> tests/ui/cast.rs:57:5
--> tests/ui/cast.rs:55:5
|
LL | 1i32 as i8;
| ^^^^^^^^^^
@ -86,7 +86,7 @@ LL + i8::try_from(1i32);
|
error: casting `i32` to `u8` may truncate the value
--> tests/ui/cast.rs:60:5
--> tests/ui/cast.rs:58:5
|
LL | 1i32 as u8;
| ^^^^^^^^^^
@ -99,7 +99,7 @@ LL + u8::try_from(1i32);
|
error: casting `f64` to `isize` may truncate the value
--> tests/ui/cast.rs:63:5
--> tests/ui/cast.rs:61:5
|
LL | 1f64 as isize;
| ^^^^^^^^^^^^^
@ -107,7 +107,7 @@ LL | 1f64 as isize;
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
error: casting `f64` to `usize` may truncate the value
--> tests/ui/cast.rs:66:5
--> tests/ui/cast.rs:64:5
|
LL | 1f64 as usize;
| ^^^^^^^^^^^^^
@ -115,13 +115,13 @@ LL | 1f64 as usize;
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
error: casting `f64` to `usize` may lose the sign of the value
--> tests/ui/cast.rs:66:5
--> tests/ui/cast.rs:64:5
|
LL | 1f64 as usize;
| ^^^^^^^^^^^^^
error: casting `u32` to `u16` may truncate the value
--> tests/ui/cast.rs:70:5
--> tests/ui/cast.rs:68:5
|
LL | 1f32 as u32 as u16;
| ^^^^^^^^^^^^^^^^^^
@ -134,7 +134,7 @@ LL + u16::try_from(1f32 as u32);
|
error: casting `f32` to `u32` may truncate the value
--> tests/ui/cast.rs:70:5
--> tests/ui/cast.rs:68:5
|
LL | 1f32 as u32 as u16;
| ^^^^^^^^^^^
@ -142,13 +142,13 @@ LL | 1f32 as u32 as u16;
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
error: casting `f32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:70:5
--> tests/ui/cast.rs:68:5
|
LL | 1f32 as u32 as u16;
| ^^^^^^^^^^^
error: casting `i32` to `i8` may truncate the value
--> tests/ui/cast.rs:76:22
--> tests/ui/cast.rs:74:22
|
LL | let _x: i8 = 1i32 as _;
| ^^^^^^^^^
@ -161,7 +161,7 @@ LL + let _x: i8 = 1i32.try_into();
|
error: casting `f32` to `i32` may truncate the value
--> tests/ui/cast.rs:79:9
--> tests/ui/cast.rs:77:9
|
LL | 1f32 as i32;
| ^^^^^^^^^^^
@ -169,7 +169,7 @@ LL | 1f32 as i32;
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
error: casting `f64` to `i32` may truncate the value
--> tests/ui/cast.rs:82:9
--> tests/ui/cast.rs:80:9
|
LL | 1f64 as i32;
| ^^^^^^^^^^^
@ -177,7 +177,7 @@ LL | 1f64 as i32;
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
error: casting `f32` to `u8` may truncate the value
--> tests/ui/cast.rs:85:9
--> tests/ui/cast.rs:83:9
|
LL | 1f32 as u8;
| ^^^^^^^^^^
@ -185,13 +185,13 @@ LL | 1f32 as u8;
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
error: casting `f32` to `u8` may lose the sign of the value
--> tests/ui/cast.rs:85:9
--> tests/ui/cast.rs:83:9
|
LL | 1f32 as u8;
| ^^^^^^^^^^
error: casting `u8` to `i8` may wrap around the value
--> tests/ui/cast.rs:90:5
--> tests/ui/cast.rs:88:5
|
LL | 1u8 as i8;
| ^^^^^^^^^
@ -200,31 +200,31 @@ LL | 1u8 as i8;
= help: to override `-D warnings` add `#[allow(clippy::cast_possible_wrap)]`
error: casting `u16` to `i16` may wrap around the value
--> tests/ui/cast.rs:93:5
--> tests/ui/cast.rs:91:5
|
LL | 1u16 as i16;
| ^^^^^^^^^^^
error: casting `u32` to `i32` may wrap around the value
--> tests/ui/cast.rs:96:5
--> tests/ui/cast.rs:94:5
|
LL | 1u32 as i32;
| ^^^^^^^^^^^
error: casting `u64` to `i64` may wrap around the value
--> tests/ui/cast.rs:99:5
--> tests/ui/cast.rs:97:5
|
LL | 1u64 as i64;
| ^^^^^^^^^^^
error: casting `usize` to `isize` may wrap around the value
--> tests/ui/cast.rs:102:5
--> tests/ui/cast.rs:100:5
|
LL | 1usize as isize;
| ^^^^^^^^^^^^^^^
error: casting `usize` to `i8` may truncate the value
--> tests/ui/cast.rs:106:5
--> tests/ui/cast.rs:104:5
|
LL | 1usize as i8;
| ^^^^^^^^^^^^
@ -237,7 +237,7 @@ LL + i8::try_from(1usize);
|
error: casting `usize` to `i16` may truncate the value
--> tests/ui/cast.rs:110:5
--> tests/ui/cast.rs:108:5
|
LL | 1usize as i16;
| ^^^^^^^^^^^^^
@ -250,7 +250,7 @@ LL + i16::try_from(1usize);
|
error: casting `usize` to `i16` may wrap around the value on targets with 16-bit wide pointers
--> tests/ui/cast.rs:110:5
--> tests/ui/cast.rs:108:5
|
LL | 1usize as i16;
| ^^^^^^^^^^^^^
@ -259,7 +259,7 @@ LL | 1usize as i16;
= note: for more information see https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types
error: casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers
--> tests/ui/cast.rs:115:5
--> tests/ui/cast.rs:113:5
|
LL | 1usize as i32;
| ^^^^^^^^^^^^^
@ -272,19 +272,19 @@ LL + i32::try_from(1usize);
|
error: casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers
--> tests/ui/cast.rs:115:5
--> tests/ui/cast.rs:113:5
|
LL | 1usize as i32;
| ^^^^^^^^^^^^^
error: casting `usize` to `i64` may wrap around the value on targets with 64-bit wide pointers
--> tests/ui/cast.rs:120:5
--> tests/ui/cast.rs:118:5
|
LL | 1usize as i64;
| ^^^^^^^^^^^^^
error: casting `u16` to `isize` may wrap around the value on targets with 16-bit wide pointers
--> tests/ui/cast.rs:126:5
--> tests/ui/cast.rs:124:5
|
LL | 1u16 as isize;
| ^^^^^^^^^^^^^
@ -293,13 +293,13 @@ LL | 1u16 as isize;
= note: for more information see https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types
error: casting `u32` to `isize` may wrap around the value on targets with 32-bit wide pointers
--> tests/ui/cast.rs:130:5
--> tests/ui/cast.rs:128:5
|
LL | 1u32 as isize;
| ^^^^^^^^^^^^^
error: casting `u64` to `isize` may truncate the value on targets with 32-bit wide pointers
--> tests/ui/cast.rs:134:5
--> tests/ui/cast.rs:132:5
|
LL | 1u64 as isize;
| ^^^^^^^^^^^^^
@ -312,55 +312,55 @@ LL + isize::try_from(1u64);
|
error: casting `u64` to `isize` may wrap around the value on targets with 64-bit wide pointers
--> tests/ui/cast.rs:134:5
--> tests/ui/cast.rs:132:5
|
LL | 1u64 as isize;
| ^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:140:5
--> tests/ui/cast.rs:138:5
|
LL | -1i32 as u32;
| ^^^^^^^^^^^^
error: casting `isize` to `usize` may lose the sign of the value
--> tests/ui/cast.rs:144:5
--> tests/ui/cast.rs:142:5
|
LL | -1isize as usize;
| ^^^^^^^^^^^^^^^^
error: casting `i8` to `u8` may lose the sign of the value
--> tests/ui/cast.rs:156:5
--> tests/ui/cast.rs:154:5
|
LL | (i8::MIN).abs() as u8;
| ^^^^^^^^^^^^^^^^^^^^^
error: casting `i64` to `u64` may lose the sign of the value
--> tests/ui/cast.rs:161:5
--> tests/ui/cast.rs:159:5
|
LL | (-1i64).abs() as u64;
| ^^^^^^^^^^^^^^^^^^^^
error: casting `isize` to `usize` may lose the sign of the value
--> tests/ui/cast.rs:163:5
--> tests/ui/cast.rs:161:5
|
LL | (-1isize).abs() as usize;
| ^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `i64` to `u64` may lose the sign of the value
--> tests/ui/cast.rs:171:5
--> tests/ui/cast.rs:169:5
|
LL | (unsafe { (-1i64).checked_abs().unwrap_unchecked() }) as u64;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `i64` to `u64` may lose the sign of the value
--> tests/ui/cast.rs:187:5
--> tests/ui/cast.rs:185:5
|
LL | (unsafe { (-1i64).checked_isqrt().unwrap_unchecked() }) as u64;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `i64` to `i8` may truncate the value
--> tests/ui/cast.rs:239:5
--> tests/ui/cast.rs:237:5
|
LL | (-99999999999i64).min(1) as i8;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -373,7 +373,7 @@ LL + i8::try_from((-99999999999i64).min(1));
|
error: casting `u64` to `u8` may truncate the value
--> tests/ui/cast.rs:253:5
--> tests/ui/cast.rs:251:5
|
LL | 999999u64.clamp(0, 256) as u8;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -386,7 +386,7 @@ LL + u8::try_from(999999u64.clamp(0, 256));
|
error: casting `main::E2` to `u8` may truncate the value
--> tests/ui/cast.rs:276:21
--> tests/ui/cast.rs:274:21
|
LL | let _ = self as u8;
| ^^^^^^^^^^
@ -399,7 +399,7 @@ LL + let _ = u8::try_from(self);
|
error: casting `main::E2::B` to `u8` will truncate the value
--> tests/ui/cast.rs:279:21
--> tests/ui/cast.rs:277:21
|
LL | let _ = Self::B as u8;
| ^^^^^^^^^^^^^
@ -408,7 +408,7 @@ LL | let _ = Self::B as u8;
= help: to override `-D warnings` add `#[allow(clippy::cast_enum_truncation)]`
error: casting `main::E5` to `i8` may truncate the value
--> tests/ui/cast.rs:321:21
--> tests/ui/cast.rs:319:21
|
LL | let _ = self as i8;
| ^^^^^^^^^^
@ -421,13 +421,13 @@ LL + let _ = i8::try_from(self);
|
error: casting `main::E5::A` to `i8` will truncate the value
--> tests/ui/cast.rs:324:21
--> tests/ui/cast.rs:322:21
|
LL | let _ = Self::A as i8;
| ^^^^^^^^^^^^^
error: casting `main::E6` to `i16` may truncate the value
--> tests/ui/cast.rs:342:21
--> tests/ui/cast.rs:340:21
|
LL | let _ = self as i16;
| ^^^^^^^^^^^
@ -440,7 +440,7 @@ LL + let _ = i16::try_from(self);
|
error: casting `main::E7` to `usize` may truncate the value on targets with 32-bit wide pointers
--> tests/ui/cast.rs:362:21
--> tests/ui/cast.rs:360:21
|
LL | let _ = self as usize;
| ^^^^^^^^^^^^^
@ -453,7 +453,7 @@ LL + let _ = usize::try_from(self);
|
error: casting `main::E10` to `u16` may truncate the value
--> tests/ui/cast.rs:410:21
--> tests/ui/cast.rs:408:21
|
LL | let _ = self as u16;
| ^^^^^^^^^^^
@ -466,7 +466,7 @@ LL + let _ = u16::try_from(self);
|
error: casting `u32` to `u8` may truncate the value
--> tests/ui/cast.rs:422:13
--> tests/ui/cast.rs:420:13
|
LL | let c = (q >> 16) as u8;
| ^^^^^^^^^^^^^^^
@ -479,7 +479,7 @@ LL + let c = u8::try_from(q >> 16);
|
error: casting `u32` to `u8` may truncate the value
--> tests/ui/cast.rs:427:13
--> tests/ui/cast.rs:425:13
|
LL | let c = (q / 1000) as u8;
| ^^^^^^^^^^^^^^^^
@ -492,85 +492,85 @@ LL + let c = u8::try_from(q / 1000);
|
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:440:9
--> tests/ui/cast.rs:438:9
|
LL | (x * x) as u32;
| ^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:446:32
--> tests/ui/cast.rs:444:32
|
LL | let _a = |x: i32| -> u32 { (x * x * x * x) as u32 };
| ^^^^^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:449:5
--> tests/ui/cast.rs:447:5
|
LL | (2_i32).checked_pow(3).unwrap() as u32;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:451:5
--> tests/ui/cast.rs:449:5
|
LL | (-2_i32).pow(3) as u32;
| ^^^^^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:456:5
--> tests/ui/cast.rs:454:5
|
LL | (-5_i32 % 2) as u32;
| ^^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:459:5
--> tests/ui/cast.rs:457:5
|
LL | (-5_i32 % -2) as u32;
| ^^^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:463:5
--> tests/ui/cast.rs:461:5
|
LL | (-2_i32 >> 1) as u32;
| ^^^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:467:5
--> tests/ui/cast.rs:465:5
|
LL | (x * x) as u32;
| ^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:469:5
--> tests/ui/cast.rs:467:5
|
LL | (x * x * x) as u32;
| ^^^^^^^^^^^^^^^^^^
error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:473:5
--> tests/ui/cast.rs:471:5
|
LL | (y * y * y * y * -2) as u16;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:476:5
--> tests/ui/cast.rs:474:5
|
LL | (y * y * y / y * 2) as u16;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:478:5
--> tests/ui/cast.rs:476:5
|
LL | (y * y / y * 2) as u16;
| ^^^^^^^^^^^^^^^^^^^^^^
error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:481:5
--> tests/ui/cast.rs:479:5
|
LL | (y / y * y * -2) as u16;
| ^^^^^^^^^^^^^^^^^^^^^^^
error: equal expressions as operands to `/`
--> tests/ui/cast.rs:481:6
--> tests/ui/cast.rs:479:6
|
LL | (y / y * y * -2) as u16;
| ^^^^^
@ -578,97 +578,97 @@ LL | (y / y * y * -2) as u16;
= note: `#[deny(clippy::eq_op)]` on by default
error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:485:5
--> tests/ui/cast.rs:483:5
|
LL | (y + y + y + -2) as u16;
| ^^^^^^^^^^^^^^^^^^^^^^^
error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:488:5
--> tests/ui/cast.rs:486:5
|
LL | (y + y + y + 2) as u16;
| ^^^^^^^^^^^^^^^^^^^^^^
error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:492:5
--> tests/ui/cast.rs:490:5
|
LL | (z + -2) as u16;
| ^^^^^^^^^^^^^^^
error: casting `i16` to `u16` may lose the sign of the value
--> tests/ui/cast.rs:495:5
--> tests/ui/cast.rs:493:5
|
LL | (z + z + 2) as u16;
| ^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:499:9
--> tests/ui/cast.rs:497:9
|
LL | (a * a * b * b * c * c) as u32;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:501:9
--> tests/ui/cast.rs:499:9
|
LL | (a * b * c) as u32;
| ^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:504:9
--> tests/ui/cast.rs:502:9
|
LL | (a * -b * c) as u32;
| ^^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:507:9
--> tests/ui/cast.rs:505:9
|
LL | (a * b * c * c) as u32;
| ^^^^^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:509:9
--> tests/ui/cast.rs:507:9
|
LL | (a * -2) as u32;
| ^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:512:9
--> tests/ui/cast.rs:510:9
|
LL | (a * b * c * -2) as u32;
| ^^^^^^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:515:9
--> tests/ui/cast.rs:513:9
|
LL | (a / b) as u32;
| ^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:517:9
--> tests/ui/cast.rs:515:9
|
LL | (a / b * c) as u32;
| ^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:520:9
--> tests/ui/cast.rs:518:9
|
LL | (a / b + b * c) as u32;
| ^^^^^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:523:9
--> tests/ui/cast.rs:521:9
|
LL | a.saturating_pow(3) as u32;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:526:9
--> tests/ui/cast.rs:524:9
|
LL | (a.abs() * b.pow(2) / c.abs()) as u32
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `i32` to `u32` may lose the sign of the value
--> tests/ui/cast.rs:534:21
--> tests/ui/cast.rs:532:21
|
LL | let _ = i32::MIN as u32; // cast_sign_loss
| ^^^^^^^^^^^^^^^
@ -679,7 +679,7 @@ LL | m!();
= note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
error: casting `u32` to `u8` may truncate the value
--> tests/ui/cast.rs:537:21
--> tests/ui/cast.rs:535:21
|
LL | let _ = u32::MAX as u8; // cast_possible_truncation
| ^^^^^^^^^^^^^^
@ -696,7 +696,7 @@ LL + let _ = u8::try_from(u32::MAX); // cast_possible_truncation
|
error: casting `f64` to `f32` may truncate the value
--> tests/ui/cast.rs:540:21
--> tests/ui/cast.rs:538:21
|
LL | let _ = std::f64::consts::PI as f32; // cast_possible_truncation
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -708,7 +708,7 @@ LL | m!();
= note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
error: casting `i64` to `usize` may truncate the value on targets with 32-bit wide pointers
--> tests/ui/cast.rs:551:5
--> tests/ui/cast.rs:549:5
|
LL | bar.unwrap().unwrap() as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -721,13 +721,13 @@ LL + usize::try_from(bar.unwrap().unwrap())
|
error: casting `i64` to `usize` may lose the sign of the value
--> tests/ui/cast.rs:551:5
--> tests/ui/cast.rs:549:5
|
LL | bar.unwrap().unwrap() as usize
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: casting `u64` to `u8` may truncate the value
--> tests/ui/cast.rs:568:5
--> tests/ui/cast.rs:566:5
|
LL | (256 & 999999u64) as u8;
| ^^^^^^^^^^^^^^^^^^^^^^^
@ -740,7 +740,7 @@ LL + u8::try_from(256 & 999999u64);
|
error: casting `u64` to `u8` may truncate the value
--> tests/ui/cast.rs:571:5
--> tests/ui/cast.rs:569:5
|
LL | (255 % 999999u64) as u8;
| ^^^^^^^^^^^^^^^^^^^^^^^

3
src/tools/clippy/tests/ui/crashes/auxiliary/proc_macro_crash.rs
View file

@ -1,6 +1,3 @@
#![feature(repr128)]
#![allow(incomplete_features)]
extern crate proc_macro;
use proc_macro::{Delimiter, Group, Ident, Span, TokenStream, TokenTree};

1
src/tools/tidy/src/issues.txt
View file

@ -939,7 +939,6 @@ ui/enum-discriminant/auxiliary/issue-41394.rs
ui/enum-discriminant/issue-104519.rs
ui/enum-discriminant/issue-41394-rpass.rs
ui/enum-discriminant/issue-41394.rs
ui/enum-discriminant/issue-43398.rs
ui/enum-discriminant/issue-46519.rs
ui/enum-discriminant/issue-50689.rs
ui/enum-discriminant/issue-51582.rs

3
tests/codegen/enum/enum-u128.rs
View file

@ -13,9 +13,6 @@
// CHECK: {{.*}}DIEnumerator{{.*}}name: "Hi",{{.*}}value: 18446744073709551616,{{.*}}
// CHECK: {{.*}}DIEnumerator{{.*}}name: "Bar",{{.*}}value: 18446745000000000123,{{.*}}
#![allow(incomplete_features)]
#![feature(repr128)]
#[repr(u128)]
pub enum Foo {
Lo,

2
tests/debuginfo/msvc-pretty-enums.rs
View file

@ -231,8 +231,6 @@
// cdb-command: dx c_style_i128_d
// cdb-check: c_style_i128_d : D [Type: enum2$<msvc_pretty_enums::CStyleI128>]
#![feature(rustc_attrs)]
#![feature(repr128)]
#![feature(arbitrary_enum_discriminant)]
use std::num::NonZero;

2
tests/mir-opt/enum_opt.rs
View file

@ -3,8 +3,6 @@
// EMIT_MIR_FOR_EACH_BIT_WIDTH
//@ compile-flags: -Zunsound-mir-opts -Zdump-mir-exclude-alloc-bytes
#![feature(arbitrary_enum_discriminant, repr128)]
// Tests that an enum with a variant with no data gets correctly transformed.
pub enum NoData {
Large([u8; 8196]),

1
tests/mir-opt/matches_reduce_branches.rs
View file

@ -1,6 +1,5 @@
//@ test-mir-pass: MatchBranchSimplification
#![feature(repr128)]
#![feature(core_intrinsics)]
#![feature(custom_mir)]
#![allow(non_camel_case_types)]

2
tests/run-make/repr128-dwarf/main.rs
View file

@ -1,5 +1,3 @@
#![feature(repr128)]
// Use .to_le() to ensure that the bytes are in the same order on both little- and big-endian
// platforms.

3
tests/rustdoc-json/enums/discriminant/limits.rs
View file

@ -1,6 +1,3 @@
#![feature(repr128)]
#![allow(incomplete_features)]
#[repr(u64)]
pub enum U64 {
//@ is "$.index[?(@.name=='U64Min')].inner.variant.discriminant.value" '"0"'

3
tests/ui/enum-discriminant/discriminant_size.rs
View file

@ -1,6 +1,5 @@
//@ run-pass
#![feature(core_intrinsics, repr128)]
//~^ WARN the feature `repr128` is incomplete
#![feature(core_intrinsics)]
use std::intrinsics::discriminant_value;

11
tests/ui/enum-discriminant/discriminant_size.stderr
View file

@ -1,11 +0,0 @@
warning: the feature `repr128` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/discriminant_size.rs:2:29
|
LL | #![feature(core_intrinsics, repr128)]
| ^^^^^^^
|
= note: see issue #56071 <https://github.com/rust-lang/rust/issues/56071> for more information
= note: `#[warn(incomplete_features)]` on by default
warning: 1 warning emitted

11
tests/ui/enum-discriminant/issue-43398.stderr
View file

@ -1,11 +0,0 @@
warning: the feature `repr128` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/issue-43398.rs:4:12
|
LL | #![feature(repr128)]
| ^^^^^^^
|
= note: see issue #56071 <https://github.com/rust-lang/rust/issues/56071> for more information
= note: `#[warn(incomplete_features)]` on by default
warning: 1 warning emitted

2
tests/ui/enum-discriminant/issue-70509-partial_eq.rs
View file

@ -1,6 +1,4 @@
//@ run-pass
#![feature(repr128)]
//~^ WARN the feature `repr128` is incomplete
#[derive(PartialEq, Debug)]
#[repr(i128)]

11
tests/ui/enum-discriminant/issue-70509-partial_eq.stderr
View file

@ -1,11 +0,0 @@
warning: the feature `repr128` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/issue-70509-partial_eq.rs:2:12
|
LL | #![feature(repr128)]
| ^^^^^^^
|
= note: see issue #56071 <https://github.com/rust-lang/rust/issues/56071> for more information
= note: `#[warn(incomplete_features)]` on by default
warning: 1 warning emitted

2
tests/ui/enum-discriminant/issue-43398.rs → tests/ui/enum-discriminant/repr128-get-discriminant-issue-43398.rs
View file

@ -1,8 +1,6 @@
//@ run-pass
#![feature(core_intrinsics)]
#![feature(repr128)]
//~^ WARN the feature `repr128` is incomplete
#[repr(i128)]
enum Big { A, B }

3
tests/ui/enum-discriminant/repr128.rs
View file

@ -1,6 +1,5 @@
//@ run-pass
#![feature(repr128, core_intrinsics, discriminant_kind)]
//~^ WARN the feature `repr128` is incomplete
#![feature(core_intrinsics, discriminant_kind)]
use std::intrinsics::discriminant_value;
use std::marker::DiscriminantKind;

11
tests/ui/enum-discriminant/repr128.stderr
View file

@ -1,11 +0,0 @@
warning: the feature `repr128` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/repr128.rs:2:12
|
LL | #![feature(repr128, core_intrinsics, discriminant_kind)]
| ^^^^^^^
|
= note: see issue #56071 <https://github.com/rust-lang/rust/issues/56071> for more information
= note: `#[warn(incomplete_features)]` on by default
warning: 1 warning emitted

5
tests/ui/error-codes/E0658.rs
View file

@ -1,6 +1,3 @@
#[repr(u128)]
enum Foo { //~ ERROR E0658
Bar(u64),
}
use std::intrinsics; //~ ERROR E0658
fn main() {}

11
tests/ui/error-codes/E0658.stderr
View file

@ -1,11 +1,10 @@
error[E0658]: repr with 128-bit type is unstable
--> $DIR/E0658.rs:2:1
error[E0658]: use of unstable library feature `core_intrinsics`: intrinsics are unlikely to ever be stabilized, instead they should be used through stabilized interfaces in the rest of the standard library
--> $DIR/E0658.rs:1:5
|
LL | enum Foo {
| ^^^^^^^^
LL | use std::intrinsics;
| ^^^^^^^^^^^^^^^
|
= note: see issue #56071 <https://github.com/rust-lang/rust/issues/56071> for more information
= help: add `#![feature(repr128)]` to the crate attributes to enable
= help: add `#![feature(core_intrinsics)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error: aborting due to 1 previous error

6
tests/ui/feature-gates/feature-gate-repr128.rs
View file

@ -1,6 +0,0 @@
#[repr(u128)]
enum A { //~ ERROR repr with 128-bit type is unstable
A(u64)
}
fn main() {}

13
tests/ui/feature-gates/feature-gate-repr128.stderr
View file

@ -1,13 +0,0 @@
error[E0658]: repr with 128-bit type is unstable
--> $DIR/feature-gate-repr128.rs:2:1
|
LL | enum A {
| ^^^^^^
|
= note: see issue #56071 <https://github.com/rust-lang/rust/issues/56071> for more information
= help: add `#![feature(repr128)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0658`.

2
tests/ui/lint/lint-ctypes-enum.rs
View file

@ -2,8 +2,6 @@
#![deny(improper_ctypes)]
#![feature(ptr_internals)]
#![feature(transparent_unions)]
#![feature(repr128)]
#![allow(incomplete_features)]
use std::num;

68
tests/ui/lint/lint-ctypes-enum.stderr
View file

@ -1,5 +1,5 @@
error: `extern` block uses type `U`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:84:14
--> $DIR/lint-ctypes-enum.rs:82:14
|
LL | fn uf(x: U);
| ^ not FFI-safe
@ -7,7 +7,7 @@ LL | fn uf(x: U);
= help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
= note: enum has no representation hint
note: the type is defined here
--> $DIR/lint-ctypes-enum.rs:11:1
--> $DIR/lint-ctypes-enum.rs:9:1
|
LL | enum U {
| ^^^^^^
@ -18,7 +18,7 @@ LL | #![deny(improper_ctypes)]
| ^^^^^^^^^^^^^^^
error: `extern` block uses type `B`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:85:14
--> $DIR/lint-ctypes-enum.rs:83:14
|
LL | fn bf(x: B);
| ^ not FFI-safe
@ -26,13 +26,13 @@ LL | fn bf(x: B);
= help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
= note: enum has no representation hint
note: the type is defined here
--> $DIR/lint-ctypes-enum.rs:14:1
--> $DIR/lint-ctypes-enum.rs:12:1
|
LL | enum B {
| ^^^^^^
error: `extern` block uses type `T`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:86:14
--> $DIR/lint-ctypes-enum.rs:84:14
|
LL | fn tf(x: T);
| ^ not FFI-safe
@ -40,39 +40,39 @@ LL | fn tf(x: T);
= help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
= note: enum has no representation hint
note: the type is defined here
--> $DIR/lint-ctypes-enum.rs:18:1
--> $DIR/lint-ctypes-enum.rs:16:1
|
LL | enum T {
| ^^^^^^
error: `extern` block uses type `U128`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:90:21
--> $DIR/lint-ctypes-enum.rs:88:21
|
LL | fn repr_u128(x: U128);
| ^^^^ not FFI-safe
|
= note: 128-bit integers don't currently have a known stable ABI
note: the type is defined here
--> $DIR/lint-ctypes-enum.rs:46:1
--> $DIR/lint-ctypes-enum.rs:44:1
|
LL | enum U128 {
| ^^^^^^^^^
error: `extern` block uses type `I128`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:91:21
--> $DIR/lint-ctypes-enum.rs:89:21
|
LL | fn repr_i128(x: I128);
| ^^^^ not FFI-safe
|
= note: 128-bit integers don't currently have a known stable ABI
note: the type is defined here
--> $DIR/lint-ctypes-enum.rs:53:1
--> $DIR/lint-ctypes-enum.rs:51:1
|
LL | enum I128 {
| ^^^^^^^^^
error: `extern` block uses type `u128`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:100:31
--> $DIR/lint-ctypes-enum.rs:98:31
|
LL | fn option_nonzero_u128(x: Option<num::NonZero<u128>>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -80,7 +80,7 @@ LL | fn option_nonzero_u128(x: Option<num::NonZero<u128>>);
= note: 128-bit integers don't currently have a known stable ABI
error: `extern` block uses type `i128`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:107:31
--> $DIR/lint-ctypes-enum.rs:105:31
|
LL | fn option_nonzero_i128(x: Option<num::NonZero<i128>>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -88,7 +88,7 @@ LL | fn option_nonzero_i128(x: Option<num::NonZero<i128>>);
= note: 128-bit integers don't currently have a known stable ABI
error: `extern` block uses type `Option<TransparentUnion<NonZero<u8>>>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:112:36
--> $DIR/lint-ctypes-enum.rs:110:36
|
LL | fn option_transparent_union(x: Option<TransparentUnion<num::NonZero<u8>>>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -97,7 +97,7 @@ LL | fn option_transparent_union(x: Option<TransparentUnion<num::NonZero<u8>
= note: enum has no representation hint
error: `extern` block uses type `Option<Rust<NonZero<u8>>>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:114:28
--> $DIR/lint-ctypes-enum.rs:112:28
|
LL | fn option_repr_rust(x: Option<Rust<num::NonZero<u8>>>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -106,7 +106,7 @@ LL | fn option_repr_rust(x: Option<Rust<num::NonZero<u8>>>);
= note: enum has no representation hint
error: `extern` block uses type `Option<u8>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:115:21
--> $DIR/lint-ctypes-enum.rs:113:21
|
LL | fn option_u8(x: Option<u8>);
| ^^^^^^^^^^ not FFI-safe
@ -115,7 +115,7 @@ LL | fn option_u8(x: Option<u8>);
= note: enum has no representation hint
error: `extern` block uses type `u128`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:125:33
--> $DIR/lint-ctypes-enum.rs:123:33
|
LL | fn result_nonzero_u128_t(x: Result<num::NonZero<u128>, ()>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -123,7 +123,7 @@ LL | fn result_nonzero_u128_t(x: Result<num::NonZero<u128>, ()>);
= note: 128-bit integers don't currently have a known stable ABI
error: `extern` block uses type `i128`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:132:33
--> $DIR/lint-ctypes-enum.rs:130:33
|
LL | fn result_nonzero_i128_t(x: Result<num::NonZero<i128>, ()>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -131,7 +131,7 @@ LL | fn result_nonzero_i128_t(x: Result<num::NonZero<i128>, ()>);
= note: 128-bit integers don't currently have a known stable ABI
error: `extern` block uses type `Result<TransparentUnion<NonZero<u8>>, ()>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:137:38
--> $DIR/lint-ctypes-enum.rs:135:38
|
LL | fn result_transparent_union_t(x: Result<TransparentUnion<num::NonZero<u8>>, ()>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -140,7 +140,7 @@ LL | fn result_transparent_union_t(x: Result<TransparentUnion<num::NonZero<u
= note: enum has no representation hint
error: `extern` block uses type `Result<Rust<NonZero<u8>>, ()>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:139:30
--> $DIR/lint-ctypes-enum.rs:137:30
|
LL | fn result_repr_rust_t(x: Result<Rust<num::NonZero<u8>>, ()>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -149,7 +149,7 @@ LL | fn result_repr_rust_t(x: Result<Rust<num::NonZero<u8>>, ()>);
= note: enum has no representation hint
error: `extern` block uses type `Result<NonZero<u8>, U>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:143:51
--> $DIR/lint-ctypes-enum.rs:141:51
|
LL | fn result_1zst_exhaustive_single_variant_t(x: Result<num::NonZero<u8>, U>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -158,7 +158,7 @@ LL | fn result_1zst_exhaustive_single_variant_t(x: Result<num::NonZero<u8>,
= note: enum has no representation hint
error: `extern` block uses type `Result<NonZero<u8>, B>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:145:53
--> $DIR/lint-ctypes-enum.rs:143:53
|
LL | fn result_1zst_exhaustive_multiple_variant_t(x: Result<num::NonZero<u8>, B>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -167,7 +167,7 @@ LL | fn result_1zst_exhaustive_multiple_variant_t(x: Result<num::NonZero<u8>
= note: enum has no representation hint
error: `extern` block uses type `Result<NonZero<u8>, NonExhaustive>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:147:51
--> $DIR/lint-ctypes-enum.rs:145:51
|
LL | fn result_1zst_non_exhaustive_no_variant_t(x: Result<num::NonZero<u8>, NonExhaustive>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -176,7 +176,7 @@ LL | fn result_1zst_non_exhaustive_no_variant_t(x: Result<num::NonZero<u8>,
= note: enum has no representation hint
error: `extern` block uses type `Result<NonZero<u8>, Field>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:150:49
--> $DIR/lint-ctypes-enum.rs:148:49
|
LL | fn result_1zst_exhaustive_single_field_t(x: Result<num::NonZero<u8>, Field>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -185,7 +185,7 @@ LL | fn result_1zst_exhaustive_single_field_t(x: Result<num::NonZero<u8>, Fi
= note: enum has no representation hint
error: `extern` block uses type `Result<Result<(), NonZero<u8>>, ()>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:152:30
--> $DIR/lint-ctypes-enum.rs:150:30
|
LL | fn result_cascading_t(x: Result<Result<(), num::NonZero<u8>>, ()>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -194,7 +194,7 @@ LL | fn result_cascading_t(x: Result<Result<(), num::NonZero<u8>>, ()>);
= note: enum has no representation hint
error: `extern` block uses type `u128`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:163:33
--> $DIR/lint-ctypes-enum.rs:161:33
|
LL | fn result_nonzero_u128_e(x: Result<(), num::NonZero<u128>>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -202,7 +202,7 @@ LL | fn result_nonzero_u128_e(x: Result<(), num::NonZero<u128>>);
= note: 128-bit integers don't currently have a known stable ABI
error: `extern` block uses type `i128`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:170:33
--> $DIR/lint-ctypes-enum.rs:168:33
|
LL | fn result_nonzero_i128_e(x: Result<(), num::NonZero<i128>>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -210,7 +210,7 @@ LL | fn result_nonzero_i128_e(x: Result<(), num::NonZero<i128>>);
= note: 128-bit integers don't currently have a known stable ABI
error: `extern` block uses type `Result<(), TransparentUnion<NonZero<u8>>>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:175:38
--> $DIR/lint-ctypes-enum.rs:173:38
|
LL | fn result_transparent_union_e(x: Result<(), TransparentUnion<num::NonZero<u8>>>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -219,7 +219,7 @@ LL | fn result_transparent_union_e(x: Result<(), TransparentUnion<num::NonZe
= note: enum has no representation hint
error: `extern` block uses type `Result<(), Rust<NonZero<u8>>>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:177:30
--> $DIR/lint-ctypes-enum.rs:175:30
|
LL | fn result_repr_rust_e(x: Result<(), Rust<num::NonZero<u8>>>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -228,7 +228,7 @@ LL | fn result_repr_rust_e(x: Result<(), Rust<num::NonZero<u8>>>);
= note: enum has no representation hint
error: `extern` block uses type `Result<U, NonZero<u8>>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:181:51
--> $DIR/lint-ctypes-enum.rs:179:51
|
LL | fn result_1zst_exhaustive_single_variant_e(x: Result<U, num::NonZero<u8>>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -237,7 +237,7 @@ LL | fn result_1zst_exhaustive_single_variant_e(x: Result<U, num::NonZero<u8
= note: enum has no representation hint
error: `extern` block uses type `Result<B, NonZero<u8>>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:183:53
--> $DIR/lint-ctypes-enum.rs:181:53
|
LL | fn result_1zst_exhaustive_multiple_variant_e(x: Result<B, num::NonZero<u8>>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -246,7 +246,7 @@ LL | fn result_1zst_exhaustive_multiple_variant_e(x: Result<B, num::NonZero<
= note: enum has no representation hint
error: `extern` block uses type `Result<NonExhaustive, NonZero<u8>>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:185:51
--> $DIR/lint-ctypes-enum.rs:183:51
|
LL | fn result_1zst_non_exhaustive_no_variant_e(x: Result<NonExhaustive, num::NonZero<u8>>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -255,7 +255,7 @@ LL | fn result_1zst_non_exhaustive_no_variant_e(x: Result<NonExhaustive, num
= note: enum has no representation hint
error: `extern` block uses type `Result<Field, NonZero<u8>>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:188:49
--> $DIR/lint-ctypes-enum.rs:186:49
|
LL | fn result_1zst_exhaustive_single_field_e(x: Result<Field, num::NonZero<u8>>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -264,7 +264,7 @@ LL | fn result_1zst_exhaustive_single_field_e(x: Result<Field, num::NonZero<
= note: enum has no representation hint
error: `extern` block uses type `Result<(), Result<(), NonZero<u8>>>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:190:30
--> $DIR/lint-ctypes-enum.rs:188:30
|
LL | fn result_cascading_e(x: Result<(), Result<(), num::NonZero<u8>>>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@ -273,7 +273,7 @@ LL | fn result_cascading_e(x: Result<(), Result<(), num::NonZero<u8>>>);
= note: enum has no representation hint
error: `extern` block uses type `Result<(), ()>`, which is not FFI-safe
--> $DIR/lint-ctypes-enum.rs:192:27
--> $DIR/lint-ctypes-enum.rs:190:27
|
LL | fn result_unit_t_e(x: Result<(), ()>);
| ^^^^^^^^^^^^^^ not FFI-safe

3
tests/ui/transmutability/enums/repr/should_handle_all.rs
View file

@ -1,8 +1,7 @@
//@ check-pass
#![crate_type = "lib"]
#![feature(repr128)]
#![feature(transmutability)]
#![allow(dead_code, incomplete_features, non_camel_case_types)]
#![allow(dead_code, non_camel_case_types)]
mod assert {
use std::mem::{Assume, TransmuteFrom};