Use minicore in tests/abi/compatibility.rs as an example

Author: jieyouxu

tests/ui/abi/compatibility.rs

@@ -1,5 +1,4 @@
 //@ check-pass
-//@ revisions: host
 //@ revisions: i686
 //@[i686] compile-flags: --target i686-unknown-linux-gnu
 //@[i686] needs-llvm-components: x86
@@ -58,76 +57,33 @@
 //@ revisions: nvptx64
 //@[nvptx64] compile-flags: --target nvptx64-nvidia-cuda
 //@[nvptx64] needs-llvm-components: nvptx
-#![feature(rustc_attrs, unsized_fn_params, transparent_unions)]
-#![cfg_attr(not(host), feature(no_core, lang_items), no_std, no_core)]
+#![feature(no_core, rustc_attrs, lang_items)]
+#![feature(unsized_fn_params, transparent_unions)]
+#![no_std]
+#![no_core]
 #![allow(unused, improper_ctypes_definitions, internal_features)]
 
 // FIXME: some targets are broken in various ways.
 // Hence there are `cfg` throughout this test to disable parts of it on those targets.
 // sparc64: https://github.com/rust-lang/rust/issues/115336
 // mips64: https://github.com/rust-lang/rust/issues/115404
 
-#[cfg(host)]
-use std::{
-    any::Any, marker::PhantomData, mem::ManuallyDrop, num::NonZero, ptr::NonNull, rc::Rc, sync::Arc,
-};
+//@ use-minicore
+extern crate minicore;
+use minicore::*;
 
-/// To work cross-target this test must be no_core.
-/// This little prelude supplies what we need.
-#[cfg(not(host))]
+/// To work cross-target this test must be no_core. This little prelude supplies what we need.
+///
+/// Note that `minicore` provides a very minimal subset of `core` items (not yet complete). This
+/// prelude contains `alloc` and non-`core` (but in `std`) items that minicore does not stub out.
 mod prelude {
-    #[lang = "sized"]
-    pub trait Sized {}
-
-    #[lang = "receiver"]
-    pub trait Receiver {}
-    impl<T: ?Sized> Receiver for &T {}
-    impl<T: ?Sized> Receiver for &mut T {}
-
-    #[lang = "copy"]
-    pub trait Copy: Sized {}
-    impl Copy for i32 {}
-    impl Copy for f32 {}
-    impl<T: ?Sized> Copy for &T {}
-    impl<T: ?Sized> Copy for *const T {}
-    impl<T: ?Sized> Copy for *mut T {}
+    use minicore::*;
 
     #[lang = "clone"]
     pub trait Clone: Sized {
         fn clone(&self) -> Self;
     }
 
-    #[lang = "phantom_data"]
-    pub struct PhantomData<T: ?Sized>;
-    impl<T: ?Sized> Copy for PhantomData<T> {}
-
-    #[lang = "unsafe_cell"]
-    #[repr(transparent)]
-    pub struct UnsafeCell<T: ?Sized> {
-        value: T,
-    }
-
-    pub trait Any: 'static {}
-
-    pub enum Option<T> {
-        None,
-        Some(T),
-    }
-    impl<T: Copy> Copy for Option<T> {}
-
-    pub enum Result<T, E> {
-        Ok(T),
-        Err(E),
-    }
-    impl<T: Copy, E: Copy> Copy for Result<T, E> {}
-
-    #[lang = "manually_drop"]
-    #[repr(transparent)]
-    pub struct ManuallyDrop<T: ?Sized> {
-        value: T,
-    }
-    impl<T: Copy + ?Sized> Copy for ManuallyDrop<T> {}
-
     #[repr(transparent)]
     #[rustc_layout_scalar_valid_range_start(1)]
     #[rustc_nonnull_optimization_guaranteed]
@@ -185,7 +141,6 @@ mod prelude {
         alloc: A,
     }
 }
-#[cfg(not(host))]
 use prelude::*;
 
 macro_rules! test_abi_compatible {