Extend pattern type constraining to closed hierarchies

Author: dwijnand

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

@@ -552,6 +552,8 @@ object Flags {
   val JavaOrPrivateOrSynthetic: FlagSet      = Artifact | JavaDefined | Private | Synthetic
   val PrivateOrSynthetic: FlagSet            = Artifact | Private | Synthetic
   val EnumCase: FlagSet                      = Case | Enum
+  val CaseOrFinalOrSealed: FlagSet           = Case | Final | Sealed
+  val CaseOrSealed: FlagSet                  = Case | Sealed
   val CovariantLocal: FlagSet                = Covariant | Local                              // A covariant type parameter
   val ContravariantLocal: FlagSet            = Contravariant | Local                          // A contravariant type parameter
   val EffectivelyErased                      = ConstructorProxy | Erased

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

@@ -233,21 +233,11 @@ trait PatternTypeConstrainer { self: TypeComparer =>
   def constrainSimplePatternType(patternTp: Type, scrutineeTp: Type, forceInvariantRefinement: Boolean): Boolean = {
     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 => tp.cls.isOneOf(CaseOrFinalOrSealed)
       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
 

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(CaseOrSealed)
+          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