Optimization: change Array.copy to System.arrayCopy

This is more efficient, especially for small sizes where setup cost for Array.copy
is higher.

Author: odersky

compiler/src/dotty/tools/dotc/core/Names.scala

@@ -376,7 +376,7 @@ object Names {
 
     override def replace(from: Char, to: Char): SimpleName = {
       val cs = new Array[Char](length)
-      Array.copy(chrs, start, cs, 0, length)
+      System.arraycopy(chrs, start, cs, 0, length)
       for (i <- 0 until length) {
         if (cs(i) == from) cs(i) = to
       }

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -2302,7 +2302,7 @@ object SymDenotations {
 
     private def resize(size: Int) = {
       val classIds1 = new Array[Int](size)
-      Array.copy(classIds, 0, classIds1, 0, classIds.length min size)
+      System.arraycopy(classIds, 0, classIds1, 0, classIds.length min size)
       classIds = classIds1
     }
 

compiler/src/dotty/tools/dotc/core/tasty/TastyBuffer.scala

@@ -59,7 +59,7 @@ class TastyBuffer(initialSize: Int) {
   /** Write the first `n` bytes of `data`. */
   def writeBytes(data: Array[Byte], n: Int): Unit = {
     while (bytes.length < length + n) bytes = dble(bytes)
-    Array.copy(data, 0, bytes, length, n)
+    System.arraycopy(data, 0, bytes, length, n)
     length += n
   }
 

compiler/src/dotty/tools/dotc/core/tasty/TastyReader.scala

@@ -54,7 +54,7 @@ class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int =
   /** Read the next `n` bytes of `data`. */
   def readBytes(n: Int): Array[Byte] = {
     val result = new Array[Byte](n)
-    Array.copy(bytes, bp, result, 0, n)
+    System.arraycopy(bytes, bp, result, 0, n)
     bp += n
     result
   }

compiler/src/dotty/tools/dotc/core/tasty/TreeBuffer.scala

@@ -137,7 +137,7 @@ class TreeBuffer extends TastyBuffer(50000) {
     var i = 0
     var wasted = 0
     def shift(end: Int) =
-      Array.copy(bytes, start, bytes, start - lastDelta, end - start)
+      System.arraycopy(bytes, start, bytes, start - lastDelta, end - start)
     while (i < numOffsets) {
       val next = offsets(i)
       shift(next)

compiler/src/dotty/tools/dotc/core/unpickleScala2/PickleBuffer.scala

@@ -20,7 +20,7 @@ class PickleBuffer(data: Array[Byte], from: Int, to: Int) {
   /** Double bytes array */
   private def dble(): Unit = {
     val bytes1 = new Array[Byte](bytes.length * 2)
-    Array.copy(bytes, 0, bytes1, 0, writeIndex)
+    System.arraycopy(bytes, 0, bytes1, 0, writeIndex)
     bytes = bytes1
   }
 
@@ -69,7 +69,7 @@ class PickleBuffer(data: Array[Byte], from: Int, to: Int) {
   def patchNat(pos: Int, x: Int): Unit = {
     def patchNatPrefix(x: Int): Unit = {
       writeByte(0)
-      Array.copy(bytes, pos, bytes, pos + 1, writeIndex - (pos + 1))
+      System.arraycopy(bytes, pos, bytes, pos + 1, writeIndex - (pos + 1))
       bytes(pos) = ((x & 0x7f) | 0x80).toByte
       val y = x >>> 7
       if (y != 0) patchNatPrefix(y)

compiler/src/dotty/tools/dotc/rewrites/Rewrites.scala

@@ -34,7 +34,7 @@ object Rewrites {
       @tailrec def loop(ps: List[Patch], inIdx: Int, outIdx: Int): Unit = {
         def copy(upTo: Int): Int = {
           val untouched = upTo - inIdx
-          Array.copy(cs, inIdx, ds, outIdx, untouched)
+          System.arraycopy(cs, inIdx, ds, outIdx, untouched)
           outIdx + untouched
         }
         ps match {

compiler/src/dotty/tools/dotc/util/SimpleIdentityMap.scala

@@ -160,8 +160,8 @@ object SimpleIdentityMap {
             m
           } else {
             val bindings1 = new Array[AnyRef](bindings.length - 2)
-            Array.copy(bindings, 0, bindings1, 0, i)
-            Array.copy(bindings, i + 2, bindings1, i, bindings1.length - i)
+            System.arraycopy(bindings, 0, bindings1, 0, i)
+            System.arraycopy(bindings, i + 2, bindings1, i, bindings1.length - i)
             new MapMore(bindings1)
           }
         }
@@ -185,7 +185,7 @@ object SimpleIdentityMap {
         i += 2
       }
       val bindings2 = new Array[AnyRef](bindings.length + 2)
-      Array.copy(bindings, 0, bindings2, 0, bindings.length)
+      System.arraycopy(bindings, 0, bindings2, 0, bindings.length)
       bindings2(bindings.length) = k
       bindings2(bindings.length + 1) = v
       new MapMore(bindings2)

compiler/src/dotty/tools/dotc/util/SimpleIdentitySet.scala

@@ -83,7 +83,7 @@ object SimpleIdentitySet {
     def size = xs.length
     def + [E >: Elem <: AnyRef](x: E): SimpleIdentitySet[E] = {
       val xs1 = new Array[AnyRef](size + 1)
-      Array.copy(xs, 0, xs1, 0, size)
+      System.arraycopy(xs, 0, xs1, 0, size)
       xs1(size) = x
       new SetN[E](xs1)
     }
@@ -98,8 +98,8 @@ object SimpleIdentitySet {
         else new Set3(xs(0), xs(1), xs(2))
       else {
         val xs1 = new Array[AnyRef](size - 1)
-        Array.copy(xs, 0, xs1, 0, i)
-        Array.copy(xs, i + 1, xs1, i, size - (i + 1))
+        System.arraycopy(xs, 0, xs1, 0, i)
+        System.arraycopy(xs, i + 1, xs1, i, size - (i + 1))
         new SetN(xs1)
       }
     }

compiler/src/dotty/tools/dotc/util/SourceFile.scala

@@ -180,7 +180,7 @@ class SourceFile(val file: AbstractFile, computeContent: => Array[Char]) extends
     val id = chunks << ChunkSizeLog
     if (chunks == sourceOfChunk.length) {
       val a = new Array[SourceFile](chunks * 2)
-      Array.copy(sourceOfChunk, 0, a, 0, chunks)
+      System.arraycopy(sourceOfChunk, 0, a, 0, chunks)
       sourceOfChunk = a
     }
     sourceOfChunk(chunks) = this

compiler/src/dotty/tools/dotc/util/Util.scala

@@ -26,7 +26,7 @@ object Util {
   /** An array twice the size of given array, with existing elements copied over */
   def dble[T: ClassTag](arr: Array[T]): Array[T] = {
     val arr1 = new Array[T](arr.length * 2)
-    Array.copy(arr, 0, arr1, 0, arr.length)
+    System.arraycopy(arr, 0, arr1, 0, arr.length)
     arr1
   }
 }

library/src-bootstrapped/scala/Tuple.scala

@@ -183,7 +183,7 @@ object Tuple {
   def $consArray[H](x: H, elems: Array[Object]): Array[Object] = {
     val elems1 = new Array[Object](elems.length + 1)
     elems1(0) = x.asInstanceOf[Object]
-    Array.copy(elems, 0, elems1, 1, elems.length)
+    System.arraycopy(elems, 0, elems1, 1, elems.length)
     elems1
   }