Fuse successive SubstBindings maps and filters

Author: odersky

compiler/src/dotty/tools/dotc/Run.scala

@@ -42,7 +42,8 @@ import dotty.tools.dotc.util.chaining.*
 import java.util.{Timer, TimerTask}
 
 /** A compiler run. Exports various methods to compile source files */
-class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with ConstraintRunInfo {
+class Run(comp: Compiler, ictx: Context)
+extends ImplicitRunInfo, ConstraintRunInfo, cc.CaptureRunInfo {
 
   /** Default timeout to stop looking for further implicit suggestions, in ms.
    *  This is usually for the first import suggestion; subsequent suggestions
@@ -519,6 +520,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   /** Print summary of warnings and errors encountered */
   def printSummary(): Unit = {
     printMaxConstraint()
+    printMaxPath()
     val r = runContext.reporter
     if !r.errorsReported then
       profile.printSummary()
@@ -529,6 +531,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   override def reset(): Unit = {
     super[ImplicitRunInfo].reset()
     super[ConstraintRunInfo].reset()
+    super[CaptureRunInfo].reset()
     myCtx = null
     myUnits = Nil
     myUnitsCached = Nil

compiler/src/dotty/tools/dotc/cc/CaptureRunInfo.scala

@@ -0,0 +1,25 @@
+package dotty.tools.dotc
+package cc
+
+import core.Contexts.{Context, ctx}
+import config.Printers.capt
+
+trait CaptureRunInfo:
+  self: Run =>
+  private var maxSize = 0
+  private var maxPath: List[CaptureSet.DerivedVar] = Nil
+
+  def recordPath(size: Int, path: => List[CaptureSet.DerivedVar]): Unit =
+    if size > maxSize then
+      maxSize = size
+      maxPath = path
+
+  def printMaxPath()(using Context): Unit =
+    if maxSize > 0 then
+      println(s"max derived capture set path length: $maxSize")
+      println(s"max derived capture set path: ${maxPath.map(_.summarize).reverse}")
+
+  protected def reset(): Unit =
+    maxSize = 0
+    maxPath = Nil
+end CaptureRunInfo

compiler/src/dotty/tools/dotc/cc/CaptureSet.scala

@@ -296,7 +296,10 @@ sealed abstract class CaptureSet extends Showable:
       val elems1 = elems.filter(p)
       if elems1 == elems then this
       else Const(elems.filter(p))
-    else Filtered(asVar, p)
+    else
+      this match
+        case self: Filtered => Filtered(self.source, ref => self.p(ref) && p(ref))
+        case _ => Filtered(asVar, p)
 
   /** Capture set obtained by applying `tm` to all elements of the current capture set
    *  and joining the results. If the current capture set is a variable, the same
@@ -326,7 +329,13 @@ sealed abstract class CaptureSet extends Showable:
         if isConst then
           if mappedElems == elems then this
           else Const(mappedElems)
-        else BiMapped(asVar, tm, mappedElems)
+        else
+          def unfused = BiMapped(asVar, tm, mappedElems)
+          this match
+            case self: BiMapped => self.bimap.fuse(tm) match
+              case Some(fused: BiTypeMap) => BiMapped(self.source, fused, mappedElems)
+              case _ => unfused
+            case _ => unfused
       case tm: IdentityCaptRefMap =>
         this
       case tm: AvoidMap if this.isInstanceOf[HiddenSet] =>
@@ -749,6 +758,25 @@ object CaptureSet:
 
     override def propagateSolved(provisional: Boolean)(using Context) =
       if source.isConst && !isConst then markSolved(provisional)
+
+    // ----------- Longest path recording -------------------------
+    
+    /** Summarize for set displaying in a path */
+    def summarize: String = getClass.toString
+
+    /** The length of the path of DerivedVars ending in this set */
+    def pathLength: Int = source match
+      case source: DerivedVar => source.pathLength + 1
+      case _ => 1
+
+    /** The path of DerivedVars ending in this set */
+    def path: List[DerivedVar] = source match
+      case source: DerivedVar => this :: source.path
+      case _ => this :: Nil
+
+    if ctx.settings.YccLog.value || util.Stats.enabled then
+      ctx.run.nn.recordPath(pathLength, path)
+
   end DerivedVar
 
   /** A variable that changes when `source` changes, where all additional new elements are mapped
@@ -852,7 +880,7 @@ object CaptureSet:
    *  Parameters as in Mapped.
    */
   final class BiMapped private[CaptureSet]
-    (val source: Var, bimap: BiTypeMap, initialElems: Refs)(using @constructorOnly ctx: Context)
+    (val source: Var, val bimap: BiTypeMap, initialElems: Refs)(using @constructorOnly ctx: Context)
   extends DerivedVar(source.owner, initialElems):
 
     override def tryInclude(elem: CaptureRef, origin: CaptureSet)(using Context, VarState): CompareResult =
@@ -881,11 +909,12 @@ object CaptureSet:
 
     override def isMaybeSet: Boolean = bimap.isInstanceOf[MaybeMap]
     override def toString = s"BiMapped$id($source, elems = $elems)"
+    override def summarize = bimap.getClass.toString
   end BiMapped
 
   /** A variable with elements given at any time as { x <- source.elems | p(x) } */
   class Filtered private[CaptureSet]
-    (val source: Var, p: Context ?=> CaptureRef => Boolean)(using @constructorOnly ctx: Context)
+    (val source: Var, val p: Context ?=> CaptureRef => Boolean)(using @constructorOnly ctx: Context)
   extends DerivedVar(source.owner, source.elems.filter(p)):
 
     override def tryInclude(elem: CaptureRef, origin: CaptureSet)(using Context, VarState): CompareResult =
@@ -1298,10 +1327,21 @@ object CaptureSet:
       case t: CaptureRef if t.isTrackableRef => mapRef(t)
       case _ => mapOver(t)
 
-    lazy val inverse = new BiTypeMap:
+    override def fuse(next: BiTypeMap)(using Context) = next match
+      case next: Inverse if next.inverse.getClass == getClass => assert(false); Some(IdentityTypeMap)
+      case next: NarrowingCapabilityMap if next.getClass == getClass => assert(false)
+      case _ => None
+
+    class Inverse extends BiTypeMap:
       def apply(t: Type) = t // since f(c) <: c, this is the best inverse
       def inverse = NarrowingCapabilityMap.this
       override def toString = NarrowingCapabilityMap.this.toString ++ ".inverse"
+      override def fuse(next: BiTypeMap)(using Context) = next match
+        case next: NarrowingCapabilityMap if next.inverse.getClass == getClass => assert(false); Some(IdentityTypeMap)
+        case next: NarrowingCapabilityMap if next.getClass == getClass => assert(false)
+        case _ => None
+
+    lazy val inverse = Inverse()
   end NarrowingCapabilityMap
 
   /** Maps `x` to `x?` */

compiler/src/dotty/tools/dotc/cc/root.scala

@@ -186,17 +186,27 @@ object root:
         case _ =>
           mapFollowingAliases(t)
 
+    override def fuse(next: BiTypeMap)(using Context) = next match
+      case next: Inverse => assert(false); Some(IdentityTypeMap)
+      case _ => None
+
     override def toString = "CapToFresh"
 
-    object inverse extends BiTypeMap, FollowAliasesMap:
+    class Inverse extends BiTypeMap, FollowAliasesMap:
       def apply(t: Type): Type = t match
         case t @ Fresh(_) => cap
         case t @ CapturingType(_, refs) => mapOver(t)
         case _ => mapFollowingAliases(t)
 
+      override def fuse(next: BiTypeMap)(using Context) = next match
+        case next: CapToFresh => assert(false); Some(IdentityTypeMap)
+        case _ => None
+
       def inverse = thisMap
       override def toString = thisMap.toString + ".inverse"
 
+    lazy val inverse = Inverse()
+
   end CapToFresh
 
   /** Maps cap to fresh */

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

@@ -164,10 +164,35 @@ object Substituters:
     }
 
   final class SubstBindingMap[BT <: BindingType](val from: BT, val to: BT)(using Context) extends DeepTypeMap, BiTypeMap {
+    override def fuse(next: BiTypeMap)(using Context) = next match
+      case next: SubstBindingMap[_] =>
+        if next.from eq to then Some(SubstBindingMap(from, next.to))
+        else Some(SubstBindingsMap(Array(from, next.from), Array(to, next.to)))
+      case _ => None
     def apply(tp: Type): Type = subst(tp, from, to, this)(using mapCtx)
     def inverse = SubstBindingMap(to, from)
   }
 
+  final class SubstBindingsMap(val from: Array[BindingType], val to: Array[BindingType])(using Context) extends DeepTypeMap, BiTypeMap {
+    override def fuse(next: BiTypeMap)(using Context) = next match
+      case next: SubstBindingMap[_] =>
+        var i = 0
+        while i < from.length && (to(i) ne next.from) do i += 1
+        if i < from.length then Some(SubstBindingsMap(from, to.updated(i, next.to)))
+        else Some(SubstBindingsMap(from :+ next.from, to :+ next.to))
+      case _ => None
+
+    def apply(tp: Type): Type = tp match
+      case tp: BoundType =>
+        var i = 0
+        while i < from.length && (from(i) ne tp.binder) do i += 1
+        if i < from.length then tp.copyBoundType(to(i).asInstanceOf[tp.BT]) else tp
+      case _ =>
+        mapOver(tp)
+
+    def inverse = SubstBindingsMap(to, from)
+  }
+
   final class Subst1Map(from: Symbol, to: Type)(using Context) extends DeepTypeMap {
     def apply(tp: Type): Type = subst1(tp, from, to, this)(using mapCtx)
   }

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

@@ -6097,6 +6097,10 @@ object Types extends TypeUtils {
     /** A restriction of the inverse to a function on tracked CaptureRefs */
     def backward(ref: CaptureRef): CaptureRef = inverse(ref) match
       case result: CaptureRef if result.isTrackableRef => result
+
+    /** Fuse with another map */
+    def fuse(next: BiTypeMap)(using Context): Option[TypeMap] = None
+
   end BiTypeMap
 
   abstract class TypeMap(implicit protected var mapCtx: Context)

tests/neg-custom-args/captures/heal-tparam-cs.check

@@ -26,7 +26,7 @@
    |    Required: (c: Capp^{io}) -> () ->{io} Unit
    |
    |    Note that the existential capture root in () ->? Unit
-   |    cannot subsume the capability <cap of (c1: Capp^?): () ->{c1} Unit>
+   |    cannot subsume the capability <cap of (x$0: Capp^?): () ->{x$0} Unit>
 21 |      (c1: Capp^{io}) => () => { c1.use() }
 22 |    }
    |
@@ -38,7 +38,7 @@
    |    Required: (c: Capp^{io}) -> () ->{net} Unit
    |
    |    Note that the existential capture root in () ->? Unit
-   |    cannot subsume the capability <cap of (c1: Capp^?): () ->{c1} Unit>
+   |    cannot subsume the capability <cap of (x$0: Capp^?): () ->{x$0} Unit>
 26 |      (c1: Capp^{io}) => () => { c1.use() }
 27 |    }
    |

tests/neg-custom-args/captures/i21920.check

@@ -1,10 +1,10 @@
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i21920.scala:34:34 ---------------------------------------
-34 |  val cell: Cell[File] = File.open(f => Cell(Seq(f))) // error
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |                         Found:    Cell[box File^{f, f²}]{val head: () ?->? IterableOnce[box File^{f²}]^?}^?
-   |                         Required: Cell[File]
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i21920.scala:34:35 ---------------------------------------
+34 |  val cell: Cell[File] = File.open(f => Cell(() => Seq(f))) // error
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^
+   |              Found:    (f: File^?) ->? box Cell[box File^?]{val head: () ->? IterableOnce[box File^?]^?}^?
+   |              Required: (f: File^) ->{fresh} box Cell[box File^?]{val head: () ->? IterableOnce[box File^?]^?}^?
    |
-   |                         where:    f  is a reference to a value parameter
-   |                                   f² is a reference to a value parameter
+   |              Note that the universal capability `cap`
+   |              cannot be included in capture set ?
    |
    | longer explanation available when compiling with `-explain`