Fix matchtype redux caching

 - Fix isUptoDate conditon
 - Include TypeVars in footprint

Author: odersky

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

@@ -108,6 +108,8 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
   protected def gadtBounds(sym: Symbol)(implicit ctx: Context) = ctx.gadt.bounds(sym)
   protected def gadtSetBounds(sym: Symbol, b: TypeBounds) = ctx.gadt.setBounds(sym, b)
 
+  protected def typeVarInstance(tvar: TypeVar)(implicit ctx: Context) = tvar.underlying
+
   // Subtype testing `<:<`
 
   def topLevelSubType(tp1: Type, tp2: Type): Boolean = {
@@ -233,7 +235,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
       case tp2: BoundType =>
         tp2 == tp1 || secondTry
       case tp2: TypeVar =>
-        recur(tp1, tp2.underlying)
+        recur(tp1, typeVarInstance(tp2))
       case tp2: WildcardType =>
         def compareWild = tp2.optBounds match {
           case TypeBounds(_, hi) => recur(tp1, hi)
@@ -348,7 +350,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
           case _ => thirdTry
         }
       case tp1: TypeVar =>
-        recur(tp1.underlying, tp2)
+        recur(typeVarInstance(tp1), tp2)
       case tp1: WildcardType =>
         def compareWild = tp1.optBounds match {
           case bounds: TypeBounds => recur(bounds.lo, tp2)
@@ -1828,6 +1830,11 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
     super.gadtSetBounds(sym, b)
   }
 
+  override def typeVarInstance(tvar: TypeVar)(implicit ctx: Context) = {
+    footprint += tvar
+    super.typeVarInstance(tvar)
+  }
+
   def matchCase(scrut: Type, cas: Type, instantiate: Boolean)(implicit ctx: Context): Type = {
 
     def paramInstances = new TypeAccumulator[Array[Type]] {

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

@@ -3598,7 +3598,7 @@ object Types {
     def underlying(implicit ctx: Context): Type = bound
 
     private[this] var myReduced: Type = null
-    private[this] var reductionContext: mutable.Map[Type, TypeBounds] = null
+    private[this] var reductionContext: mutable.Map[Type, Type] = null
 
     override def tryNormalize(implicit ctx: Context): Type = reduced.normalized
 
@@ -3634,38 +3634,41 @@ object Types {
         }
       }
 
-      def isRelevant(tp: Type) = tp match {
-        case tp: TypeParamRef => ctx.typerState.constraint.entry(tp).exists
+      def isBounded(tp: Type) = tp match {
+        case tp: TypeParamRef =>
         case tp: TypeRef => ctx.gadt.bounds.contains(tp.symbol)
       }
 
-      def contextBounds(tp: Type): TypeBounds = tp match {
-        case tp: TypeParamRef => ctx.typerState.constraint.fullBounds(tp)
-        case tp: TypeRef => ctx.gadt.bounds(tp.symbol)
+      def contextInfo(tp: Type): Type = tp match {
+        case tp: TypeParamRef =>
+          val constraint = ctx.typerState.constraint
+          if (constraint.entry(tp).exists) constraint.fullBounds(tp)
+          else NoType
+        case tp: TypeRef =>
+          val bounds = ctx.gadt.bounds(tp.symbol)
+          if (bounds == null) NoType else bounds
+        case tp: TypeVar =>
+          tp.underlying
       }
 
       def updateReductionContext() = {
         reductionContext = new mutable.HashMap
-        for (tp <- cmp.footprint if isRelevant(tp))
-          reductionContext(tp) = contextBounds(tp)
+        for (tp <- cmp.footprint)
+          reductionContext(tp) = contextInfo(tp)
+        typr.println(i"footprint for $this $hashCode: ${cmp.footprint.toList.map(x => (x, contextInfo(x)))}%, %")
       }
 
       def upToDate =
-        cmp.footprint.forall { tp =>
-          !isRelevant(tp) || {
-            reductionContext.get(tp) match {
-              case Some(bounds) => bounds `eq` contextBounds(tp)
-              case None => false
-            }
-          }
+        reductionContext.keysIterator.forall { tp =>
+          reductionContext(tp) `eq` contextInfo(tp)
         }
 
       record("MatchType.reduce called")
       if (!Config.cacheMatchReduced || myReduced == null || !upToDate) {
         record("MatchType.reduce computed")
         if (myReduced != null) record("MatchType.reduce cache miss")
         myReduced =
-          trace(i"reduce match type $this", typr, show = true) {
+          trace(i"reduce match type $this $hashCode", typr, show = true) {
             try
               if (defn.isBottomType(scrutinee)) defn.NothingType
               else if (reduceInParallel) reduceParallel(trackingCtx)

tests/pos/matchtype.scala

@@ -65,7 +65,7 @@ object Test {
   checkSame[Concat[(Boolean, Boolean), (String, Int)], Boolean *: Boolean *: (String, Int)]
   checkSub[(Boolean, Boolean, String, Int), Concat[(Boolean, Boolean), String *: Int *: Unit]]
 
-  inline def index[Xs <: NonEmptyTuple](xs: Xs, n: Int): Elem[Xs, n.type] = xs(n).asInstanceOf
+  def index[Xs <: NonEmptyTuple](xs: Xs, n: Int): Elem[Xs, n.type] = xs(n).asInstanceOf
 
   val test = (1, "hi", true, 2.0)
   index(test, 0): Int