Merge rayon-rs#575

575: u128 and i128 ranges r=cuviper a=paulkernfeld

This is an attempt at rayon-rs#573. I don't have experience with functionality that is conditional on the version of rustc, so I apologize if this PR is completely bonkers. I went with a feature flag in this case, but I would be happy to reimplement this using an alternative method.

Co-authored-by: Paul Kernfeld <[email protected]>
Co-authored-by: Josh Stone <[email protected]>

Author: 3 people

build.rs

@@ -0,0 +1,33 @@
+use std::env;
+use std::io::Write;
+use std::process::{Command, Stdio};
+
+fn main() {
+    if probe("fn main() { 0i128; }") {
+        println!("cargo:rustc-cfg=has_i128");
+    }
+}
+
+/// Test if a code snippet can be compiled
+fn probe(code: &str) -> bool {
+    let rustc = env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
+    let out_dir = env::var_os("OUT_DIR").expect("environment variable OUT_DIR");
+
+    let mut child = Command::new(rustc)
+        .arg("--out-dir")
+        .arg(out_dir)
+        .arg("--emit=obj")
+        .arg("-")
+        .stdin(Stdio::piped())
+        .spawn()
+        .expect("rustc probe");
+
+    child
+        .stdin
+        .as_mut()
+        .expect("rustc stdin")
+        .write_all(code.as_bytes())
+        .expect("write rustc stdin");
+
+    child.wait().expect("rustc probe").success()
+}

src/iter/find_first_last/test.rs

@@ -101,9 +101,17 @@ fn find_last_folder_yields_last_match() {
     assert_eq!(f.complete(), Some(2_i32));
 }
 
-
 /// Produce a parallel iterator for 0u128..10²⁷
+#[cfg(has_i128)]
 fn octillion() -> impl ParallelIterator<Item = u128> {
+    // Using parse because some versions of rust don't allow long literals
+    let octillion = "1000000000000000000000000000".parse::<u128>().unwrap();
+    (0u128..octillion).into_par_iter()
+}
+
+/// Produce a parallel iterator for 0u128..10²⁷
+#[cfg(not(has_i128))]
+fn octillion() -> impl ParallelIterator<Item = u128>{
     (0u32..1_000_000_000)
         .into_par_iter()
         .with_max_len(1_000)

src/iter/mod.rs

@@ -1436,7 +1436,7 @@ impl<T: ParallelIterator> IntoParallelIterator for T {
 /// that you can split it at arbitrary indices and draw data from
 /// those points.
 ///
-/// **Note:** Not implemented for `u64` and `i64` ranges
+/// **Note:** Not implemented for `u64`, `i64`, `u128`, or `i128` ranges
 pub trait IndexedParallelIterator: ParallelIterator {
     /// Collects the results of the iterator into the specified
     /// vector. The vector is always truncated before execution

src/range.rs

@@ -23,7 +23,7 @@ use std::ops::Range;
 /// Parallel iterator over a range, implemented for all integer types.
 ///
 /// **Note:** The `zip` operation requires `IndexedParallelIterator`
-/// which is not implemented for `u64` or `i64`.
+/// which is not implemented for `u64`, `i64`, `u128`, or `i128`.
 ///
 /// ```
 /// use rayon::prelude::*;
@@ -128,12 +128,12 @@ macro_rules! indexed_range_impl {
 }
 
 macro_rules! unindexed_range_impl {
-    ( $t:ty ) => {
+    ( $t:ty, $len_t:ty ) => {
         impl IterProducer<$t> {
-            fn len(&self) -> u64 {
+            fn len(&self) -> $len_t {
                 let Range { start, end } = self.range;
                 if end > start {
-                    end.wrapping_sub(start) as u64
+                    end.wrapping_sub(start) as $len_t
                 } else {
                     0
                 }
@@ -185,9 +185,10 @@ indexed_range_impl!{i32}
 indexed_range_impl!{isize}
 
 // other Range<T> with just Iterator
-unindexed_range_impl!{u64}
-unindexed_range_impl!{i64}
-
+unindexed_range_impl!{u64, u64}
+unindexed_range_impl!{i64, u64}
+#[cfg(has_i128)] unindexed_range_impl!{u128, u128}
+#[cfg(has_i128)] unindexed_range_impl!{i128, u128}
 
 #[test]
 pub fn check_range_split_at_overflow() {
@@ -198,3 +199,13 @@ pub fn check_range_split_at_overflow() {
     let r2: i32 = right.range.map(|i| i as i32).sum();
     assert_eq!(r1 + r2, -100);
 }
+
+#[cfg(has_i128)]
+#[test]
+pub fn test_i128_len_doesnt_overflow() {
+    // Using parse because some versions of rust don't allow long literals
+    let octillion = "1000000000000000000000000000".parse::<i128>().unwrap();
+    let producer = IterProducer { range: 0..octillion };
+
+    assert_eq!(octillion as u128, producer.len());
+}