Use build.rs instead of feature flag, fix len()

Author: Paul Kernfeld

.travis.yml

@@ -73,15 +73,13 @@ matrix:
 
 
 script:
+  - cargo build
   - |
     if [ $TRAVIS_RUST_VERSION == nightly ]; then
-      cargo build --features range128 &&
-      cargo test -p rayon --features range128 &&
+      cargo test -p rayon &&
       cargo test -p rayon-core &&
       cargo test -p rayon-demo &&
       ./ci/highlander.sh
-    else
-      cargo build
     fi
   - |
     if [ -n "$RUSTFLAGS" ]; then

Cargo.toml

@@ -16,11 +16,6 @@ categories = ["concurrency"]
 members = ["rayon-demo", "rayon-core", "rayon-futures"]
 exclude = ["ci"]
 
-[features]
-default = []
-
-range128 = []
-
 [dependencies]
 rayon-core = { version = "1.4", path = "rayon-core" }
 

appveyor.yml

@@ -51,13 +51,11 @@ matrix:
 build: false
 
 test_script:
+  - cargo build
   - if [%CHANNEL%]==[nightly] (
-      cargo build --features range128 &&
-      cargo test -p rayon --features range128 &&
+      cargo test -p rayon &&
       cargo test -p rayon-core &&
       cargo test -p rayon-demo
-    ) else (
-      cargo build
     )
   - if not "%RUSTFLAGS%"=="%^RUSTFLAGS%" (
       cargo clean &&

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,15 @@ 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> {
+    (0u128..1_000_000_000_000_000_000_000_000_000).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)
@@ -127,19 +133,6 @@ fn octillion() -> impl ParallelIterator<Item = u128> {
         )
 }
 
-#[cfg(feature = "range128")]
-fn octillion_range128() -> impl ParallelIterator<Item = u128> {
-    (0u128..1_000_000_000_000_000_000_000_000_000).into_par_iter()
-}
-
-#[cfg(feature = "range128")]
-#[test]
-fn find_first_octillion() {
-    let x = octillion_range128().find_first(|_| true);
-    assert_eq!(x, Some(0));
-}
-
-#[cfg(not(feature = "range128"))]
 #[test]
 fn find_first_octillion() {
     let x = octillion().find_first(|_| true);

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,12 +185,10 @@ indexed_range_impl!{i32}
 indexed_range_impl!{isize}
 
 // other Range<T> with just Iterator
-unindexed_range_impl!{u64}
-unindexed_range_impl!{i64}
-
-// 128-bit support uses a feature to permit rustc < 1.26
-#[cfg(feature = "range128")] unindexed_range_impl !{u128}
-#[cfg(feature = "range128")] unindexed_range_impl !{i128}
+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() {
@@ -201,3 +199,12 @@ 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() {
+    let octillion = 1_000_000_000_000_000_000_000_000_000i128;
+    let producer = IterProducer { range: 0..octillion };
+
+    assert_eq!(octillion as u128, producer.len());
+}