1 files changed, 16 insertions, 14 deletions
diff --git a/src/dotty/tools/dotc/ast/Trees.scala b/src/dotty/tools/dotc/ast/Trees.scala
index 54ace3be4..5fbbad9a1 100644
--- a/src/dotty/tools/dotc/ast/Trees.scala
+++ b/src/dotty/tools/dotc/ast/Trees.scala
@@ -515,16 +515,18 @@ object Trees {
     type ThisTree[-T >: Untyped] = Try[T]
   }
 
-  /** Seq(elems) */
-  case class SeqLiteral[-T >: Untyped] private[ast] (elems: List[Tree[T]])
+  /** Seq(elems)
+   *  @param  tpt  The element type of the sequence.
+   */
+  case class SeqLiteral[-T >: Untyped] private[ast] (elems: List[Tree[T]], elemtpt: Tree[T])
     extends Tree[T] {
     type ThisTree[-T >: Untyped] = SeqLiteral[T]
   }
 
   /** Array(elems) */
-  class JavaSeqLiteral[T >: Untyped] private[ast] (elems: List[Tree[T]])
-    extends SeqLiteral(elems) {
-    override def toString = s"JavaSeqLiteral($elems)"
+  class JavaSeqLiteral[T >: Untyped] private[ast] (elems: List[Tree[T]], elemtpt: Tree[T])
+    extends SeqLiteral(elems, elemtpt) {
+    override def toString = s"JavaSeqLiteral($elems, $elemtpt)"
   }
 
   /** A type tree that represents an existing or inferred type */
@@ -974,12 +976,12 @@ object Trees {
         case tree: Try if (expr eq tree.expr) && (cases eq tree.cases) && (finalizer eq tree.finalizer) => tree
         case _ => finalize(tree, untpd.Try(expr, cases, finalizer))
       }
-      def SeqLiteral(tree: Tree)(elems: List[Tree])(implicit ctx: Context): SeqLiteral = tree match {
+      def SeqLiteral(tree: Tree)(elems: List[Tree], elemtpt: Tree)(implicit ctx: Context): SeqLiteral = tree match {
         case tree: JavaSeqLiteral =>
-          if (elems eq tree.elems) tree
-          else finalize(tree, new JavaSeqLiteral(elems))
-        case tree: SeqLiteral if elems eq tree.elems => tree
-        case _ => finalize(tree, untpd.SeqLiteral(elems))
+          if ((elems eq tree.elems) && (elemtpt eq tree.elemtpt)) tree
+          else finalize(tree, new JavaSeqLiteral(elems, elemtpt))
+        case tree: SeqLiteral if (elems eq tree.elems) && (elemtpt eq tree.elemtpt) => tree
+        case _ => finalize(tree, untpd.SeqLiteral(elems, elemtpt))
       }
       def TypeTree(tree: Tree)(original: Tree): TypeTree = tree match {
         case tree: TypeTree if original eq tree.original => tree
@@ -1125,8 +1127,8 @@ object Trees {
           cpy.Return(tree)(transform(expr), transformSub(from))
         case Try(block, cases, finalizer) =>
           cpy.Try(tree)(transform(block), transformSub(cases), transform(finalizer))
-        case SeqLiteral(elems) =>
-          cpy.SeqLiteral(tree)(transform(elems))
+        case SeqLiteral(elems, elemtpt) =>
+          cpy.SeqLiteral(tree)(transform(elems), transform(elemtpt))
         case TypeTree(original) =>
           tree
         case SingletonTypeTree(ref) =>
@@ -1229,8 +1231,8 @@ object Trees {
             this(this(x, expr), from)
           case Try(block, handler, finalizer) =>
             this(this(this(x, block), handler), finalizer)
-          case SeqLiteral(elems) =>
-            this(x, elems)
+          case SeqLiteral(elems, elemtpt) =>
+            this(this(x, elems), elemtpt)
           case TypeTree(original) =>
             x
           case SingletonTypeTree(ref) =>