Merge pull request #317 from dotty-staging/fix/java-varargs

Fix/java varargs

Author: DarkDimius

src/dotty/runtime/Arrays.scala

@@ -2,7 +2,7 @@ package dotty.runtime
 
 import scala.reflect.ClassTag
 
-/** All but the first operation should be short-circuited and implemented specially by
+/** All but the first two operations should be short-circuited and implemented specially by
  *  the backend.
  */
 object Arrays {
@@ -12,7 +12,14 @@ object Arrays {
    */
   def newGenericArray[T](length: Int)(implicit tag: ClassTag[T]): Array[T] =
     tag.newArray(length)
-
+  
+  /** Convert a sequence to a Java array with element type given by `clazz`. */
+  def seqToArray[T](xs: Seq[T], clazz: Class[_]): Array[T] = {
+    val arr = java.lang.reflect.Array.newInstance(clazz, xs.length).asInstanceOf[Array[T]]
+    xs.copyToArray(arr)
+    arr
+  }
+  
   /** Create an array of type T. T must be of form Array[E], with
    *  E being a reference type.
    */

src/dotty/tools/dotc/core/StdNames.scala

@@ -468,6 +468,7 @@ object StdNames {
     val selectTerm: N           = "selectTerm"
     val selectType: N           = "selectType"
     val self: N                 = "self"
+    val seqToArray: N           = "seqToArray"
     val setAccessible: N        = "setAccessible"
     val setAnnotations: N       = "setAnnotations"
     val setSymbol: N            = "setSymbol"

src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -368,7 +368,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   def toText(const: Constant): Text = const.tag match {
     case StringTag => "\"" + escapedString(const.value.toString) + "\""
-    case ClazzTag => "classOf[" ~ toText(const.tpe) ~ "]"
+    case ClazzTag => "classOf[" ~ toText(const.tpe.firstBaseArgInfo(defn.ClassClass)) ~ "]"
     case CharTag => s"'${escapedChar(const.charValue)}'"
     case LongTag => const.longValue.toString + "L"
     case EnumTag => const.symbolValue.name.toString

src/dotty/tools/dotc/transform/ElimRepeated.scala

@@ -3,12 +3,14 @@ package transform
 
 import core._
 import Names._
+import StdNames.nme
 import Types._
 import dotty.tools.dotc.transform.TreeTransforms.{AnnotationTransformer, TransformerInfo, MiniPhaseTransform, TreeTransformer}
-import ast.Trees.flatten
+import ast.Trees._
 import Flags._
 import Contexts.Context
 import Symbols._
+import Constants._
 import Denotations._, SymDenotations._
 import Decorators.StringInterpolators
 import dotty.tools.dotc.ast.tpd
@@ -56,9 +58,33 @@ class ElimRepeated extends MiniPhaseTransform with InfoTransformer with Annotati
   override def transformSelect(tree: Select)(implicit ctx: Context, info: TransformerInfo): Tree =
     transformTypeOfTree(tree)
 
-  override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree =
-    transformTypeOfTree(tree) // should also transform the tree if argument needs adaptation
+  override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    val args1 = tree.args.map { 
+      case arg: Typed if isWildcardStarArg(arg) =>
+        if (tree.fun.symbol.is(JavaDefined) && arg.expr.tpe.derivesFrom(defn.SeqClass)) 
+          seqToArray(arg.expr)
+        else arg.expr
+      case arg => arg
+    }
+    transformTypeOfTree(cpy.Apply(tree)(tree.fun, args1))
+  }
 
+  /** Convert sequence argument to Java array */
+  private def seqToArray(tree: Tree)(implicit ctx: Context): Tree = tree match {
+    case SeqLiteral(elems) => 
+      JavaSeqLiteral(elems)
+    case _ =>
+      val elemType = tree.tpe.firstBaseArgInfo(defn.SeqClass)
+      var elemClass = elemType.classSymbol
+      if (defn.PhantomClasses contains elemClass) elemClass = defn.ObjectClass
+      ref(defn.DottyArraysModule)
+        .select(nme.seqToArray)
+        .appliedToType(elemType)
+        .appliedTo(tree, Literal(Constant(elemClass.typeRef)))
+        .ensureConforms(defn.ArrayType(elemType))
+          // Because of phantomclasses, the Java array's type might not conform to the resturn type
+  }
+  
   override def transformTypeApply(tree: TypeApply)(implicit ctx: Context, info: TransformerInfo): Tree =
     transformTypeOfTree(tree)
 

src/dotty/tools/dotc/typer/Namer.scala

@@ -656,6 +656,7 @@ class Namer { typer: Typer =>
         (paramSymss :\ restpe1) { (params, restpe) =>
           val make =
             if (params.nonEmpty && (params.head is Implicit)) ImplicitMethodType
+            else if (ddef.mods.is(JavaDefined)) JavaMethodType
             else MethodType
           make.fromSymbols(params, restpe)
         }

tests/pending/pos/arrays2.scala

@@ -0,0 +1,30 @@
+case class C();
+
+object arrays2 {
+
+  def main(args: Array[String]): Unit = {
+    val a: Array[Array[C]] = new Array[Array[C]](2);
+    a(0) = new Array[C](2);
+    a(0)(0) = new C();
+  }
+}
+
+// #2422
+object arrays4 {
+  val args = Array[String]("World")
+  "Hello %1$s".format(args: _*)
+}
+
+// #2461
+object arrays3 {
+  import scala.collection.JavaConversions._
+  def apply[X](xs : X*) : java.util.List[X] = java.util.Arrays.asList(xs: _*)
+
+  def apply1[X <: String](xs : X*) : java.util.List[X] = java.util.Arrays.asList(xs: _*)
+  def apply2[X <: AnyVal](xs : X*) : java.util.List[X] = java.util.Arrays.asList(xs: _*)
+  def apply3(xs : Int*) : java.util.List[Int] = java.util.Arrays.asList(xs: _*)
+  def apply4(xs : Unit*) : java.util.List[Unit] = java.util.Arrays.asList(xs: _*)
+  def apply5(xs : Null*) : java.util.List[Null] = java.util.Arrays.asList(xs: _*)
+  def apply6(xs : Nothing*) : java.util.List[Nothing] = java.util.Arrays.asList(xs: _*)
+}
+