Removed long dead AST Node Sequence.

detritus from regular expression patterns, but Star still depends

on REGPATmode existing -- nothing checks for that mode specifically,
but not having it set causes failure.  So it is renamed to STARmode.

14 files changed, 18 insertions, 93 deletions

diff --git a/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala b/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala
index 701fd9401e..58b0dce333 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala
@@ -299,9 +299,6 @@ abstract class TreeBrowsers {
       case Block(stats, expr) =>
         ("Block", EMPTY)
 
-      case Sequence(trees) =>
-        ("Sequence", EMPTY)
-
       case Alternative(trees) =>
         ("Alternative", EMPTY)
 
@@ -449,9 +446,6 @@ abstract class TreeBrowsers {
       case Block(stats, expr) =>
         stats ::: List(expr)
 
-      case Sequence(trees) =>
-        trees
-
       case Alternative(trees) =>
         trees
 
diff --git a/src/compiler/scala/tools/nsc/ast/TreeInfo.scala b/src/compiler/scala/tools/nsc/ast/TreeInfo.scala
index a4f585b196..28fb914f11 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeInfo.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeInfo.scala
@@ -272,7 +272,6 @@ abstract class TreeInfo {
   /** Is this pattern node a sequence-valued pattern? */
   def isSequenceValued(tree: Tree): Boolean = tree match {
     case Bind(_, body) => isSequenceValued(body)
-    case Sequence(_) => true
     case ArrayValue(_, _) => true
     case Star(_) => true
     case Alternative(ts) => ts exists isSequenceValued
diff --git a/src/compiler/scala/tools/nsc/ast/TreePrinters.scala b/src/compiler/scala/tools/nsc/ast/TreePrinters.scala
index 275b422d5f..c3819baae0 100644
--- a/src/compiler/scala/tools/nsc/ast/TreePrinters.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreePrinters.scala
@@ -255,9 +255,6 @@ abstract class TreePrinters {
           print(pat); printOpt(" if ", guard)
           print(" => "); print(body)
 
-        case Sequence(trees) =>
-          printRow(trees, "[", ", ", "]")
-
         case Alternative(trees) =>
           printRow(trees, "(", "| ", ")")
 
diff --git a/src/compiler/scala/tools/nsc/ast/Trees.scala b/src/compiler/scala/tools/nsc/ast/Trees.scala
index f91ff83e37..7da71eaed6 100644
--- a/src/compiler/scala/tools/nsc/ast/Trees.scala
+++ b/src/compiler/scala/tools/nsc/ast/Trees.scala
@@ -670,12 +670,6 @@ trait Trees {
   /** casedef shorthand */
   def CaseDef(pat: Tree, body: Tree): CaseDef = CaseDef(pat, EmptyTree, body)
 
-  /** Sequence of patterns (comma separated expressions), eliminated by the
-   *  <code>TransMatch</code> phase.
-   */
-  case class Sequence(trees: List[Tree])
-       extends TermTree
-
   /** Alternatives of patterns, eliminated by TransMatch, except for
    *  occurences in encoded Switch stmt (=remaining Match(CaseDef(...))
    */
@@ -970,8 +964,6 @@ trait Trees {
      // { stats; expr }
   case CaseDef(pat, guard, body) =>                               (eliminated by transmatch/explicitouter)
     // case pat if guard => body
-  case Sequence(trees) =>                                         (eliminated by transmatch/explicitouter)
-    // pat1, ..., pat_n
   case Alternative(trees) =>                                      (eliminated by transmatch/explicitouter)
     // pat1 | ... | patn
   case Star(elem) =>                                              (eliminated by transmatch/explicitouter)
@@ -1058,7 +1050,6 @@ trait Trees {
     def Template(tree: Tree, parents: List[Tree], self: ValDef, body: List[Tree]): Template
     def Block(tree: Tree, stats: List[Tree], expr: Tree): Block
     def CaseDef(tree: Tree, pat: Tree, guard: Tree, body: Tree): CaseDef
-    def Sequence(tree: Tree, trees: List[Tree]): Sequence
     def Alternative(tree: Tree, trees: List[Tree]): Alternative
     def Star(tree: Tree, elem: Tree): Star
     def Bind(tree: Tree, name: Name, body: Tree): Bind
@@ -1118,8 +1109,6 @@ trait Trees {
       new Block(stats, expr).copyAttrs(tree)
     def CaseDef(tree: Tree, pat: Tree, guard: Tree, body: Tree) =
       new CaseDef(pat, guard, body).copyAttrs(tree)
-    def Sequence(tree: Tree, trees: List[Tree]) =
-      new Sequence(trees).copyAttrs(tree)
     def Alternative(tree: Tree, trees: List[Tree]) =
       new Alternative(trees).copyAttrs(tree)
     def Star(tree: Tree, elem: Tree) =
@@ -1249,11 +1238,6 @@ trait Trees {
       if (pat0 == pat) && (guard0 == guard) && (body0 == body) => t
       case _ => treeCopy.CaseDef(tree, pat, guard, body)
     }
-    def Sequence(tree: Tree, trees: List[Tree]) = tree match {
-      case t @ Sequence(trees0)
-      if trees0 == trees => t
-      case _ => treeCopy.Sequence(tree, trees)
-    }
     def Alternative(tree: Tree, trees: List[Tree]) = tree match {
       case t @ Alternative(trees0)
       if trees0 == trees => t
@@ -1469,8 +1453,6 @@ trait Trees {
         treeCopy.Block(tree, transformStats(stats, currentOwner), transform(expr))
       case CaseDef(pat, guard, body) =>
         treeCopy.CaseDef(tree, transform(pat), transform(guard), transform(body))
-      case Sequence(trees) =>
-        treeCopy.Sequence(tree, transformTrees(trees))
       case Alternative(trees) =>
         treeCopy.Alternative(tree, transformTrees(trees))
       case Star(elem) =>
@@ -1622,8 +1604,6 @@ trait Trees {
         traverseTrees(stats); traverse(expr)
       case CaseDef(pat, guard, body) =>
         traverse(pat); traverse(guard); traverse(body)
-      case Sequence(trees) =>
-        traverseTrees(trees)
       case Alternative(trees) =>
         traverseTrees(trees)
       case Star(elem) =>
diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
index 66b358383d..41dabd92d5 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
@@ -54,7 +54,7 @@ abstract class TreeBuilder {
         treeCopy.Typed(tree, transform(expr), tpt)
       case Bind(name, body) =>
         treeCopy.Bind(tree, name, transform(body))
-      case Sequence(_) | Alternative(_) | Star(_) =>
+      case Alternative(_) | Star(_) =>
         super.transform(tree)
       case _ =>
         tree
@@ -422,15 +422,6 @@ abstract class TreeBuilder {
     Alternative(ts flatMap alternatives)
   }
 
-  /** Create tree for a pattern sequence */
-  def makeSequence(ts: List[Tree]): Tree = {
-    def elements(t: Tree): List[Tree] = t match {
-      case Sequence(ts) => ts
-      case _            => List(t)
-    }
-    Sequence(ts flatMap elements)
-  }
-
   /** Create visitor <x => x match cases> */
   def makeVisitor(cases: List[CaseDef], checkExhaustive: Boolean): Tree =
     makeVisitor(cases, checkExhaustive, "x$")
diff --git a/src/compiler/scala/tools/nsc/matching/Patterns.scala b/src/compiler/scala/tools/nsc/matching/Patterns.scala
index ffbe8191e7..8a596f1257 100644
--- a/src/compiler/scala/tools/nsc/matching/Patterns.scala
+++ b/src/compiler/scala/tools/nsc/matching/Patterns.scala
@@ -553,11 +553,9 @@ trait Patterns extends ast.TreeDSL {
 
     def isStarSequence = isSequence && hasStar
     def isSequence = cond(unadorn(tree)) {
-      case Sequence(xs) => true
-      case ArrayValue(tpt, xs) => true
+      case ArrayValue(_, _) => true
     }
     def hasStar = cond(unadorn(tree)) {
-      case Sequence(xs) if endsStar(xs)       => true
       case ArrayValue(_, xs) if endsStar(xs)  => true
     }
 
diff --git a/src/compiler/scala/tools/nsc/models/SemanticTokens.scala b/src/compiler/scala/tools/nsc/models/SemanticTokens.scala
index 6c76968149..ed9ef4f419 100644
--- a/src/compiler/scala/tools/nsc/models/SemanticTokens.scala
+++ b/src/compiler/scala/tools/nsc/models/SemanticTokens.scala
@@ -476,7 +476,6 @@ class SemanticTokens(val compiler: Global) {
         build(tree.pat)
         build(tree.guard)
         build(tree.body)
-      case tree : Sequence   => build(tree.trees);
       case tree : Assign     => build(tree.lhs); build(tree.rhs);
       case tree : If         => build(tree.cond); build(tree.thenp); build(tree.elsep);
       case tree : New        =>
diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolWalker.scala b/src/compiler/scala/tools/nsc/symtab/SymbolWalker.scala
index 69481067d4..5f0574b525 100644
--- a/src/compiler/scala/tools/nsc/symtab/SymbolWalker.scala
+++ b/src/compiler/scala/tools/nsc/symtab/SymbolWalker.scala
@@ -220,7 +220,6 @@ trait SymbolWalker {
       case tree : Typed => f(tree.expr); f(tree.tpt)
       case tree : Block => fs(tree.stats); f(tree.expr)
       case tree: CaseDef => f(tree.pat);f(tree.guard);f(tree.body)
-      case tree : Sequence   => fs(tree.trees);
       case tree : Assign     => f(tree.lhs); f(tree.rhs);
       case tree : If         => f(tree.cond); f(tree.thenp); f(tree.elsep);
       case tree : New        => f(tree.tpt);
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/PickleFormat.scala b/src/compiler/scala/tools/nsc/symtab/classfile/PickleFormat.scala
index aef29b0b21..aed501d3ab 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/PickleFormat.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/PickleFormat.scala
@@ -183,7 +183,8 @@ object PickleFormat {
     final val TEMPLATEtree = 12
     final val BLOCKtree = 13
     final val CASEtree = 14
-    final val SEQUENCEtree = 15
+    // This node type has been removed.
+    // final val SEQUENCEtree = 15
     final val ALTERNATIVEtree = 16
     final val STARtree = 17
     final val BINDtree = 18
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
index a5521c7eb9..583b05f039 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
@@ -289,9 +289,6 @@ abstract class Pickler extends SubComponent {
           putTree(guard)
           putTree(body)
 
-        case Sequence(trees) =>
-          putTrees(trees)
-
         case Alternative(trees) =>
           putTrees(trees)
 
@@ -752,12 +749,6 @@ abstract class Pickler extends SubComponent {
           writeRef(body)
           TREE
 
-        case tree@Sequence(trees) =>
-          writeNat(SEQUENCEtree)
-          writeRef(tree.tpe)
-          writeRefs(trees)
-          TREE
-
         case tree@Alternative(trees) =>
           writeNat(ALTERNATIVEtree)
           writeRef(tree.tpe)
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala
index e26e8d41ca..76c181b783 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala
@@ -582,10 +582,6 @@ abstract class UnPickler {
           val body = readTreeRef()
           CaseDef(pat, guard, body).setType(tpe)
 
-        case SEQUENCEtree =>
-          val trees = until(end, readTreeRef)
-          Sequence(trees).setType(tpe)
-
         case ALTERNATIVEtree =>
           val trees = until(end, readTreeRef)
           Alternative(trees).setType(tpe)
diff --git a/src/compiler/scala/tools/nsc/transform/LiftCode.scala b/src/compiler/scala/tools/nsc/transform/LiftCode.scala
index b2af3a0d73..da4961b345 100644
--- a/src/compiler/scala/tools/nsc/transform/LiftCode.scala
+++ b/src/compiler/scala/tools/nsc/transform/LiftCode.scala
@@ -148,7 +148,6 @@ abstract class LiftCode extends Transform with Reifiers {
 // case TypeTree() =>
 // /* Pattern matching */
 // case CaseDef(pat, guard, body) =>
-// case Sequence(trees) =>
 // case Alternative(trees) =>
 // case Star(elem) =>
 // case Bind(name, body) =>
diff --git a/src/compiler/scala/tools/nsc/transform/TailCalls.scala b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
index 95643e5fd4..c3cdc55ad6 100644
--- a/src/compiler/scala/tools/nsc/transform/TailCalls.scala
+++ b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
@@ -223,8 +223,7 @@ abstract class TailCalls extends Transform
         case CaseDef(pat, guard, body) =>
           treeCopy.CaseDef(tree, pat, guard, transform(body))
 
-        case Sequence(_) | Alternative(_) |
-             Star(_)     | Bind(_, _) =>
+        case Alternative(_) | Star(_) | Bind(_, _) =>
           throw new RuntimeException("We should've never gotten inside a pattern")
 
         case Function(vparams, body) =>
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index e07d1e252d..ac3321ba78 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -128,10 +128,10 @@ trait Typers { self: Analyzer =>
    */
   val LHSmode       = 0x400
 
-  /** The mode <code>REGPATmode</code> is set when regular expression patterns
-   *  are allowed.
+  /** The mode <code>STARmode</code> is set when star patterns are allowed.
+   *  (This was formerly called REGPATmode.)
    */
-  val REGPATmode    = 0x1000
+  val STARmode      = 0x1000
 
   /** The mode <code>ALTmode</code> is set when we are under a pattern alternative */
   val ALTmode       = 0x2000
@@ -387,11 +387,9 @@ trait Typers { self: Analyzer =>
       }
     }
 
-    def checkRegPatOK(pos: Position, mode: Int) =
-      if ((mode & REGPATmode) == 0 &&
-          phase.id <= currentRun.typerPhase.id) // fixes t1059
-        error(pos, "no regular expression pattern allowed here\n"+
-              "(regular expression patterns are only allowed in arguments to *-parameters)")
+    def checkStarPatOK(pos: Position, mode: Int) =
+      if ((mode & STARmode) == 0 && phase.id <= currentRun.typerPhase.id)
+        error(pos, "star patterns must correspond with varargs parameters")
 
     /** Check that type of given tree does not contain local or private
      *  components.
@@ -1921,18 +1919,11 @@ trait Typers { self: Analyzer =>
       args mapConserve (arg => typedArg(arg, mode, 0, WildcardType))
 
     def typedArgs(args: List[Tree], mode: Int, originalFormals: List[Type], adaptedFormals: List[Type]) = {
-      if (isVarArgs(originalFormals)) {
-        val nonVarCount = originalFormals.length - 1
-        val prefix =
-          List.map2(args take nonVarCount, adaptedFormals take nonVarCount) ((arg, formal) =>
-            typedArg(arg, mode, 0, formal))
-        val suffix =
-          List.map2(args drop nonVarCount, adaptedFormals drop nonVarCount) ((arg, formal) =>
-            typedArg(arg, mode, REGPATmode, formal))
-        prefix ::: suffix
-      } else {
-        List.map2(args, adaptedFormals)((arg, formal) => typedArg(arg, mode, 0, formal))
-      }
+      def newmode(i: Int) =
+        if (isVarArgs(originalFormals) && i >= originalFormals.length - 1) STARmode else 0
+
+      for (((arg, formal), i) <- (args zip adaptedFormals).zipWithIndex) yield
+        typedArg(arg, mode, newmode(i), formal)
     }
 
     /** Does function need to be instantiated, because a missing parameter
@@ -1963,11 +1954,7 @@ trait Typers { self: Analyzer =>
     /** Is `tree' a block created by a named application?
      */
     def isNamedApplyBlock(tree: Tree) =
-      context.namedApplyBlockInfo match {
-        case Some((block, _)) => block == tree
-        case None => false
-      }
-
+      context.namedApplyBlockInfo exists (_._1 == tree)
 
     /**
      *  @param tree ...
@@ -3534,17 +3521,12 @@ trait Typers { self: Analyzer =>
           newTyper(context.makeNewScope(tree, context.owner)(BlockScopeKind(context.depth)))
             .typedBlock(tree, mode, pt)
 
-        case Sequence(elems) =>
-          checkRegPatOK(tree.pos, mode)
-          val elems1 = elems mapConserve (elem => typed(elem, mode, pt))
-          treeCopy.Sequence(tree, elems1) setType pt
-
         case Alternative(alts) =>
           val alts1 = alts mapConserve (alt => typed(alt, mode | ALTmode, pt))
           treeCopy.Alternative(tree, alts1) setType pt
 
         case Star(elem) =>
-          checkRegPatOK(tree.pos, mode)
+          checkStarPatOK(tree.pos, mode)
           val elem1 = typed(elem, mode, pt)
           treeCopy.Star(tree, elem1) setType pt