Fixes scala/bug#12706

Author: AminMal

src/library/scala/collection/immutable/NumericRange.scala

@@ -138,16 +138,27 @@ sealed class NumericRange[T](
   // based on the given value.
   private def newEmptyRange(value: T) = NumericRange(value, value, step)
 
+  // Calling length when a range contains more than Int.MaxValue causes IllegalArgumentException
+  // because the length of the range cannot be represented with Int numbers.
+  // This method tries to compare the length of this with the given Int number.
+  private def compareLength(n: Int): Int = {
+    val diff = num.minus(end, start)
+    val thisLength = num.quot(diff, step)
+    num.compare(num.fromInt(n), thisLength)
+  }
+
   override def take(n: Int): NumericRange[T] = {
     if (n <= 0 || isEmpty) newEmptyRange(start)
-    else if (n >= length) this
-    else new NumericRange.Inclusive(start, locationAfterN(n - 1), step)
+    else if (compareLength(n) < 0)
+      new NumericRange.Inclusive(start, locationAfterN(n - 1), step)
+    else this
   }
 
   override def drop(n: Int): NumericRange[T] = {
     if (n <= 0 || isEmpty) this
-    else if (n >= length) newEmptyRange(end)
-    else copy(locationAfterN(n), end, step)
+    else if (compareLength(n) < 0)
+      copy(locationAfterN(n), end, step)
+    else newEmptyRange(end)
   }
 
   override def splitAt(n: Int): (NumericRange[T], NumericRange[T]) = (take(n), drop(n))

test/junit/scala/collection/immutable/NumericRangeTest.scala

@@ -157,4 +157,42 @@ class NumericRangeTest {
     assertEquals(Nil, check(testDecreaseCase.start to testIncreaseCase.last by testIncreaseCase.step))
     assertEquals(Nil, check(testDecreaseCase.inclusive))
   }
+
+  @Test
+  def numericRangeWithMoreThanMaxIntTake() = {
+    val start = BigInt(0)
+    val step = BigInt(1)
+    val end = BigInt(Int.MaxValue) * 5
+
+    // evaluation of length causes IllegalArgumentException because it cannot be represented as Int number
+    // Yet using `take` should be independent of evaluating length when it's not necessary.
+    assertThrows[IllegalArgumentException]((start until end by step).length)
+    val range = start until end by step
+
+    val take = 100
+    val smallChunkOfRange = range.take(take)
+    val expected = start until BigInt(100) by step
+    assertTrue(smallChunkOfRange equals expected)
+    assertTrue(smallChunkOfRange.length == take)
+  }
+
+  @Test
+  def numericRangeWithMoreThanMaxIntDrop() = {
+    val start = BigInt(0)
+    val step = BigInt(1)
+    val toAddToMaxInt = 50
+    val end = BigInt(Int.MaxValue) + toAddToMaxInt
+
+    val drop = Int.MaxValue
+
+    // evaluation of length causes IllegalArgumentException because it cannot be represented as Int number
+    // Yet using `drop` should be independent of evaluating length when it's not necessary.
+    assertThrows[IllegalArgumentException]((start until end by step).length)
+    val range = start until end by step
+
+    val smallChunkOfRange = range.drop(drop)
+    val expected = BigInt(Int.MaxValue) until end by step
+    assertTrue(smallChunkOfRange equals expected)
+    assertTrue(smallChunkOfRange.length == toAddToMaxInt)
+  }
 }