Tweaking the sealed logic in light of #3097. Closes #3097.

Reorganizes children a little so they always come back sorted
the same way the pickler does.   Taking advantage of
-Yfatal-warnings in the test case.  Review by community.

git-svn-id: http://lampsvn.epfl.ch/svn-repos/scala/scala/trunk@20983 5e8d7ff9-d8ef-0310-90f0-a4852d11357a

src/compiler/scala/tools/nsc/matching/MatrixAdditions.scala

@@ -160,10 +160,20 @@ trait MatrixAdditions extends ast.TreeDSL
                 singleType(sym.tpe.prefix, lmoc)   // e.g. None, Nil
               else sym.tpe
 
+            /** Note to Martin should you come through this way: this
+             *  logic looks way overcomplicated for the intention, but a little
+             *  experimentation showed that at least most of it is serving
+             *  some necessary purpose.  It doesn't seem like much more than
+             *  "sym.tpe matchesPattern tpe" ought to be necessary though.
+             *
+             *  For the time being I tacked the matchesPattern test onto the
+             *  end to address #3097.
+             */
             (tpe.typeSymbol == sym) ||
             (symtpe <:< tpe) ||
             (symtpe.parents exists (x => cmpSymbols(x, tpe))) || // e.g. Some[Int] <: Option[&b]
-            ((tpe.prefix memberType sym) <:< tpe)  // outer, see combinator.lexical.Scanner
+            ((tpe.prefix memberType sym) <:< tpe) ||  // outer, see combinator.lexical.Scanner
+            (symtpe matchesPattern tpe)
           }
 
           cond(p.tree) {
@@ -180,18 +190,13 @@ trait MatrixAdditions extends ast.TreeDSL
       private def requiresExhaustive(s: Symbol) =
          (s hasFlag MUTABLE) &&                 // indicates that have not yet checked exhaustivity
         !(s hasFlag TRANS_FLAG) &&              // indicates @unchecked
-         (s.tpe.typeSymbol hasFlag SEALED) &&
+         (s.tpe.typeSymbol.isSealed) &&
          { s resetFlag MUTABLE ; true }         // side effects MUTABLE flag
 
-      private def sealedSymsFor(s: Symbol): Set[Symbol] = {
-        val kids = s.children flatMap sealedSymsFor
-        if (s hasFlag ABSTRACT) kids else kids + s
-      }
-      
       private lazy val inexhaustives: List[List[Combo]] = {
         val collected =
           for ((pv, i) <- tvars.zipWithIndex ; val sym = pv.lhs ; if requiresExhaustive(sym)) yield
-            i -> sealedSymsFor(sym.tpe.typeSymbol)
+            i -> sym.tpe.typeSymbol.sealedDescendants
 
         val folded =
           collected.foldRight(List[List[Combo]]())((c, xs) => {

src/compiler/scala/tools/nsc/symtab/Symbols.scala

@@ -24,7 +24,6 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable =>
   def symbolCount = ids // statistics
 
   val emptySymbolArray = new Array[Symbol](0)
-  val emptySymbolSet = Set.empty[Symbol]
 
   /** Used for deciding in the IDE whether we can interrupt the compiler */
   protected var activeLocks = 0
@@ -1425,7 +1424,15 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable =>
       (if (isModule) moduleClass else toplevelClass).isFromClassFile
 
     /** If this is a sealed class, its known direct subclasses. Otherwise Set.empty */
-    def children: Set[Symbol] = emptySymbolSet
+    def children: List[Symbol] = Nil
+    
+    /** Recursively finds all sealed descendants and returns a sorted list. */
+    def sealedDescendants: List[Symbol] = {
+      val kids = children flatMap (_.sealedDescendants)
+      val all = if (this hasFlag ABSTRACT) kids else this :: kids
+      
+      all.distinct sortBy (_.sealedSortName)
+    }
 
 // ToString -------------------------------------------------------------------
 
@@ -1951,8 +1958,8 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable =>
     override def sourceModule =
       if (isModuleClass) linkedModuleOfClass else NoSymbol
 
-    private var childSet: Set[Symbol] = emptySymbolSet
-    override def children: Set[Symbol] = childSet
+    private var childSet: Set[Symbol] = Set()
+    override def children: List[Symbol] = childSet.toList sortBy (_.sealedSortName)
     override def addChild(sym: Symbol) { childSet = childSet + sym }
 
     incCounter(classSymbolCount)

test/files/jvm/interpreter.check

@@ -218,8 +218,8 @@ defined class Fact
 defined class Term
 
 scala>      |      | <console>:16: warning: match is not exhaustive!
-missing combination           Term
 missing combination            Exp
+missing combination           Term
 
        def f(e: Exp) = e match {  // non-exhaustive warning here
                        ^

test/files/neg/patmatexhaust.check

@@ -15,8 +15,8 @@ missing combination           Qult          Qult
     def ma3(x:Mult) = (x,x) match { // not exhaustive
                        ^
 patmatexhaust.scala:49: warning: match is not exhaustive!
-missing combination             Gu
 missing combination             Gp
+missing combination             Gu
 
     def ma4(x:Deep) = x match { // missing cases: Gu, Gp
                       ^

test/files/pos/bug3097.flags

@@ -0,0 +1 @@
+-unchecked -Yfatal-warnings

test/files/pos/bug3097.scala

@@ -0,0 +1,31 @@
+package seal
+
+sealed trait ISimpleValue
+
+sealed trait IListValue extends ISimpleValue {
+  def items: List[IAtomicValue[_]]
+}
+sealed trait IAtomicValue[O] extends ISimpleValue {
+  def data: O
+}
+
+sealed trait IAbstractDoubleValue[O] extends IAtomicValue[O] { }
+sealed trait IDoubleValue extends IAbstractDoubleValue[Double]
+
+case class ListValue(val items: List[IAtomicValue[_]]) extends IListValue
+class DoubleValue(val data: Double) extends IDoubleValue {
+  def asDouble = data
+}
+
+object Test {
+  /**
+   * @param args the command line arguments
+   */
+  def main(args: Array[String]): Unit = {
+    val v: ISimpleValue = new DoubleValue(1)
+    v match {
+      case m: IListValue => println("list")
+      case a: IAtomicValue[_] => println("atomic")
+    }
+  }
+}