sort: add wasi_no_threads cfg alias to reduce predicate verbosity

Author: DePasqualeOrg

src/uu/sort/build.rs

@@ -0,0 +1,15 @@
+fn main() {
+    // Set a short alias for the WASI-without-threads configuration so that
+    // source files can use `#[cfg(wasi_no_threads)]` instead of the verbose
+    // `#[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]`.
+    println!("cargo::rustc-check-cfg=cfg(wasi_no_threads)");
+
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
+    let has_atomics = std::env::var("CARGO_CFG_TARGET_FEATURE")
+        .map(|f| f.split(',').any(|feat| feat == "atomics"))
+        .unwrap_or(false);
+
+    if target_os == "wasi" && !has_atomics {
+        println!("cargo::rustc-cfg=wasi_no_threads");
+    }
+}

src/uu/sort/src/check.rs

@@ -17,9 +17,9 @@ use std::{
     io::Read,
     iter,
 };
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 use std::sync::mpsc::{sync_channel, SyncSender, Receiver};
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 use std::thread;
 use uucore::error::UResult;
 
@@ -41,17 +41,17 @@ pub fn check(path: &OsStr, settings: &GlobalSettings) -> UResult<()> {
         100 * 1024
     };
 
-    #[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+    #[cfg(not(wasi_no_threads))]
     {
         check_threaded(path, settings, max_allowed_cmp, file, chunk_size)
     }
-    #[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+    #[cfg(wasi_no_threads)]
     {
         check_sync(path, settings, max_allowed_cmp, file, chunk_size)
     }
 }
 
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 fn check_threaded(
     path: &OsStr,
     settings: &GlobalSettings,
@@ -115,7 +115,7 @@ fn check_threaded(
 }
 
 /// The function running on the reader thread.
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 fn reader(
     mut file: Box<dyn Read + Send>,
     receiver: &Receiver<RecycledChunk>,
@@ -142,7 +142,7 @@ fn reader(
 }
 
 /// Synchronous check for targets without thread support.
-#[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+#[cfg(wasi_no_threads)]
 fn check_sync(
     path: &OsStr,
     settings: &GlobalSettings,

src/uu/sort/src/chunks.rs

@@ -13,7 +13,7 @@ use std::{
     io::{ErrorKind, Read},
     ops::Range,
 };
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 use std::sync::mpsc::SyncSender;
 
 use memchr::memchr_iter;
@@ -246,7 +246,7 @@ pub fn read_to_chunk<T: Read>(
 /// Read a chunk, parse lines and send them via channel.
 ///
 /// Wrapper around [`read_to_chunk`] for the threaded code path.
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 #[allow(clippy::too_many_arguments)]
 pub fn read<T: Read>(
     sender: &SyncSender<Chunk>,

src/uu/sort/src/ext_sort/threaded.rs

@@ -10,19 +10,19 @@ use std::cmp::Ordering;
 use std::fs::File;
 use std::io::{Read, Write, stderr};
 use std::path::PathBuf;
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 use std::sync::mpsc::{Receiver, SyncSender};
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 use std::thread;
 
 use itertools::Itertools;
 use uucore::error::UResult;
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 use uucore::error::strip_errno;
 
 use crate::Output;
 use crate::chunks::RecycledChunk;
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 use crate::merge::WriteableCompressedTmpFile;
 use crate::merge::WriteablePlainTmpFile;
 use crate::merge::WriteableTmpFile;
@@ -41,7 +41,7 @@ const DEFAULT_BUF_SIZE: usize = 8 * 1024;
 ///
 /// Uses the same chunked sort-write-merge strategy as the threaded version,
 /// but reads and sorts each chunk sequentially on the calling thread.
-#[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+#[cfg(wasi_no_threads)]
 pub fn ext_sort(
     files: &mut impl Iterator<Item = UResult<Box<dyn Read + Send>>>,
     settings: &GlobalSettings,
@@ -159,7 +159,7 @@ pub fn ext_sort(
 }
 
 /// Print a single sorted chunk.
-#[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+#[cfg(wasi_no_threads)]
 fn print_chunk(
     chunk: &Chunk,
     settings: &GlobalSettings,
@@ -180,7 +180,7 @@ fn print_chunk(
 }
 
 /// Merge two in-memory chunks and print.
-#[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+#[cfg(wasi_no_threads)]
 fn print_two_chunks(
     a: Chunk,
     b: Chunk,
@@ -215,7 +215,7 @@ fn print_two_chunks(
 /// Two threads cooperate: one reads input and writes temporary chunk files,
 /// while the other sorts each chunk in memory. Once all chunks are written,
 /// they are merged back together for final output.
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 pub fn ext_sort(
     files: &mut impl Iterator<Item = UResult<Box<dyn Read + Send>>>,
     settings: &GlobalSettings,
@@ -276,7 +276,7 @@ pub fn ext_sort(
     }
 }
 
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 fn reader_writer<
     F: Iterator<Item = UResult<Box<dyn Read + Send>>>,
     Tmp: WriteableTmpFile + 'static,
@@ -362,7 +362,7 @@ fn reader_writer<
 }
 
 /// The function that is executed on the sorter thread.
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 fn sorter(receiver: &Receiver<Chunk>, sender: &SyncSender<Chunk>, settings: &GlobalSettings) {
     while let Ok(mut payload) = receiver.recv() {
         payload.with_dependent_mut(|_, contents| {
@@ -377,7 +377,7 @@ fn sorter(receiver: &Receiver<Chunk>, sender: &SyncSender<Chunk>, settings: &Glo
 }
 
 /// Describes how we read the chunks from the input.
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 enum ReadResult<I: WriteableTmpFile> {
     /// The input was empty. Nothing was read.
     EmptyInput,
@@ -389,7 +389,7 @@ enum ReadResult<I: WriteableTmpFile> {
     WroteChunksToFile { tmp_files: Vec<I::Closed> },
 }
 /// The function that is executed on the reader/writer thread.
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 fn read_write_loop<I: WriteableTmpFile>(
     mut files: impl Iterator<Item = UResult<Box<dyn Read + Send>>>,
     tmp_dir: &mut TmpDirWrapper,

src/uu/sort/src/merge.rs

@@ -21,14 +21,14 @@ use std::{
     process::{Child, ChildStdin, ChildStdout, Command, Stdio},
     rc::Rc,
 };
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 use std::{
     sync::mpsc::{Receiver, Sender, SyncSender, channel, sync_channel},
     thread::{self, JoinHandle},
 };
 
 use compare::Compare;
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 use uucore::error::FromIo;
 use uucore::error::UResult;
 
@@ -108,7 +108,7 @@ pub fn merge(
     let files = files
         .iter()
         .map(|file| open(file).map(|file| PlainMergeInput { inner: file }));
-    #[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+    #[cfg(wasi_no_threads)]
     if settings.compress_prog.is_some() {
         let _ = writeln!(
             std::io::stderr(),
@@ -132,9 +132,9 @@ fn do_merge_to_output<M: MergeInput + 'static>(
     settings: &GlobalSettings,
     output: Output,
 ) -> UResult<()> {
-    #[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+    #[cfg(not(wasi_no_threads))]
     return merge_without_limit(files, settings)?.write_all(settings, output);
-    #[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+    #[cfg(wasi_no_threads)]
     return merge_without_limit_sync(files, settings)?.write_all(settings, output);
 }
 
@@ -144,9 +144,9 @@ fn do_merge_to_writer<M: MergeInput + 'static>(
     settings: &GlobalSettings,
     out: &mut impl Write,
 ) -> UResult<()> {
-    #[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+    #[cfg(not(wasi_no_threads))]
     return merge_without_limit(files, settings)?.write_all_to(settings, out);
-    #[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+    #[cfg(wasi_no_threads)]
     return merge_without_limit_sync(files, settings)?.write_all_to(settings, out);
 }
 
@@ -208,7 +208,7 @@ pub fn merge_with_file_limit<
 ///
 /// It is the responsibility of the caller to ensure that `files` yields only
 /// as many files as we are allowed to open concurrently.
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 fn merge_without_limit<M: MergeInput + 'static, F: Iterator<Item = UResult<M>>>(
     files: F,
     settings: &GlobalSettings,
@@ -273,15 +273,15 @@ fn merge_without_limit<M: MergeInput + 'static, F: Iterator<Item = UResult<M>>>(
     })
 }
 /// The struct on the reader thread representing an input file
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 struct ReaderFile<M: MergeInput> {
     file: M,
     sender: SyncSender<Chunk>,
     carry_over: Vec<u8>,
 }
 
 /// The function running on the reader thread.
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 fn reader(
     recycled_receiver: &Receiver<(usize, RecycledChunk)>,
     files: &mut [Option<ReaderFile<impl MergeInput>>],
@@ -316,7 +316,7 @@ fn reader(
     Ok(())
 }
 /// The struct on the main thread representing an input file
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 pub struct MergeableFile {
     current_chunk: Rc<Chunk>,
     line_idx: usize,
@@ -330,20 +330,20 @@ pub struct MergeableFile {
 struct PreviousLine {
     chunk: Rc<Chunk>,
     line_idx: usize,
-    #[cfg_attr(all(target_os = "wasi", not(target_feature = "atomics")), allow(dead_code))]
+    #[cfg_attr(wasi_no_threads, allow(dead_code))]
     file_number: usize,
 }
 
 /// Merges files together. This is **not** an iterator because of lifetime problems.
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 struct FileMerger<'a> {
     heap: binary_heap_plus::BinaryHeap<MergeableFile, FileComparator<'a>>,
     request_sender: Sender<(usize, RecycledChunk)>,
     prev: Option<PreviousLine>,
     reader_join_handle: JoinHandle<UResult<()>>,
 }
 
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 impl FileMerger<'_> {
     /// Write the merged contents to the output file.
     fn write_all(self, settings: &GlobalSettings, output: Output) -> UResult<()> {
@@ -425,7 +425,7 @@ struct FileComparator<'a> {
     settings: &'a GlobalSettings,
 }
 
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 impl Compare<MergeableFile> for FileComparator<'_> {
     fn compare(&self, a: &MergeableFile, b: &MergeableFile) -> Ordering {
         let mut cmp = compare_by(
@@ -646,20 +646,20 @@ impl<R: Read + Send> MergeInput for PlainMergeInput<R> {
 // Synchronous merge for targets without thread support (e.g. wasm32-wasip1).
 // ---------------------------------------------------------------------------
 
-#[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+#[cfg(wasi_no_threads)]
 struct SyncReaderFile<M: MergeInput> {
     file: M,
     carry_over: Vec<u8>,
 }
 
-#[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+#[cfg(wasi_no_threads)]
 struct SyncMergeableFile {
     current_chunk: Rc<Chunk>,
     line_idx: usize,
     file_number: usize,
 }
 
-#[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+#[cfg(wasi_no_threads)]
 impl Compare<SyncMergeableFile> for FileComparator<'_> {
     fn compare(&self, a: &SyncMergeableFile, b: &SyncMergeableFile) -> Ordering {
         let mut cmp = compare_by(
@@ -676,7 +676,7 @@ impl Compare<SyncMergeableFile> for FileComparator<'_> {
     }
 }
 
-#[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+#[cfg(wasi_no_threads)]
 struct SyncFileMerger<'a, M: MergeInput> {
     heap: binary_heap_plus::BinaryHeap<SyncMergeableFile, FileComparator<'a>>,
     readers: Vec<Option<SyncReaderFile<M>>>,
@@ -685,7 +685,7 @@ struct SyncFileMerger<'a, M: MergeInput> {
     settings: &'a GlobalSettings,
 }
 
-#[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+#[cfg(wasi_no_threads)]
 impl<M: MergeInput> SyncFileMerger<'_, M> {
     fn write_all(self, settings: &GlobalSettings, output: Output) -> UResult<()> {
         let mut out = output.into_write();
@@ -782,7 +782,7 @@ impl<M: MergeInput> SyncFileMerger<'_, M> {
     }
 }
 
-#[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+#[cfg(wasi_no_threads)]
 fn merge_without_limit_sync<'a, M: MergeInput + 'static, F: Iterator<Item = UResult<M>>>(
     files: F,
     settings: &'a GlobalSettings,

src/uu/sort/src/sort.rs

@@ -29,7 +29,7 @@ use foldhash::fast::FoldHasher;
 use foldhash::{HashMap, SharedSeed};
 use numeric_str_cmp::{NumInfo, NumInfoParseSettings, human_numeric_str_cmp, numeric_str_cmp};
 use rand::{RngExt as _, rng};
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 use rayon::slice::ParallelSliceMut;
 use std::cmp::Ordering;
 use std::env;
@@ -38,7 +38,7 @@ use std::fs::{File, OpenOptions};
 use std::hash::{Hash, Hasher};
 use std::io::{BufRead, BufReader, BufWriter, Read, Write, stdin, stdout};
 use std::num::IntErrorKind;
-#[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+#[cfg(not(wasi_no_threads))]
 use std::num::NonZero;
 use std::ops::Range;
 #[cfg(unix)]
@@ -2126,7 +2126,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         settings.threads = matches
             .get_one::<String>(options::PARALLEL)
             .map_or_else(|| "0".to_string(), String::from);
-        #[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+        #[cfg(not(wasi_no_threads))]
         {
             let num_threads = match settings.threads.parse::<usize>() {
                 Ok(0) | Err(_) => std::thread::available_parallelism().map_or(1, NonZero::get),
@@ -2620,14 +2620,14 @@ fn sort_by<'a>(unsorted: &mut Vec<Line<'a>>, settings: &GlobalSettings, line_dat
     // WASI does not support threads, so use non-parallel sort to avoid
     // rayon's thread pool which triggers an unreachable trap.
     if settings.stable || settings.unique {
-        #[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+        #[cfg(not(wasi_no_threads))]
         unsorted.par_sort_by(cmp);
-        #[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+        #[cfg(wasi_no_threads)]
         unsorted.sort_by(cmp);
     } else {
-        #[cfg(not(all(target_os = "wasi", not(target_feature = "atomics"))))]
+        #[cfg(not(wasi_no_threads))]
         unsorted.par_sort_unstable_by(cmp);
-        #[cfg(all(target_os = "wasi", not(target_feature = "atomics")))]
+        #[cfg(wasi_no_threads)]
         unsorted.sort_unstable_by(cmp);
     }
 }