More tailrec in handling long seq

Author: som-snytt

src/reflect/scala/reflect/internal/Printers.scala

@@ -109,7 +109,8 @@ trait Printers extends api.Printers { self: SymbolTable =>
         out.write(indentString, 0, indentMargin)
     }
 
-    def printSeq[a](ls: List[a])(printelem: a => Unit)(printsep: => Unit): Unit =
+    @tailrec
+    final def printSeq[A](ls: List[A])(printelem: A => Unit)(printsep: => Unit): Unit =
       ls match {
         case List() =>
         case List(x) => printelem(x)

src/reflect/scala/reflect/internal/tpe/GlbLubs.scala

@@ -198,29 +198,34 @@ private[internal] trait GlbLubs {
 
   /** From a list of types, retain only maximal types as determined by the partial order `po`. */
   private def maxTypes(ts: List[Type])(po: (Type, Type) => Boolean): List[Type] = {
-    def loop(ts: List[Type]): List[Type] = ts match {
-      case t :: ts1 =>
-        val ts2 = loop(ts1.filterNot(po(_, t)))
-        if (ts2.exists(po(t, _))) ts2 else t :: ts2
-      case Nil => Nil
+    @tailrec
+    def loop(remaining: List[Type], hs: List[Type]): List[Type] = remaining match {
+      case h :: rest =>
+        loop(rest.filterNot(po(_, h)), h :: hs)
+      case _ =>
+        def sieve(res: List[Type], todo: List[Type]): List[Type] = todo match {
+          case h :: tail =>
+            val res1 = if (res.exists(po(h, _))) res else h :: res
+            sieve(res1, tail)
+          case _ => res
+        }
+        sieve(Nil, hs)
     }
 
     // The order here matters because type variables and
     // wildcards can act both as subtypes and supertypes.
-    val (ts2, ts1) = partitionConserve(ts) { tp =>
-      isWildCardOrNonGroundTypeVarCollector.collect(tp).isDefined
-    }
+    val (wilds, ts1) = partitionConserve(ts)(isWildCardOrNonGroundTypeVarCollector.collect(_).isDefined)
 
-    loop(ts1 ::: ts2)
+    loop(ts1 ::: wilds, Nil)
   }
 
   /** Eliminate from list of types all elements which are a supertype
-    *  of some other element of the list. */
+   *  of some other element of the list. */
   private def elimSuper(ts: List[Type]): List[Type] =
     maxTypes(ts)((t1, t2) => t2 <:< t1)
 
   /** Eliminate from list of types all elements which are a subtype
-    *  of some other element of the list. */
+   *  of some other element of the list. */
   @tailrec private def elimSub(ts: List[Type], depth: Depth): List[Type] = {
     val ts1 = maxTypes(ts)(isSubType(_, _, depth.decr))
     if (ts1.lengthCompare(1) <= 0) ts1 else {

test/files/run/t12757.scala

@@ -0,0 +1,16 @@
+
+import scala.tools.partest.DirectTest
+
+object Test extends DirectTest {
+  def header = """|object Test extends App {
+                  |  val myStrings: List[String] = List(""".stripMargin.linesIterator
+  def footer = """|  )
+                  |  println(myStrings.mkString(","))
+                  |}""".stripMargin.linesIterator
+  def values = Iterator.tabulate(4000)(i => s"    \"$i\",")
+  def code   = (header ++ values ++ footer).mkString("\n")
+
+  override def extraSettings: String = "-usejavacp -J-Xms256k"
+
+  def show() = assert(compile())
+}