Merge pull request #984 from scalamacros/ticket/6058

SI-6058 makes JavaMirror caches weak

1 files changed, 25 insertions, 11 deletions

diff --git a/src/reflect/scala/reflect/runtime/TwoWayCache.scala b/src/reflect/scala/reflect/runtime/TwoWayCache.scala
index c7bfb3435d..f47d59e411 100644
--- a/src/reflect/scala/reflect/runtime/TwoWayCache.scala
+++ b/src/reflect/scala/reflect/runtime/TwoWayCache.scala
@@ -1,27 +1,40 @@
 package scala.reflect
 package runtime
 
+import collection.mutable.WeakHashMap
+import java.lang.ref.WeakReference
+
 /** A cache that maintains a bijection between Java reflection type `J`
  *  and Scala reflection type `S`.
+ *
+ *  The cache is two-way weak (i.e. is powered by weak references),
+ *  so that neither Java artifacts prevent Scala artifacts from being garbage collected,
+ *  nor the other way around.
  */
-import collection.mutable.HashMap
-
 private[runtime] class TwoWayCache[J, S] {
 
-  private val toScalaMap = new HashMap[J, S]
-  private val toJavaMap = new HashMap[S, J]
+  private val toScalaMap = new WeakHashMap[J, WeakReference[S]]
+  private val toJavaMap = new WeakHashMap[S, WeakReference[J]]
 
   def enter(j: J, s: S) = synchronized {
     // debugInfo("cached: "+j+"/"+s)
-    toScalaMap(j) = s
-    toJavaMap(s) = j
+    toScalaMap(j) = new WeakReference(s)
+    toJavaMap(s) = new WeakReference(j)
+  }
+
+  private object SomeRef {
+    def unapply[T](optRef: Option[WeakReference[T]]): Option[T] =
+      if (optRef.nonEmpty) {
+        val result = optRef.get.get
+        if (result != null) Some(result) else None
+      } else None
   }
 
   def toScala(key: J)(body: => S): S = synchronized {
     toScalaMap get key match {
-      case Some(v) =>
+      case SomeRef(v) =>
         v
-      case none =>
+      case None =>
         val result = body
         enter(key, result)
         result
@@ -30,9 +43,9 @@ private[runtime] class TwoWayCache[J, S] {
 
   def toJava(key: S)(body: => J): J = synchronized {
     toJavaMap get key match {
-      case Some(v) =>
+      case SomeRef(v) =>
         v
-      case none =>
+      case None =>
         val result = body
         enter(result, key)
         result
@@ -41,11 +54,12 @@ private[runtime] class TwoWayCache[J, S] {
 
   def toJavaOption(key: S)(body: => Option[J]): Option[J] = synchronized {
     toJavaMap get key match {
+      case SomeRef(v) =>
+        Some(v)
       case None =>
         val result = body
         for (value <- result) enter(value, key)
         result
-      case some => some
     }
   }
 }