TEMP COMMIT, to be deleted on rebase: remove i128/u128 warnings

Author: niacdoial

compiler/rustc_lint/messages.ftl

@@ -374,8 +374,6 @@ lint_improper_ctypes = {$desc} uses type `{$ty}`, which is not FFI-safe
     .label = not FFI-safe
     .note = the type is defined here
 
-lint_improper_ctypes_128bit = 128-bit integers don't currently have a known stable ABI
-
 lint_improper_ctypes_array_help = consider passing a pointer to the array
 
 lint_improper_ctypes_array_reason = passing raw arrays by value is not FFI-safe

compiler/rustc_lint/src/types/improper_ctypes.rs

@@ -3,7 +3,7 @@ use std::cmp::{Eq, PartialEq};
 use std::iter;
 use std::ops::ControlFlow;
 
-use rustc_abi::{Integer, IntegerType, VariantIdx};
+use rustc_abi::VariantIdx;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::DiagMessage;
 use rustc_hir::def::CtorKind;
@@ -582,11 +582,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
     }
 
     /// Checks whether an uninhabited type (one without valid values) is safe-ish to have here
-    fn visit_uninhabited(
-        &self,
-        state: CTypesVisitorState,
-        ty: Ty<'tcx>,
-    ) -> FfiResult<'tcx> {
+    fn visit_uninhabited(&self, state: CTypesVisitorState, ty: Ty<'tcx>) -> FfiResult<'tcx> {
         if state.is_in_function_return() {
             FfiResult::FfiSafe
         } else {
@@ -604,17 +600,16 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
     fn visit_numeric(&self, ty: Ty<'tcx>) -> FfiResult<'tcx> {
         // FIXME: for now, this is very incomplete, and seems to assume a x86_64 target
         match ty.kind() {
-            ty::Int(ty::IntTy::I128) | ty::Uint(ty::UintTy::U128) => {
-                FfiResult::new_with_reason(ty, fluent::lint_improper_ctypes_128bit, None)
-            }
+            // note: before rust 1.77, 128-bit ints were not FFI-safe on x86_64
+            // ...they probably are still unsafe on i686 and other x86_32 architectures
             ty::Int(..) | ty::Uint(..) | ty::Float(..) => FfiResult::FfiSafe,
 
             ty::Char => FfiResult::new_with_reason(
                 ty,
                 fluent::lint_improper_ctypes_char_reason,
                 Some(fluent::lint_improper_ctypes_char_help),
             ),
-            _ => bug!("visit_numeric is to be called with numeric (int, float) types"),
+            _ => bug!("visit_numeric is to be called with numeric (char, int, float) types"),
         }
     }
 
@@ -984,9 +979,8 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
             );
         }
 
-        if let Some(IntegerType::Fixed(Integer::I128, _)) = def.repr().int {
-            return FfiResult::new_with_reason(ty, fluent::lint_improper_ctypes_128bit, None);
-        }
+        // FIXME: connect `def.repr().int` to visit_numeric
+        // (for now it's OK, `repr(char)` doesn't exist and visit_numeric doesn't warn on anything else)
 
         let non_exhaustive = def.variant_list_has_applicable_non_exhaustive();
         // Check the contained variants.

tests/ui/asm/naked-functions-ffi.rs

@@ -7,6 +7,5 @@ use std::arch::naked_asm;
 #[unsafe(naked)]
 pub extern "C" fn naked(p: char) -> u128 {
     //~^ WARN uses type `char`
-    //~| WARN uses type `u128`
     naked_asm!("")
 }

tests/ui/asm/naked-functions-ffi.stderr

@@ -8,13 +8,5 @@ LL | pub extern "C" fn naked(p: char) -> u128 {
    = note: the `char` type has no C equivalent
    = note: `#[warn(improper_c_fn_definitions)]` on by default
 
-warning: `extern` fn uses type `u128`, which is not FFI-safe
-  --> $DIR/naked-functions-ffi.rs:8:37
-   |
-LL | pub extern "C" fn naked(p: char) -> u128 {
-   |                                     ^^^^ not FFI-safe
-   |
-   = note: 128-bit integers don't currently have a known stable ABI
-
-warning: 2 warnings emitted
+warning: 1 warning emitted
 

tests/ui/lint/improper_ctypes/ctypes.rs

@@ -76,8 +76,8 @@ extern "C" {
     pub fn box_type(p: Box<u32>);
     pub fn opt_box_type(p: Option<Box<u32>>);
     pub fn char_type(p: char); //~ ERROR uses type `char`
-    pub fn i128_type(p: i128); //~ ERROR uses type `i128`
-    pub fn u128_type(p: u128); //~ ERROR uses type `u128`
+    pub fn i128_type(p: i128);
+    pub fn u128_type(p: u128);
     pub fn pat_type1() -> pattern_type!(u32 is 1..);
     pub fn pat_type2(p: pattern_type!(u32 is 1..)); // no error!
     pub fn trait_type(p: &dyn Bar); //~ ERROR uses type `&dyn Bar`
@@ -91,7 +91,7 @@ extern "C" {
     pub fn fn_type(p: RustFn); //~ ERROR uses type `fn()`
     pub fn fn_type2(p: fn()); //~ ERROR uses type `fn()`
     pub fn fn_contained(p: RustBoxRet);
-    pub fn transparent_i128(p: TransparentI128); //~ ERROR: uses type `TransparentI128`
+    pub fn transparent_i128(p: TransparentI128);
     pub fn transparent_str(p: TransparentStr); //~ ERROR: uses type `TransparentStr`
     pub fn transparent_fn(p: TransparentBoxFn);
     pub fn raw_array(arr: [u8; 8]); //~ ERROR: uses type `[u8; 8]`
@@ -110,8 +110,8 @@ extern "C" {
     pub fn no_niche_b(b: Option<UnsafeCell<&i32>>);
     //~^ ERROR: uses type `Option<UnsafeCell<&i32>>`
 
-    pub static static_u128_type: u128; //~ ERROR: uses type `u128`
-    pub static static_u128_array_type: [u128; 16]; //~ ERROR: uses type `u128`
+    pub static static_u128_type: u128;
+    pub static static_u128_array_type: [u128; 16];
 
     pub fn good3(fptr: Option<extern "C" fn()>);
     pub fn good4(aptr: &[u8; 4 as usize]);

tests/ui/lint/improper_ctypes/ctypes.stderr

@@ -30,22 +30,6 @@ LL |     pub fn char_type(p: char);
    = help: consider using `u32` or `libc::wchar_t` instead
    = note: the `char` type has no C equivalent
 
-error: `extern` block uses type `i128`, which is not FFI-safe
-  --> $DIR/ctypes.rs:79:25
-   |
-LL |     pub fn i128_type(p: i128);
-   |                         ^^^^ not FFI-safe
-   |
-   = note: 128-bit integers don't currently have a known stable ABI
-
-error: `extern` block uses type `u128`, which is not FFI-safe
-  --> $DIR/ctypes.rs:80:25
-   |
-LL |     pub fn u128_type(p: u128);
-   |                         ^^^^ not FFI-safe
-   |
-   = note: 128-bit integers don't currently have a known stable ABI
-
 error: `extern` block uses type `&dyn Bar`, which is not FFI-safe
   --> $DIR/ctypes.rs:83:26
    |
@@ -125,20 +109,6 @@ LL |     pub fn fn_type2(p: fn());
    = help: consider using an `extern fn(...) -> ...` function pointer instead
    = note: this function pointer has Rust-specific calling convention
 
-error: `extern` block uses type `TransparentI128`, which is not FFI-safe
-  --> $DIR/ctypes.rs:94:32
-   |
-LL |     pub fn transparent_i128(p: TransparentI128);
-   |                                ^^^^^^^^^^^^^^^ not FFI-safe
-   |
-   = note: this struct/enum/union (`TransparentI128`) is FFI-unsafe due to a `i128` field
-note: the type is defined here
-  --> $DIR/ctypes.rs:34:1
-   |
-LL | pub struct TransparentI128(i128);
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: 128-bit integers don't currently have a known stable ABI
-
 error: `extern` block uses type `TransparentStr`, which is not FFI-safe
   --> $DIR/ctypes.rs:95:31
    |
@@ -229,22 +199,6 @@ LL |     pub fn no_niche_b(b: Option<UnsafeCell<&i32>>);
    = help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
    = note: enum has no representation hint
 
-error: `extern` block uses type `u128`, which is not FFI-safe
-  --> $DIR/ctypes.rs:113:34
-   |
-LL |     pub static static_u128_type: u128;
-   |                                  ^^^^ not FFI-safe
-   |
-   = note: 128-bit integers don't currently have a known stable ABI
-
-error: `extern` block uses type `u128`, which is not FFI-safe
-  --> $DIR/ctypes.rs:114:40
-   |
-LL |     pub static static_u128_array_type: [u128; 16];
-   |                                        ^^^^^^^^^^ not FFI-safe
-   |
-   = note: 128-bit integers don't currently have a known stable ABI
-
 error: foreign-code-reachable static uses type `&str`, which is not FFI-safe
   --> $DIR/ctypes.rs:147:29
    |
@@ -259,5 +213,5 @@ note: the lint level is defined here
 LL | #![deny(improper_c_fn_definitions, improper_c_var_definitions)]
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 25 previous errors
+error: aborting due to 20 previous errors
 

tests/ui/lint/improper_ctypes/lint-enum.rs

@@ -84,8 +84,8 @@ extern "C" {
     fn repr_c(x: ReprC);
     fn repr_u8(x: U8);
     fn repr_isize(x: Isize);
-    fn repr_u128(x: U128); //~ ERROR `extern` block uses type `U128`
-    fn repr_i128(x: I128); //~ ERROR `extern` block uses type `I128`
+    fn repr_u128(x: U128);
+    fn repr_i128(x: I128);
     fn option_ref(x: Option<&'static u8>);
     fn option_fn(x: Option<extern "C" fn()>);
     fn option_nonnull(x: Option<std::ptr::NonNull<u8>>);
@@ -95,14 +95,12 @@ extern "C" {
     fn option_nonzero_u32(x: Option<num::NonZero<u32>>);
     fn option_nonzero_u64(x: Option<num::NonZero<u64>>);
     fn option_nonzero_u128(x: Option<num::NonZero<u128>>);
-    //~^ ERROR `extern` block uses type `u128`
     fn option_nonzero_usize(x: Option<num::NonZero<usize>>);
     fn option_nonzero_i8(x: Option<num::NonZero<i8>>);
     fn option_nonzero_i16(x: Option<num::NonZero<i16>>);
     fn option_nonzero_i32(x: Option<num::NonZero<i32>>);
     fn option_nonzero_i64(x: Option<num::NonZero<i64>>);
     fn option_nonzero_i128(x: Option<num::NonZero<i128>>);
-    //~^ ERROR `extern` block uses type `i128`
     fn option_nonzero_isize(x: Option<num::NonZero<isize>>);
     fn option_transparent_struct(x: Option<TransparentStruct<num::NonZero<u8>>>);
     fn option_transparent_enum(x: Option<TransparentEnum<num::NonZero<u8>>>);
@@ -120,14 +118,12 @@ extern "C" {
     fn result_nonzero_u32_t(x: Result<num::NonZero<u32>, ()>);
     fn result_nonzero_u64_t(x: Result<num::NonZero<u64>, ()>);
     fn result_nonzero_u128_t(x: Result<num::NonZero<u128>, ()>);
-    //~^ ERROR `extern` block uses type `u128`
     fn result_nonzero_usize_t(x: Result<num::NonZero<usize>, ()>);
     fn result_nonzero_i8_t(x: Result<num::NonZero<i8>, ()>);
     fn result_nonzero_i16_t(x: Result<num::NonZero<i16>, ()>);
     fn result_nonzero_i32_t(x: Result<num::NonZero<i32>, ()>);
     fn result_nonzero_i64_t(x: Result<num::NonZero<i64>, ()>);
     fn result_nonzero_i128_t(x: Result<num::NonZero<i128>, ()>);
-    //~^ ERROR `extern` block uses type `i128`
     fn result_nonzero_isize_t(x: Result<num::NonZero<isize>, ()>);
     fn result_transparent_struct_t(x: Result<TransparentStruct<num::NonZero<u8>>, ()>);
     fn result_transparent_enum_t(x: Result<TransparentEnum<num::NonZero<u8>>, ()>);
@@ -158,14 +154,12 @@ extern "C" {
     fn result_nonzero_u32_e(x: Result<(), num::NonZero<u32>>);
     fn result_nonzero_u64_e(x: Result<(), num::NonZero<u64>>);
     fn result_nonzero_u128_e(x: Result<(), num::NonZero<u128>>);
-    //~^ ERROR `extern` block uses type `u128`
     fn result_nonzero_usize_e(x: Result<(), num::NonZero<usize>>);
     fn result_nonzero_i8_e(x: Result<(), num::NonZero<i8>>);
     fn result_nonzero_i16_e(x: Result<(), num::NonZero<i16>>);
     fn result_nonzero_i32_e(x: Result<(), num::NonZero<i32>>);
     fn result_nonzero_i64_e(x: Result<(), num::NonZero<i64>>);
     fn result_nonzero_i128_e(x: Result<(), num::NonZero<i128>>);
-    //~^ ERROR `extern` block uses type `i128`
     fn result_nonzero_isize_e(x: Result<(), num::NonZero<isize>>);
     fn result_transparent_struct_e(x: Result<(), TransparentStruct<num::NonZero<u8>>>);
     fn result_transparent_enum_e(x: Result<(), TransparentEnum<num::NonZero<u8>>>);