Ensure invariant refinement for classes extended case classes

Author: odersky

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

@@ -176,12 +176,15 @@ object Inferencing {
    *  `DynamicScrutineeType`?
    *
    *   - If `DynamicScrutineeType` refines the type parameters of `StaticScrutineeType`
-   *     in the same way as `PatternType`, the subtype test `PatternType <:< StaticScrutineeType`
-   *     tells us all we need to know.
+   *     in the same way as `PatternType` ("invariant refinement"), the subtype test
+   *     `PatternType <:< StaticScrutineeType` tells us all we need to know.
    *   - Otherwise, if variant refinement is a possibility we can only make predictions
    *     about invariant parameters of `StaticScrutineeType`. Hence we do a subtype test
    *     where `PatternType <: widenVariantParams(StaticScrutineeType)`, where `widenVariantParams`
    *     replaces all type argument of variant parameters with empty bounds.
+   *
+   *  Invariant refinement can be assumed if `PatternType`'s class(es) are final or
+   *  case classes (because of `RefChecks#checkCaseClassInheritanceInvariant`).
    */
   def constrainPatternType(tp: Type, pt: Type)(implicit ctx: Context) = {
     def refinementIsInvariant(tp: Type): Boolean = tp match {

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

@@ -641,6 +641,27 @@ object RefChecks {
         }
       }
 
+      /** Check that inheriting a case 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`.
+       */
+      def checkCaseClassInheritanceInvariant() = {
+        for (caseCls <- clazz.info.baseClasses.tail.find(_.is(Case)))
+          for (bc <- caseCls.info.baseClasses.tail)
+            if (bc.typeParams.exists(_.paramVariance != 0)) {
+              val caseBT = self.baseType(caseCls)
+              val thisBT = self.baseType(bc)
+              val combinedBT = caseBT.baseType(bc)
+              if (!(thisBT =:= combinedBT))
+                ctx.errorOrMigrationWarning(
+                  em"""illegal inheritance: $clazz inherits case $caseCls
+                      |but the two have different base type instances for $bc.
+                      |
+                      |  Basetype for $clazz: $thisBT
+                      |  Basetype via $caseCls: $combinedBT""", clazz.pos)
+            }
+      }
+
       checkNoAbstractMembers()
       if (abstractErrors.isEmpty)
         checkNoAbstractDecls(clazz)
@@ -649,6 +670,7 @@ object RefChecks {
         ctx.error(abstractErrorMessage, clazz.pos)
 
       checkMemberTypesOK()
+      checkCaseClassInheritanceInvariant()
     } else if (clazz.is(Trait) && !(clazz derivesFrom defn.AnyValClass)) {
       // For non-AnyVal classes, prevent abstract methods in interfaces that override
       // final members in Object; see #4431

tests/neg/i3989b.scala

@@ -0,0 +1,10 @@
+object Test extends App {
+  trait A[+X]
+  case class B[+X](val x: X) extends A[X]
+  class C[+X](x: Any) extends B[Any](x) with A[X] // error
+  def f(a: A[Int]): Int = a match {
+    case a: B[_] => a.x
+    case _ => 0
+  }
+  f(new C[Int]("foo"))
+}