CC-UPDATE: Make TypeMaps impure

Author: odersky

tests/pos-with-compiler-cc/dotc/ast/Trees.scala

@@ -1394,7 +1394,7 @@ object Trees {
         case _ =>
           sourced
 
-    abstract class TreeMap(val cpy: TreeCopier = inst.cpy) { self =>
+    abstract class TreeMap(val cpy: TreeCopier = inst.cpy) { self: TreeMap @retains(caps.*) =>
       def transform(tree: Tree)(using Context): Tree = {
         inContext(transformCtx(tree)) {
           Stats.record(s"TreeMap.transform/$getClass")

tests/pos-with-compiler-cc/dotc/core/Annotations.scala

@@ -9,6 +9,7 @@ import printing.{Showable, Printer}
 import printing.Texts.Text
 import annotation.internal.sharable
 import language.experimental.pureFunctions
+import annotation.retains
 
 object Annotations {
 
@@ -54,7 +55,7 @@ object Annotations {
      *  be overridden. Returns EmptyAnnotation if type type map produces a range
      *  type, since ranges cannot be types of trees.
      */
-    def mapWith(tm: TypeMap)(using Context) =
+    def mapWith(tm: TypeMap @retains(caps.*))(using Context) =
       val args = arguments
       if args.isEmpty then this
       else

tests/pos-with-compiler-cc/dotc/core/Types.scala

@@ -2160,7 +2160,7 @@ object Types {
   trait ProtoType extends Type {
     def isMatchedBy(tp: Type, keepConstraint: Boolean = false)(using Context): Boolean
     def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T
-    def map(tm: TypeMap)(using Context): ProtoType
+    def map(tm: TypeMap @retains(caps.*))(using Context): ProtoType
 
     /** If this prototype captures a context, the same prototype except that the result
      *  captures the given context `ctx`.
@@ -5572,8 +5572,10 @@ object Types {
       case result: CaptureRef if result.canBeTracked => result
   end BiTypeMap
 
-  abstract class TypeMap(implicit protected var mapCtx: Context)
-  extends VariantTraversal with (Type -> Type) { thisMap: TypeMap =>
+  abstract class TypeMap(using protected val mapCtx: Context @retains(caps.*))
+  extends VariantTraversal with (Type -> Type) { thisMap: TypeMap @retains(mapCtx) =>
+
+    def detach: TypeMap = this.asInstanceOf[TypeMap] // !cc! change once we track contexts
 
     def apply(tp: Type): Type
 
@@ -5639,7 +5641,7 @@ object Types {
     protected def mapCapturingType(tp: Type, parent: Type, refs: CaptureSet, v: Int): Type =
       val saved = variance
       variance = v
-      try derivedCapturingType(tp, this(parent), refs.map(this))
+      try derivedCapturingType(tp, this(parent), refs.map(detach))
       finally variance = saved
 
     /** Map this function over given type */
@@ -5705,16 +5707,16 @@ object Types {
           derivedSuperType(tp, this(thistp), this(supertp))
 
         case tp: LazyRef =>
+          val mapCtx1 = mapCtx.asInstanceOf[FreshContext]
           LazyRef { refCtx =>
-            given Context = refCtx
-            val ref1 = tp.ref
-            if refCtx.runId == mapCtx.runId then this(ref1)
+            val ref1 = tp.ref(using refCtx)
+            if refCtx.runId == mapCtx1.runId then this(ref1)
             else // splice in new run into map context
-              val saved = mapCtx
-              mapCtx = mapCtx.fresh
-                .setPeriod(Period(refCtx.runId, mapCtx.phaseId))
-                .setRun(refCtx.run)
-              try this(ref1) finally mapCtx = saved
+              val savedPeriod = mapCtx1.period
+              val savedRun = mapCtx1.run
+              mapCtx1.setPeriod(Period(refCtx.runId, mapCtx1.phaseId)).setRun(refCtx.run)
+              try this(ref1)
+              finally mapCtx1.setPeriod(savedPeriod).setRun(savedRun)
           }
 
         case tp: ClassInfo =>
@@ -5769,7 +5771,8 @@ object Types {
   }
 
   /** A type map that maps also parents and self type of a ClassInfo */
-  abstract class DeepTypeMap(using Context) extends TypeMap {
+  abstract class DeepTypeMap(using mapCtx: Context @retains(caps.*))
+  extends TypeMap { thisMap: TypeMap @retains(mapCtx) =>
     override def mapClassInfo(tp: ClassInfo): ClassInfo = {
       val prefix1 = this(tp.prefix)
       val parents1 = tp.declaredParents mapConserve this
@@ -5781,7 +5784,7 @@ object Types {
     }
   }
 
-  @sharable object IdentityTypeMap extends TypeMap()(NoContext) {
+  @sharable object IdentityTypeMap extends TypeMap(using NoContext) {
     def apply(tp: Type): Type = tp
   }
 
@@ -5792,7 +5795,8 @@ object Types {
    *     variance < 0 : approximate by lower bound
    *     variance = 0 : propagate bounds to next outer level
    */
-  abstract class ApproximatingTypeMap(using Context) extends TypeMap { thisMap =>
+  abstract class ApproximatingTypeMap(using mapCtx: Context @retains(caps.*))
+  extends TypeMap { thisMap: TypeMap @retains(mapCtx) =>
 
     protected def range(lo: Type, hi: Type): Type =
       if (variance > 0) hi

tests/pos-with-compiler-cc/dotc/core/classfile/ClassfileParser.scala

@@ -24,6 +24,7 @@ import typer.Checking.checkNonCyclic
 import io.{AbstractFile, ZipArchive}
 import scala.util.control.NonFatal
 import language.experimental.pureFunctions
+import annotation.retains
 
 object ClassfileParser {
   /** Marker trait for unpicklers that can be embedded in classfiles. */
@@ -34,7 +35,7 @@ object ClassfileParser {
   object NoEmbedded extends Embedded
 
   /** Replace raw types with wildcard applications */
-  def cook(using Context): TypeMap = new TypeMap {
+  def cook(using ctx: Context): TypeMap = (new TypeMap {
     def apply(tp: Type): Type = tp match {
       case tp: TypeRef if tp.symbol.typeParams.nonEmpty =>
         AppliedType(tp, tp.symbol.typeParams.map(Function.const(TypeBounds.empty)))
@@ -50,7 +51,7 @@ object ClassfileParser {
       case _ =>
         mapOver(tp)
     }
-  }
+  }).detach // !cc! should thread context through instead
 }
 
 class ClassfileParser(

tests/pos-with-compiler-cc/dotc/inlines/Inliner.scala

@@ -551,7 +551,7 @@ class Inliner(val call: tpd.Tree)(using Context):
     // the owner from the inlined method to the current owner.
     val inliner = new InlinerMap(
       typeMap =
-        new DeepTypeMap {
+        (new DeepTypeMap {
           override def stopAt =
             if opaqueProxies.isEmpty then StopAt.Static else StopAt.Package
           def apply(t: Type) = t match {
@@ -562,7 +562,7 @@ class Inliner(val call: tpd.Tree)(using Context):
               else paramProxy.getOrElse(t, mapOver(t))
             case t => mapOver(t)
           }
-        },
+        }).detach,
       treeMap = {
         case tree: This =>
           tree.tpe match {
@@ -926,14 +926,14 @@ class Inliner(val call: tpd.Tree)(using Context):
     if (typeBindings.nonEmpty) {
       val typeBindingsSet = typeBindings.foldLeft[SimpleIdentitySet[Symbol]](SimpleIdentitySet.empty)(_ + _.symbol)
       val inlineTypeBindings = new TreeTypeMap(
-        typeMap = new TypeMap() {
+        typeMap = (new TypeMap() {
           override def apply(tp: Type): Type = tp match {
             case tr: TypeRef if tr.prefix.eq(NoPrefix) && typeBindingsSet.contains(tr.symbol) =>
               val TypeAlias(res) = tr.info: @unchecked
               res
             case tp => mapOver(tp)
           }
-        },
+        }).detach,
         treeMap = {
           case ident: Ident if ident.isType && typeBindingsSet.contains(ident.symbol) =>
             val TypeAlias(r) = ident.symbol.info: @unchecked

tests/pos-with-compiler-cc/dotc/quoted/PickledQuotes.scala

@@ -188,7 +188,7 @@ object PickledQuotes {
               mapOver(tp)
           }
         }
-        val expansion2 = new TreeTypeMap(new ReplaceSplicedTyped).transform(expr1)
+        val expansion2 = new TreeTypeMap((new ReplaceSplicedTyped).detach).transform(expr1)
         quotePickling.println(i"**** typed quote\n${expansion2.show}")
         expansion2
       case _ =>

tests/pos-with-compiler-cc/dotc/transform/HoistSuperArgs.scala

@@ -138,7 +138,7 @@ class HoistSuperArgs extends MiniPhase, IdentityDenotTransformer { thisPhase =>
             val paramSyms = prefss.flatten.map(pref =>
               if pref.isType then pref.tpe.typeSymbol else pref.symbol)
             val tmap = new TreeTypeMap(
-              typeMap = new TypeMap {
+              typeMap = (new TypeMap {
                 lazy val origToParam = (origParams ::: lifted).zip(paramSyms).toMap
                 def apply(tp: Type) = tp match {
                   case tp: NamedType if needsRewire(tp) =>
@@ -149,7 +149,7 @@ class HoistSuperArgs extends MiniPhase, IdentityDenotTransformer { thisPhase =>
                   case _ =>
                     mapOver(tp)
                 }
-              },
+              }).detach,
               treeMap = {
                 case tree: RefTree if needsRewire(tree.tpe) =>
                   cpy.Ident(tree)(tree.name).withType(tree.tpe)

tests/pos-with-compiler-cc/dotc/typer/ProtoTypes.scala

@@ -125,7 +125,7 @@ object ProtoTypes {
   /** A trait for prototypes that match all types */
   trait MatchAlways extends ProtoType, caps.Pure {
     def isMatchedBy(tp1: Type, keepConstraint: Boolean)(using Context): Boolean = true
-    def map(tm: TypeMap)(using Context): ProtoType = this
+    def map(tm: TypeMap @retains(caps.*))(using Context): ProtoType = this
     def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T = x
     override def toString: String = getClass.toString
   }
@@ -239,7 +239,7 @@ object ProtoTypes {
     override def unusableForInference(using Context): Boolean =
       memberProto.unusableForInference
 
-    def map(tm: TypeMap)(using Context): SelectionProto = derivedSelectionProto(name, tm(memberProto), compat)
+    def map(tm: TypeMap @retains(caps.*))(using Context): SelectionProto = derivedSelectionProto(name, tm(memberProto), compat)
     def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T = ta(x, memberProto)
 
     override def deepenProto(using Context): SelectionProto =
@@ -542,7 +542,7 @@ object ProtoTypes {
 
     override def toString: String = s"FunProto(${args mkString ","} => $resultType)"
 
-    def map(tm: TypeMap)(using Context): FunProto =
+    def map(tm: TypeMap @retains(caps.*))(using Context): FunProto =
       derivedFunProto(args, tm(resultType), typer)
 
     def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T =
@@ -600,7 +600,7 @@ object ProtoTypes {
     override def unusableForInference(using Context): Boolean =
       argType.unusableForInference || resType.unusableForInference
 
-    def map(tm: TypeMap)(using Context): ViewProto = derivedViewProto(tm(argType), tm(resultType))
+    def map(tm: TypeMap @retains(caps.*))(using Context): ViewProto = derivedViewProto(tm(argType), tm(resultType))
 
     def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T =
       ta(ta(x, argType), resultType)
@@ -653,7 +653,7 @@ object ProtoTypes {
     override def unusableForInference(using Context): Boolean =
       targs.exists(_.tpe.unusableForInference)
 
-    def map(tm: TypeMap)(using Context): PolyProto =
+    def map(tm: TypeMap @retains(caps.*))(using Context): PolyProto =
       derivedPolyProto(targs, tm(resultType))
 
     def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T =

tests/pos-with-compiler-cc/dotc/typer/QuotesAndSplices.scala

@@ -329,7 +329,7 @@ trait QuotesAndSplices {
             case tp => mapOver(tp)
           }
         }
-        new TreeTypeMap(typeMap = typeMap).transform(shape1)
+        new TreeTypeMap(typeMap = typeMap.detach).transform(shape1)
       }
 
     (typeBindings.toMap, shape2, patterns)