Cache results of attempts to reduce match types

Author: odersky

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

@@ -38,7 +38,7 @@ trait ConstraintHandling {
   /** Potentially a type lambda that is still instantiatable, even though the constraint
    *  is generally frozen.
    */
-  protected var unfrozen: Type = NoType
+  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.
@@ -52,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
@@ -174,13 +174,13 @@ trait ConstraintHandling {
 
   @forceInline final def inFrozenConstraint[T](op: => T): T = {
     val savedFrozen = frozenConstraint
-    val savedUnfrozen = unfrozen
+    val savedLambda = caseLambda
     frozenConstraint = true
-    unfrozen = NoType
+    caseLambda = NoType
     try op
     finally {
       frozenConstraint = savedFrozen
-      unfrozen = savedUnfrozen
+      caseLambda = savedLambda
     }
   }
 
@@ -325,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 {
@@ -361,7 +361,7 @@ trait ConstraintHandling {
 
   /** Can `param` be constrained with new bounds? */
   final def canConstrain(param: TypeParamRef): Boolean =
-    (!frozenConstraint || (unfrozen `eq` param.binder)) && 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

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

@@ -103,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 = {
@@ -375,7 +378,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
     def thirdTryNamed(tp2: NamedType): Boolean = tp2.info match {
       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)) &&
@@ -601,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)) &&
@@ -1146,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 }
       }
     }
   }
@@ -1737,11 +1740,33 @@ 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` unfrozen =>
+        case t @ TypeParamRef(b, n) if b `eq` caseLambda =>
           inst(n) = instanceType(t, fromBelow = variance >= 0)
           inst
         case _ =>
@@ -1751,7 +1776,7 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
 
     def instantiateParams(inst: Array[Type]) = new TypeMap {
       def apply(t: Type) = t match {
-        case t @ TypeParamRef(b, n) if b `eq` unfrozen => inst(n)
+        case t @ TypeParamRef(b, n) if b `eq` caseLambda => inst(n)
         case t: LazyRef => apply(t.ref)
         case _ => mapOver(t)
       }
@@ -1762,16 +1787,16 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
       inFrozenConstraint {
         val cas1 = cas match {
           case cas: HKTypeLambda =>
-            unfrozen = constrained(cas)
-            unfrozen.resultType
+            caseLambda = constrained(cas)
+            caseLambda.resultType
           case _ =>
             cas
         }
         val defn.FunctionOf(pat :: Nil, body, _, _) = cas1
         if (isSubType(scrut, pat))
-          unfrozen match {
-            case unfrozen: HKTypeLambda if instantiate =>
-              val instances = paramInstances(new Array(unfrozen.paramNames.length), pat)
+          caseLambda match {
+            case caseLambda: HKTypeLambda if instantiate =>
+              val instances = paramInstances(new Array(caseLambda.paramNames.length), pat)
               instantiateParams(instances)(body)
             case _ =>
               body

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

@@ -3545,7 +3545,7 @@ object Types {
 
     def alternatives(implicit ctx: Context): List[Type] = cases.map(caseType)
 
-    private var myUnderlying: Type = null
+    private[this] var myUnderlying: Type = null
 
     def underlying(implicit ctx: Context): Type = {
       if (myUnderlying == null) myUnderlying = alternatives.reduceLeft(OrType(_, _))
@@ -3564,16 +3564,20 @@ object Types {
       }
     }
 
-    private var myApproxScrut: Type = null
+    private[this] var myApproxScrut: Type = null
 
     def approximatedScrutinee(implicit ctx: Context): Type = {
       if (myApproxScrut == null) myApproxScrut = wildApproxMap.apply(scrutinee)
       myApproxScrut
     }
 
+    private[this] var myReduced: Type = null
+    private[this] var reductionContext: mutable.Map[Type, TypeBounds] = null
+
     def reduced(implicit ctx: Context): Type = {
       val trackingCtx = ctx.fresh.setTypeComparerFn(new TrackingTypeComparer(_))
       val cmp = trackingCtx.typeComparer.asInstanceOf[TrackingTypeComparer]
+
       def recur(cases: List[Type])(implicit ctx: Context): Type = cases match {
         case Nil => NoType
         case cas :: cases1 =>
@@ -3582,7 +3586,30 @@ object Types {
           else if (cmp.matchCase(approximatedScrutinee, cas, instantiate = false).exists) NoType
           else recur(cases1)
       }
-      recur(cases)(trackingCtx)
+
+      def contextBounds(tp: Type): TypeBounds = tp match {
+        case tp: TypeParamRef => ctx.typerState.constraint.fullBounds(tp)
+        case tp: TypeRef => ctx.gadt.bounds(tp.symbol)
+      }
+
+      def updateReductionContext() = {
+        reductionContext = new mutable.HashMap
+        for (tp <- cmp.footprint) reductionContext(tp) = contextBounds(tp)
+      }
+
+      def upToDate =
+        cmp.footprint.forall { tp =>
+          reductionContext.get(tp) match {
+            case Some(bounds) => bounds `eq` contextBounds(tp)
+            case None => false
+          }
+        }
+
+      if (!Config.cacheMatchReduced || myReduced == null || !upToDate) {
+        myReduced = recur(cases)(trackingCtx)
+        updateReductionContext()
+      }
+      myReduced
     }
   }