some BytecodeWriter need a Context, except ClassBytecodeWriter

Author: magarciaEPFL

src/dotty/tools/dotc/backend/jvm/BCodeHelpers.scala

@@ -223,7 +223,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
               log("No Main-Class designated or discovered.")
             case name :: Nil =>
               log(s"Unique entry point: setting Main-Class to $name")
-              settings.mainClass.value = name
+              settings.mainClass.update(name)
             case names =>
               log(s"No Main-Class due to multiple entry points:\n  ${names.mkString("\n  ")}")
           }
@@ -232,7 +232,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
 
         new DirectToJarfileWriter(f.file)
 
-      case _ => factoryNonJarBytecodeWriter()
+      case _ => factoryNonJarBytecodeWriter(ctx)
     }
   }
 
@@ -299,17 +299,6 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
 
   } // end of method addInnerClassesASM()
 
-  /**
-   * All components (e.g. BCPickles, BCInnerClassGen) of the builder classes
-   * extend this trait to have access to the context.
-   *
-   * The context is provided by the three leaf classes (PlainClassBuilder,
-   * JMirrorBuilder and JBeanInfoBuilder) as class parameter.
-   */
-  trait HasContext {
-    implicit protected val ctx: Context
-  }
-
   /*
    * Custom attribute (JVMS 4.7.1) "ScalaSig" used as marker only
    * i.e., the pickle is contained in a custom annotation, see:

src/dotty/tools/dotc/backend/jvm/BytecodeWriters.scala

@@ -41,14 +41,14 @@ trait BytecodeWriters {
   def getFile(sym: Symbol, clsName: String, suffix: String): AbstractFile =
     getFile(outputDirectory(sym), clsName, suffix)
 
-  def factoryNonJarBytecodeWriter(implicit ctx: Context): BytecodeWriter = {
-    val emitAsmp  = ctx.base.settings.Ygenasmp.isSetByUser
-    val doDump    = ctx.base.settings.Ydumpclasses.isSetByUser
+  def factoryNonJarBytecodeWriter(implicit ctx0: Context): BytecodeWriter = {
+    val emitAsmp  = ctx0.base.settings.Ygenasmp.isSetByUser
+    val doDump    = ctx0.base.settings.Ydumpclasses.isSetByUser
     (emitAsmp, doDump) match {
       case (false, false) => new ClassBytecodeWriter { }
-      case (false, true ) => new ClassBytecodeWriter with DumpBytecodeWriter { }
-      case (true,  false) => new ClassBytecodeWriter with AsmpBytecodeWriter
-      case (true,  true ) => new ClassBytecodeWriter with AsmpBytecodeWriter with DumpBytecodeWriter { }
+      case (false, true ) => new ClassBytecodeWriter with DumpBytecodeWriter { val ctx = ctx0 }
+      case (true,  false) => new ClassBytecodeWriter with AsmpBytecodeWriter { val ctx = ctx0 }
+      case (true,  true ) => new ClassBytecodeWriter with AsmpBytecodeWriter with DumpBytecodeWriter { val ctx = ctx0 }
     }
   }
 
@@ -57,10 +57,12 @@ trait BytecodeWriters {
     def close(): Unit = ()
   }
 
-  class DirectToJarfileWriter(jfile: JFile) extends BytecodeWriter {
+  class DirectToJarfileWriter(jfile: JFile)(implicit protected val ctx: Context)
+  extends BytecodeWriter
+  with HasContext {
     val jarMainAttrs = (
-      if (settings.mainClass.isDefault) Nil
-      else List(Name.MAIN_CLASS -> settings.mainClass.value)
+      if (ctx.base.settings.mainClass.isDefault) Nil
+      else List(Name.MAIN_CLASS -> ctx.base.settings.mainClass.value)
     )
     val writer = new Jar(jfile).jarWriter(jarMainAttrs: _*)
 
@@ -86,10 +88,10 @@ trait BytecodeWriters {
    *        their expansion by ASM is more readable.
    *
    * */
-  trait AsmpBytecodeWriter extends BytecodeWriter {
+  trait AsmpBytecodeWriter extends BytecodeWriter with HasContext {
     import dotty.tools.asm
 
-    private val baseDir = Directory(settings.Ygenasmp.value).createDirectory()
+    private val baseDir = Directory(ctx.base.settings.Ygenasmp.value).createDirectory()
 
     private def emitAsmp(jclassBytes: Array[Byte], asmpFile: io.File): Unit = {
       val pw = asmpFile.printWriter()
@@ -127,8 +129,8 @@ trait BytecodeWriters {
     }
   }
 
-  trait DumpBytecodeWriter extends BytecodeWriter {
-    val baseDir = Directory(settings.Ydumpclasses.value).createDirectory()
+  trait DumpBytecodeWriter extends BytecodeWriter with HasContext {
+    val baseDir = Directory(ctx.base.settings.Ydumpclasses.value).createDirectory()
 
     abstract override def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile): Unit = {
       super.writeClass(label, jclassName, jclassBytes, outfile)

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

@@ -297,6 +297,9 @@ object GenBCode extends BCodeSyncAndTry {
 
       // clearing maps
       clearBCodeTypes()
+
+      // free the Context instance reachable from BytecodeWriter
+      bytecodeWriter = null
     }
 
     override def run(implicit ctx: Context): Unit = unsupported("run()")

src/dotty/tools/dotc/backend/jvm/HasContext.scala

@@ -0,0 +1,24 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2012 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+
+package dotty.tools.dotc
+package backend.jvm
+
+import core.Contexts.Context
+
+/**
+ * All components (e.g. BCPickles, BCInnerClassGen) of the builder classes
+ * extend this trait to have access to the context.
+ *
+ * The context is provided by the three leaf classes (PlainClassBuilder,
+ * JMirrorBuilder and JBeanInfoBuilder) as class parameter.
+ * 
+ * Same goes for BytecodeWriter
+ */
+trait HasContext {
+  implicit protected val ctx: Context
+}
+
+