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

@@ -225,29 +225,19 @@ trait PatternTypeConstrainer { self: TypeComparer =>
    *
    *  It'd be unsound for us to say that `t <: T`, even though that follows from `D[t] <: C[T]`.
    *  Note, however, that if `D` was a final class, we *could* rely on that relationship.
-   *  To support typical case classes, we also assume that this relationship holds for them and their parent traits.
-   *  This is enforced by checking that classes inheriting from case classes do not extend the parent traits of those
-   *  case classes without also appropriately extending the relevant case class
-   *  (see `RefChecks#checkCaseClassInheritanceInvariant`).
+   *  Case classes and sealed traits (and sealed classes) are supported,
+   *  by assuming that this relationship holds for them and their parent traits.
+   *  This is enforced by checking no subclass of them mixes in any parent trait with a different type argument.
+   *  (see `RefChecks#checkVariantInheritanceProblems`).
    */
   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

@@ -802,16 +802,21 @@ object RefChecks {
         }
       }
 
-      /** Check that inheriting a case class does not constitute a variant refinement
+      /** Check that inheriting a case class or a sealed trait (or sealed class) does not constitute a variant refinement
        *  of a base type of the case class. It is because of this restriction that we
-       *  can assume invariant refinement for case classes in `constrainPatternType`.
+       *  can assume invariant refinement for these classes in `constrainSimplePatternType`.
        */
-      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`)
+      def checkVariantInheritanceProblems() =
+        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)
@@ -820,7 +825,7 @@ object RefChecks {
         report.error(abstractErrorMessage, clazz.srcPos)
 
       checkMemberTypesOK()
-      checkCaseClassInheritanceInvariant()
+      checkVariantInheritanceProblems()
     }
 
     if (!clazz.is(Trait)) {

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