Add match type

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -306,6 +306,7 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
     case mdef: TypeDef =>
       def isBounds(rhs: Tree): Boolean = rhs match {
         case _: TypeBoundsTree => true
+        case _: Match => true // Typedefs with Match rhs classify as abstract
         case LambdaTypeTree(_, body) => isBounds(body)
         case _ => false
       }

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -115,10 +115,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   }
 
   def CaseDef(pat: Tree, guard: Tree, body: Tree)(implicit ctx: Context): CaseDef =
-    ta.assignType(untpd.CaseDef(pat, guard, body), body)
+    ta.assignType(untpd.CaseDef(pat, guard, body), pat, body)
 
   def Match(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match =
-    ta.assignType(untpd.Match(selector, cases), cases)
+    ta.assignType(untpd.Match(selector, cases), selector, cases)
 
   def Labeled(bind: Bind, expr: Tree)(implicit ctx: Context): Labeled =
     ta.assignType(untpd.Labeled(bind, expr))
@@ -575,7 +575,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
     }
 
-
     override def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure = {
       val tree1 = untpd.cpy.Closure(tree)(env, meth, tpt)
       tree match {
@@ -584,19 +583,20 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         case _ => ta.assignType(tree1, meth, tpt)
       }
     }
+
     override def Match(tree: Tree)(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match = {
       val tree1 = untpd.cpy.Match(tree)(selector, cases)
       tree match {
         case tree: Match if sameTypes(cases, tree.cases) => tree1.withTypeUnchecked(tree.tpe)
-        case _ => ta.assignType(tree1, cases)
+        case _ => ta.assignType(tree1, selector, cases)
       }
     }
 
     override def CaseDef(tree: Tree)(pat: Tree, guard: Tree, body: Tree)(implicit ctx: Context): CaseDef = {
       val tree1 = untpd.cpy.CaseDef(tree)(pat, guard, body)
       tree match {
         case tree: CaseDef if body.tpe eq tree.body.tpe => tree1.withTypeUnchecked(tree.tpe)
-        case _ => ta.assignType(tree1, body)
+        case _ => ta.assignType(tree1, pat, body)
       }
     }
 

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -6,6 +6,7 @@ object Config {
   final val cacheAsSeenFrom = true
   final val cacheMemberNames = true
   final val cacheImplicitScopes = true
+  final val cacheMatchReduced = true
 
   final val checkCacheMembersNamed = false
 

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

@@ -35,6 +35,11 @@ trait ConstraintHandling {
   /** If the constraint is frozen we cannot add new bounds to the constraint. */
   protected var frozenConstraint = false
 
+  /** Potentially a type lambda that is still instantiatable, even though the constraint
+   *  is generally frozen.
+   */
+  protected var caseLambda: Type = NoType
+
   /** If set, align arguments `S1`, `S2`when taking the glb
    *  `T1 { X = S1 } & T2 { X = S2 }` of a constraint upper bound for some type parameter.
    *  Aligning means computing `S1 =:= S2` which may change the current constraint.
@@ -47,7 +52,7 @@ trait ConstraintHandling {
    */
   protected var comparedTypeLambdas: Set[TypeLambda] = Set.empty
 
-  private def addOneBound(param: TypeParamRef, bound: Type, isUpper: Boolean): Boolean =
+  protected def addOneBound(param: TypeParamRef, bound: Type, isUpper: Boolean): Boolean =
     !constraint.contains(param) || {
       def occursIn(bound: Type): Boolean = {
         val b = bound.dealias
@@ -167,19 +172,20 @@ trait ConstraintHandling {
       isSubType(tp1, tp2)
   }
 
-  final def isSubTypeWhenFrozen(tp1: Type, tp2: Type): Boolean = {
-    val saved = frozenConstraint
+  @forceInline final def inFrozenConstraint[T](op: => T): T = {
+    val savedFrozen = frozenConstraint
+    val savedLambda = caseLambda
     frozenConstraint = true
-    try isSubType(tp1, tp2)
-    finally frozenConstraint = saved
+    caseLambda = NoType
+    try op
+    finally {
+      frozenConstraint = savedFrozen
+      caseLambda = savedLambda
+    }
   }
 
-  final def isSameTypeWhenFrozen(tp1: Type, tp2: Type): Boolean = {
-    val saved = frozenConstraint
-    frozenConstraint = true
-    try isSameType(tp1, tp2)
-    finally frozenConstraint = saved
-  }
+  final def isSubTypeWhenFrozen(tp1: Type, tp2: Type): Boolean = inFrozenConstraint(isSubType(tp1, tp2))
+  final def isSameTypeWhenFrozen(tp1: Type, tp2: Type): Boolean = inFrozenConstraint(isSameType(tp1, tp2))
 
   /** Test whether the lower bounds of all parameters in this
    *  constraint are a solution to the constraint.
@@ -319,7 +325,7 @@ trait ConstraintHandling {
     }
 
   /** The current bounds of type parameter `param` */
-  final def bounds(param: TypeParamRef): TypeBounds = {
+  def bounds(param: TypeParamRef): TypeBounds = {
     val e = constraint.entry(param)
     if (e.exists) e.bounds
     else {
@@ -355,7 +361,7 @@ trait ConstraintHandling {
 
   /** Can `param` be constrained with new bounds? */
   final def canConstrain(param: TypeParamRef): Boolean =
-    !frozenConstraint && (constraint contains param)
+    (!frozenConstraint || (caseLambda `eq` param.binder)) && constraint.contains(param)
 
   /** Add constraint `param <: bound` if `fromBelow` is false, `param >: bound` otherwise.
    *  `bound` is assumed to be in normalized form, as specified in `firstTry` and
@@ -492,19 +498,18 @@ trait ConstraintHandling {
   /** Check that constraint is fully propagated. See comment in Config.checkConstraintsPropagated */
   def checkPropagated(msg: => String)(result: Boolean): Boolean = {
     if (Config.checkConstraintsPropagated && result && addConstraintInvocations == 0) {
-      val saved = frozenConstraint
-      frozenConstraint = true
-      for (p <- constraint.domainParams) {
-        def check(cond: => Boolean, q: TypeParamRef, ordering: String, explanation: String): Unit =
-          assert(cond, i"propagation failure for $p $ordering $q: $explanation\n$msg")
-        for (u <- constraint.upper(p))
-          check(bounds(p).hi <:< bounds(u).hi, u, "<:", "upper bound not propagated")
-        for (l <- constraint.lower(p)) {
-          check(bounds(l).lo <:< bounds(p).hi, l, ">:", "lower bound not propagated")
-          check(constraint.isLess(l, p), l, ">:", "reverse ordering (<:) missing")
+      inFrozenConstraint {
+        for (p <- constraint.domainParams) {
+          def check(cond: => Boolean, q: TypeParamRef, ordering: String, explanation: String): Unit =
+            assert(cond, i"propagation failure for $p $ordering $q: $explanation\n$msg")
+          for (u <- constraint.upper(p))
+            check(bounds(p).hi <:< bounds(u).hi, u, "<:", "upper bound not propagated")
+          for (l <- constraint.lower(p)) {
+            check(bounds(l).lo <:< bounds(p).hi, l, ">:", "lower bound not propagated")
+            check(constraint.isLess(l, p), l, ">:", "reverse ordering (<:) missing")
+          }
         }
       }
-      frozenConstraint = saved
     }
     result
   }

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

@@ -337,8 +337,8 @@ class TypeApplications(val self: Type) extends AnyVal {
             tl => arg.paramInfos.map(_.subst(arg, tl).bounds),
             tl => arg.resultType.subst(arg, tl)
           )
-        case arg @ TypeAlias(alias) =>
-          arg.derivedTypeAlias(adaptArg(alias))
+        case arg: AliasingBounds =>
+          arg.derivedAlias(adaptArg(arg.alias))
         case arg @ TypeBounds(lo, hi) =>
           arg.derivedTypeBounds(adaptArg(lo), adaptArg(hi))
         case _ =>
@@ -401,8 +401,8 @@ class TypeApplications(val self: Type) extends AnyVal {
         dealiased.derivedAndType(dealiased.tp1.appliedTo(args), dealiased.tp2.appliedTo(args))
       case dealiased: OrType =>
         dealiased.derivedOrType(dealiased.tp1.appliedTo(args), dealiased.tp2.appliedTo(args))
-      case dealiased: TypeAlias =>
-        dealiased.derivedTypeAlias(dealiased.alias.appliedTo(args))
+      case dealiased: AliasingBounds =>
+        dealiased.derivedAlias(dealiased.alias.appliedTo(args))
       case dealiased: TypeBounds =>
         dealiased.derivedTypeBounds(dealiased.lo.appliedTo(args), dealiased.hi.appliedTo(args))
       case dealiased: LazyRef =>
@@ -434,10 +434,13 @@ class TypeApplications(val self: Type) extends AnyVal {
       appliedTo(args)
   }
 
-  /** Turns non-bounds types to type aliases */
+  /** Turns non-bounds types to type bounds.
+   *  A (possible lambda abstracted) match type is turned into an abstract type.
+   *  Every other type is turned into a type alias
+   */
   final def toBounds(implicit ctx: Context): TypeBounds = self match {
     case self: TypeBounds => self // this can happen for wildcard args
-    case _ => TypeAlias(self)
+    case _ => if (self.isMatch) MatchAlias(self) else TypeAlias(self)
   }
 
   /** Translate a type of the form From[T] to To[T], keep other types as they are.

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

@@ -12,6 +12,7 @@ import config.Printers.{typr, constr, subtyping, gadts, noPrinter}
 import TypeErasure.{erasedLub, erasedGlb}
 import TypeApplications._
 import scala.util.control.NonFatal
+import typer.ProtoTypes.constrained
 import reporting.trace
 
 /** Provides methods to compare types.
@@ -102,6 +103,9 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
     true
   }
 
+  protected def gadtBounds(sym: Symbol)(implicit ctx: Context) = ctx.gadt.bounds(sym)
+  protected def gadtSetBounds(sym: Symbol, b: TypeBounds) = ctx.gadt.setBounds(sym, b)
+
   // Subtype testing `<:<`
 
   def topLevelSubType(tp1: Type, tp2: Type): Boolean = {
@@ -336,7 +340,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
         recur(tp1.underlying, tp2)
       case tp1: WildcardType =>
         def compareWild = tp1.optBounds match {
-          case TypeBounds(lo, _) => recur(lo, tp2)
+          case bounds: TypeBounds => recur(bounds.lo, tp2)
           case _ => true
         }
         compareWild
@@ -362,22 +366,25 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
             false
         }
         joinOK || recur(tp11, tp2) && recur(tp12, tp2)
+      case tp1: MatchType =>
+        val reduced = tp1.reduced
+        if (reduced.exists) recur(reduced, tp2) else thirdTry
       case _: FlexType =>
         true
       case _ =>
         thirdTry
     }
 
     def thirdTryNamed(tp2: NamedType): Boolean = tp2.info match {
-      case TypeBounds(lo2, _) =>
+      case info2: TypeBounds =>
         def compareGADT: Boolean = {
-          val gbounds2 = ctx.gadt.bounds(tp2.symbol)
+          val gbounds2 = gadtBounds(tp2.symbol)
           (gbounds2 != null) &&
             (isSubTypeWhenFrozen(tp1, gbounds2.lo) ||
               narrowGADTBounds(tp2, tp1, approx, isUpper = false)) &&
             GADTusage(tp2.symbol)
         }
-        isSubApproxHi(tp1, lo2) || compareGADT || fourthTry
+        isSubApproxHi(tp1, info2.lo) || compareGADT || fourthTry
 
       case _ =>
         val cls2 = tp2.symbol
@@ -532,6 +539,9 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
           case _ =>
         }
         either(recur(tp1, tp21), recur(tp1, tp22)) || fourthTry
+      case tp2: MatchType =>
+        val reduced = tp2.reduced
+        if (reduced.exists) recur(tp1, reduced) else fourthTry
       case tp2: MethodType =>
         def compareMethod = tp1 match {
           case tp1: MethodType =>
@@ -594,7 +604,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
         tp1.info match {
           case TypeBounds(_, hi1) =>
             def compareGADT = {
-              val gbounds1 = ctx.gadt.bounds(tp1.symbol)
+              val gbounds1 = gadtBounds(tp1.symbol)
               (gbounds1 != null) &&
                 (isSubTypeWhenFrozen(gbounds1.hi, tp2) ||
                 narrowGADTBounds(tp1, tp2, approx, isUpper = true)) &&
@@ -665,6 +675,14 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
           case _ =>
         }
         either(recur(tp11, tp2), recur(tp12, tp2))
+      case tp1: MatchType =>
+        def compareMatch = tp2 match {
+          case tp2: MatchType =>
+            isSameType(tp1.scrutinee, tp2.scrutinee) &&
+            tp1.cases.corresponds(tp2.cases)(isSubType)
+          case _ => false
+        }
+        recur(tp1.underlying, tp2) || compareMatch
       case tp1: AnnotatedType if tp1.isRefining =>
         isNewSubType(tp1.parent)
       case JavaArrayType(elem1) =>
@@ -1131,12 +1149,12 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
       gadts.println(i"narrow gadt bound of $tparam: ${tparam.info} from ${if (isUpper) "above" else "below"} to $bound ${bound.toString} ${bound.isRef(tparam)}")
       if (bound.isRef(tparam)) false
       else {
-        val oldBounds = ctx.gadt.bounds(tparam)
+        val oldBounds = gadtBounds(tparam)
         val newBounds =
           if (isUpper) TypeBounds(oldBounds.lo, oldBounds.hi & bound)
           else TypeBounds(oldBounds.lo | bound, oldBounds.hi)
         isSubType(newBounds.lo, newBounds.hi) &&
-          { ctx.gadt.setBounds(tparam, newBounds); true }
+          { gadtSetBounds(tparam, newBounds); true }
       }
     }
   }
@@ -1719,6 +1737,77 @@ object TypeComparer {
   }
 }
 
+class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
+  import state.constraint
+
+  val footprint = mutable.Set[Type]()
+
+  override def bounds(param: TypeParamRef): TypeBounds = {
+    if (param.binder `ne` caseLambda) footprint += param
+    super.bounds(param)
+  }
+
+  override def addOneBound(param: TypeParamRef, bound: Type, isUpper: Boolean): Boolean = {
+    if (param.binder `ne` caseLambda) footprint += param
+    super.addOneBound(param, bound, isUpper)
+  }
+
+  override def gadtBounds(sym: Symbol)(implicit ctx: Context) = {
+    footprint += sym.typeRef
+    super.gadtBounds(sym)
+  }
+
+  override def gadtSetBounds(sym: Symbol, b: TypeBounds) = {
+    footprint += sym.typeRef
+    super.gadtSetBounds(sym, b)
+  }
+
+  def matchCase(scrut: Type, cas: Type, instantiate: Boolean)(implicit ctx: Context): Type = {
+
+    def paramInstances = new TypeAccumulator[Array[Type]] {
+      def apply(inst: Array[Type], t: Type) = t match {
+        case t @ TypeParamRef(b, n) if b `eq` caseLambda =>
+          inst(n) = instanceType(t, fromBelow = variance >= 0)
+          inst
+        case _ =>
+          foldOver(inst, t)
+      }
+    }
+
+    def instantiateParams(inst: Array[Type]) = new TypeMap {
+      def apply(t: Type) = t match {
+        case t @ TypeParamRef(b, n) if b `eq` caseLambda => inst(n)
+        case t: LazyRef => apply(t.ref)
+        case _ => mapOver(t)
+      }
+    }
+
+    val saved = constraint
+    try {
+      inFrozenConstraint {
+        val cas1 = cas match {
+          case cas: HKTypeLambda =>
+            caseLambda = constrained(cas)
+            caseLambda.resultType
+          case _ =>
+            cas
+        }
+        val defn.FunctionOf(pat :: Nil, body, _, _) = cas1
+        if (isSubType(scrut, pat))
+          caseLambda match {
+            case caseLambda: HKTypeLambda if instantiate =>
+              val instances = paramInstances(new Array(caseLambda.paramNames.length), pat)
+              instantiateParams(instances)(body)
+            case _ =>
+              body
+          }
+        else NoType
+      }
+    }
+    finally constraint = saved
+  }
+}
+
 /** A type comparer that can record traces of subtype operations */
 class ExplainingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
   import TypeComparer._

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

@@ -101,8 +101,8 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
       }
     case  _: ThisType | _: BoundType =>
       tp
-    case tp: TypeAlias =>
-      tp.derivedTypeAlias(simplify(tp.alias, theMap))
+    case tp: AliasingBounds =>
+      tp.derivedAlias(simplify(tp.alias, theMap))
     case AndType(l, r) if !ctx.mode.is(Mode.Type) =>
       simplify(l, theMap) & simplify(r, theMap)
     case OrType(l, r) if !ctx.mode.is(Mode.Type) =>