New footprint calculation scheme

The old one clearly did not work. It either never worked or was
disabled by the changes to matchtype reduction.

I now changed it to a more straightforward scheme that computes the
footprint directly instead of relying on TypeComparer to produce the
right trace.

Author: odersky

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

@@ -5009,6 +5009,8 @@ object Types extends TypeUtils {
         case ex: Throwable =>
           handleRecursive("normalizing", s"${scrutinee.show} match ..." , ex)
 
+    private def thisMatchType = this
+
     def reduced(using Context): Type = {
 
       def contextInfo(tp: Type): Type = tp match {
@@ -5027,12 +5029,44 @@ object Types extends TypeUtils {
         reductionContext = util.HashMap()
         for (tp <- footprint)
           reductionContext(tp) = contextInfo(tp)
-        typr.println(i"footprint for $this $hashCode: ${footprint.toList.map(x => (x, contextInfo(x)))}%, %")
+        matchTypes.println(i"footprint for $this $hashCode: ${footprint.toList.map(x => (x, contextInfo(x)))}%, %")
 
       def isUpToDate: Boolean =
-        reductionContext.keysIterator.forall { tp =>
+        reductionContext.keysIterator.forall: tp =>
           reductionContext(tp) `eq` contextInfo(tp)
-        }
+
+      def computeFootprint(): Unit =
+        new TypeTraverser:
+          var footprint: Set[Type] = Set()
+          var deep: Boolean = true
+          val seen = util.HashSet[Type]()
+          def traverse(tp: Type) =
+            if !seen.contains(tp) then
+              seen += tp
+              tp match
+                case tp: NamedType =>
+                  if tp.symbol.is(TypeParam) then footprint += tp
+                  traverseChildren(tp)
+                case _: AppliedType | _: RefinedType =>
+                  if deep then traverseChildren(tp)
+                case TypeBounds(lo, hi) =>
+                  traverse(hi)
+                case tp: TypeVar =>
+                  footprint += tp
+                  traverse(tp.underlying)
+                case tp: TypeParamRef =>
+                  footprint += tp
+                case _ =>
+                  traverseChildren(tp)
+          end traverse
+
+          traverse(scrutinee)
+          deep = false
+          cases.foreach(traverse)
+          reductionContext = util.HashMap()
+          for tp <- footprint do
+            reductionContext(tp) = contextInfo(tp)
+          matchTypes.println(i"footprint for $thisMatchType $hashCode: ${footprint.toList.map(x => (x, contextInfo(x)))}%, %")
 
       record("MatchType.reduce called")
       if !Config.cacheMatchReduced
@@ -5044,19 +5078,21 @@ object Types extends TypeUtils {
         if (myReduced != null) record("MatchType.reduce cache miss")
         myReduced =
           trace(i"reduce match type $this $hashCode", matchTypes, show = true)(withMode(Mode.Type) {
+            computeFootprint()
             def matchCases(cmp: TrackingTypeComparer): Type =
               val saved = ctx.typerState.snapshot()
               try cmp.matchCases(scrutinee.normalized, cases.map(MatchTypeCaseSpec.analyze(_)))
               catch case ex: Throwable =>
                 handleRecursive("reduce type ", i"$scrutinee match ...", ex)
               finally
-                updateReductionContext(cmp.footprint)
+                //updateReductionContext(cmp.footprint)
                 ctx.typerState.resetTo(saved)
                   // this drops caseLambdas in constraint and undoes any typevar
                   // instantiations during matchtype reduction
 
             TypeComparer.tracked(matchCases)
           })
+      //else println(i"no change for $this $hashCode / $myReduced")
       myReduced.nn
     }
 

tests/pos/bad-footprint.scala

@@ -0,0 +1,99 @@
+
+object NamedTuple:
+
+  opaque type AnyNamedTuple = Any
+  opaque type NamedTuple[N <: Tuple, +V <: Tuple] >: V <: AnyNamedTuple = V
+
+  export NamedTupleDecomposition.{Names, DropNames}
+
+  /** The type of the named tuple `X` mapped with the type-level function `F`.
+   *  If `X = (n1 : T1, ..., ni : Ti)` then `Map[X, F] = `(n1 : F[T1], ..., ni : F[Ti])`.
+   */
+  type Map[X <: AnyNamedTuple, F[_ <: Tuple.Union[DropNames[X]]]] =
+    NamedTuple[Names[X], Tuple.Map[DropNames[X], F]]
+
+end NamedTuple
+
+object NamedTupleDecomposition:
+  import NamedTuple.*
+
+  /** The names of a named tuple, represented as a tuple of literal string values. */
+  type Names[X <: AnyNamedTuple] <: Tuple = X match
+    case NamedTuple[n, _] => n
+
+  /** The value types of a named tuple represented as a regular tuple. */
+  type DropNames[NT <: AnyNamedTuple] <: Tuple = NT match
+    case NamedTuple[_, x] => x
+end NamedTupleDecomposition
+
+class Expr[Result]
+
+object Expr:
+  import NamedTuple.{NamedTuple, AnyNamedTuple}
+
+  type Of[A] = Expr[A]
+
+  type StripExpr[E] = E match
+    case Expr.Of[b] => b
+
+  case class Ref[A]($name: String = "") extends Expr.Of[A]
+
+  case class Join[A <: AnyNamedTuple](a: A)
+  extends Expr.Of[NamedTuple.Map[A, StripExpr]]
+end Expr
+
+trait Query[A]
+
+object Query:
+  // Extension methods to support for-expression syntax for queries
+  extension [R](x: Query[R])
+    def map[B](f: Expr.Ref[R] => Expr.Of[B]): Query[B] = ???
+
+case class City(zipCode: Int, name: String, population: Int)
+
+object Test:
+  import Expr.StripExpr
+  import NamedTuple.{NamedTuple, AnyNamedTuple}
+
+  val cities: Query[City] = ???
+  val q6 =
+    cities.map: city =>
+      val x: NamedTuple[
+        ("name", "zipCode"),
+        (Expr.Of[String], Expr.Of[Int])] = ???
+      Expr.Join(x)
+
+/* Was error:
+
+-- [E007] Type Mismatch Error: bad-footprint.scala:60:16 -----------------------
+60 |    cities.map: city =>
+   |                ^
+   |Found:    Expr.Ref[City] =>
+   |  Expr[
+   |    NamedTuple.NamedTuple[(("name" : String), ("zipCode" : String)), (String,
+   |      Int)]
+   |  ]
+   |Required: Expr.Ref[City] =>
+   |  Expr[
+   |    NamedTuple.NamedTuple[
+   |      NamedTupleDecomposition.Names[
+   |        NamedTuple.NamedTuple[(("name" : String), ("zipCode" : String)), (
+   |          Expr[String], Expr[Int])]
+   |      ],
+   |      Tuple.Map[
+   |        NamedTupleDecomposition.DropNames[
+   |          NamedTuple.NamedTuple[(("name" : String), ("zipCode" : String)), (
+   |            Expr[String], Expr[Int])]
+   |        ],
+   |      Expr.StripExpr]
+   |    ]
+   |  ]
+61 |      val x: NamedTuple[
+62 |        ("name", "zipCode"),
+63 |        (Expr.Of[String], Expr.Of[Int])] = ???
+64 |      Expr.Join(x)
+   |
+   | longer explanation available when compiling with `-explain`
+1 error found
+
+*/