use SymList instead of SymSet to avoid spurious...

use SymList instead of SymSet to avoid spurious stability problem

2 files changed, 22 insertions, 18 deletions

diff --git a/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala b/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala
index 3c4bc850e7..55944c8c20 100644
--- a/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala
+++ b/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala
@@ -770,13 +770,13 @@ object Rep {
     def _2 = row
   }
 
-  var vss: List[SymSet] = _
+  var vss: List[SymList] = _
   var labels:  Array[Symbol] = new Array[Symbol](4)
   var targets: List[Tree] = _
   var reached64: Set64 = _
   var reached: List[Int] = Nil
 
-  final def apply(temp:List[Symbol], row:List[Row], targets: List[Tree], vss:List[SymSet]): Rep = {
+  final def apply(temp:List[Symbol], row:List[Row], targets: List[Tree], vss:List[SymList]): Rep = {
     this.targets   = targets
     if(targets.length > labels.length)
       this.labels    = new Array[Symbol](targets.length)
@@ -1149,7 +1149,7 @@ object Rep {
       root.setFlag(symtab.Flags.CAPTURED)
     var bx = 0;
     val targets = new ListBuffer[Tree]
-    val vss = new ListBuffer[SymSet]
+    val vss = new ListBuffer[SymList]
     val row = new ListBuffer[Row]
 
     var cs = cases; while (cs ne Nil) cs.head match {  // stash away pvars and bodies for later
diff --git a/src/compiler/scala/tools/nsc/matching/PatternNodes.scala b/src/compiler/scala/tools/nsc/matching/PatternNodes.scala
index 29760ec004..e23ec59d94 100644
--- a/src/compiler/scala/tools/nsc/matching/PatternNodes.scala
+++ b/src/compiler/scala/tools/nsc/matching/PatternNodes.scala
@@ -41,21 +41,24 @@ trait PatternNodes { self: transform.ExplicitOuter =>
   case class FinalState(label:Symbol,body:Tree)
   // misc methods END ---
 
-  final def definedVars(args:List[Tree]): SymSet = {
-    var vs = emptySymbolSet
-    var xs = args; while(xs ne Nil) {vs = vs ++ definedVars(xs.head); xs = xs.tail };
-    vs
-  }
 
-  final def definedVars(x:Tree): SymSet = x match {
-    case Alternative(bs) => definedVars(bs)
-    case Apply(_, args)  => definedVars(args)
-    case b @ Bind(_,p)   => definedVars(p) + b.symbol
-    case Ident(_)        => emptySymbolSet
-    case Literal(_)      => emptySymbolSet
-    case Select(_,_)     => emptySymbolSet
-    case Typed(p,_)      => definedVars(p)
-    case UnApply(_,args) => definedVars(args)
+  final def definedVars(x:Tree): SymList = {
+    var vs = new collection.mutable.ListBuffer[Symbol]
+    def definedVars1(x:Tree): Unit = x match {
+      case Alternative(bs) => definedVars2(bs)
+      case Apply(_, args)  => definedVars2(args)
+      case b @ Bind(_,p)   => vs += b.symbol; definedVars1(p)
+      case Ident(_)        => ;
+      case Literal(_)      => ;
+      case Select(_,_)     => ;
+      case Typed(p,_)      => definedVars1(p)
+      case UnApply(_,args) => definedVars2(args)
+    }
+    def definedVars2(args:List[Tree]): Unit = {
+      var xs = args; while(xs ne Nil) { definedVars1(xs.head); xs = xs.tail };
+    }
+    definedVars1(x);
+    vs.toList
   }
 
   // insert in sorted list, larger items first
@@ -90,7 +93,8 @@ trait PatternNodes { self: transform.ExplicitOuter =>
     override def toString = "."
   }
   //
-  type SymSet = collection.immutable.Set[Symbol]
+  type SymSet  = collection.immutable.Set[Symbol]
+  type SymList = List[Symbol]
 
   /** returns the child patterns of a pattern
    */