Add sequence method via reflect.internal.Sequenceable implicit

scala · adriaanm · Aug 5, 2013 · Aug 5, 2013 · Aug 5, 2013 · Aug 6, 2013
commit c5084023e6ddb518c10c9f6fcea6dd70f6646f3f
diff --git a/bincompat-forward.whitelist.conf b/bincompat-forward.whitelist.conf
@@ -547,6 +547,10 @@ filter {
         {
             matchName="scala.reflect.internal.annotations.uncheckedBounds"
             problemName=MissingClassProblem
+        },
+        {
+            matchName="scala.reflect.internal.util.package$Sequenceable"
+            problemName=MissingClassProblem
         }
     ]
 }
diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala
@@ -12,6 +12,7 @@ import scala.collection.mutable
 import scala.reflect.internal.util.Statistics
 import scala.reflect.internal.util.Position
 import scala.reflect.internal.util.NoPosition
+import scala.reflect.internal.util.Sequenceable
 
 /** Optimize and analyze matches based on their TreeMaker-representation.
  *
@@ -240,9 +241,6 @@ trait MatchOptimization extends MatchTreeMaking with MatchAnalysis {
       def defaultBody: Tree
       def defaultCase(scrutSym: Symbol = defaultSym, guard: Tree = EmptyTree, body: Tree = defaultBody): CaseDef
 
-      private def sequence[T](xs: List[Option[T]]): Option[List[T]] =
-        if (xs exists (_.isEmpty)) None else Some(xs.flatten)
-
       object GuardAndBodyTreeMakers {
           def unapply(tms: List[TreeMaker]): Option[(Tree, Tree)] = {
             tms match {
@@ -451,7 +449,7 @@ trait MatchOptimization extends MatchTreeMaking with MatchAnalysis {
                 }
 
                 // succeed if they were all switchable
-                sequence(switchableAlts) map { switchableAlts =>
+                switchableAlts.sequence map { switchableAlts =>
                   def extractConst(t: Tree) = t match {
                     case Literal(const) => const
                     case _              => t
@@ -470,7 +468,7 @@ trait MatchOptimization extends MatchTreeMaking with MatchAnalysis {
             }
           }
 
-          val caseDefsWithGuards = sequence(caseDefs) match {
+          val caseDefsWithGuards = caseDefs.sequence match {
             case None      => return Nil
             case Some(cds) => cds
           }

diff --git a/src/reflect/scala/reflect/internal/util/package.scala b/src/reflect/scala/reflect/internal/util/package.scala
@@ -1,9 +1,25 @@
 package scala.reflect
 package internal
 
+import scala.collection.generic.GenericTraversableTemplate
+import scala.collection.GenTraversableOnce
+
 package object util {
-  /**
-   * Adds the `sm` String interpolator to a [[scala.StringContext]].
+  /** Adds the `sm` String interpolator to a [[scala.StringContext]].
    */
   implicit class StringContextStripMarginOps(val stringContext: StringContext) extends StripMarginInterpolator
+
+  /** Adds the `sequence` method to a traversable `xss` that has traversables as elements.
+   *  `xss.sequence` returns `None` if `xss` contains an empty traversable,
+   *  or else `Some(xss.flatten)`.
+   */
+  implicit class Sequenceable[CC[X] <: Traversable[X] with GenericTraversableTemplate[X, CC], A](xss: CC[A]) {
+    def sequence[B](implicit asTraversable: A => GenTraversableOnce[B]): Option[CC[B]] = {
+      val b = xss.genericBuilder[B]
+      for (xs <- xss)
+        if (xs.isEmpty) return None
+        else b ++= asTraversable(xs).seq
+      Some(b.result)
+    }
+  }
 }