Fix variance for match types in type maps and type accumulators

Author: odersky

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

@@ -943,6 +943,12 @@ class Definitions {
       case _ =>
         None
     }
+    def isInstance(tp: Type)(implicit ctx: Context): Boolean = tp match {
+      case AppliedType(tycon: TypeRef, _) =>
+        tycon.name == tpnme.MatchCase && // necessary pre-filter to avoid forcing symbols
+        tycon.isRef(MatchCaseClass)
+      case _ => false
+    }
   }
 
   /** An extractor for multi-dimensional arrays.

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

@@ -337,6 +337,7 @@ object StdNames {
     val Literal: N              = "Literal"
     val LiteralAnnotArg: N      = "LiteralAnnotArg"
     val longHash: N             = "longHash"
+    val MatchCase: N            = "MatchCase"
     val Modifiers: N            = "Modifiers"
     val NestedAnnotArg: N       = "NestedAnnotArg"
     val NoFlags: N              = "NoFlags"

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

@@ -4417,10 +4417,12 @@ object Types {
 
         case tp: LambdaType =>
           def mapOverLambda = {
-            variance = -variance
+            val restpe = tp.resultType
+            val saved = variance
+            variance = if (defn.MatchCase.isInstance(restpe)) 0 else -variance
             val ptypes1 = tp.paramInfos.mapConserve(this).asInstanceOf[List[tp.PInfo]]
-            variance = -variance
-            derivedLambdaType(tp)(ptypes1, this(tp.resultType))
+            variance = saved
+            derivedLambdaType(tp)(ptypes1, this(restpe))
           }
           mapOverLambda
 
@@ -4440,7 +4442,9 @@ object Types {
           derivedOrType(tp, this(tp.tp1), this(tp.tp2))
 
         case tp: MatchType =>
-          derivedMatchType(tp, this(tp.bound), this(tp.scrutinee), tp.cases.mapConserve(this))
+          val bound1 = this(tp.bound)
+          val scrut1 = atVariance(0)(this(tp.scrutinee))
+          derivedMatchType(tp, bound1, scrut1, tp.cases.mapConserve(this))
 
         case tp: SkolemType =>
           derivedSkolemType(tp, this(tp.info))
@@ -4804,10 +4808,12 @@ object Types {
       case _: BoundType | _: ThisType => x
 
       case tp: LambdaType =>
-        variance = -variance
+        val restpe = tp.resultType
+        val saved = variance
+        variance = if (defn.MatchCase.isInstance(restpe)) 0 else -variance
         val y = foldOver(x, tp.paramInfos)
-        variance = -variance
-        this(y, tp.resultType)
+        variance = saved
+        this(y, restpe)
 
       case tp: TermRef =>
         if (stopAtStatic && tp.currentSymbol.isStatic || (tp.prefix `eq` NoPrefix)) x
@@ -4835,7 +4841,9 @@ object Types {
         this(this(x, tp.tp1), tp.tp2)
 
       case tp: MatchType =>
-        foldOver(this(this(x, tp.bound), tp.scrutinee), tp.cases)
+        val x1 = this(x, tp.bound)
+        val x2 = atVariance(0)(this(x1, tp.scrutinee))
+        foldOver(x2, tp.cases)
 
       case AnnotatedType(underlying, annot) =>
         this(applyToAnnot(x, annot), underlying)

library/src/scala/internal/MatchCase.scala

@@ -0,0 +1,5 @@
+package scala.internal
+
+/** A type constructor for a case in a match type.
+ */
+final abstract class MatchCase[Pat, +Body]

tests/neg/i6047.scala

@@ -0,0 +1,43 @@
+type Id[+X] = X match { // error: covariant type X appears in nonvariant position
+  case Int => Int
+  case String => String
+}
+type T1[+X, Y] = Y match {  // error: covariant type X appears in nonvariant position
+  case List[X] => Int
+  case _ => String
+}
+type T2[+X, Y] = Y match { // error: covariant type X appears in nonvariant position
+  case List[_ >: X] => Int
+  case _ => String
+}
+type T3[+X, Y] = Y match { // error: covariant type X appears in nonvariant position
+  case List[_ <: X] => Int
+  case _ => String
+}
+type Id2[-X] = X match { // error: contravariant type X appears in nonvariant position
+  case Int => Int
+  case String => String
+}
+type T4[+X, Y] = Y match {  // error: contravariant type X appears in nonvariant position
+  case List[X] => Int
+  case _ => String
+}
+type T5[+X, Y] = Y match { // error: contravariant type X appears in nonvariant position
+  case List[_ >: X] => Int
+  case _ => String
+}
+type T6[+X, Y] = Y match { // error: contravariant type X appears in nonvariant position
+  case List[_ <: X] => Int
+  case _ => String
+}
+type T7[-X, Y] = Y match { // error: contravariant type X appears in covariant position
+  case List[_] => X
+  case _ => String
+}
+
+class C[+X] {
+  type Id = X match {
+    case Int => Int
+    case String => String
+  }
+}