Include the type when emitting Array.apply calls

This prevents Array[Nothing] being inferred when called without arguments.

Author: Alexey Romanov

src/common/ArrayOps.scala

@@ -206,6 +206,7 @@ trait ScalaGenArrayOps extends BaseGenArrayOps with ScalaGenBase {
   override def emitNode(sym: Sym[Any], rhs: Def[Any]) = rhs match {
     case a@ArrayNew(n) => emitValDef(sym, src"new Array[${remap(a.m)}]($n)")
     case e@ArrayFromSeq(xs) => {
+      val m = e.m
       emitData(sym, xs)
       emitValDef(sym,
         if(xs.size > ARRAY_LITERAL_MAX_SIZE) {
@@ -217,10 +218,15 @@ trait ScalaGenArrayOps extends BaseGenArrayOps with ScalaGenBase {
           }
           val numBlocks = Math.ceil(xs.size / ARRAY_LITERAL_MAX_SIZE).intValue
           "{val buf=new Array[" + remap(e.mt) + "](" + xs.size + ")\n" + ((0 until numBlocks).map(append)).mkString("\n") + "buf}" */
-          "{import scala.io.Source;(Source.fromFile(\"" + symDataPath(sym) + "\").getLines.map{Integer.parseInt(_)}).toArray}"
-        }
-        else {
-          "Array(" + (xs map quote).mkString(",") + ")"
+          val parseMethod = m.asInstanceOf[Manifest[_]] match {
+            case Manifest.Int => "Integer.parseInt"
+            case Manifest.Long | Manifest.Float | Manifest.Double => s"java.lang.$m.parse$m"
+            case _ if m == manifest[String] => "x => x"
+            case _ => throw new GenerationFailedException(s"Can't store an array of type $m in a file")
+          }
+          s"""scala.io.Source.fromFile("${symDataPath(sym)}").getLines.map($parseMethod).toArray"""
+        } else {
+          src"Array[$m]($xs)"
         }
       )
     }

test-out/epfl/test12-array-seq-creation.check

@@ -3,7 +3,7 @@
 *******************************************/
 class IntArrayCreation extends ((Int)=>(Unit)) {
 def apply(x0:Int): Unit = {
-val x1 = Array(1,2,3)
+val x1 = Array[Int](1,2,3)
 val x2 = x1(0)
 val x3 = println(x2)
 x3
@@ -17,7 +17,7 @@ x3
 *******************************************/
 class CharArrayCreation extends ((Int)=>(Unit)) {
 def apply(x5:Int): Unit = {
-val x6 = Array('a','b','c')
+val x6 = Array[Char]('a','b','c')
 val x7 = x6(0)
 val x8 = println(x7)
 x8

test-out/epfl/test2-fft3.check

@@ -27,7 +27,7 @@ val x15 = x3-x7
 val x24 = x12-x15
 val x25 = x11-x16
 val x26 = x12+x15
-val x27 = Array(x17,x18,x23,x24,x19,x20,x25,x26)
+val x27 = Array[Double](x17,x18,x23,x24,x19,x20,x25,x26)
 x27
 }
 }

test-src/epfl/test1-arith/Arrays.scala

@@ -22,7 +22,7 @@ trait Arrays extends Base {
 trait ArraysExp extends Arrays with BaseExp {
   case class ArrayApply[T:Manifest](x:Rep[Array[T]], i:Int) extends Def[T]
   //case class ArrayUpdate[T](x:Rep[Array[T]], i:Int) extends Def[T]
-  case class MakeArray[T:Manifest](x:List[Rep[T]]) extends Def[Array[T]]
+  case class MakeArray[T](x:List[Rep[T]])(implicit val m: Manifest[T]) extends Def[Array[T]]
 
   def arrayApply[T:Manifest](x: Rep[Array[T]], i:Int) = ArrayApply(x, i)
   //def arrayUpdate(x: Rep[Double]) = ArrayUpdate(x)
@@ -34,8 +34,8 @@ trait ScalaGenArrays extends ScalaGenBase {
   import IR._
 
   override def emitNode(sym: Sym[Any], rhs: Def[Any]) = rhs match {
-    case ArrayApply(x,i) =>  emitValDef(sym, "" + quote(x) + ".apply(" + i + ")")
-    case MakeArray(x) =>  emitValDef(sym, "Array(" + x.map(quote).mkString(",") + ")")
+    case ArrayApply(x,i) => emitValDef(sym, src"$x.apply(${i.toString})")
+    case a @ MakeArray(x) => emitValDef(sym, src"Array[${a.m}]($x)")
     case _ => super.emitNode(sym, rhs)
   }
 }