Merge pull request #141 from dotty-staging/transform/repeated

Transform/repeated

Author: odersky

src/dotty/tools/dotc/Compiler.scala

@@ -19,8 +19,10 @@ class Compiler {
   def phases: List[List[Phase]] =
     List(
       List(new FrontEnd),
-      List(new Companions, new ElimRepeated /*, new ElimLocals*/),
+      List(new Companions),
       List(new SuperAccessors),
+      // pickling and refchecks goes here
+      List(new ElimRepeated/*, new ElimLocals*/),
       List(new ExtensionMethods),
       List(new TailRec),
       List(new PatternMatcher,

src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -175,7 +175,6 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
   def isRepeatedParamType(tpt: Tree)(implicit ctx: Context) = tpt match {
     case tpt: TypeTree => tpt.typeOpt.isRepeatedParam
     case AppliedTypeTree(Select(_, tpnme.REPEATED_PARAM_CLASS), _)      => true
-    case AppliedTypeTree(Select(_, tpnme.JAVA_REPEATED_PARAM_CLASS), _) => true
     case _                                                              => false
   }
 

src/dotty/tools/dotc/ast/tpd.scala

@@ -256,7 +256,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def ref(tp: NamedType)(implicit ctx: Context): NameTree =
     if (tp.symbol.isStatic || tp.prefix == NoPrefix) Ident(tp)
     else tp.prefix match {
-      case pre: TermRef => ref(pre).select(tp)
+      case pre: SingletonType => singleton(pre).select(tp)
       case pre => SelectFromTypeTree(TypeTree(pre), tp)
     } // no checks necessary
 

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

@@ -235,7 +235,6 @@ class Definitions {
   lazy val EqualsPatternClass     = specialPolyClass(tpnme.EQUALS_PATTERN, EmptyFlags, AnyType)
 
   lazy val RepeatedParamClass     = specialPolyClass(tpnme.REPEATED_PARAM_CLASS, Covariant, SeqType)
-  lazy val JavaRepeatedParamClass = specialPolyClass(tpnme.JAVA_REPEATED_PARAM_CLASS, Covariant, ArrayClass.typeRef)
 
   // fundamental classes
   lazy val StringClass                  = ctx.requiredClass("java.lang.String")
@@ -327,7 +326,6 @@ class Definitions {
   def PairType: Type = PairClass.typeRef
   def StringType: Type = StringClass.typeRef
   def RepeatedParamType = RepeatedParamClass.typeRef
-  def JavaRepeatedParamType = JavaRepeatedParamClass.typeRef
   def ThrowableType = ThrowableClass.typeRef
   def OptionType = OptionClass.typeRef
   def VolatileAnnotType = VolatileAnnot.typeRef
@@ -396,8 +394,6 @@ class Definitions {
   lazy val TupleClasses: Set[Symbol] = TupleClass.toSet
   lazy val ProductClasses: Set[Symbol] = ProductNClass.toSet
 
-  lazy val RepeatedParamClasses: Set[Symbol] = Set(RepeatedParamClass, JavaRepeatedParamClass)
-
   /** `Modules whose members are in the default namespace and their module classes */
   lazy val UnqualifiedOwners = RootImports.toSet ++ RootImports.map(_.moduleClass)
 
@@ -554,7 +550,6 @@ class Definitions {
     AnyClass,
     AnyRefAlias,
     RepeatedParamClass,
-    JavaRepeatedParamClass,
     ByNameParamClass2x,
     AnyValClass,
     NullClass,

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

@@ -160,7 +160,6 @@ object StdNames {
 
     final val BYNAME_PARAM_CLASS: N             = "<byname>"
     final val EQUALS_PATTERN: N                 = "<equals>"
-    final val JAVA_REPEATED_PARAM_CLASS: N      = "<repeated...>"
     final val LOCAL_CHILD: N                    = "<local child>"
     final val REPEATED_PARAM_CLASS: N           = "<repeated>"
     final val WILDCARD_STAR: N                  = "_*"

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

@@ -284,6 +284,13 @@ class TypeApplications(val self: Type) extends AnyVal {
         to.typeRef
     else self
 
+  /** If this is repeated parameter type, its underlying Seq type,
+   *  or, if isJava is true, Array type, else the type itself.
+   */
+  def underlyingIfRepeated(isJava: Boolean)(implicit ctx: Context): Type =
+    if (self.isRepeatedParam) translateParameterized(defn.RepeatedParamClass, defn.SeqClass)
+    else self
+
   /** If this is an encoding of a (partially) applied type, return its arguments,
    *  otherwise return Nil.
    *  Existential types in arguments are returned as TypeBounds instances.

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

@@ -156,7 +156,16 @@ object Types {
 
     /** Is this a type of a repeated parameter? */
     def isRepeatedParam(implicit ctx: Context): Boolean =
-      defn.RepeatedParamClasses contains typeSymbol
+      typeSymbol eq defn.RepeatedParamClass
+
+    /** Is this the type of a method that has a repeated parameter type as
+     *  last parameter type?
+     */
+    def isVarArgsMethod(implicit ctx: Context): Boolean = this match {
+      case tp: PolyType => tp.resultType.isVarArgsMethod
+      case MethodType(_, paramTypes) => paramTypes.nonEmpty && paramTypes.last.isRepeatedParam
+      case _ => false
+    }
 
     /** Is this an alias TypeBounds? */
     def isAlias: Boolean = this match {
@@ -622,16 +631,6 @@ object Types {
     final def objToAny(implicit ctx: Context) =
       if ((this isRef defn.ObjectClass) && !ctx.phase.erasedTypes) defn.AnyType else this
 
-    /** If this is repeated parameter type, its underlying Seq type,
-     *  else the type itself.
-     */
-    def underlyingIfRepeated(implicit ctx: Context): Type = this match {
-      case rt @ RefinedType(tref: TypeRef, name) if defn.RepeatedParamClasses contains tref.symbol =>
-        RefinedType(defn.SeqClass.typeRef, name, rt.refinedInfo)
-      case _ =>
-        this
-    }
-
     /** If this is a (possibly aliased, annotated, and/or parameterized) reference to
      *  a class, the class type ref, otherwise NoType.
      */
@@ -867,7 +866,7 @@ object Types {
      */
     def toFunctionType(implicit ctx: Context): Type = this match {
       case mt @ MethodType(_, formals) if !mt.isDependent =>
-        defn.FunctionType(formals mapConserve (_.underlyingIfRepeated), mt.resultType)
+        defn.FunctionType(formals mapConserve (_.underlyingIfRepeated(mt.isJava)), mt.resultType)
     }
 
     /** The signature of this type. This is by default NotAMethod,

src/dotty/tools/dotc/core/pickling/UnPickler.scala

@@ -70,7 +70,7 @@ object UnPickler {
   }
 
   /** Convert array parameters denoting a repeated parameter of a Java method
-   *  to `JavaRepeatedParamClass` types.
+   *  to `RepeatedParamClass` types.
    */
   def arrayToRepeated(tp: Type)(implicit ctx: Context): Type = tp match {
     case tp @ MethodType(paramNames, paramTypes) =>
@@ -85,7 +85,7 @@ object UnPickler {
       }
       tp.derivedMethodType(
         paramNames,
-        paramTypes.init :+ defn.JavaRepeatedParamType.appliedTo(elemtp),
+        paramTypes.init :+ defn.RepeatedParamType.appliedTo(elemtp),
         tp.resultType)
     case tp @ PolyType(paramNames) =>
       tp.derivedPolyType(paramNames, tp.paramBounds, arrayToRepeated(tp.resultType))

src/dotty/tools/dotc/core/transform/Erasure.scala

@@ -46,8 +46,12 @@ object Erasure {
 
   def erasure(tp: Type)(implicit ctx: Context): Type = scalaErasureFn(tp)
   def semiErasure(tp: Type)(implicit ctx: Context): Type = semiErasureFn(tp)
-  def sigName(tp: Type, isJava: Boolean)(implicit ctx: Context): TypeName =
-    (if (isJava) javaSigFn else scalaSigFn).sigName(tp)
+  def sigName(tp: Type, isJava: Boolean)(implicit ctx: Context): TypeName = {
+    val normTp =
+      if (tp.isRepeatedParam) tp.translateParameterized(defn.RepeatedParamClass, defn.SeqClass)
+      else tp
+    (if (isJava) javaSigFn else scalaSigFn).sigName(normTp)
+  }
 
   /**  The symbol's erased info. This is the type's erasure, except for the following symbols:
    *

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

@@ -32,10 +32,8 @@ class ElimRepeated extends TreeTransform with InfoTransformer { thisTransformer
     case tp @ MethodType(paramNames, paramTypes) =>
       val resultType1 = elimRepeated(tp.resultType)
       val paramTypes1 =
-        if (paramTypes.nonEmpty && paramTypes.last.isRepeatedParam) {
-          paramTypes.init :+
-            paramTypes.last.translateParameterized(defn.RepeatedParamClass, defn.SeqClass)
-        }
+        if (paramTypes.nonEmpty && paramTypes.last.isRepeatedParam)
+          paramTypes.init :+ paramTypes.last.underlyingIfRepeated(tp.isJava)
         else paramTypes
       tp.derivedMethodType(paramNames, paramTypes1, resultType1)
     case tp: PolyType =>
@@ -58,4 +56,48 @@ class ElimRepeated extends TreeTransform with InfoTransformer { thisTransformer
 
   override def transformTypeApply(tree: TypeApply)(implicit ctx: Context, info: TransformerInfo): Tree =
     transformTypeOfTree(tree)
+
+  /** If method overrides a Java varargs method, add a varargs bridge.
+   */
+  override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    assert(ctx.phase == thisTransformer)
+    def overridesJava = tree.symbol.allOverriddenSymbols.exists(_ is JavaDefined)
+    if (tree.symbol.info.isVarArgsMethod && overridesJava)
+      addVarArgsBridge(tree)(ctx.withPhase(thisTransformer.next))
+    else
+      tree
+  }
+
+  /** Add a Java varargs bridge
+   *  @param  ddef  the original method definition which is assumed to override
+   *                a Java varargs method JM up to this phase.
+   *  @return  a thicket consisting of `ddef` and a varargs bridge method
+   *           which overrides the Java varargs method JM from this phase on
+   *           and forwards to `ddef`.
+   */
+  private def addVarArgsBridge(ddef: DefDef)(implicit ctx: Context): Tree = {
+    val original = ddef.symbol.asTerm
+    val bridge = original.copy(
+      flags = ddef.symbol.flags &~ Private | Artifact,
+      info = toJavaVarArgs(ddef.symbol.info)).enteredAfter(thisTransformer).asTerm
+    val bridgeDef = polyDefDef(bridge, trefs => vrefss => {
+      val (vrefs :+ varArgRef) :: vrefss1 = vrefss
+      val elemtp = varArgRef.tpe.widen.argTypes.head
+      ref(original.termRef)
+        .appliedToTypes(trefs)
+        .appliedToArgs(vrefs :+ TreeGen.wrapArray(varArgRef, elemtp))
+        .appliedToArgss(vrefss1)
+    })
+    Thicket(ddef, bridgeDef)
+  }
+
+  /** Convert type from Scala to Java varargs method */
+  private def toJavaVarArgs(tp: Type)(implicit ctx: Context): Type = tp match {
+    case tp: PolyType =>
+      tp.derivedPolyType(tp.paramNames, tp.paramBounds, toJavaVarArgs(tp.resultType))
+    case tp: MethodType =>
+      val inits :+ last = tp.paramTypes
+      val last1 = last.underlyingIfRepeated(isJava = true)
+      tp.derivedMethodType(tp.paramNames, inits :+ last1, tp.resultType)
+  }
 }

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

@@ -23,6 +23,7 @@ import ast.Trees._
 import scala.collection.mutable.ListBuffer
 import dotty.tools.dotc.core.Flags
 import ValueClasses._
+import TypeUtils._
 
 class Erasure extends Phase with DenotTransformer {
 
@@ -83,7 +84,6 @@ object Erasure {
     }
 
     def isErasedValueType(tpe: Type)(implicit ctx: Context): Boolean = tpe.isInstanceOf[ErasedValueType]
-    def isPrimitiveValueType(tpe: Type)(implicit ctx: Context): Boolean = tpe.classSymbol.isPrimitiveValueClass
 
     def constant(tree: Tree, const: Tree)(implicit ctx: Context) =
       if (isPureExpr(tree)) Block(tree :: Nil, const) else const
@@ -112,7 +112,7 @@ object Erasure {
       pt match {
         case ErasedValueType(clazz, underlying) =>
           val tree1 =
-            if ((tree.tpe isRef defn.NullClass) && isPrimitiveValueType(underlying))
+            if ((tree.tpe isRef defn.NullClass) && underlying.isPrimitiveValueType)
               // convert `null` directly to underlying type, as going
               // via the unboxed type would yield a NPE (see SI-5866)
               unbox(tree, underlying)
@@ -137,7 +137,7 @@ object Erasure {
       if (pt isRef defn.UnitClass) unbox(tree, pt)
       else (tree.tpe, pt) match {
         case (defn.ArrayType(treeElem), defn.ArrayType(ptElem))
-        if isPrimitiveValueType(treeElem.widen) && !isPrimitiveValueType(ptElem) =>
+        if treeElem.widen.isPrimitiveValueType && !ptElem.isPrimitiveValueType =>
           // See SI-2386 for one example of when this might be necessary.
           cast(runtimeCall(nme.toObjectArray, tree :: Nil), pt)
         case _ =>
@@ -157,13 +157,13 @@ object Erasure {
     def adaptToType(tree: Tree, pt: Type)(implicit ctx: Context): Tree =
       if (tree.tpe <:< pt)
         tree
-      else if (isErasedValueType(tree.tpe.widen))
+      else if (tree.tpe.widen.isErasedValueType)
         adaptToType(box(tree), pt)
-      else if (isErasedValueType(pt))
+      else if (pt.isErasedValueType)
         adaptToType(unbox(tree, pt), pt)
-      else if (isPrimitiveValueType(tree.tpe.widen) && !isPrimitiveValueType(pt))
+      else if (tree.tpe.widen.isPrimitiveValueType && !pt.isPrimitiveValueType)
         adaptToType(box(tree), pt)
-      else if (isPrimitiveValueType(pt) && !isPrimitiveValueType(tree.tpe.widen))
+      else if (pt.isPrimitiveValueType && !tree.tpe.widen.isPrimitiveValueType)
         adaptToType(unbox(tree, pt), pt)
       else
         cast(tree, pt)
@@ -211,11 +211,11 @@ object Erasure {
         else recur(cast(qual, erasedPre))
 
       def recur(qual: Tree): Tree = {
-        val qualIsPrimitive = isPrimitiveValueType(qual.tpe.widen)
+        val qualIsPrimitive = qual.tpe.widen.isPrimitiveValueType
         val symIsPrimitive = sym.owner.isPrimitiveValueClass
         if ((sym.owner eq defn.AnyClass) || (sym.owner eq defn.AnyValClass))
           select(qual, defn.ObjectClass.info.decl(sym.name).symbol)
-        else if (qualIsPrimitive && !symIsPrimitive || isErasedValueType(qual.tpe))
+        else if (qualIsPrimitive && !symIsPrimitive || qual.tpe.isErasedValueType)
           recur(box(qual))
         else if (!qualIsPrimitive && symIsPrimitive)
           recur(unbox(qual, sym.owner.typeRef))

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

@@ -0,0 +1,26 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Symbols._, Contexts._, Types._, Names._, StdNames._
+import ast._
+import Trees._
+import TypeUtils._
+
+object TreeGen {
+
+  import tpd._
+
+  def wrapArrayMethodName(elemtp: Type)(implicit ctx: Context): TermName = {
+    val elemCls = elemtp.classSymbol
+    if (elemCls.isPrimitiveValueClass) nme.wrapXArray(elemCls.name)
+    else if (elemCls.derivesFrom(defn.ObjectClass) && !elemCls.isPhantomClass) nme.wrapRefArray
+    else nme.genericWrapArray
+  }
+
+  def wrapArray(tree: Tree, elemtp: Type)(implicit ctx: Context): Tree =
+    ref(defn.ScalaPredefModule)
+      .select(wrapArrayMethodName(elemtp))
+      .appliedToTypes(if (elemtp.isPrimitiveValueType) Nil else elemtp :: Nil)
+      .appliedTo(tree)
+}

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

@@ -1,9 +1,15 @@
 package dotty.tools.dotc
 package transform
 
-import dotty.tools.dotc.core.Types._
-
-import scala.language.implicitConversions
+import core._
+import core.transform.Erasure.ErasedValueType
+import Types._
+import Contexts._
+import Symbols._
+import Decorators._
+import StdNames.nme
+import NameOps._
+import language.implicitConversions
 
 object TypeUtils {
   implicit def decorateTypeUtils(tpe: Type): TypeUtils = new TypeUtils(tpe)
@@ -15,4 +21,10 @@ object TypeUtils {
  */
 class TypeUtils(val self: Type) extends AnyVal {
 
-}
+  def isErasedValueType(implicit ctx: Context): Boolean =
+    self.isInstanceOf[ErasedValueType]
+
+  def isPrimitiveValueType(implicit ctx: Context): Boolean =
+    self.classSymbol.isPrimitiveValueClass
+
+ }

tests/disabled/java-interop/pos/varargs-bridge/A.java

@@ -0,0 +1,8 @@
+package test;
+public class A {
+
+    int foo(int... x) {
+        return x.length;
+    }
+
+}

tests/disabled/java-interop/pos/varargs-bridge/B.scala

@@ -0,0 +1,7 @@
+package test
+class B extends A {
+  override def foo(x: Int*): Int = x.length + 1
+}
+object B extends App {
+  println(new B().foo(1, 2, 3))
+}