Extend pattern type constraining to closed hierarchies

Author: dwijnand

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

@@ -231,23 +231,20 @@ trait PatternTypeConstrainer { self: TypeComparer =>
    *  (see `RefChecks#checkCaseClassInheritanceInvariant`).
    */
   def constrainSimplePatternType(patternTp: Type, scrutineeTp: Type, forceInvariantRefinement: Boolean): Boolean = {
+    def refinementIsInvariantCls(cls: Symbol): Boolean =
+      cls.isOneOf(Final | Case)
+      || cls.is(Sealed) && cls.children.forall { c =>
+        c == cls // means the `cls` has (at least one) anonymous child - which is effectively final, so that's ok
+        || refinementIsInvariantCls(c)
+      }
+
     def refinementIsInvariant(tp: Type): Boolean = tp match {
       case tp: SingletonType => true
-      case tp: ClassInfo => tp.cls.is(Final) || tp.cls.is(Case)
+      case tp: ClassInfo => refinementIsInvariantCls(tp.cls)
       case tp: TypeProxy => refinementIsInvariant(tp.superType)
       case _ => false
     }
 
-    def widenVariantParams(tp: Type) = tp match {
-      case tp @ AppliedType(tycon, args) =>
-        val args1 = args.zipWithConserve(tycon.typeParams)((arg, tparam) =>
-          if (tparam.paramVarianceSign != 0) TypeBounds.empty else arg
-        )
-        tp.derivedAppliedType(tycon, args1)
-      case tp =>
-        tp
-    }
-
     val patternCls = patternTp.classSymbol
     val scrutineeCls = scrutineeTp.classSymbol
 
@@ -258,12 +255,10 @@ trait PatternTypeConstrainer { self: TypeComparer =>
     val pt = if upcastPattern then patternTp.baseType(scrutineeCls) else patternTp
     val tp = if !upcastPattern then scrutineeTp.baseType(patternCls) else scrutineeTp
 
-    val assumeInvariantRefinement =
-      migrateTo3 || forceInvariantRefinement || refinementIsInvariant(patternTp)
-
     trace(i"constraining simple pattern type $tp >:< $pt", gadts, (res: Boolean) => i"$res gadt = ${ctx.gadt}") {
       (tp, pt) match {
         case (AppliedType(tyconS, argsS), AppliedType(tyconP, argsP)) =>
+          val assumeInvariantRefinement = migrateTo3 || forceInvariantRefinement || refinementIsInvariant(patternTp)
           val saved = state.nn.constraint
           val result =
             ctx.gadtState.rollbackGadtUnless {

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

@@ -892,7 +892,16 @@ class Namer { typer: Typer =>
       val sym = denot.symbol
 
       def register(child: Symbol, parentCls: ClassSymbol) = {
-        if (parentCls.is(Sealed))
+        // The class `*:` (aka "Pair") is weird:
+        // it's patched as the parent of the 22 tuple classes
+        // but it's also sealed so it should know its children.
+        // But what can eventually happens is it's queried
+        // and then later another child is loaded, which blows up:
+        // "children of class *: were already queried before class Tuple10 was discovered."
+        // I think it's sealed only so it's not inherited by users.
+        // So let's just say it has no known sealed children (only subclasses).
+        // So skip adding any of its subclasses as its children.
+        if parentCls.is(Sealed) && parentCls != defn.PairClass then
           if ((child.isInaccessibleChildOf(parentCls) || child.isAnonymousClass) && !sym.hasAnonymousChild)
             addChild(parentCls, parentCls)
           else if (!parentCls.is(ChildrenQueried))

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

@@ -807,11 +807,15 @@ object RefChecks {
        *  can assume invariant refinement for case classes in `constrainPatternType`.
        */
       def checkCaseClassInheritanceInvariant() =
-        for (caseCls <- clazz.info.baseClasses.tail.find(_.is(Case)))
-          for (baseCls <- caseCls.info.baseClasses.tail)
-            if (baseCls.typeParams.exists(_.paramVarianceSign != 0))
-              for (problem <- variantInheritanceProblems(baseCls, caseCls, "non-variant", "case "))
-                report.errorOrMigrationWarning(problem, clazz.srcPos, from = `3.0`)
+        for
+          middle <- clazz.info.baseClasses.tail
+          if middle.isOneOf(Case | Sealed)
+          baseCls <- middle.info.baseClasses.tail
+          if baseCls.typeParams.exists(_.paramVarianceSign != 0)
+          middleStr = if middle.is(Case) then "case " else if middle.is(Sealed) then "sealed " else ""
+          problem <- variantInheritanceProblems(baseCls, middle, "non-variant", middleStr)
+        do
+          report.errorOrMigrationWarning(problem, clazz.srcPos, from = `3.0`)
       checkNoAbstractMembers()
       if (abstractErrors.isEmpty)
         checkNoAbstractDecls(clazz)

tests/pos/i4790.scala

@@ -0,0 +1,21 @@
+class Test:
+  def foo(as: Seq[Int]) =
+    val List(_, bs: _*) = as: @unchecked
+    val cs: Seq[Int] = bs
+
+class Test2:
+  def foo(as: SSeq[Int]) =
+    val LList(_, tail) = as: @unchecked
+    val cs: SSeq[Int] = tail
+
+trait SSeq[+A]
+sealed trait LList[+A] extends SSeq[A]
+final case class CCons[+A](head: A, tail: LList[A]) extends LList[A]
+case object NNil extends LList[Nothing]
+object LList:
+  def unapply[A](xs: LList[A]): Extractor[A] = Extractor[A](xs)
+  final class Extractor[A](private val xs: LList[A]) extends AnyVal:
+    def get: this.type   = this
+    def isEmpty: Boolean = xs.isInstanceOf[CCons[?]]
+    def _1: A            = xs.asInstanceOf[CCons[A]].head
+    def _2: SSeq[A]      = xs.asInstanceOf[CCons[A]].tail