Use MatchCase instead of FunctionOf for match cases

That way, we can control that the variance of a case is 0.

Author: odersky

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

@@ -759,6 +759,9 @@ class Definitions {
 
     lazy val TypeBox_CAP: TypeSymbol = TypeBoxType.symbol.requiredType(tpnme.CAP)
 
+  lazy val MatchCaseType: TypeRef = ctx.requiredClassRef("scala.internal.MatchCase")
+  def MatchCaseClass(implicit ctx: Context): ClassSymbol = MatchCaseType.symbol.asClass
+
   lazy val NotType: TypeRef = ctx.requiredClassRef("scala.implicits.Not")
   def NotClass(implicit ctx: Context): ClassSymbol = NotType.symbol.asClass
   def NotModule(implicit ctx: Context): Symbol = NotClass.companionModule
@@ -931,6 +934,17 @@ class Definitions {
     }
   }
 
+  object MatchCase {
+    def apply(pat: Type, body: Type)(implicit ctx: Context): Type =
+      MatchCaseType.appliedTo(pat, body)
+    def unapply(tp: Type)(implicit ctx: Context): Option[(Type, Type)] = tp match {
+      case AppliedType(tycon, pat :: body :: Nil) if tycon.isRef(MatchCaseClass) =>
+        Some((pat, body))
+      case _ =>
+        None
+    }
+  }
+
   /** An extractor for multi-dimensional arrays.
    *  Note that this will also extract the high bound if an
    *  element type is a wildcard. E.g.

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

@@ -2148,7 +2148,7 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
         case _ =>
           cas
       }
-      val defn.FunctionOf(pat :: Nil, body, _, _) = cas1
+      val defn.MatchCase(pat, body) = cas1
       if (isSubType(scrut, pat))
         // `scrut` is a subtype of `pat`: *It's a Match!*
         Some {

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

@@ -3756,7 +3756,7 @@ object Types {
 
     def caseType(tp: Type)(implicit ctx: Context): Type = tp match {
       case tp: HKTypeLambda => caseType(tp.resType)
-      case defn.FunctionOf(_, restpe, _, _) => restpe
+      case defn.MatchCase(_, body) => body
     }
 
     def alternatives(implicit ctx: Context): List[Type] = cases.map(caseType)

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

@@ -487,7 +487,7 @@ trait TypeAssigner {
         }
         HKTypeLambda.fromParams(
           params(new mutable.ListBuffer[TypeSymbol](), pat).toList,
-          defn.FunctionOf(pat.tpe :: Nil, body.tpe))
+          defn.MatchCase(pat.tpe, body.tpe))
       }
       else body.tpe
     tree.withType(ownType)