Implement spreads in the middle of pattern sequences

Author: odersky

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

@@ -570,11 +570,12 @@ class Definitions {
     @tu lazy val Seq_apply        : Symbol = SeqClass.requiredMethod(nme.apply)
     @tu lazy val Seq_head         : Symbol = SeqClass.requiredMethod(nme.head)
     @tu lazy val Seq_drop         : Symbol = SeqClass.requiredMethod(nme.drop)
+    @tu lazy val Seq_dropRight    : Symbol = SeqClass.requiredMethod(nme.dropRight)
+    @tu lazy val Seq_takeRight    : Symbol = SeqClass.requiredMethod(nme.takeRight)
     @tu lazy val Seq_lengthCompare: Symbol = SeqClass.requiredMethod(nme.lengthCompare, List(IntType))
     @tu lazy val Seq_length       : Symbol = SeqClass.requiredMethod(nme.length)
     @tu lazy val Seq_toSeq        : Symbol = SeqClass.requiredMethod(nme.toSeq)
 
-
   @tu lazy val StringOps: Symbol = requiredClass("scala.collection.StringOps")
     @tu lazy val StringOps_format: Symbol  = StringOps.requiredMethod(nme.format)
 

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

@@ -470,6 +470,7 @@ object StdNames {
     val doubleHash: N           = "doubleHash"
     val dotty: N                = "dotty"
     val drop: N                 = "drop"
+    val dropRight: N            = "dropRight"
     val dynamics: N             = "dynamics"
     val elem: N                 = "elem"
     val elems: N                = "elems"
@@ -802,6 +803,7 @@ object StdNames {
     val takeModulo: N             = "takeModulo"
     val takeNot: N                = "takeNot"
     val takeOr: N                 = "takeOr"
+    val takeRight: N              = "takeRight"
     val takeXor: N                = "takeXor"
     val testEqual: N              = "testEqual"
     val testGreaterOrEqualThan: N = "testGreaterOrEqualThan"

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3352,7 +3352,9 @@ object Parsers {
       if (in.token == RPAREN) Nil else patterns(location)
 
     /** ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’
-     *                      |  ‘(’ [Patterns ‘,’] PatVar ‘*’ ‘)’
+     *                      |  ‘(’ [Patterns ‘,’] PatVar ‘*’ [‘,’ Patterns] ‘)’
+     *
+     *  -- It is checked in Typer that there are no repeated PatVar arguments.
      */
     def argumentPatterns(): List[Tree] =
       inParensWithCommas(patternsOpt(Location.InPatternArgs))

compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -299,30 +299,57 @@ object PatternMatcher {
       }
 
       /** Plan for matching the sequence in `getResult` against sequence elements
-       *  and a possible last varargs argument `args`.
+       *  `args`. Sequence elements may contain a varargs argument.
+       *  Example:
+       *
+       *    lst match case Seq(1, xs*, 2, 3) => ...
+       *
+       *  generates code which is equivalent to:
+       *
+       *    if lst != null then
+       *      if lst.lengthCompare >= 1 then
+       *        if lst(0) == 1 then
+       *          val x1 = lst.drop(1)
+       *          val xs = x1.dropRight(2)
+       *          val x2 = lst.takeRight(2)
+       *          if x2.lengthCompare >= 2 then
+       *            if x2(0) == 2 then
+       *              if x2(1) == 3 then
+       *                return[matchResult] ...
        */
-      def unapplySeqPlan(getResult: Symbol, args: List[Tree]): Plan = args.lastOption match {
-        case Some(VarArgPattern(arg)) =>
-          val matchRemaining =
-            if (args.length == 1) {
-              val toSeq = ref(getResult)
-                .select(defn.Seq_toSeq.matchingMember(getResult.info))
-              letAbstract(toSeq) { toSeqResult =>
-                patternPlan(toSeqResult, arg, onSuccess)
-              }
-            }
-            else {
-              val dropped = ref(getResult)
-                .select(defn.Seq_drop.matchingMember(getResult.info))
-                .appliedTo(Literal(Constant(args.length - 1)))
-              letAbstract(dropped) { droppedResult =>
-                patternPlan(droppedResult, arg, onSuccess)
-              }
-            }
-          matchElemsPlan(getResult, args.init, exact = false, matchRemaining)
-        case _ =>
-          matchElemsPlan(getResult, args, exact = true, onSuccess)
-      }
+      def unapplySeqPlan(getResult: Symbol, args: List[Tree]): Plan =
+        val (leading, varargAndRest) = args.span:
+          case VarArgPattern(_) => false
+          case _ => true
+        varargAndRest match
+          case VarArgPattern(arg) :: trailing =>
+            val remaining =
+              if leading.isEmpty then
+                ref(getResult)
+                  .select(defn.Seq_toSeq.matchingMember(getResult.info))
+              else
+                ref(getResult)
+                  .select(defn.Seq_drop.matchingMember(getResult.info))
+                  .appliedTo(Literal(Constant(leading.length)))
+            val matchRemaining =
+              letAbstract(remaining): remainingResult =>
+                if trailing.isEmpty then
+                  patternPlan(remainingResult, arg, onSuccess)
+                else
+                  val seq = ref(remainingResult)
+                    .select(defn.Seq_dropRight.matchingMember(remainingResult.info))
+                    .appliedTo(Literal(Constant(trailing.length)))
+                  letAbstract(seq): seqResult =>
+                    val rest = ref(remainingResult)
+                      .select(defn.Seq_takeRight.matchingMember(remainingResult.info))
+                      .appliedTo(Literal(Constant(trailing.length)))
+                    val matchTrailing =
+                      letAbstract(rest): trailingResult =>
+                        matchElemsPlan(trailingResult, trailing, exact = true, onSuccess)
+                    patternPlan(seqResult, arg, matchTrailing)
+            matchElemsPlan(getResult, leading, exact = false, matchRemaining)
+          case _ =>
+            matchElemsPlan(getResult, args, exact = true, onSuccess)
 
       /** Plan for matching the sequence in `getResult`
        *

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -303,6 +303,11 @@ object Applications {
           report.error(UnapplyInvalidNumberOfArguments(qual, argTypes), pos)
           argTypes.take(args.length) ++
             List.fill(argTypes.length - args.length)(WildcardType)
+
+      val varArgs = alignedArgs.filter(untpd.isWildcardStarArg)
+      if varArgs.length >= 2 then
+        report.error(em"Ony one spread pattern allowed in sequence", varArgs(1).srcPos)
+
       alignedArgs.lazyZip(alignedArgTypes).map(typer.typed(_, _))
         .showing(i"unapply patterns = $result", unapp)
 

docs/_docs/internals/syntax.md

@@ -365,7 +365,7 @@ Patterns          ::=  Pattern {‘,’ Pattern}
 NamedPattern      ::=  id '=' Pattern
 
 ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’                                       Apply(fn, pats)
-                    |  ‘(’ [Patterns ‘,’] PatVar ‘*’ ‘)’
+                    |  ‘(’ [Patterns ‘,’] PatVar ‘*’ [‘,’ Patterns]‘)’
 ```
 
 ### Type and Value Parameters

tests/neg/spread-patterns.scala

@@ -0,0 +1,15 @@
+import language.experimental.multiSpreads
+
+def use[T](xs: T*) = println(xs)
+
+def useInt(xs: Int*) = ???
+
+@main def Test() =
+  val arr: Array[Int] = Array(1, 2, 3, 4, 5, 6)
+  val xs = List(1, 2, 3, 4, 5, 6)
+
+  xs match
+    case List(1, 2, xs*, ys*, 6) => println(xs) // error
+
+
+

tests/run/spread-patterns.check

@@ -0,0 +1,4 @@
+List(3, 4, 5)
+ArraySeq(4, 5, 6)
+ArraySeq(1, 2, 3)
+ArraySeq(3, 4, 5, 6)

tests/run/spread-patterns.scala

@@ -0,0 +1,38 @@
+import language.experimental.multiSpreads
+
+def use[T](xs: T*) = println(xs)
+
+def useInt(xs: Int*) = ???
+
+@main def Test() =
+  val arr: Array[Int] = Array(1, 2, 3, 4, 5, 6)
+  val lst = List(1, 2, 3, 4, 5, 6)
+
+  lst match
+    case List(1, xs*, 2, 3, 4, 5, 6) =>
+      assert(xs.isEmpty)
+
+  lst match
+    case List(1, 2, xs*, 6) => println(xs)
+
+  arr match
+    case Array(1, 2, xs*, 7) => assert(false)
+    case Array(1, 2, 3, xs*) => println(xs)
+
+  arr match
+    case Array(xs*, 1, 2)    => assert(false)
+    case Array(xs*, 4, 5, 6) => println(xs)
+
+  arr match
+    case Array(1, 2, xs*) => println(xs)
+
+  lst match
+    case List(1, 2, 3, 4, 5, 6, xs*) => assert(xs.isEmpty)
+
+  lst match
+    case Seq(xs*, 1, 2, 3, 4, 5, 6) => assert(xs.isEmpty)
+
+
+
+
+