Moved Predef.Array* to scala.Array.apply*

5 files changed, 119 insertions, 122 deletions

diff --git a/src/library/scala/Array.scala b/src/library/scala/Array.scala
index 22872d1b39..b64df80406 100644
--- a/src/library/scala/Array.scala
+++ b/src/library/scala/Array.scala
@@ -69,23 +69,107 @@ object Array {
     for (val i <- Iterator.range(start, end)) result(i - start) = i
     result
   }
+
+  /** Create an array with given elements.
+   *
+   *  @param xs the elements to put in the array
+   *  @return the array containing elements xs.
+   */
+  def apply[A <: AnyRef](xs: A*): Array[A] = {
+    val array = new Array[A](xs.length)
+    var i = 0
+    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
+    array
+  }
+
+
+/* The following metod clashes with the previous one, and has therefore been
+ * removed. Note that this is a choice between efficiency and generality.
+ * The previous factory method is more efficient than the one that has been
+ * commented out. Since it is anyway possible to create a polymorphic array
+ * using
+ *        new Array[T]
+ * it was preferred to restrict the definition of the factory method.
+
+   def Array[A](xs: A*): Array[A] = {
+    val array = new Array[A](xs.length)
+    var i = 0
+    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
+    array
+  }
+*/
+
+  def apply(xs: Boolean*): Array[Boolean] = {
+    val array = new Array[Boolean](xs.length)
+    var i = 0
+    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
+    array
+  }
+  def apply(xs: Byte*): Array[Byte] = {
+    val array = new Array[Byte](xs.length)
+    var i = 0
+    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
+    array
+  }
+  def apply(xs: Short*): Array[Short] = {
+    val array = new Array[Short](xs.length)
+    var i = 0
+    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
+    array
+  }
+  def apply(xs: Char*): Array[Char] = {
+    val array = new Array[Char](xs.length)
+    var i = 0
+    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
+    array
+  }
+  def apply(xs: Int*): Array[Int] = {
+    val array = new Array[Int](xs.length)
+    var i = 0
+    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
+    array
+  }
+  def apply(xs: Long*): Array[Long] = {
+    val array = new Array[Long](xs.length)
+    var i = 0
+    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
+    array
+  }
+  def apply(xs: Float*): Array[Float] = {
+    val array = new Array[Float](xs.length)
+    var i = 0
+    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
+    array
+  }
+  def apply(xs: Double*): Array[Double] = {
+    val array = new Array[Double](xs.length)
+    var i = 0
+    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
+    array
+  }
+  def apply(xs: Unit*): Array[Unit] = {
+    val array = new Array[Unit](xs.length)
+    var i = 0
+    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
+    array
+  }
+
 }
 
-/** This class ...
+/** This class represents polymorphic arrays. It is never instantiated.
  *
  *  @author Martin Odersky
  *  @version 1.0
  */
-[cloneable,serializable]
-final class Array[a](_length: Int) extends Seq[a] {
+final class Array[A](_length: Int) extends Seq[A] {
   def length: Int = throw new Error()
-  def apply(i: Int): a = throw new Error()
-  def update(i: Int, x: a): Unit = throw new Error()
-  def elements: Iterator[a] = throw new Error()
-  def subArray(from: Int, end: Int): Array[a] = throw new Error()
-  def filter(p: a => Boolean): Array[a] = throw new Error()
-  def map[b](f: a => b): Array[b] = throw new Error()
-  def flatMap[b](f: a => Array[b]): Array[b] = throw new Error()
-  def zip[b](that: Array[b]): Array[Tuple2[a,b]] = throw new Error()
-  def zipWithIndex: Array[Tuple2[a,Int]] = throw new Error()
+  def apply(i: Int): A = throw new Error()
+  def update(i: Int, x: A): Unit = throw new Error()
+  def elements: Iterator[A] = throw new Error()
+  def subArray(from: Int, end: Int): Array[A] = throw new Error()
+  def filter(p: A => Boolean): Array[A] = throw new Error()
+  def map[B](f: A => B): Array[B] = throw new Error()
+  def flatMap[B](f: A => Array[B]): Array[B] = throw new Error()
+  def zip[B](that: Array[B]): Array[Tuple2[A,B]] = throw new Error()
+  def zipWithIndex: Array[Tuple2[A,Int]] = throw new Error()
 }
diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala
index 785546624a..dcb67d2900 100644
--- a/src/library/scala/Predef.scala
+++ b/src/library/scala/Predef.scala
@@ -74,93 +74,6 @@ object Predef {
 
   type Function[-a,+b] = Function1[a,b]
 
-  // arrays -----------------------------------------------------------
-
-  /** Create an array with given elements.
-   *
-   *  @param xs the elements to put in the array
-   *  @return the array containing elements xs.
-   */
-  def Array[A <: AnyRef](xs: A*): Array[A] = {
-    val array = new Array[A](xs.length)
-    var i = 0
-    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
-    array
-  }
-
-  val Array = scala.Array
-
-/* The following metod clashes with the previous one, and has therefore been
- * removed. Note that this is a choice between efficiency and generality.
- * The previous factory method is more efficient than the one that has been
- * commented out. Since it is anyway possible to create a polymorphic array
- * using
- *        new Array[T]
- * it was preferred to restrict the definition of the factory method.
-
-   def Array[A](xs: A*): Array[A] = {
-    val array = new Array[A](xs.length)
-    var i = 0
-    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
-    array
-  }
-*/
-
-  def Array(xs: boolean*): Array[boolean] = {
-    val array = new Array[boolean](xs.length)
-    var i = 0
-    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
-    array
-  }
-  def Array(xs: byte*): Array[byte] = {
-    val array = new Array[byte](xs.length)
-    var i = 0
-    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
-    array
-  }
-  def Array(xs: short*): Array[short] = {
-    val array = new Array[short](xs.length)
-    var i = 0
-    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
-    array
-  }
-  def Array(xs: char*): Array[char] = {
-    val array = new Array[char](xs.length)
-    var i = 0
-    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
-    array
-  }
-  def Array(xs: int*): Array[int] = {
-    val array = new Array[int](xs.length)
-    var i = 0
-    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
-    array
-  }
-  def Array(xs: long*): Array[long] = {
-    val array = new Array[long](xs.length)
-    var i = 0
-    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
-    array
-  }
-  def Array(xs: float*): Array[float] = {
-    val array = new Array[float](xs.length)
-    var i = 0
-    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
-    array
-  }
-  def Array(xs: double*): Array[double] = {
-    val array = new Array[double](xs.length)
-    var i = 0
-    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
-    array
-  }
-  def Array(xs: unit*): Array[unit] = {
-    val array = new Array[unit](xs.length)
-    var i = 0
-    for (val x <- xs.elements) { array(i) = x; i = i + 1; }
-    array
-  }
-
   // errors and asserts -------------------------------------------------
 
   def error(message: String): Nothing = throw new Error(message)
diff --git a/src/library/scala/mobile/Code.scala b/src/library/scala/mobile/Code.scala
index 27de533b83..c15db16f01 100644
--- a/src/library/scala/mobile/Code.scala
+++ b/src/library/scala/mobile/Code.scala
@@ -44,16 +44,16 @@ class Code(clazz: java.lang.Class) {
 
   def apply[R](funName: String) =
     () => {
-      val args  = Predef.Array[JObject]();
-      val types = Predef.Array[Class]();
+      val args  = Array[JObject]();
+      val types = Array[Class]();
       applyFun(funName, args, types).asInstanceOf[R];
     };
 
   def apply[A0, R](funName: String) =
     (_0: A0) => {
       val p     = boxValue(_0);
-      val args  = Predef.Array(p._1);
-      val types = Predef.Array(p._2);
+      val args  = Array(p._1);
+      val types = Array(p._2);
       applyFun(funName, args, types).asInstanceOf[R];
     };
 
@@ -61,8 +61,8 @@ class Code(clazz: java.lang.Class) {
     (_0: A0, _1: A1) => {
       val p0    = boxValue(_0);
       val p1    = boxValue(_1);
-      val args  = Predef.Array(p0._1, p1._1);
-      val types = Predef.Array(p0._2, p1._2);
+      val args  = Array(p0._1, p1._1);
+      val types = Array(p0._2, p1._2);
       applyFun(funName, args, types).asInstanceOf[R];
     };
 
@@ -71,8 +71,8 @@ class Code(clazz: java.lang.Class) {
       val p0    = boxValue(_0);
       val p1    = boxValue(_1);
       val p2    = boxValue(_2);
-      val args  = Predef.Array(p0._1, p1._1, p2._1);
-      val types = Predef.Array(p0._2, p1._2, p2._2);
+      val args  = Array(p0._1, p1._1, p2._1);
+      val types = Array(p0._2, p1._2, p2._2);
       applyFun(funName, args, types).asInstanceOf[R];
     };
 
@@ -82,8 +82,8 @@ class Code(clazz: java.lang.Class) {
       val p1    = boxValue(_1);
       val p2    = boxValue(_2);
       val p3    = boxValue(_3);
-      val args  = Predef.Array(p0._1, p1._1, p2._1, p3._1);
-      val types = Predef.Array(p0._2, p1._2, p2._2, p3._2);
+      val args  = Array(p0._1, p1._1, p2._1, p3._1);
+      val types = Array(p0._2, p1._2, p2._2, p3._2);
       applyFun(funName, args, types).asInstanceOf[R];
     };
 
@@ -94,8 +94,8 @@ class Code(clazz: java.lang.Class) {
       val p2    = boxValue(_2);
       val p3    = boxValue(_3);
       val p4    = boxValue(_4);
-      val args  = Predef.Array(p0._1, p1._1, p2._1, p3._1, p4._1);
-      val types = Predef.Array(p0._2, p1._2, p2._2, p3._2, p4._2);
+      val args  = Array(p0._1, p1._1, p2._1, p3._1, p4._1);
+      val types = Array(p0._2, p1._2, p2._2, p3._2, p4._2);
       applyFun(funName, args, types).asInstanceOf[R];
     };
 
@@ -107,8 +107,8 @@ class Code(clazz: java.lang.Class) {
       val p3    = boxValue(_3);
       val p4    = boxValue(_4);
       val p5    = boxValue(_5);
-      val args  = Predef.Array(p0._1, p1._1, p2._1, p3._1, p4._1, p5._1);
-      val types = Predef.Array(p0._2, p1._2, p2._2, p3._2, p4._2, p5._2);
+      val args  = Array(p0._1, p1._1, p2._1, p3._1, p4._1, p5._1);
+      val types = Array(p0._2, p1._2, p2._2, p3._2, p4._2, p5._2);
       applyFun(funName, args, types).asInstanceOf[R];
     };
 
@@ -121,8 +121,8 @@ class Code(clazz: java.lang.Class) {
       val p4    = boxValue(_4);
       val p5    = boxValue(_5);
       val p6    = boxValue(_6);
-      val args  = Predef.Array(p0._1, p1._1, p2._1, p3._1, p4._1, p5._1, p6._1);
-      val types = Predef.Array(p0._2, p1._2, p2._2, p3._2, p4._2, p5._2, p6._2);
+      val args  = Array(p0._1, p1._1, p2._1, p3._1, p4._1, p5._1, p6._1);
+      val types = Array(p0._2, p1._2, p2._2, p3._2, p4._2, p5._2, p6._2);
       applyFun(funName, args, types).asInstanceOf[R];
     };
 
@@ -136,8 +136,8 @@ class Code(clazz: java.lang.Class) {
       val p5    = boxValue(_5);
       val p6    = boxValue(_6);
       val p7    = boxValue(_7);
-      val args  = Predef.Array(p0._1, p1._1, p2._1, p3._1, p4._1, p5._1, p6._1, p7._1);
-      val types = Predef.Array(p0._2, p1._2, p2._2, p3._2, p4._2, p5._2, p6._2, p7._2);
+      val args  = Array(p0._1, p1._1, p2._1, p3._1, p4._1, p5._1, p6._1, p7._1);
+      val types = Array(p0._2, p1._2, p2._2, p3._2, p4._2, p5._2, p6._2, p7._2);
       applyFun(funName, args, types).asInstanceOf[R];
     };
 
@@ -152,8 +152,8 @@ class Code(clazz: java.lang.Class) {
       val p6    = boxValue(_6);
       val p7    = boxValue(_7);
       val p8    = boxValue(_8);
-      val args  = Predef.Array(p0._1, p1._1, p2._1, p3._1, p4._1, p5._1, p6._1, p7._1, p8._1);
-      val types = Predef.Array(p0._2, p1._2, p2._2, p3._2, p4._2, p5._2, p6._2, p7._2, p8._2);
+      val args  = Array(p0._1, p1._1, p2._1, p3._1, p4._1, p5._1, p6._1, p7._1, p8._1);
+      val types = Array(p0._2, p1._2, p2._2, p3._2, p4._2, p5._2, p6._2, p7._2, p8._2);
       applyFun(funName, args, types).asInstanceOf[R];
     };
 
@@ -194,7 +194,7 @@ class Code(clazz: java.lang.Class) {
             val cs = clazz.getConstructors();
 //Console.println("cs.length=" + cs.length);
             if (cs.length > 0) {
-              cs(0).newInstance(Predef.Array(""))
+              cs(0).newInstance(Array(""))
             } else {
               error("class " + clazz.getName() + " has no public constructor");
               null
diff --git a/src/library/scala/mobile/Location.scala b/src/library/scala/mobile/Location.scala
index 816edd9dcb..388cc2d415 100644
--- a/src/library/scala/mobile/Location.scala
+++ b/src/library/scala/mobile/Location.scala
@@ -48,7 +48,7 @@ class Location(url: URL) {
     case Some(cl) =>
       cl
     case _ =>
-      val cl = new URLClassLoader(Predef.Array(url));
+      val cl = new URLClassLoader(Array(url));
       lcache(url) = cl;
       cl
   };
diff --git a/src/library/scala/xml/Utility.scala b/src/library/scala/xml/Utility.scala
index dd3afc61a0..4bdb480483 100644
--- a/src/library/scala/xml/Utility.scala
+++ b/src/library/scala/xml/Utility.scala
@@ -316,7 +316,7 @@ object Utility extends AnyRef with parsing.TokenTests {
       }
       nextch();
     }
-    new String(Predef.Array(i.asInstanceOf[char]))
+    new String(Array(i.asInstanceOf[char]))
   }
 
 }