Always set #![no_std] and remove redundant imports

taiki-e · taiki-e · commit 79785ec41d95 · 2024-02-26T23:26:11.000+09:00
```
error: the item `Box` is imported redundantly
  --&gt; futures-core/src/future.rs:89:9
   |
89 |     use alloc::boxed::Box;
   |         ^^^^^^^^^^^^^^^^^
  --&gt; /rustc/381d69953bb7c3390cec0fee200f24529cb6320f/library/std/src/prelude/mod.rs:115:13
   |
   = note: the item `Box` is already defined here
   |
   = note: `-D unused-imports` implied by `-D warnings`
   = help: to override `-D warnings` add `#[allow(unused_imports)]`

error: the item `Box` is imported redundantly
   --&gt; futures-core/src/stream.rs:203:9
    |
203 |     use alloc::boxed::Box;
    |         ^^^^^^^^^^^^^^^^^
   --&gt; /rustc/381d69953bb7c3390cec0fee200f24529cb6320f/library/std/src/prelude/mod.rs:115:13
    |
    = note: the item `Box` is already defined here
```
diff --git a/futures-channel/src/lib.rs b/futures-channel/src/lib.rs
@@ -11,20 +11,22 @@
 //! All items are only available when the `std` or `alloc` feature of this
 //! library is activated, and it is activated by default.
 
-#![cfg_attr(not(feature = "std"), no_std)]
-#![warn(missing_docs, unsafe_op_in_unsafe_fn)]
+#![no_std]
 #![doc(test(
     no_crate_inject,
     attr(
         deny(warnings, rust_2018_idioms, single_use_lifetimes),
         allow(dead_code, unused_assignments, unused_variables)
     )
 ))]
+#![warn(missing_docs, unsafe_op_in_unsafe_fn)]
 #![allow(clippy::arc_with_non_send_sync)] // false positive https://github.com/rust-lang/rust-clippy/issues/11076
 
 #[cfg_attr(target_os = "none", cfg(target_has_atomic = "ptr"))]
 #[cfg(feature = "alloc")]
 extern crate alloc;
+#[cfg(feature = "std")]
+extern crate std;
 
 #[cfg_attr(target_os = "none", cfg(target_has_atomic = "ptr"))]
 #[cfg(feature = "alloc")]
diff --git a/futures-channel/src/mpsc/queue.rs b/futures-channel/src/mpsc/queue.rs
@@ -43,6 +43,7 @@
 
 pub(super) use self::PopResult::*;
 
+use std::boxed::Box;
 use std::cell::UnsafeCell;
 use std::ptr;
 use std::sync::atomic::{AtomicPtr, Ordering};
diff --git a/futures-core/src/lib.rs b/futures-core/src/lib.rs
@@ -1,17 +1,19 @@
 //! Core traits and types for asynchronous operations in Rust.
 
-#![cfg_attr(not(feature = "std"), no_std)]
-#![warn(missing_docs, /* unsafe_op_in_unsafe_fn */)] // unsafe_op_in_unsafe_fn requires Rust 1.52
+#![no_std]
 #![doc(test(
     no_crate_inject,
     attr(
         deny(warnings, rust_2018_idioms, single_use_lifetimes),
         allow(dead_code, unused_assignments, unused_variables)
     )
 ))]
+#![warn(missing_docs, /* unsafe_op_in_unsafe_fn */)] // unsafe_op_in_unsafe_fn requires Rust 1.52
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
+#[cfg(feature = "std")]
+extern crate std;
 
 pub mod future;
 #[doc(no_inline)]
diff --git a/futures-executor/src/enter.rs b/futures-executor/src/enter.rs
@@ -1,7 +1,7 @@
 use std::cell::Cell;
 use std::fmt;
 
-thread_local!(static ENTERED: Cell<bool> = Cell::new(false));
+std::thread_local!(static ENTERED: Cell<bool> = Cell::new(false));
 
 /// Represents an executor context.
 ///
diff --git a/futures-executor/src/lib.rs b/futures-executor/src/lib.rs
@@ -36,18 +36,21 @@
 //! [`spawn_obj`]: https://docs.rs/futures/0.3/futures/task/trait.Spawn.html#tymethod.spawn_obj
 //! [`spawn_local_obj`]: https://docs.rs/futures/0.3/futures/task/trait.LocalSpawn.html#tymethod.spawn_local_obj
 
-#![cfg_attr(not(feature = "std"), no_std)]
-#![warn(missing_docs, unsafe_op_in_unsafe_fn)]
+#![no_std]
 #![doc(test(
     no_crate_inject,
     attr(
         deny(warnings, rust_2018_idioms, single_use_lifetimes),
         allow(dead_code, unused_assignments, unused_variables)
     )
 ))]
+#![warn(missing_docs, unsafe_op_in_unsafe_fn)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 #![allow(clippy::thread_local_initializer_can_be_made_const)] // clippy bug: this lint doesn't consider MSRV
 
+#[cfg(feature = "std")]
+extern crate std;
+
 #[cfg(feature = "std")]
 mod local_pool;
 #[cfg(feature = "std")]
diff --git a/futures-executor/src/local_pool.rs b/futures-executor/src/local_pool.rs
@@ -15,6 +15,7 @@ use std::sync::{
     Arc,
 };
 use std::thread::{self, Thread};
+use std::vec::Vec;
 
 /// A single-threaded task pool for polling futures to completion.
 ///
@@ -53,7 +54,7 @@ pub(crate) struct ThreadNotify {
     unparked: AtomicBool,
 }
 
-thread_local! {
+std::thread_local! {
     static CURRENT_THREAD_NOTIFY: Arc<ThreadNotify> = Arc::new(ThreadNotify {
         thread: thread::current(),
         unparked: AtomicBool::new(false),
diff --git a/futures-executor/src/thread_pool.rs b/futures-executor/src/thread_pool.rs
@@ -5,9 +5,12 @@ use futures_core::task::{Context, Poll};
 use futures_task::{waker_ref, ArcWake};
 use futures_task::{FutureObj, Spawn, SpawnError};
 use futures_util::future::FutureExt;
+use std::boxed::Box;
 use std::cmp;
 use std::fmt;
+use std::format;
 use std::io;
+use std::string::String;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::mpsc;
 use std::sync::{Arc, Mutex};
@@ -358,7 +361,6 @@ impl ArcWake for WakeHandle {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::sync::mpsc;
 
     #[test]
     fn test_drop_after_start() {
diff --git a/futures-io/src/lib.rs b/futures-io/src/lib.rs
@@ -8,23 +8,28 @@
 //! All items of this library are only available when the `std` feature of this
 //! library is activated, and it is activated by default.
 
-#![cfg_attr(not(feature = "std"), no_std)]
-#![warn(missing_docs, /* unsafe_op_in_unsafe_fn */)] // unsafe_op_in_unsafe_fn requires Rust 1.52
+#![no_std]
 #![doc(test(
     no_crate_inject,
     attr(
         deny(warnings, rust_2018_idioms, single_use_lifetimes),
         allow(dead_code, unused_assignments, unused_variables)
     )
 ))]
+#![warn(missing_docs, /* unsafe_op_in_unsafe_fn */)] // unsafe_op_in_unsafe_fn requires Rust 1.52
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
+#[cfg(feature = "std")]
+extern crate std;
+
 #[cfg(feature = "std")]
 mod if_std {
+    use std::boxed::Box;
     use std::io;
     use std::ops::DerefMut;
     use std::pin::Pin;
     use std::task::{Context, Poll};
+    use std::vec::Vec;
 
     // Re-export some types from `std::io` so that users don't have to deal
     // with conflicts when `use`ing `futures::io` and `std::io`.
diff --git a/futures-sink/src/lib.rs b/futures-sink/src/lib.rs
@@ -3,18 +3,20 @@
 //! This crate contains the `Sink` trait which allows values to be sent
 //! asynchronously.
 
-#![cfg_attr(not(feature = "std"), no_std)]
-#![warn(missing_docs, /* unsafe_op_in_unsafe_fn */)] // unsafe_op_in_unsafe_fn requires Rust 1.52
+#![no_std]
 #![doc(test(
     no_crate_inject,
     attr(
         deny(warnings, rust_2018_idioms, single_use_lifetimes),
         allow(dead_code, unused_assignments, unused_variables)
     )
 ))]
+#![warn(missing_docs, /* unsafe_op_in_unsafe_fn */)] // unsafe_op_in_unsafe_fn requires Rust 1.52
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
+#[cfg(feature = "std")]
+extern crate std;
 
 use core::ops::DerefMut;
 use core::pin::Pin;
diff --git a/futures-task/src/lib.rs b/futures-task/src/lib.rs
@@ -1,17 +1,19 @@
 //! Tools for working with tasks.
 
-#![cfg_attr(not(feature = "std"), no_std)]
-#![warn(missing_docs, unsafe_op_in_unsafe_fn)]
+#![no_std]
 #![doc(test(
     no_crate_inject,
     attr(
         deny(warnings, rust_2018_idioms, single_use_lifetimes),
         allow(dead_code, unused_assignments, unused_variables)
     )
 ))]
+#![warn(missing_docs, unsafe_op_in_unsafe_fn)]
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
+#[cfg(feature = "std")]
+extern crate std;
 
 mod spawn;
 pub use crate::spawn::{LocalSpawn, Spawn, SpawnError};
diff --git a/futures-test/src/lib.rs b/futures-test/src/lib.rs
@@ -1,13 +1,13 @@
 //! Utilities to make testing [`Future`s](futures_core::future::Future) easier
 
-#![warn(missing_docs, unsafe_op_in_unsafe_fn)]
 #![doc(test(
     no_crate_inject,
     attr(
         deny(warnings, rust_2018_idioms, single_use_lifetimes),
         allow(dead_code, unused_assignments, unused_variables)
     )
 ))]
+#![warn(missing_docs, unsafe_op_in_unsafe_fn)]
 #![allow(clippy::test_attr_in_doctest)]
 
 #[cfg(not(feature = "std"))]
diff --git a/futures-util/src/async_await/random.rs b/futures-util/src/async_await/random.rs
@@ -25,7 +25,7 @@ fn gen_index(n: usize) -> usize {
 ///
 /// [xorshift*]: https://en.wikipedia.org/wiki/Xorshift#xorshift*
 fn random() -> u64 {
-    thread_local! {
+    std::thread_local! {
         static RNG: Cell<Wrapping<u64>> = Cell::new(Wrapping(prng_seed()));
     }
 
diff --git a/futures-util/src/compat/compat01as03.rs b/futures-util/src/compat/compat01as03.rs
@@ -8,6 +8,7 @@ use futures_01::{AsyncSink as AsyncSink01, Sink as Sink01};
 use futures_core::{future::Future as Future03, stream::Stream as Stream03, task as task03};
 #[cfg(feature = "sink")]
 use futures_sink::Sink as Sink03;
+use std::boxed::Box;
 use std::pin::Pin;
 use std::task::Context;
 
diff --git a/futures-util/src/future/either.rs b/futures-util/src/future/either.rs
@@ -201,8 +201,6 @@ where
 mod if_std {
     use super::*;
 
-    use core::pin::Pin;
-    use core::task::{Context, Poll};
     use futures_io::{
         AsyncBufRead, AsyncRead, AsyncSeek, AsyncWrite, IoSlice, IoSliceMut, Result, SeekFrom,
     };
diff --git a/futures-util/src/future/future/catch_unwind.rs b/futures-util/src/future/future/catch_unwind.rs
@@ -1,5 +1,6 @@
 use core::any::Any;
 use core::pin::Pin;
+use std::boxed::Box;
 use std::panic::{catch_unwind, AssertUnwindSafe, UnwindSafe};
 
 use futures_core::future::Future;
diff --git a/futures-util/src/future/future/remote_handle.rs b/futures-util/src/future/future/remote_handle.rs
@@ -9,6 +9,7 @@ use {
     pin_project_lite::pin_project,
     std::{
         any::Any,
+        boxed::Box,
         fmt,
         panic::{self, AssertUnwindSafe},
         pin::Pin,
diff --git a/futures-util/src/io/allow_std.rs b/futures-util/src/io/allow_std.rs
@@ -1,6 +1,8 @@
 use futures_core::task::{Context, Poll};
 use futures_io::{AsyncBufRead, AsyncRead, AsyncSeek, AsyncWrite, IoSlice, IoSliceMut, SeekFrom};
 use std::pin::Pin;
+use std::string::String;
+use std::vec::Vec;
 use std::{fmt, io};
 
 /// A simple wrapper type which allows types which implement only
diff --git a/futures-util/src/io/buf_reader.rs b/futures-util/src/io/buf_reader.rs
@@ -4,8 +4,10 @@ use futures_core::ready;
 use futures_core::task::{Context, Poll};
 use futures_io::{AsyncBufRead, AsyncRead, AsyncSeek, AsyncWrite, IoSliceMut, SeekFrom};
 use pin_project_lite::pin_project;
+use std::boxed::Box;
 use std::io::{self, Read};
 use std::pin::Pin;
+use std::vec;
 use std::{cmp, fmt};
 
 pin_project! {
diff --git a/futures-util/src/io/buf_writer.rs b/futures-util/src/io/buf_writer.rs
@@ -7,6 +7,7 @@ use std::fmt;
 use std::io::{self, Write};
 use std::pin::Pin;
 use std::ptr;
+use std::vec::Vec;
 
 pin_project! {
     /// Wraps a writer and buffers its output.
diff --git a/futures-util/src/io/cursor.rs b/futures-util/src/io/cursor.rs
@@ -1,7 +1,9 @@
 use futures_core::task::{Context, Poll};
 use futures_io::{AsyncBufRead, AsyncRead, AsyncSeek, AsyncWrite, IoSlice, IoSliceMut, SeekFrom};
+use std::boxed::Box;
 use std::io;
 use std::pin::Pin;
+use std::vec::Vec;
 
 /// A `Cursor` wraps an in-memory buffer and provides it with a
 /// [`AsyncSeek`] implementation.
diff --git a/futures-util/src/io/lines.rs b/futures-util/src/io/lines.rs
@@ -7,6 +7,8 @@ use pin_project_lite::pin_project;
 use std::io;
 use std::mem;
 use std::pin::Pin;
+use std::string::String;
+use std::vec::Vec;
 
 pin_project! {
     /// Stream for the [`lines`](super::AsyncBufReadExt::lines) method.
diff --git a/futures-util/src/io/mod.rs b/futures-util/src/io/mod.rs
@@ -21,7 +21,7 @@
 use crate::compat::Compat;
 use crate::future::assert_future;
 use crate::stream::assert_stream;
-use std::{pin::Pin, ptr};
+use std::{pin::Pin, ptr, string::String, vec::Vec};
 
 // Re-export some types from `std::io` so that users don't have to deal
 // with conflicts when `use`ing `futures::io` and `std::io`.
diff --git a/futures-util/src/io/read_line.rs b/futures-util/src/io/read_line.rs
@@ -7,6 +7,8 @@ use std::io;
 use std::mem;
 use std::pin::Pin;
 use std::str;
+use std::string::String;
+use std::vec::Vec;
 
 /// Future for the [`read_line`](super::AsyncBufReadExt::read_line) method.
 #[derive(Debug)]
diff --git a/futures-util/src/io/read_to_string.rs b/futures-util/src/io/read_to_string.rs
@@ -4,6 +4,7 @@ use futures_core::ready;
 use futures_core::task::{Context, Poll};
 use futures_io::AsyncRead;
 use std::pin::Pin;
+use std::string::String;
 use std::vec::Vec;
 use std::{io, mem, str};
 
diff --git a/futures-util/src/io/read_until.rs b/futures-util/src/io/read_until.rs
@@ -5,6 +5,7 @@ use futures_io::AsyncBufRead;
 use std::io;
 use std::mem;
 use std::pin::Pin;
+use std::vec::Vec;
 
 /// Future for the [`read_until`](super::AsyncBufReadExt::read_until) method.
 #[derive(Debug)]
diff --git a/futures-util/src/io/write_all_vectored.rs b/futures-util/src/io/write_all_vectored.rs
@@ -49,6 +49,8 @@ mod tests {
     use std::io;
     use std::pin::Pin;
     use std::task::{Context, Poll};
+    use std::vec;
+    use std::vec::Vec;
 
     use crate::io::{AsyncWrite, AsyncWriteExt, IoSlice};
     use crate::task::noop_waker;
diff --git a/futures-util/src/lib.rs b/futures-util/src/lib.rs
@@ -1,16 +1,16 @@
 //! Combinators and utilities for working with `Future`s, `Stream`s, `Sink`s,
 //! and the `AsyncRead` and `AsyncWrite` traits.
 
-#![cfg_attr(feature = "write-all-vectored", feature(io_slice_advance))]
-#![cfg_attr(not(feature = "std"), no_std)]
-#![warn(missing_docs, unsafe_op_in_unsafe_fn)]
+#![no_std]
 #![doc(test(
     no_crate_inject,
     attr(
         deny(warnings, rust_2018_idioms, single_use_lifetimes),
         allow(dead_code, unused_assignments, unused_variables)
     )
 ))]
+#![warn(missing_docs, unsafe_op_in_unsafe_fn)]
+#![cfg_attr(feature = "write-all-vectored", feature(io_slice_advance))]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 #![allow(clippy::needless_borrow)] // https://github.com/rust-lang/futures-rs/pull/2558#issuecomment-1030745203
 #![allow(clippy::arc_with_non_send_sync)] // false positive https://github.com/rust-lang/rust-clippy/issues/11076
@@ -20,6 +20,8 @@ compile_error!("The `bilock` feature requires the `unstable` feature as an expli
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
+#[cfg(feature = "std")]
+extern crate std;
 
 // Macro re-exports
 pub use futures_core::ready;
diff --git a/futures-util/src/lock/mutex.rs b/futures-util/src/lock/mutex.rs
diff --git a/futures-util/src/stream/stream/catch_unwind.rs b/futures-util/src/stream/stream/catch_unwind.rs
diff --git a/futures-util/src/stream/stream/split.rs b/futures-util/src/stream/stream/split.rs
diff --git a/futures/src/lib.rs b/futures/src/lib.rs
