Fix semantic issue according to Stefan's review comments and add test cases again

Author: ackratos

collections/src/main/scala/strawman/collection/immutable/ImmutableArray.scala

@@ -187,7 +187,10 @@ object ImmutableArray extends StrictOptimizedSeqFactory[ImmutableArray] {
     override def slice(from: Int, until: Int): ImmutableArray[T] = {
       val lo = scala.math.max(from, 0)
       val hi = scala.math.min(until, length)
-      new ofRef(Arrays.copyOfRange[T](unsafeArray, lo, hi))
+      if (lo >= hi)
+        emptyImpl
+      else
+        new ofRef(Arrays.copyOfRange[T](unsafeArray, lo, hi))
     }
   }
 
@@ -203,7 +206,10 @@ object ImmutableArray extends StrictOptimizedSeqFactory[ImmutableArray] {
     override def slice(from: Int, until: Int): ImmutableArray[Byte] = {
       val lo = scala.math.max(from, 0)
       val hi = scala.math.min(until, length)
-      new ofByte(Arrays.copyOfRange(unsafeArray, lo, hi))
+      if (lo >= hi)
+        emptyImpl
+      else
+        new ofByte(Arrays.copyOfRange(unsafeArray, lo, hi))
     }
   }
 
@@ -219,7 +225,10 @@ object ImmutableArray extends StrictOptimizedSeqFactory[ImmutableArray] {
     override def slice(from: Int, until: Int): ImmutableArray[Short] = {
       val lo = scala.math.max(from, 0)
       val hi = scala.math.min(until, length)
-      new ofShort(Arrays.copyOfRange(unsafeArray, lo, hi))
+      if (lo > hi)
+        emptyImpl
+      else
+        new ofShort(Arrays.copyOfRange(unsafeArray, lo, hi))
     }
   }
 
@@ -235,7 +244,10 @@ object ImmutableArray extends StrictOptimizedSeqFactory[ImmutableArray] {
     override def slice(from: Int, until: Int): ImmutableArray[Char] = {
       val lo = scala.math.max(from, 0)
       val hi = scala.math.min(until, length)
-      new ofChar(Arrays.copyOfRange(unsafeArray, lo, hi))
+      if (lo >= hi)
+        emptyImpl
+      else
+        new ofChar(Arrays.copyOfRange(unsafeArray, lo, hi))
     }
   }
 
@@ -251,7 +263,10 @@ object ImmutableArray extends StrictOptimizedSeqFactory[ImmutableArray] {
     override def slice(from: Int, until: Int): ImmutableArray[Int] = {
       val lo = scala.math.max(from, 0)
       val hi = scala.math.min(until, length)
-      new ofInt(Arrays.copyOfRange(unsafeArray, lo, hi))
+      if (lo >= hi)
+        emptyImpl
+      else
+        new ofInt(Arrays.copyOfRange(unsafeArray, lo, hi))
     }
   }
 
@@ -267,7 +282,10 @@ object ImmutableArray extends StrictOptimizedSeqFactory[ImmutableArray] {
     override def slice(from: Int, until: Int): ImmutableArray[Long] = {
       val lo = scala.math.max(from, 0)
       val hi = scala.math.min(until, length)
-      new ofLong(Arrays.copyOfRange(unsafeArray, lo, hi))
+      if (lo >= hi)
+        emptyImpl
+      else
+        new ofLong(Arrays.copyOfRange(unsafeArray, lo, hi))
     }
   }
 
@@ -283,7 +301,10 @@ object ImmutableArray extends StrictOptimizedSeqFactory[ImmutableArray] {
     override def slice(from: Int, until: Int): ImmutableArray[Float] = {
       val lo = scala.math.max(from, 0)
       val hi = scala.math.min(until, length)
-      new ofFloat(Arrays.copyOfRange(unsafeArray, lo, hi))
+      if (lo >= hi)
+        emptyImpl
+      else
+        new ofFloat(Arrays.copyOfRange(unsafeArray, lo, hi))
     }
   }
 
@@ -299,7 +320,10 @@ object ImmutableArray extends StrictOptimizedSeqFactory[ImmutableArray] {
     override def slice(from: Int, until: Int): ImmutableArray[Double] = {
       val lo = scala.math.max(from, 0)
       val hi = scala.math.min(until, length)
-      new ofDouble(Arrays.copyOfRange(unsafeArray, lo, hi))
+      if (lo >= hi)
+        emptyImpl
+      else
+        new ofDouble(Arrays.copyOfRange(unsafeArray, lo, hi))
     }
   }
 
@@ -315,7 +339,10 @@ object ImmutableArray extends StrictOptimizedSeqFactory[ImmutableArray] {
     override def slice(from: Int, until: Int): ImmutableArray[Boolean] = {
       val lo = scala.math.max(from, 0)
       val hi = scala.math.min(until, length)
-      new ofBoolean(Arrays.copyOfRange(unsafeArray, lo, hi))
+      if (lo >= hi)
+        emptyImpl
+      else
+        new ofBoolean(Arrays.copyOfRange(unsafeArray, lo, hi))
     }
   }
 
@@ -334,9 +361,13 @@ object ImmutableArray extends StrictOptimizedSeqFactory[ImmutableArray] {
       // cant use util.Arrays.copyOfRange[Unit](repr, from, until) - Unit is special and doesnt compile
       val lo = scala.math.max(from, 0)
       val hi = scala.math.min(until, length)
-      val slicedLenght = hi - lo
-      val res = new Array[Unit](slicedLenght)
-      new ofUnit(res)
+      val slicedLength = hi - lo
+      if (slicedLength <= 0)
+        emptyImpl
+      else {
+        val res = new Array[Unit](slicedLength)
+        new ofUnit(res)
+      }
     }
   }
 }

test/junit/src/test/scala/strawman/collection/immutable/ImmutableArrayTest.scala

@@ -56,5 +56,7 @@ class ImmutableArrayTest {
     Assert.assertEquals(array, array.slice(-1, 5))
     Assert.assertEquals(expectedSliceResult1, array.slice(0, 2))
     Assert.assertEquals(expectedSliceResult2, array.slice(1, 3))
+    Assert.assertEquals(ImmutableArray.empty[T], array.slice(1, 1))
+    Assert.assertEquals(ImmutableArray.empty[T], array.slice(2, 1))
   }
 }