Fix Typer to use a normal function as LazyRef parameter

Author: odersky

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

@@ -541,7 +541,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.of(hi)) :: pinfos1
       }
       ensureFresh(tl.newLikeThis(tl.paramNames, paramInfos, tl.resultType))
     }

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

@@ -363,7 +363,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(dealiased.ref.appliedTo(args))
+        LazyRef.of(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/TypeOps.scala

@@ -687,8 +687,8 @@ object TypeOps:
           tp // break cycles
 
         case tp: TypeRef if !tp.symbol.isClass =>
-          def lo = LazyRef(apply(tp.underlying.loBound))
-          def hi = LazyRef(apply(tp.underlying.hiBound))
+          def lo = LazyRef.of(apply(tp.underlying.loBound))
+          def hi = LazyRef.of(apply(tp.underlying.hiBound))
           val lookup = boundTypeParams.lookup(tp)
           if lookup != null then lookup
           else

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

@@ -2800,7 +2800,7 @@ object Types {
     }
   }
 
-  case class LazyRef(private var refFn: Context ?=> Type) extends UncachedProxyType with ValueType {
+  case class LazyRef(private var refFn: Context => Type) extends UncachedProxyType with ValueType {
     private var myRef: Type = null
     private var computed = false
 
@@ -2813,7 +2813,7 @@ object Types {
           throw CyclicReference(NoDenotation)
       else
         computed = true
-        val result = refFn
+        val result = refFn(ctx)
         refFn = null
         if result != null then myRef = result
         else assert(myRef != null)  // must have been `update`d
@@ -2835,6 +2835,8 @@ object Types {
     override def equals(other: Any): Boolean = this.eq(other.asInstanceOf[AnyRef])
     override def hashCode: Int = System.identityHashCode(this)
   }
+  object LazyRef:
+    def of(refFn: Context ?=> Type): LazyRef = LazyRef(refFn(using _))
 
   // --- Refined Type and RecType ------------------------------------------------
 
@@ -4655,7 +4657,7 @@ object Types {
             RefinedType(selfType, sym.name,
               TypeAlias(
                 withMode(Mode.CheckCyclic)(
-                  LazyRef(force))))
+                  LazyRef.of(force))))
           cinfo.selfInfo match
             case self: Type =>
               cinfo.derivedClassInfo(
@@ -5254,7 +5256,8 @@ object Types {
           derivedSuperType(tp, this(thistp), this(supertp))
 
         case tp: LazyRef =>
-          LazyRef { refCtx ?=>
+          LazyRef { refCtx =>
+            given Context = refCtx
             val ref1 = tp.ref
             if refCtx.runId == mapCtx.runId then this(ref1)
             else // splice in new run into map context

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

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