Convert context functions in Types to CFTs

Author: odersky

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

@@ -537,7 +537,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
         // HKLambdas are hash-consed, need to create an artificial difference by adding
         // a LazyRef to a bound.
         val TypeBounds(lo, hi) :: pinfos1 = tl.paramInfos
-        paramInfos = TypeBounds(lo, LazyRef(_ => hi)) :: pinfos1
+        paramInfos = TypeBounds(lo, LazyRef(hi)) :: pinfos1
       }
       ensureFresh(tl.newLikeThis(tl.paramNames, paramInfos, tl.resultType))
     }

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

@@ -337,7 +337,7 @@ class TypeApplications(val self: Type) extends AnyVal {
       case dealiased: TypeBounds =>
         dealiased.derivedTypeBounds(dealiased.lo.appliedTo(args), dealiased.hi.appliedTo(args))
       case dealiased: LazyRef =>
-        LazyRef(c => dealiased.ref(using c).appliedTo(args)(using c))
+        LazyRef(dealiased.ref.appliedTo(args))
       case dealiased: WildcardType =>
         WildcardType(dealiased.optBounds.orElse(TypeBounds.empty).appliedTo(args).bounds)
       case dealiased: TypeRef if dealiased.symbol == defn.NothingClass =>

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

@@ -1209,7 +1209,7 @@ object Types {
           case Atoms.Unknown => Atoms.Unknown
       case _ => Atoms.Unknown
 
-    private def dealias1(keep: AnnotatedType => Context => Boolean)(using Context): Type = this match {
+    private def dealias1(keep: AnnotatedType => Context ?=> Boolean)(using Context): Type = this match {
       case tp: TypeRef =>
         if (tp.symbol.isClass) tp
         else tp.info match {
@@ -1225,7 +1225,7 @@ object Types {
         if (tp1.exists) tp1.dealias1(keep) else tp
       case tp: AnnotatedType =>
         val tp1 = tp.parent.dealias1(keep)
-        if (keep(tp)(ctx)) tp.derivedAnnotatedType(tp1, tp.annot) else tp1
+        if keep(tp) then tp.derivedAnnotatedType(tp1, tp.annot) else tp1
       case tp: LazyRef =>
         tp.ref.dealias1(keep)
       case _ => this
@@ -1260,7 +1260,7 @@ object Types {
      */
     def tryNormalize(using Context): Type = NoType
 
-    private def widenDealias1(keep: AnnotatedType => Context => Boolean)(using Context): Type = {
+    private def widenDealias1(keep: AnnotatedType => Context ?=> Boolean)(using Context): Type = {
       val res = this.widen.dealias1(keep)
       if (res eq this) res else res.widenDealias1(keep)
     }
@@ -2627,7 +2627,7 @@ object Types {
     }
   }
 
-  case class LazyRef(private var refFn: Context => Type, reportCycles: Boolean = false) extends UncachedProxyType with ValueType {
+  case class LazyRef(private var refFn: Context ?=> Type, reportCycles: Boolean = false) extends UncachedProxyType with ValueType {
     private var myRef: Type = null
     private var computed = false
 
@@ -2640,7 +2640,7 @@ object Types {
           throw CyclicReference(NoDenotation)
       else
         computed = true
-        val result = refFn(ctx)
+        val result = refFn
         refFn = null
         if result != null then myRef = result
         else assert(myRef != null)  // must have been `update`d
@@ -4431,7 +4431,7 @@ object Types {
             else defn.AnyType         // dummy type in case of errors
           def refineSelfType(selfType: Type) =
             RefinedType(selfType, sym.name,
-              TypeAlias(LazyRef(force(using _), reportCycles = true)))
+              TypeAlias(LazyRef(force, reportCycles = true)))
           cinfo.selfInfo match
             case self: Type =>
               cinfo.derivedClassInfo(
@@ -4990,14 +4990,14 @@ object Types {
           derivedSuperType(tp, this(thistp), this(supertp))
 
         case tp: LazyRef =>
-          LazyRef { c =>
-            val ref1 = tp.ref(using c)
-            if currentRunId(using c) == currentRunId(using mapCtx) then this(ref1)
+          LazyRef {
+            val ref1 = tp.ref
+            if currentRunId == currentRunId(using mapCtx) then this(ref1)
             else // splice in new run into map context
               val saved = mapCtx
               mapCtx = mapCtx.fresh
-                .setPeriod(Period(currentRunId(using c), currentPhaseId(using mapCtx)))
-                .setRun(c.run)
+                .setPeriod(Period(currentRunId, currentPhaseId(using mapCtx)))
+                .setRun(ctx.run)
               try this(ref1) finally mapCtx = saved
           }
 
@@ -5658,9 +5658,9 @@ object Types {
       }
   }
 
-  private val keepAlways: AnnotatedType => Context => Boolean = _ => _ => true
-  private val keepNever: AnnotatedType => Context => Boolean = _ => _ => false
-  private val keepIfRefining: AnnotatedType => Context => Boolean = tp => ctx => tp.isRefining(using ctx)
+  private val keepAlways: AnnotatedType => Context ?=> Boolean = _ => true
+  private val keepNever: AnnotatedType => Context ?=> Boolean = _ => false
+  private val keepIfRefining: AnnotatedType => Context ?=> Boolean = _.isRefining
 
   val isBounds: Type => Boolean = _.isInstanceOf[TypeBounds]
 }

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -300,7 +300,7 @@ object Checking {
         catch {
           case ex: CyclicReference =>
             report.debuglog(i"cycle detected for $tp, $nestedCycleOK, $cycleOK")
-            if (cycleOK) LazyRef(_ => tp)
+            if (cycleOK) LazyRef(tp)
             else if (reportErrors) throw ex
             else tp
         }