diff --git a/src/dotty/tools/dotc/backend/jvm/BCodeBodyBuilder.scala b/src/dotty/tools/dotc/backend/jvm/BCodeBodyBuilder.scala
index bf351454cef2..1addc588fc43 100755
--- a/src/dotty/tools/dotc/backend/jvm/BCodeBodyBuilder.scala
+++ b/src/dotty/tools/dotc/backend/jvm/BCodeBodyBuilder.scala
@@ -3,18 +3,16 @@
  * @author  Martin Odersky
  */
 
-
-package dotty.tools
-package dotc
-package backend
-package jvm
+package dotty.tools.dotc
+package backend.jvm
 
 import scala.collection.{ mutable, immutable }
 import scala.annotation.switch
 
 import dotty.tools.asm
 
-import dotc.ast.Trees._
+import ast.Trees._
+import core.Contexts.Context
 import core.Flags
 import core.Types.Type
 import core.StdNames
@@ -36,8 +34,8 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
   /*
    * Functionality to build the body of ASM MethodNode, except for `synchronized` and `try` expressions.
    */
-  abstract class PlainBodyBuilder(cunit: CompilationUnit,
-                                  implicit val ctx: dotc.core.Contexts.Context) extends PlainSkelBuilder(cunit) {
+  abstract class PlainBodyBuilder(cunit: CompilationUnit)
+  extends PlainSkelBuilder(cunit) {
 
     import icodes.TestOp
     import icodes.opcodes.InvokeStyle
diff --git a/src/dotty/tools/dotc/backend/jvm/BCodeGlue.scala b/src/dotty/tools/dotc/backend/jvm/BCodeGlue.scala
index ba0425473e41..cc6db856fb70 100755
--- a/src/dotty/tools/dotc/backend/jvm/BCodeGlue.scala
+++ b/src/dotty/tools/dotc/backend/jvm/BCodeGlue.scala
@@ -3,17 +3,16 @@
  * @author  Martin Odersky
  */
 
-package dotty.tools
-package dotc
+package dotty.tools.dotc
 package backend.jvm
 
 import dotty.tools.asm
 import scala.annotation.switch
 import scala.collection.{ immutable, mutable }
 
-import dotc.ast.Trees.Tree
-import dotc.core.Types.Type
-import dotc.core.Symbols.{Symbol, NoSymbol}
+import ast.Trees.Tree
+import core.Types.Type
+import core.Symbols.{Symbol, NoSymbol}
 
 /*
  *  Immutable representations of bytecode-level types.
diff --git a/src/dotty/tools/dotc/backend/jvm/BCodeHelpers.scala b/src/dotty/tools/dotc/backend/jvm/BCodeHelpers.scala
index d8198933efa1..934cbbd5ae41 100755
--- a/src/dotty/tools/dotc/backend/jvm/BCodeHelpers.scala
+++ b/src/dotty/tools/dotc/backend/jvm/BCodeHelpers.scala
@@ -3,8 +3,7 @@
  * @author  Martin Odersky
  */
 
-package dotty.tools
-package dotc
+package dotty.tools.dotc
 package backend.jvm
 
 import dotty.tools.asm
@@ -12,14 +11,14 @@ import scala.annotation.switch
 import scala.collection.{ immutable, mutable }
 import dotty.tools.io.AbstractFile
 
-import dotc.ast.Trees._
-
-import dotc.core.StdNames
-import dotc.core.Types.Type
-import dotc.core.Symbols.{Symbol, NoSymbol}
-import dotc.core.SymDenotations._
-import dotc.core.Flags
-import dotc.core.StdNames.{nme, tpnme}
+import ast.Trees._
+import core.Contexts.Context
+import core.StdNames
+import core.Types.Type
+import core.Symbols.{Symbol, NoSymbol}
+import core.SymDenotations._
+import core.Flags
+import core.StdNames.{nme, tpnme}
 
 /*
  *  Traits encapsulating functionality to convert Scala AST Trees into ASM ClassNodes.
@@ -209,7 +208,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
   /*
    * must-single-thread
    */
-  def initBytecodeWriter(entryPoints: List[Symbol])(implicit ctx: core.Contexts.Context): BytecodeWriter = {
+  def initBytecodeWriter(entryPoints: List[Symbol])(implicit ctx: Context): BytecodeWriter = {
     settings.outputDirs.getSingleOutput match {
       case Some(f) if f hasExtension "jar" =>
         // If no main class was specified, see if there's only one
@@ -236,7 +235,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
   /*
    *  must-single-thread
    */
-  def fieldSymbols(cls: Symbol)(implicit ctx: core.Contexts.Context): List[Symbol] = {
+  def fieldSymbols(cls: Symbol)(implicit ctx: Context): List[Symbol] = {
     for (f <- cls.info.decls.toList ;
          if !(f is Flags.Method) && f.isTerm && !(f is Flags.ModuleVal)
     ) yield f;
@@ -296,6 +295,17 @@ 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:
@@ -308,7 +318,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
    * while the "Signature" attribute can be associated to classes, methods, and fields.)
    *
    */
-  trait BCPickles {
+  trait BCPickles extends HasContext {
 
     import scala.reflect.internal.pickling.{ PickleFormat, PickleBuffer }
 
@@ -383,7 +393,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
 
   } // end of trait BCPickles
 
-  trait BCInnerClassGen {
+  trait BCInnerClassGen extends HasContext {
 
     def debugLevel = settings.debuginfo.indexOfChoice
 
@@ -405,14 +415,14 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
      *
      *  must-single-thread
      */
-    final def internalName(sym: Symbol)(implicit ctx: core.Contexts.Context): String = asmClassType(sym).getInternalName
+    final def internalName(sym: Symbol): String = asmClassType(sym).getInternalName
 
     /*
      *  Tracks (if needed) the inner class given by `sym`.
      *
      *  must-single-thread
      */
-    final def asmClassType(sym: Symbol)(implicit ctx: core.Contexts.Context): BType = {
+    final def asmClassType(sym: Symbol): BType = {
       assert(
         hasInternalName(sym),
         {
@@ -438,10 +448,8 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
      *  Tracks (if needed) the inner class given by `t`.
      *
      * must-single-thread
-     * 
-     * TODO(lry): check if `ctx` should be a paramter of the class instead.
      */
-    final def toTypeKind(t: Type)(implicit ctx: dotc.core.Contexts.Context): BType = {
+    final def toTypeKind(t: Type): BType = {
 
       /* Interfaces have to be handled delicately to avoid introducing spurious errors,
        *  but if we treat them all as AnyRef we lose too much information.
@@ -535,7 +543,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
     /*
      * must-single-thread
      */
-    def asmMethodType(msym: Symbol)(implicit ctx: core.Contexts.Context): BType = {
+    def asmMethodType(msym: Symbol): BType = {
       assert(msym is Flags.Method, s"not a method-symbol: $msym")
       val resT: BType =
         if (msym.isClassConstructor || msym.isConstructor) BType.VOID_TYPE
@@ -550,7 +558,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
      *
      *  must-single-thread
      */
-    final def trackMemberClasses(csym: Symbol, lateClosuresBTs: List[BType])(implicit ctx: core.Contexts.Context): List[BType] = {
+    final def trackMemberClasses(csym: Symbol, lateClosuresBTs: List[BType]): List[BType] = {
       val lateInnerClasses = exitingErasure {
         for (sym <- List(csym, csym.linkedClassOfClass); memberc <- sym.info.decls.map(innerClassSymbolFor) if memberc.isClass)
         yield memberc
@@ -574,14 +582,14 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
      *
      *  must-single-thread
      */
-    final def descriptor(t: Type)(implicit ctx: core.Contexts.Context): String = (toTypeKind(t).getDescriptor)
+    final def descriptor(t: Type): String = (toTypeKind(t).getDescriptor)
 
     /*
      *  Tracks (if needed) the inner class given by `sym`.
      *
      *  must-single-thread
      */
-    final def descriptor(sym: Symbol)(implicit ctx: core.Contexts.Context): String = (asmClassType(sym).getDescriptor)
+    final def descriptor(sym: Symbol): String = (asmClassType(sym).getDescriptor)
 
   } // end of trait BCInnerClassGen
 
@@ -774,7 +782,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
 
   } // end of trait BCAnnotGen
 
-  trait BCJGenSigGen {
+  trait BCJGenSigGen extends HasContext {
 
     // @M don't generate java generics sigs for (members of) implementation
     // classes, as they are monomorphic (TODO: ok?)
@@ -996,7 +1004,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
 
   } // end of trait BCForwardersGen
 
-  trait BCClassGen extends BCInnerClassGen {
+  trait BCClassGen extends BCInnerClassGen with HasContext {
 
     // Used as threshold above which a tableswitch bytecode instruction is preferred over a lookupswitch.
     // There's a space tradeoff between these multi-branch instructions (details in the JVM spec).
@@ -1081,7 +1089,10 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
 
   } // end of class JBuilder
 
-  /* functionality for building plain and mirror classes */
+  /* functionality for building plain and mirror classes
+   * TODO(lrytz): it seems only `JMirrorBuilder` extends `JCommonBuilder`.
+   * So this class could be removed.
+   */
   abstract class JCommonBuilder
     extends JBuilder
     with    BCAnnotGen
@@ -1089,7 +1100,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
     with    BCPickles { }
 
   /* builder of mirror classes */
-  class JMirrorBuilder extends JCommonBuilder {
+  class JMirrorBuilder(implicit protected val ctx: Context) extends JCommonBuilder {
 
     private var cunit: CompilationUnit = _
     def getCurrentCUnit(): CompilationUnit = cunit;
@@ -1144,7 +1155,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters {
   } // end of class JMirrorBuilder
 
   /* builder of bean info classes */
-  class JBeanInfoBuilder extends JBuilder {
+  class JBeanInfoBuilder(implicit protected val ctx: Context) extends JBuilder {
 
     /*
      * Generate a bean info class that describes the given class.
diff --git a/src/dotty/tools/dotc/backend/jvm/BCodeIdiomatic.scala b/src/dotty/tools/dotc/backend/jvm/BCodeIdiomatic.scala
index 393a64ec76e9..7618c6220901 100755
--- a/src/dotty/tools/dotc/backend/jvm/BCodeIdiomatic.scala
+++ b/src/dotty/tools/dotc/backend/jvm/BCodeIdiomatic.scala
@@ -3,8 +3,7 @@
  * @author  Martin Odersky
  */
 
-package dotty.tools
-package dotc
+package dotty.tools.dotc
 package backend.jvm
 
 import dotty.tools.asm
@@ -12,9 +11,10 @@ import scala.annotation.switch
 import scala.collection.{ immutable, mutable }
 import collection.convert.Wrappers.JListWrapper
 
-import dotc.ast.Trees.Tree
-import dotc.core.Types.Type
-import dotc.core.Symbols.{Symbol, NoSymbol}
+import ast.Trees.Tree
+import core.Contexts.Context
+import core.Types.Type
+import core.Symbols.{Symbol, NoSymbol}
 
 /*
  *  A high-level facade to the ASM API for bytecode generation.
@@ -692,7 +692,7 @@ abstract class BCodeIdiomatic extends BCodeGlue {
     }
   }
 
-  def abort(msg: => AnyRef)(implicit ctx: core.Contexts.Context): Nothing = {
+  def abort(msg: => AnyRef)(implicit ctx: Context): Nothing = {
     ctx.error(msg)
     throw new FatalError(msg)
   }
diff --git a/src/dotty/tools/dotc/backend/jvm/BCodeSkelBuilder.scala b/src/dotty/tools/dotc/backend/jvm/BCodeSkelBuilder.scala
index b27e6a93ff00..23b20c63497c 100755
--- a/src/dotty/tools/dotc/backend/jvm/BCodeSkelBuilder.scala
+++ b/src/dotty/tools/dotc/backend/jvm/BCodeSkelBuilder.scala
@@ -3,21 +3,18 @@
  * @author  Martin Odersky
  */
 
-
-package dotty.tools
-package dotc
-package backend
-package jvm
+package dotty.tools.dotc
+package backend.jvm
 
 import scala.collection.{ mutable, immutable }
-import scala.tools.nsc.symtab._
 import scala.annotation.switch
 
 import dotty.tools.asm
 
-import dotc.ast.Trees._
-import dotc.core.Types.Type
-import dotc.core.Symbols.{Symbol, NoSymbol}
+import ast.Trees._
+import core.Contexts.Context
+import core.Types.Type
+import core.Symbols.{Symbol, NoSymbol}
 
 /*
  *
diff --git a/src/dotty/tools/dotc/backend/jvm/BCodeSyncAndTry.scala b/src/dotty/tools/dotc/backend/jvm/BCodeSyncAndTry.scala
index 8a12d0f149df..4f80a809e0d8 100755
--- a/src/dotty/tools/dotc/backend/jvm/BCodeSyncAndTry.scala
+++ b/src/dotty/tools/dotc/backend/jvm/BCodeSyncAndTry.scala
@@ -3,20 +3,18 @@
  * @author  Martin Odersky
  */
 
-
-package dotty.tools
-package dotc
-package backend
-package jvm
+package dotty.tools.dotc
+package backend.jvm
 
 import scala.collection.{ mutable, immutable }
 import scala.annotation.switch
 
 import dotty.tools.asm
 
-import dotc.ast.Trees._
-import dotc.core.Types.Type
-import dotc.core.Symbols.{Symbol, NoSymbol}
+import ast.Trees._
+import core.Contexts.Context
+import core.Types.Type
+import core.Symbols.{Symbol, NoSymbol}
 
 /*
  *
@@ -29,8 +27,8 @@ abstract class BCodeSyncAndTry extends BCodeBodyBuilder {
   /*
    * Functionality to lower `synchronized` and `try` expressions.
    */
-  abstract class SyncAndTryBuilder(cunit: CompilationUnit,
-                                   ctx:   dotc.core.Contexts.Context) extends PlainBodyBuilder(cunit, ctx) {
+  abstract class SyncAndTryBuilder(cunit: CompilationUnit)
+  extends PlainBodyBuilder(cunit) {
 
     import ast.tpd._
 
diff --git a/src/dotty/tools/dotc/backend/jvm/BCodeTypes.scala b/src/dotty/tools/dotc/backend/jvm/BCodeTypes.scala
index bf95c5c95144..4f56204376f8 100755
--- a/src/dotty/tools/dotc/backend/jvm/BCodeTypes.scala
+++ b/src/dotty/tools/dotc/backend/jvm/BCodeTypes.scala
@@ -3,19 +3,19 @@
  * @author  Martin Odersky
  */
 
-package dotty.tools
-package dotc
+package dotty.tools.dotc
 package backend.jvm
 
 import dotty.tools.asm
 import scala.collection.{ immutable, mutable }
 
-import dotc.ast.Trees.Tree
-import dotc.core.Types.Type
-import dotc.core.StdNames
-import dotc.core.Symbols.{Symbol, NoSymbol}
-import dotc.core.SymDenotations._
-import dotc.core.Flags
+import ast.Trees.Tree
+import core.Contexts.Context
+import core.Types.Type
+import core.StdNames
+import core.Symbols.{Symbol, NoSymbol}
+import core.SymDenotations._
+import core.Flags
 
 import StdNames.{nme, tpnme}
 
@@ -78,7 +78,7 @@ abstract class BCodeTypes extends BCodeIdiomatic {
   /*
    * must-single-thread
    */
-  def initBCodeTypes(implicit ctx: core.Contexts.Context): Unit = {
+  def initBCodeTypes(implicit ctx: Context): Unit = {
 
     import core.Symbols.defn
 
@@ -334,7 +334,7 @@ abstract class BCodeTypes extends BCodeIdiomatic {
   final def isDeprecated(sym: Symbol): Boolean = { sym.annotations exists (_ matches definitions.DeprecatedAttr) }
 
   /* must-single-thread */
-  final def hasInternalName(sym: Symbol)(implicit ctx: core.Contexts.Context) = (
+  final def hasInternalName(sym: Symbol)(implicit ctx: Context) = (
     sym.isClass ||
     ((sym is Flags.ModuleVal) && !(sym is Flags.Method))
   )
@@ -383,10 +383,8 @@ abstract class BCodeTypes extends BCodeIdiomatic {
    * On the other hand, this method does record the inner-class status of the argument, via `buildExemplar()`.
    *
    * must-single-thread
-   * 
-   * TODO(lry) check if ctx should be a class parameter
    */
-  final def exemplar(csym0: Symbol)(implicit ctx: dotc.core.Contexts.Context): Tracked = {
+  final def exemplar(csym0: Symbol)(implicit ctx: Context): Tracked = {
     assert(csym0 != NoSymbol, "NoSymbol can't be tracked")
 
     val csym = {
diff --git a/src/dotty/tools/dotc/backend/jvm/BytecodeWriters.scala b/src/dotty/tools/dotc/backend/jvm/BytecodeWriters.scala
index f71e511d5303..cb528dc06c78 100755
--- a/src/dotty/tools/dotc/backend/jvm/BytecodeWriters.scala
+++ b/src/dotty/tools/dotc/backend/jvm/BytecodeWriters.scala
@@ -3,14 +3,15 @@
  * @author  Martin Odersky
  */
 
-package dotty.tools
-package dotc
+package dotty.tools.dotc
 package backend.jvm
 
+import scala.language.postfixOps
+
 import java.io.{ DataOutputStream, FileOutputStream, IOException, OutputStream, File => JFile }
-import scala.tools.nsc.io._
 import java.util.jar.Attributes.Name
-import scala.language.postfixOps
+
+import dotty.tools.io._
 
 /** Can't output a file due to the state of the file system. */
 class FileConflictException(msg: String, val file: AbstractFile) extends IOException(msg)
diff --git a/src/dotty/tools/dotc/backend/jvm/GenBCode.scala b/src/dotty/tools/dotc/backend/jvm/GenBCode.scala
index 03fecd0998f0..a906badf3166 100755
--- a/src/dotty/tools/dotc/backend/jvm/GenBCode.scala
+++ b/src/dotty/tools/dotc/backend/jvm/GenBCode.scala
@@ -3,20 +3,19 @@
  * @author  Martin Odersky
  */
 
-
-package dotty.tools
-package dotc
-package backend
-package jvm
+package dotty.tools.dotc
+package backend.jvm
 
 import scala.collection.{ mutable, immutable }
 import scala.annotation.switch
 
 import dotty.tools.asm
 
-import dotc.ast.Trees
-import dotc.core.Types.Type
-import dotc.core.Symbols.{Symbol, NoSymbol}
+import ast.Trees._
+import core.Contexts.Context
+import core.Phases.Phase
+import core.Types.Type
+import core.Symbols.{Symbol, NoSymbol}
 
 /*
  *  Prepare in-memory representations of classfiles using the ASM Tree API, and serialize them to disk.
@@ -49,22 +48,26 @@ import dotc.core.Symbols.{Symbol, NoSymbol}
  */
 object GenBCode extends BCodeSyncAndTry {
 
-  final class PlainClassBuilder(cunit: CompilationUnit,
-                                ctx:   dotc.core.Contexts.Context) extends SyncAndTryBuilder(cunit, ctx)
+  import ast.tpd._
+
+  final class PlainClassBuilder(cunit: CompilationUnit)(implicit protected val ctx: Context)
+  extends SyncAndTryBuilder(cunit)
 
-  class BCodePhase extends dotc.core.Phases.Phase {
+  class BCodePhase extends Phase {
 
-    override def name = "jvm"
+    def name = "jvm"
     override def description = "Generate bytecode from ASTs using the ASM library"
-    override def erasedTypes = true
+//    override def erasedTypes = true // TODO(lrytz) remove, probably not necessary in dotty
 
     private var bytecodeWriter  : BytecodeWriter   = null
+    // TODO(lrytz): pass builders around instead of storing them in fields. Builders
+    // have a context, potential for memory leaks.
     private var mirrorCodeGen   : JMirrorBuilder   = null
     private var beanInfoCodeGen : JBeanInfoBuilder = null
 
     /* ---------------- q1 ---------------- */
 
-    case class Item1(arrivalPos: Int, cd: ast.tpd.TypeDef, cunit: CompilationUnit) {
+    case class Item1(arrivalPos: Int, cd: TypeDef, cunit: CompilationUnit) {
       def isPoison = { arrivalPos == Int.MaxValue }
     }
     private val poison1 = Item1(Int.MaxValue, null, null)
@@ -76,7 +79,7 @@ object GenBCode extends BCodeSyncAndTry {
                      mirror:       asm.tree.ClassNode,
                      plain:        asm.tree.ClassNode,
                      bean:         asm.tree.ClassNode,
-                     outFolder:    scala.tools.nsc.io.AbstractFile) {
+                     outFolder:    dotty.tools.io.AbstractFile) {
       def isPoison = { arrivalPos == Int.MaxValue }
     }
 
@@ -101,7 +104,7 @@ object GenBCode extends BCodeSyncAndTry {
                      mirror:     SubItem3,
                      plain:      SubItem3,
                      bean:       SubItem3,
-                     outFolder:  scala.tools.nsc.io.AbstractFile) {
+                     outFolder:  dotty.tools.io.AbstractFile) {
 
       def isPoison  = { arrivalPos == Int.MaxValue }
     }
@@ -118,8 +121,7 @@ object GenBCode extends BCodeSyncAndTry {
     /*
      *  Pipeline that takes ClassDefs from queue-1, lowers them into an intermediate form, placing them on queue-2
      */
-    class Worker1(needsOutFolder: Boolean,
-                  implicit val ctx: dotc.core.Contexts.Context) {
+    class Worker1(needsOutFolder: Boolean, implicit val ctx: Context) {
 
       val caseInsensitively = mutable.Map.empty[String, Symbol]
 
@@ -263,7 +265,7 @@ object GenBCode extends BCodeSyncAndTry {
      *    (c) tear down (closing the classfile-writer and clearing maps)
      *
      */
-    def runOn(units: List[CompilationUnit])(implicit ctx: dotc.core.Contexts.Context): Unit = {
+    def runOn(units: List[CompilationUnit])(implicit ctx: Context): Unit = {
 
       arrivalPos = 0 // just in case
       scalaPrimitives.init
@@ -297,7 +299,7 @@ object GenBCode extends BCodeSyncAndTry {
       clearBCodeTypes()
     }
 
-    override def run(implicit ctx: dotc.core.Contexts.Context): Unit = unsupported("run()")
+    override def run(implicit ctx: Context): Unit = unsupported("run()")
 
     /*
      *  Sequentially:
@@ -308,7 +310,7 @@ object GenBCode extends BCodeSyncAndTry {
      */
     private def buildAndSendToDisk(needsOutFolder: Boolean,
                                    units: List[CompilationUnit],
-                                   ctx: dotc.core.Contexts.Context) {
+                                   ctx: Context) {
 
       feedPipeline1(units)
       (new Worker1(needsOutFolder, ctx)).run()
@@ -319,14 +321,14 @@ object GenBCode extends BCodeSyncAndTry {
 
     /* Feed pipeline-1: place all ClassDefs on q1, recording their arrival position. */
     private def feedPipeline1(units: List[CompilationUnit]): Unit = {
-      units forech apply
+      units foreach addToQ1
       q1 add poison1
     }
 
     /* Pipeline that writes classfile representations to disk. */
     private def drainQ3(): Unit = {
 
-      def sendToDisk(cfr: SubItem3, outFolder: scala.tools.nsc.io.AbstractFile): Unit = {
+      def sendToDisk(cfr: SubItem3, outFolder: dotty.tools.io.AbstractFile): Unit = {
         if (cfr != null){
           val SubItem3(jclassName, jclassBytes) = cfr
           try {
@@ -363,26 +365,19 @@ object GenBCode extends BCodeSyncAndTry {
       assert(q1.isEmpty, s"Some ClassDefs remained in the first queue: $q1")
       assert(q2.isEmpty, s"Some classfiles remained in the second queue: $q2")
       assert(q3.isEmpty, s"Some classfiles weren't written to disk: $q3")
-
     }
 
-    override def apply(cunit: CompilationUnit): Unit = {
-
-      def gen(tree: Trees.Tree): Unit = {
-
-        import Trees.{PackageDef, TypeDef}
-
+    def addToQ1(cunit: CompilationUnit): Unit = {
+      def gen(tree: Tree): Unit = {
         tree match {
-          case ast.untpd.EmptyTree  => ()
-          case ast.tpd.EmptyTree    => ()
+          case EmptyTree    => ()
           case PackageDef(_, stats) => stats foreach gen
           case cd: TypeDef          =>
             q1 add Item1(arrivalPos, cd, cunit)
             arrivalPos += 1
         }
       }
-
-      gen(cunit.body)
+      gen(cunit.tpdTree)
     }
 
   } // end of class BCodePhase
diff --git a/src/dotty/tools/dotc/backend/jvm/icodes.scala b/src/dotty/tools/dotc/backend/jvm/icodes.scala
index 1bf364527118..7d63725916c1 100755
--- a/src/dotty/tools/dotc/backend/jvm/icodes.scala
+++ b/src/dotty/tools/dotc/backend/jvm/icodes.scala
@@ -3,11 +3,8 @@
  * @author  Martin Odersky
  */
 
-
-package dotty.tools
-package dotc
-package backend
-package jvm
+package dotty.tools.dotc
+package backend.jvm
 
 object icodes {
 
diff --git a/src/dotty/tools/dotc/backend/jvm/scalaPrimitives.scala b/src/dotty/tools/dotc/backend/jvm/scalaPrimitives.scala
index c4ef47b88429..57f26c4f325f 100755
--- a/src/dotty/tools/dotc/backend/jvm/scalaPrimitives.scala
+++ b/src/dotty/tools/dotc/backend/jvm/scalaPrimitives.scala
@@ -3,11 +3,12 @@
  * @author  Martin Odersky
  */
 
-package dotty.tools
-package dotc
+package dotty.tools.dotc
 package backend.jvm
 
 import scala.collection.{ mutable, immutable }
+
+import core.Contexts.Context
 import core.Symbols.{Symbol, NoSymbol}
 
 /** Scala primitive operations are represented as methods in `Any` and
@@ -195,7 +196,7 @@ object scalaPrimitives {
   }
 
   /** Initialize the primitive map */
-  def init(implicit ctx: core.Contexts.Context): Unit = {
+  def init(implicit ctx: Context): Unit = {
 
     import core.Symbols.defn
 
diff --git a/src/dotty/tools/dotc/core/Flags.scala b/src/dotty/tools/dotc/core/Flags.scala
index f30863e305f3..65a40beee9b0 100644
--- a/src/dotty/tools/dotc/core/Flags.scala
+++ b/src/dotty/tools/dotc/core/Flags.scala
@@ -26,7 +26,7 @@ object Flags {
       }
 
     /** The intersection of this flag set and the given flag set 
-     *  TODO(lry): check if resulting flag set has a non-empty kind?
+     *  TODO(lrytz): check if resulting flag set has a non-empty kind?
      */
     def & (that: FlagSet) = FlagSet(bits & that.bits)
 
@@ -115,7 +115,7 @@ object Flags {
    *  conjunctively. I.e. for a flag conjunction `fc`,
    *  `x is fc` tests whether `x` contains all flags in `fc`.
    *
-   * TODO(lry) cannot be a value class because its erause is the same as `FlagSet`,
+   * TODO(lrytz) cannot be a value class because its erause is the same as `FlagSet`,
    * the overloaded `is` would not work. Maybe rename `is` to `isAny` and `isAll`,
    * get rid of `FlagConjunction`? Code would also be more explicit.
    */
@@ -256,7 +256,7 @@ object Flags {
   final val PackageClass = Package.toTypeFlags
 
   /** A case class or its companion object
-   *  TODO(lry): Is CaseVal set for the companion of a case class? Or for a `case object`?
+   *  TODO(lrytz): Is CaseVal set for the companion of a case class? Or for a `case object`?
    *  Or both? Is CaseClass set for the module class of a `case object`?
    */
   final val Case = commonFlag(17, "case")
@@ -524,4 +524,4 @@ object Flags {
 
   implicit def conjToFlagSet(conj: FlagConjunction): FlagSet =
     FlagSet(conj.bits)
-}
\ No newline at end of file
+}
diff --git a/src/dotty/tools/package.scala b/src/dotty/tools/package.scala
index f23b62862d27..9c66d3fc7e26 100644
--- a/src/dotty/tools/package.scala
+++ b/src/dotty/tools/package.scala
@@ -1,6 +1,9 @@
 package dotty
 
 package object tools {
+  // TODO(lrytz) there also exists the class `dotty.tools.dotc.FatalError`. The aliases here
+  // seem to be used in the `dotty.tools.io` package. Needs clean up. If `io` needs a different
+  // exception, it should have a different name.
   type FatalError = scala.reflect.internal.FatalError
   val FatalError = scala.reflect.internal.FatalError