Do not store tasty bytes when not placed the classfile

To allow the bytes to be GCed after pickler

Author: nicolasstucki

compiler/src/dotty/tools/backend/jvm/GenBCode.scala

@@ -213,31 +213,36 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
         val outF = if (needsOutFolder) getOutFolder(claszSymbol, pcb.thisName) else null;
         val plainC = pcb.cnode
 
-        if (claszSymbol.isClass) // @DarkDimius is this test needed here?
-          for (binary <- ctx.compilationUnit.pickled.get(claszSymbol.asClass)) {
+        if (claszSymbol.isClass) { // @DarkDimius is this test needed here?
+          def storeTastyTagBytes(getBytes: String => Array[Byte]): Unit = {
             val store = if (mirrorC ne null) mirrorC else plainC
-            val tasty =
-              if (!ctx.settings.YemitTastyInClass.value) {
-                val uuid = new TastyHeaderUnpickler(binary).readHeader()
-                val lo = uuid.getMostSignificantBits
-                val hi = uuid.getLeastSignificantBits
-
+            val bytes = getBytes(store.name)
+            val dataAttr = new CustomAttr(nme.TASTYATTR.mangledString, bytes)
+            store.visitAttribute(dataAttr)
+          }
+          if (ctx.settings.YemitTastyInClass.value) {
+            for (binary <- ctx.compilationUnit.pickled.get(claszSymbol.asClass)) {
+              storeTastyTagBytes { name =>
+                // Create an empty file to signal that a tasty section exist in the corresponding .class
+                // This is much cheaper and simpler to check than doing classfile parsing
+                getFileForClassfile(outF, name, ".hasTasty")
+                binary
+              }
+            }
+          } else {
+            for (uuid <- ctx.compilationUnit.tastyUUID.get(claszSymbol.asClass)) {
+              assert(!ctx.settings.YemitTastyInClass.value)
+              storeTastyTagBytes { name =>
                 // TASTY attribute is created but only the UUID bytes are stored in it.
                 // A TASTY attribute has length 16 if and only if the .tasty file exists.
                 val buffer = new TastyBuffer(16)
-                buffer.writeUncompressedLong(lo)
-                buffer.writeUncompressedLong(hi)
+                buffer.writeUncompressedLong(uuid.getLeastSignificantBits)
+                buffer.writeUncompressedLong(uuid.getMostSignificantBits)
                 buffer.bytes
-              } else {
-                // Create an empty file to signal that a tasty section exist in the corresponding .class
-                // This is much cheaper and simpler to check than doing classfile parsing
-                getFileForClassfile(outF, store.name, ".hasTasty")
-                binary
               }
-            val dataAttr = new CustomAttr(nme.TASTYATTR.mangledString, tasty)
-            store.visitAttribute(dataAttr)
+            }
           }
-
+        }
 
         // ----------- create files
 

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -4,13 +4,15 @@ package dotc
 import core.Types.Type // Do not remove me #3383
 import util.SourceFile
 import ast.{tpd, untpd}
-import tpd.{ Tree, TreeTraverser }
+import tpd.{Tree, TreeTraverser}
 import typer.PrepareTransparent.InlineAccessors
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.SymDenotations.ClassDenotation
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.transform.SymUtils._
 
+import java.util.UUID
+
 class CompilationUnit(val source: SourceFile) {
 
   override def toString = source.toString
@@ -19,11 +21,14 @@ class CompilationUnit(val source: SourceFile) {
 
   var tpdTree: tpd.Tree = tpd.EmptyTree
 
-  def isJava = source.file.name.endsWith(".java")
+  def isJava: Boolean = source.file.name.endsWith(".java")
 
   /** Pickled TASTY binaries, indexed by class. */
   var pickled: Map[ClassSymbol, Array[Byte]] = Map()
 
+  /** UUID of the pickled TASTY, indexed by class. */
+  var tastyUUID: Map[ClassSymbol, UUID] = Map()
+
   /** Will be reset to `true` if `untpdTree` contains `Quote` trees. The information
    *  is used in phase ReifyQuotes in order to avoid traversing a quote-less tree.
    */

compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala

@@ -92,7 +92,7 @@ object PickledQuotes {
     if (pickling ne noPrinter)
       println(i"**** pickling quote of \n${tree.show}")
 
-    val pickled = pickler.assembleParts()
+    val pickled = pickler.assembleParts()._2
 
     if (pickling ne noPrinter)
       new TastyPrinter(pickled).printContents()

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

@@ -6,10 +6,12 @@ package tasty
 import TastyFormat._
 import collection.mutable
 import TastyBuffer._
-import core.Symbols.{Symbol, ClassSymbol}
+import core.Symbols.{ClassSymbol, Symbol}
 import ast.tpd
 import Decorators._
 
+import java.util.UUID
+
 class TastyPickler(val rootCls: ClassSymbol) {
 
   private val sections = new mutable.ArrayBuffer[(NameRef, TastyBuffer)]
@@ -19,7 +21,8 @@ class TastyPickler(val rootCls: ClassSymbol) {
   def newSection(name: String, buf: TastyBuffer) =
     sections += ((nameBuffer.nameIndex(name.toTermName), buf))
 
-  def assembleParts(): Array[Byte] = {
+  /** Returns the UUID and bytes of the tasty file */
+  def assembleParts(): (UUID, Array[Byte]) = {
     def lengthWithLength(buf: TastyBuffer) =
       buf.length + natSize(buf.length)
 
@@ -60,7 +63,7 @@ class TastyPickler(val rootCls: ClassSymbol) {
       all.writeBytes(buf.bytes, buf.length)
     }
     assert(all.length == totalSize && all.bytes.length == totalSize, s"totalSize = $totalSize, all.length = ${all.length}, all.bytes.length = ${all.bytes.length}")
-    all.bytes
+    (new UUID(uuidHi, uuidLow), all.bytes)
   }
 
   /** The address in the TASTY file of a given tree, or None if unknown.

compiler/src/dotty/tools/dotc/transform/Pickler.scala

@@ -65,10 +65,12 @@ class Pickler extends Phase {
         new CommentPickler(pickler, treePkl.buf.addrOfTree).pickleComment(tree)
 
       // other pickle sections go here.
-      val pickled = pickler.assembleParts()
-      unit.pickled += (cls -> pickled)
+      val (uuid, pickled) = pickler.assembleParts()
 
-      if (!ctx.settings.YemitTastyInClass.value) {
+      if (ctx.settings.YemitTastyInClass.value) {
+        unit.pickled += (cls -> pickled)
+      } else {
+        unit.tastyUUID += (cls -> uuid)
         val parts = cls.fullName.stripModuleClassSuffix.mangledString.split('.')
         val name = parts.last
         val tastyDirectory = parts.init.foldLeft(ctx.settings.outputDir.value)((dir, part) => dir.subdirectoryNamed(part))
@@ -108,7 +110,8 @@ class Pickler extends Phase {
     ctx.initialize()
     val unpicklers =
       for ((cls, pickler) <- picklers) yield {
-        val unpickler = new DottyUnpickler(pickler.assembleParts())
+        val bytes = pickler.assembleParts()._2
+        val unpickler = new DottyUnpickler(bytes)
         unpickler.enter(roots = Set.empty)
         cls -> unpickler
       }