Make LazyRef completers take a context

This avoids memory leaks in unpicklers, where lazy refs
don't capture the context anymore. Other lazyrefs still need
to capture context, though.

Author: odersky

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

@@ -443,7 +443,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(c => dealiased.ref(c).appliedTo(args))
       case dealiased: WildcardType =>
         WildcardType(dealiased.optBounds.appliedTo(args).bounds)
       case dealiased: TypeRef if dealiased.symbol == defn.NothingClass =>

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

@@ -2149,25 +2149,23 @@ object Types {
     }
   }
 
-  case class LazyRef(private var refFn: () => 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
-    def ref = {
+    def ref(implicit ctx: Context) = {
       if (computed) assert(myRef != null)
       else {
         computed = true
-        myRef = refFn()
+        myRef = refFn(ctx)
+        refFn = null
       }
       myRef
     }
     def evaluating = computed && myRef == null
     override def underlying(implicit ctx: Context) = ref
-    override def toString = s"LazyRef($ref)"
-    override def equals(other: Any) = other match {
-      case other: LazyRef => this.ref.equals(other.ref)
-      case _ => false
-    }
-    override def hashCode = ref.hashCode + 37
+    override def toString = s"LazyRef(...)"
+    override def equals(other: Any) = this eq other.asInstanceOf[AnyRef]
+    override def hashCode = System.identityHashCode(this)
   }
 
   // --- Refined Type and RecType ------------------------------------------------
@@ -3768,7 +3766,7 @@ object Types {
           derivedSuperType(tp, this(thistp), this(supertp))
 
         case tp: LazyRef =>
-          LazyRef(() => this(tp.ref))
+          LazyRef(_ => this(tp.ref))
 
         case tp: ClassInfo =>
           mapClassInfo(tp)

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -295,9 +295,8 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
           RecThis(readTypeRef().asInstanceOf[RecType])
         case LAZYref =>
           val rdr = fork
-          def readUnderlying() = rdr.readType()
           skipTree()
-          LazyRef(readUnderlying)
+          LazyRef(implicit ctx => rdr.readType())
         case SHARED =>
           val ref = readAddr()
           typeAtAddr.getOrElseUpdate(ref, forkAt(ref).readType())

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

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