Add second field to SeqLiteral

The field keeps track of the element type. This is necessary
because JavaSeqLiteral is nonvariant and the elements might
be empty, so we cannot always compute the type from the
element types.

4 files changed, 20 insertions, 12 deletions

diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala
index 3b8c56ea6..3ad9902a4 100644
--- a/src/dotty/tools/dotc/typer/Applications.scala
+++ b/src/dotty/tools/dotc/typer/Applications.scala
@@ -442,7 +442,10 @@ trait Applications extends Compatibility { self: Typer =>
     def makeVarArg(n: Int, elemFormal: Type): Unit = {
       val args = typedArgBuf.takeRight(n).toList
       typedArgBuf.trimEnd(n)
-      val seqLit = if (methodType.isJava) JavaSeqLiteral(args) else SeqLiteral(args)
+      val elemtpt = TypeTree(elemFormal)
+      val seqLit =
+        if (methodType.isJava) JavaSeqLiteral(args, elemtpt)
+        else SeqLiteral(args, elemtpt)
       typedArgBuf += seqToRepeated(seqLit)
     }
 
@@ -771,7 +774,7 @@ trait Applications extends Compatibility { self: Typer =>
         for (argType <- argTypes) assert(!argType.isInstanceOf[TypeBounds], unapplyApp.tpe.show)
         val bunchedArgs = argTypes match {
           case argType :: Nil =>
-            if (argType.isRepeatedParam) untpd.SeqLiteral(args) :: Nil
+            if (argType.isRepeatedParam) untpd.SeqLiteral(args, untpd.TypeTree()) :: Nil
             else if (args.lengthCompare(1) > 0 && ctx.canAutoTuple) untpd.Tuple(args) :: Nil
             else args
           case _ => args
diff --git a/src/dotty/tools/dotc/typer/ReTyper.scala b/src/dotty/tools/dotc/typer/ReTyper.scala
index 49718fd00..225451886 100644
--- a/src/dotty/tools/dotc/typer/ReTyper.scala
+++ b/src/dotty/tools/dotc/typer/ReTyper.scala
@@ -92,7 +92,7 @@ class ReTyper extends Typer {
     try super.typedUnadapted(tree, pt)
     catch {
       case NonFatal(ex) =>
-        Printers.transforms.println(i"exception while typing $tree of class ${tree.getClass} # ${tree.uniqueId}")
+        println(i"exception while typing $tree of class ${tree.getClass} # ${tree.uniqueId}")
         throw ex
     }
 
diff --git a/src/dotty/tools/dotc/typer/TypeAssigner.scala b/src/dotty/tools/dotc/typer/TypeAssigner.scala
index 476839ab3..84951fd2b 100644
--- a/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -392,14 +392,12 @@ trait TypeAssigner {
     if (cases.isEmpty) tree.withType(expr.tpe)
     else tree.withType(ctx.typeComparer.lub(expr.tpe :: cases.tpes))
 
-  def assignType(tree: untpd.SeqLiteral, elems: List[Tree])(implicit ctx: Context) = tree match {
-    case tree: JavaSeqLiteral =>
-      tree.withType(defn.ArrayOf(ctx.typeComparer.lub(elems.tpes).widen))
-    case _ =>
-      val ownType =
-        if (ctx.erasedTypes) defn.SeqType
-        else defn.SeqType.appliedTo(ctx.typeComparer.lub(elems.tpes).widen)
-      tree.withType(ownType)
+  def assignType(tree: untpd.SeqLiteral, elems: List[Tree], elemtpt: Tree)(implicit ctx: Context) = {
+    val ownType = tree match {
+      case tree: JavaSeqLiteral => defn.ArrayOf(elemtpt.tpe)
+      case _ => if (ctx.erasedTypes) defn.SeqType else defn.SeqType.appliedTo(elemtpt.tpe)
+    }
+    tree.withType(ownType)
   }
 
   def assignType(tree: untpd.SingletonTypeTree, ref: Tree)(implicit ctx: Context) =
diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index fdb92a40b..2683b2364 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -836,7 +836,14 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(implicit ctx: Context): SeqLiteral = track("typedSeqLiteral") {
     val proto1 = pt.elemType orElse WildcardType
     val elems1 = tree.elems mapconserve (typed(_, proto1))
-    assignType(cpy.SeqLiteral(tree)(elems1), elems1)
+    val proto2 = // the computed type of the `elemtpt` field
+      if (!tree.elemtpt.isEmpty) WildcardType
+      else if (isFullyDefined(proto1, ForceDegree.none)) proto1
+      else if (tree.elems.isEmpty && tree.isInstanceOf[Trees.JavaSeqLiteral[_]]) 
+        defn.ObjectType // generic empty Java varargs are of type Object[]
+      else ctx.typeComparer.lub(elems1.tpes)
+    val elemtpt1 = typed(tree.elemtpt, proto2)
+    assignType(cpy.SeqLiteral(tree)(elems1, elemtpt1), elems1, elemtpt1)
   }
 
   def typedTypeTree(tree: untpd.TypeTree, pt: Type)(implicit ctx: Context): TypeTree = track("typedTypeTree") {