diff --git a/project/Build.scala b/project/Build.scala
index 4dd86fa01d10..b395f6f09851 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -5,11 +5,15 @@ import java.nio.channels.FileLock
 
 object DottyBuild extends Build {
 
+  val travisMemLimit = List("-Xmx1g", "-Xss2m")
+
   val TRAVIS_BUILD = "dotty.travis.build"
 
   val agentOptions = List(
     // "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005"
     // "-agentpath:/home/dark/opt/yjp-2013-build-13072/bin/linux-x86-64/libyjpagent.so"
+    // "-agentpath:/Applications/YourKit_Java_Profiler_2015_build_15052.app/Contents/Resources/bin/mac/libyjpagent.jnilib",
+    // "-XX:+HeapDumpOnOutOfMemoryError", "-Xmx1g", "-Xss2m"
   )
 
   var partestLock: FileLock = null
@@ -79,7 +83,7 @@ object DottyBuild extends Build {
 
        val travis_build = // propagate if this is a travis build
          if (sys.props.isDefinedAt(TRAVIS_BUILD))
-           List(s"-D$TRAVIS_BUILD=${sys.props(TRAVIS_BUILD)}")
+           List(s"-D$TRAVIS_BUILD=${sys.props(TRAVIS_BUILD)}") ::: travisMemLimit
          else
            List()
 
diff --git a/src/dotty/runtime/LazyVals.scala b/src/dotty/runtime/LazyVals.scala
index 4130d4d60335..2aa45e6fd144 100644
--- a/src/dotty/runtime/LazyVals.scala
+++ b/src/dotty/runtime/LazyVals.scala
@@ -11,8 +11,8 @@ object LazyVals {
   final val BITS_PER_LAZY_VAL = 2
   final val LAZY_VAL_MASK = 3
 
-  @inline def STATE(cur: Long, ord: Long) = (cur >> (ord * BITS_PER_LAZY_VAL)) & LAZY_VAL_MASK
-  @inline def CAS(t: Object, offset: Long, e: Long, v: Long, ord: Int) = {
+  @inline def STATE(cur: Long, ord: Int) = (cur >> (ord * BITS_PER_LAZY_VAL)) & LAZY_VAL_MASK
+  @inline def CAS(t: Object, offset: Long, e: Long, v: Int, ord: Int) = {
     val mask = ~(LAZY_VAL_MASK << ord * BITS_PER_LAZY_VAL)
     val n = (e & mask) | (v << (ord * BITS_PER_LAZY_VAL))
     compareAndSet(t, offset, e, n)
@@ -65,7 +65,7 @@ object LazyVals {
     monitors(id)
   }
 
-  @inline def getOffset(obj: Object, name: String) = unsafe.objectFieldOffset(obj.getClass.getDeclaredField(name))
+  @inline def getOffset(clz: Class[_], name: String) = unsafe.objectFieldOffset(clz.getDeclaredField(name))
 
   object Names {
     final val state = "STATE"
diff --git a/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
index 009b7fb2b9f7..2e904cc23532 100644
--- a/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
+++ b/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
@@ -589,7 +589,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
     def isDeferred: Boolean = sym is Flags.Deferred
     def isPrivate: Boolean = sym is Flags.Private
     def getsJavaFinalFlag: Boolean =
-      isFinal &&  !toDenot(sym).isClassConstructor && !(sym is Flags.Mutable) &&  !(sym.enclosingClass is Flags.JavaInterface)
+      isFinal &&  !toDenot(sym).isClassConstructor && !(sym is Flags.Mutable) &&  !(sym.enclosingClass is Flags.Trait)
 
     def getsJavaPrivateFlag: Boolean =
       isPrivate //|| (sym.isPrimaryConstructor && sym.owner.isTopLevelModuleClass)
diff --git a/src/dotty/tools/dotc/Compiler.scala b/src/dotty/tools/dotc/Compiler.scala
index 1657adbbb739..102d99347c92 100644
--- a/src/dotty/tools/dotc/Compiler.scala
+++ b/src/dotty/tools/dotc/Compiler.scala
@@ -49,8 +49,7 @@ class Compiler {
       List(new PatternMatcher,
            new ExplicitOuter,
            new Splitter),
-      List(new LazyVals,
-           new SeqLiterals,
+      List(new SeqLiterals,
            new InterceptedMethods,
            new Literalize,
            new Getters,
@@ -58,11 +57,12 @@ class Compiler {
            new ResolveSuper),
       List(new Erasure),
       List(new Mixin,
+           new LazyVals,
            new Memoize,
-           new CapturedVars,
+           new CapturedVars, // capturedVars has a transformUnit: no phases should introduce local mutable vars here
            new Constructors,
            new FunctionalInterfaces),
-      List(new LambdaLift,
+      List(new LambdaLift,   // in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here
            new Flatten,
            new RestoreScopes),
       List(/*new PrivateToStatic,*/ new CollectEntryPoints, new LabelDefs, new ElimWildcardIdents, new TraitConstructors),
diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index 0a1611b61acd..de0ef3344e4e 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -2,6 +2,7 @@ package dotty.tools
 package dotc
 package ast
 
+import dotty.tools.dotc.transform.ExplicitOuter
 import dotty.tools.dotc.typer.ProtoTypes.FunProtoTyped
 import transform.SymUtils._
 import core._
@@ -243,6 +244,17 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     ta.assignType(untpd.TypeDef(cls.name, impl), cls)
   }
 
+  // { <label> def while$(): Unit = if (cond) { body; while$() } ; while$() }
+  def WhileDo(owner: Symbol, cond: Tree, body: List[Tree])(implicit ctx: Context): Tree = {
+    val sym = ctx.newSymbol(owner, nme.WHILE_PREFIX, Flags.Label | Flags.Synthetic,
+      MethodType(Nil, defn.UnitType), coord = cond.pos)
+
+    val call = Apply(ref(sym), Nil)
+    val rhs = If(cond, Block(body, call), unitLiteral)
+    Block(List(DefDef(sym, rhs)), call)
+  }
+
+
   def Import(expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import =
     ta.assignType(untpd.Import(expr, selectors), ctx.newImportSymbol(ctx.owner, expr))
 
@@ -288,7 +300,16 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     if (tp.isType) TypeTree(tp)
     else if (prefixIsElidable(tp)) Ident(tp)
     else tp.prefix match {
-      case pre: SingletonType => singleton(pre).select(tp)
+      case pre: SingletonType =>
+        val prefix =
+          singleton(pre) match {
+            case t: This if ctx.erasedTypes && !(t.symbol == ctx.owner.enclosingClass || t.symbol.isStaticOwner) =>
+              // after erasure outer paths should be respected
+              new ExplicitOuter.OuterOps(ctx).path(t.tpe.widen.classSymbol)
+            case t =>
+              t
+          }
+        prefix.select(tp)
       case pre => SelectFromTypeTree(TypeTree(pre), tp)
     } // no checks necessary
 
@@ -563,7 +584,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
           loop(from.owner, from :: froms, to :: tos)
         else {
           //println(i"change owner ${from :: froms}%, % ==> $tos of $tree")
-          new TreeTypeMap(oldOwners = from :: froms, newOwners = tos).apply(tree)
+          new TreeTypeMap(oldOwners = from :: froms, newOwners = tos)(ctx.withMode(Mode.FutureDefsOK)).apply(tree)
         }
       }
       loop(from, Nil, to :: Nil)
@@ -578,8 +599,11 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         def traverse(tree: Tree)(implicit ctx: Context) = tree match {
           case tree: DefTree =>
             val sym = tree.symbol
-            if (sym.denot(ctx.withPhase(trans)).owner == from)
-              sym.copySymDenotation(owner = to).installAfter(trans)
+            if (sym.denot(ctx.withPhase(trans)).owner == from) {
+              val d = sym.copySymDenotation(owner = to)
+              d.installAfter(trans)
+              d.transformAfter(trans, d => if (d.owner eq from) d.copySymDenotation(owner = to) else d)
+            }
             if (sym.isWeakOwner) traverseChildren(tree)
           case _ =>
             traverseChildren(tree)
diff --git a/src/dotty/tools/dotc/core/Denotations.scala b/src/dotty/tools/dotc/core/Denotations.scala
index a30cff714f62..6502c4a400a3 100644
--- a/src/dotty/tools/dotc/core/Denotations.scala
+++ b/src/dotty/tools/dotc/core/Denotations.scala
@@ -620,14 +620,9 @@ object Denotations {
         // println(s"installing $this after $phase/${phase.id}, valid = ${current.validFor}")
         // printPeriods(current)
         this.validFor = Period(ctx.runId, targetId, current.validFor.lastPhaseId)
-        if (current.validFor.firstPhaseId == targetId) {
-          // replace current with this denotation
-          var prev = current
-          while (prev.nextInRun ne current) prev = prev.nextInRun
-          prev.nextInRun = this
-          this.nextInRun = current.nextInRun
-          current.validFor = Nowhere
-        } else {
+        if (current.validFor.firstPhaseId == targetId)
+          replaceDenotation(current)
+        else {
           // insert this denotation after current
           current.validFor = Period(ctx.runId, current.validFor.firstPhaseId, targetId - 1)
           this.nextInRun = current.nextInRun
@@ -637,6 +632,33 @@ object Denotations {
       }
     }
 
+    /** Apply a transformation `f` to all denotations in this group that start at or after
+     *  given phase. Denotations are replaced while keeping the same validity periods.
+     */
+    protected def transformAfter(phase: DenotTransformer, f: SymDenotation => SymDenotation)(implicit ctx: Context): Unit = {
+      var current = symbol.current
+      while (current.validFor.firstPhaseId < phase.id && (current.nextInRun.validFor.code > current.validFor.code))
+        current = current.nextInRun
+      var hasNext = true
+      while ((current.validFor.firstPhaseId >= phase.id) && hasNext) {
+        val current1: SingleDenotation = f(current.asSymDenotation)
+        if (current1 ne current) {
+          current1.validFor = current.validFor
+          current1.replaceDenotation(current)
+        }
+        hasNext = current1.nextInRun.validFor.code > current1.validFor.code
+        current = current1.nextInRun
+      }
+    }
+
+    private def replaceDenotation(current: SingleDenotation): Unit = {
+      var prev = current
+      while (prev.nextInRun ne current) prev = prev.nextInRun
+      prev.nextInRun = this
+      this.nextInRun = current.nextInRun
+      current.validFor = Nowhere
+    }
+
     def staleSymbolError(implicit ctx: Context) = {
       def ownerMsg = this match {
         case denot: SymDenotation => s"in ${denot.owner}"
diff --git a/src/dotty/tools/dotc/core/SymDenotations.scala b/src/dotty/tools/dotc/core/SymDenotations.scala
index 83499ca7b53c..bcd46810e0eb 100644
--- a/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -1043,6 +1043,12 @@ object SymDenotations {
     /** Install this denotation as the result of the given denotation transformer. */
     override def installAfter(phase: DenotTransformer)(implicit ctx: Context): Unit =
       super.installAfter(phase)
+
+    /** Apply a transformation `f` to all denotations in this group that start at or after
+     *  given phase. Denotations are replaced while keeping the same validity periods.
+     */
+    override def transformAfter(phase: DenotTransformer, f: SymDenotation => SymDenotation)(implicit ctx: Context): Unit =
+      super.transformAfter(phase, f)
   }
 
   /** The contents of a class definition during a period
diff --git a/src/dotty/tools/dotc/core/pickling/NameBuffer.scala b/src/dotty/tools/dotc/core/pickling/NameBuffer.scala
index 2a6239c5a49a..7ea94089fa9e 100644
--- a/src/dotty/tools/dotc/core/pickling/NameBuffer.scala
+++ b/src/dotty/tools/dotc/core/pickling/NameBuffer.scala
@@ -11,7 +11,7 @@ import scala.io.Codec
 import TastyName._
 import PickleFormat._
 
-class NameBuffer extends TastyBuffer(100000) {
+class NameBuffer extends TastyBuffer(10000) {
 
   private val nameRefs = new mutable.LinkedHashMap[TastyName, NameRef]
 
diff --git a/src/dotty/tools/dotc/core/pickling/PositionPickler.scala b/src/dotty/tools/dotc/core/pickling/PositionPickler.scala
index e8a0b3d0173f..1e36105cb3c6 100644
--- a/src/dotty/tools/dotc/core/pickling/PositionPickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/PositionPickler.scala
@@ -38,7 +38,7 @@ object PositionPickler {
 import PositionPickler._
 
 class PositionPickler(pickler: TastyPickler, addrOfTree: Tree => Option[Addr]) {
-  val buf = new TastyBuffer(100000)
+  val buf = new TastyBuffer(5000)
   pickler.newSection("Positions", buf)
   import buf._
 
diff --git a/src/dotty/tools/dotc/core/pickling/TastyBuffer.scala b/src/dotty/tools/dotc/core/pickling/TastyBuffer.scala
index a67722227bab..f57c15a3d8a8 100644
--- a/src/dotty/tools/dotc/core/pickling/TastyBuffer.scala
+++ b/src/dotty/tools/dotc/core/pickling/TastyBuffer.scala
@@ -44,7 +44,8 @@ class TastyBuffer(initialSize: Int) {
 
   /** Write a byte of data. */
   def writeByte(b: Int): Unit = {
-    if (length == bytes.length) bytes = dble(bytes)
+    if (length >= bytes.length)
+      bytes = dble(bytes)
     bytes(length) = b.toByte
     length += 1
   }
@@ -116,6 +117,8 @@ class TastyBuffer(initialSize: Int) {
   def putNat(at: Addr, x: Int, width: Int): Unit = {
     var y = x
     var w = width
+    if(at.index + w >= bytes.length)
+      bytes = dble(bytes)
     var digit = y & 0x7f | 0x80
     while (w > 0) {
       w -= 1
diff --git a/src/dotty/tools/dotc/core/pickling/TreeBuffer.scala b/src/dotty/tools/dotc/core/pickling/TreeBuffer.scala
index c224fc30ba7b..393ffd2789bc 100644
--- a/src/dotty/tools/dotc/core/pickling/TreeBuffer.scala
+++ b/src/dotty/tools/dotc/core/pickling/TreeBuffer.scala
@@ -8,10 +8,9 @@ import TastyBuffer.{Addr, AddrWidth}
 import config.Printers.pickling
 import ast.tpd.Tree
 
-class TreeBuffer extends TastyBuffer(1000000) {
+class TreeBuffer extends TastyBuffer(50000) {
 
   private final val ItemsOverOffsets = 2
-
   private val initialOffsetSize = bytes.length / (AddrWidth * ItemsOverOffsets)
   private var offsets = new Array[Int](initialOffsetSize)
   private var isRelative = new Array[Boolean](initialOffsetSize)
diff --git a/src/dotty/tools/dotc/transform/Constructors.scala b/src/dotty/tools/dotc/transform/Constructors.scala
index cd64497e9a26..ddd64d500e14 100644
--- a/src/dotty/tools/dotc/transform/Constructors.scala
+++ b/src/dotty/tools/dotc/transform/Constructors.scala
@@ -80,11 +80,10 @@ class Constructors extends MiniPhaseTransform with SymTransformer { thisTransfor
     //  (2) If the parameter accessor reference was to an alias getter,
     //      drop the () when replacing by the parameter.
     object intoConstr extends TreeMap {
-      private var excluded: FlagSet = _
       override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
         case Ident(_) | Select(This(_), _) =>
           var sym = tree.symbol
-          if (sym is (ParamAccessor, butNot = excluded)) sym = sym.subst(accessors, paramSyms)
+          if (sym is (ParamAccessor, butNot = Mutable)) sym = sym.subst(accessors, paramSyms)
           if (sym.owner.isConstructor) ref(sym).withPos(tree.pos) else tree
         case Apply(fn, Nil) =>
           val fn1 = transform(fn)
@@ -95,9 +94,8 @@ class Constructors extends MiniPhaseTransform with SymTransformer { thisTransfor
           if (noDirectRefsFrom(tree)) tree else super.transform(tree)
       }
 
-      def apply(tree: Tree, inSuperCall: Boolean = false)(implicit ctx: Context): Tree = {
-        this.excluded = if (inSuperCall) EmptyFlags else Mutable
-        transform(tree)
+      def apply(tree: Tree, prevOwner: Symbol)(implicit ctx: Context): Tree = {
+        transform(tree).changeOwnerAfter(prevOwner, constr.symbol, thisTransform)
       }
     }
 
@@ -153,19 +151,19 @@ class Constructors extends MiniPhaseTransform with SymTransformer { thisTransfor
             val sym = stat.symbol
             if (isRetained(sym)) {
               if (!stat.rhs.isEmpty && !isWildcardArg(stat.rhs))
-                constrStats += Assign(ref(sym), intoConstr(stat.rhs)).withPos(stat.pos)
+                constrStats += Assign(ref(sym), intoConstr(stat.rhs, sym)).withPos(stat.pos)
               clsStats += cpy.ValDef(stat)(rhs = EmptyTree)
             }
             else if (!stat.rhs.isEmpty) {
               sym.copySymDenotation(
                 initFlags = sym.flags &~ Private,
                 owner = constr.symbol).installAfter(thisTransform)
-              constrStats += intoConstr(stat)
+              constrStats += intoConstr(stat, sym)
             }
           case _: DefTree =>
             clsStats += stat
           case _ =>
-            constrStats += intoConstr(stat)
+            constrStats += intoConstr(stat, tree.symbol)
         }
         splitStats(stats1)
       case Nil =>
diff --git a/src/dotty/tools/dotc/transform/Erasure.scala b/src/dotty/tools/dotc/transform/Erasure.scala
index 79db568b8a8d..51a06f9ff37b 100644
--- a/src/dotty/tools/dotc/transform/Erasure.scala
+++ b/src/dotty/tools/dotc/transform/Erasure.scala
@@ -502,6 +502,8 @@ object Erasure extends TypeTestsCasts{
 
       traverse(newStats, oldStats)
     }
+    
+    private final val NoBridgeFlags = Flags.Accessor | Flags.Deferred | Flags.Lazy
 
     /** Create a bridge DefDef which overrides a parent method.
      *
@@ -520,7 +522,7 @@ object Erasure extends TypeTestsCasts{
         ???
       }
       val bridge = ctx.newSymbol(currentClass,
-        parentSym.name, parentSym.flags | Flags.Bridge, parentSym.info, coord = newDefSym.owner.coord).asTerm
+        parentSym.name, parentSym.flags &~ NoBridgeFlags | Flags.Bridge, parentSym.info, coord = newDefSym.owner.coord).asTerm
       bridge.enteredAfter(ctx.phase.prev.asInstanceOf[DenotTransformer]) // this should be safe, as we're executing in context of next phase
       ctx.debuglog(s"generating bridge from ${newDefSym} to $bridge")
 
diff --git a/src/dotty/tools/dotc/transform/ExplicitOuter.scala b/src/dotty/tools/dotc/transform/ExplicitOuter.scala
index 9fc164d3b4b9..20e367e1f382 100644
--- a/src/dotty/tools/dotc/transform/ExplicitOuter.scala
+++ b/src/dotty/tools/dotc/transform/ExplicitOuter.scala
@@ -28,8 +28,8 @@ import collection.mutable
  *
  *   - add outer parameters to constructors
  *   - pass outer arguments in constructor calls
- *   - replace outer this by outer paths.
  *
+ *   replacement of outer this by outer paths is done in Erasure.
  *   needs to run after pattern matcher as it can add outer checks and force creation of $outer
  */
 class ExplicitOuter extends MiniPhaseTransform with InfoTransformer { thisTransformer =>
diff --git a/src/dotty/tools/dotc/transform/Getters.scala b/src/dotty/tools/dotc/transform/Getters.scala
index 918a92a041dc..e1c35febaf82 100644
--- a/src/dotty/tools/dotc/transform/Getters.scala
+++ b/src/dotty/tools/dotc/transform/Getters.scala
@@ -16,15 +16,21 @@ import Decorators._
 /** Performs the following rewritings for fields of a class:
  *
  *    <mods> val x: T = e
- *      -->  <mods> <stable> def x: T = e
+ *      -->  <mods> <stable> <accessor> def x: T = e
  *    <mods> var x: T = e
- *      -->  <mods> def x: T = e
+ *      -->  <mods> <accessor> def x: T = e
  *
  *    <mods> val x: T
- *      -->  <mods> <stable> def x: T
+ *      -->  <mods> <stable> <accessor> def x: T
+ *
+ *    <mods> lazy val x: T = e
+ *      -->  <mods> <accessor> lazy def x: T =e
  *
  *    <mods> var x: T
- *      -->  <mods> def x: T
+ *      -->  <mods> <accessor> def x: T
+ *
+ *    <mods> non-static <module> val x$ = e
+ *      -->  <mods> <module> <accessor> def x$ = e
  *
  *  Omitted from the rewritings are
  *
@@ -47,10 +53,10 @@ class Getters extends MiniPhaseTransform with SymTransformer { thisTransform =>
   override def transformSym(d: SymDenotation)(implicit ctx: Context): SymDenotation = {
     def noGetterNeeded =
       d.is(NoGetterNeeded) ||
-      d.initial.asInstanceOf[SymDenotation].is(PrivateLocal) && !d.owner.is(Trait) ||
+      d.initial.asInstanceOf[SymDenotation].is(PrivateLocal) && !d.owner.is(Trait) && !d.is(Flags.Lazy) ||
       d.is(Module) && d.isStatic ||
       d.isSelfSym
-    if (d.isTerm && d.owner.isClass && d.info.isValueType && !noGetterNeeded) {
+    if (d.isTerm && (d.is(Lazy) || d.owner.isClass) && d.info.isValueType && !noGetterNeeded) {
       val maybeStable = if (d.isStable) Stable else EmptyFlags
       d.copySymDenotation(
         initFlags = d.flags | maybeStable | AccessorCreationFlags,
@@ -58,7 +64,7 @@ class Getters extends MiniPhaseTransform with SymTransformer { thisTransform =>
     }
     else d
   }
-  private val NoGetterNeeded = Method | Param | JavaDefined | JavaStatic | Lazy
+  private val NoGetterNeeded = Method | Param | JavaDefined | JavaStatic
 
   override def transformValDef(tree: ValDef)(implicit ctx: Context, info: TransformerInfo): Tree =
     if (tree.symbol is Method) DefDef(tree.symbol.asTerm, tree.rhs) else tree
diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index a28102d7b744..62dc2f085531 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -1,6 +1,8 @@
 package dotty.tools.dotc
 package transform
 
+import dotty.tools.dotc.typer.Mode
+
 import scala.collection.mutable
 import core._
 import Contexts._
@@ -14,54 +16,46 @@ import dotty.tools.dotc.ast.{untpd, tpd}
 import dotty.tools.dotc.core.Constants.Constant
 import dotty.tools.dotc.core.Types.{ExprType, NoType, MethodType}
 import dotty.tools.dotc.core.Names.Name
-import dotty.runtime.{LazyVals => RLazyVals} // dotty deviation
 import SymUtils._
 import scala.collection.mutable.ListBuffer
 import dotty.tools.dotc.core.Denotations.SingleDenotation
 import dotty.tools.dotc.core.SymDenotations.SymDenotation
 import dotty.tools.dotc.core.DenotTransformers.{SymTransformer, IdentityDenotTransformer, DenotTransformer}
+import Erasure.Boxing.adaptToType
 
-class LazyVals extends MiniPhaseTransform with SymTransformer {
+class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
+  import LazyVals._
 
   import tpd._
 
-
-  def transformSym(d: SymDenotation)(implicit ctx: Context): SymDenotation = {
-    if (d is(Flags.Lazy, butNot = Flags.ModuleVal | Flags.Method)) {
-      // Method flag is set on lazy vals coming from Unpickler. They are already methods and shouldn't be transformed twice
-      d.copySymDenotation(
-        initFlags = d.flags | Flags.Method,
-        info = ExprType(d.info))
-    }
-    else d
-  }
-
   def transformer = new LazyVals
 
   val containerFlags = Flags.Synthetic | Flags.Mutable | Flags.Lazy
-  val initFlags = Flags.Synthetic | Flags.Method
+  val initFlags      = Flags.Synthetic | Flags.Method
+
+  val containerFlagsMask = Flags.Method | Flags.Lazy | Flags.Accessor | Flags.Module
 
   /** this map contains mutable state of transformation: OffsetDefs to be appended to companion object definitions,
     * and number of bits currently used */
   class OffsetInfo(var defs: List[Tree], var ord:Int)
-  val appendOffsetDefs = mutable.Map.empty[Name, OffsetInfo]
+  val appendOffsetDefs = mutable.Map.empty[Symbol, OffsetInfo]
 
   override def phaseName: String = "LazyVals"
 
-    /** List of names of phases that should have finished processing of tree
-      * before this phase starts processing same tree */
-    // override def ensureAfter: Set[String] = Set("mixin")
+  /** List of names of phases that should have finished processing of tree
+    * before this phase starts processing same tree */
+  override def runsAfter = Set(classOf[Mixin])
 
-    override def transformValDef(tree: ValDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
-      if (!(tree.mods is Flags.Lazy) || (tree.mods is Flags.ModuleVal)) tree
+    override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
+      if (!(tree.symbol is Flags.Lazy) || tree.symbol.owner.is(Flags.Trait)) tree
       else {
-        val isField = tree.symbol.owner.isClass
+          val isField = tree.symbol.owner.isClass
 
-        if (isField) {
-          if (tree.symbol.isVolatile) transformFieldValDefVolatile(tree)
-          else transformFieldValDefNonVolatile(tree)
-        }
-        else transformLocalValDef(tree)
+          if (isField) {
+            if (tree.symbol.isVolatile || tree.symbol.is(Flags.Module)) transformMemberDefVolatile(tree)
+            else transformMemberDefNonVolatile(tree)
+          }
+          else transformLocalDef(tree)
       }
     }
 
@@ -70,11 +64,12 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
     override def transformTypeDef(tree: TypeDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
       if (!tree.symbol.isClass) tree
       else {
-        appendOffsetDefs.get(tree.symbol.name) match {
+        appendOffsetDefs.get(tree.symbol) match {
           case None => tree
           case Some(data) =>
             val template = tree.rhs.asInstanceOf[Template]
-            ClassDef(tree.symbol.asClass, template.constr, data.defs.mapConserve(transformFollowingDeep) ::: template.body)
+            val newTemplate = cpy.Template(template)(body = data.defs ::: template.body)
+            cpy.TypeDef(tree)(rhs = newTemplate) //(ctx.withMode(Mode.FutureDefsOK))
         }
       }
     }
@@ -82,12 +77,11 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
       * with a LazyHolder from
       * dotty.runtime(eg dotty.runtime.LazyInt)
       */
-    def transformLocalValDef(x: ValDef)(implicit ctx: Context) = x match {
-      case ValDef(name, tpt, _) =>
+    def transformLocalDef(x: DefDef)(implicit ctx: Context) = {
         val valueInitter = x.rhs
-        val holderName = ctx.freshName(name.toString + StdNames.nme.LAZY_LOCAL).toTermName
-        val initName = ctx.freshName(name.toString + StdNames.nme.LAZY_LOCAL_INIT).toTermName
-        val tpe = x.tpe.widen
+        val holderName = ctx.freshName(x.name ++ StdNames.nme.LAZY_LOCAL).toTermName
+        val initName = ctx.freshName(x.name ++ StdNames.nme.LAZY_LOCAL_INIT).toTermName
+        val tpe = x.tpe.widen.resultType.widen
 
         val holderType =
           if (tpe isRef defn.IntClass) "LazyInt"
@@ -105,17 +99,19 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
 
         val holderSymbol = ctx.newSymbol(x.symbol.owner, holderName, containerFlags, holderImpl.typeRef, coord = x.pos)
         val initSymbol = ctx.newSymbol(x.symbol.owner, initName, initFlags, MethodType(Nil, tpe), coord = x.pos)
-        val result = ref(holderSymbol).select("value".toTermName)
-        val flag = ref(holderSymbol).select("initialized".toTermName)
+        val result = ref(holderSymbol).select(lazyNme.value)
+        val flag = ref(holderSymbol).select(lazyNme.initialized)
         val initer = valueInitter.changeOwner(x.symbol, initSymbol)
         val initBody =
-          ref(holderSymbol).select(defn.Object_synchronized).appliedToType(tpe).appliedTo(
-          mkNonThreadSafeDef(result, flag, initer).ensureConforms(tpe))
+          adaptToType(
+            ref(holderSymbol).select(defn.Object_synchronized).appliedTo(
+              adaptToType(mkNonThreadSafeDef(result, flag, initer), defn.ObjectType)),
+            tpe)
         val initTree = DefDef(initSymbol, initBody)
         val holderTree = ValDef(holderSymbol, New(holderImpl.typeRef, List()))
         val methodBody = {
           tpd.If(flag, EmptyTree, ref(initSymbol))
-          result.ensureConforms(tpe)
+          result.ensureApplied.ensureConforms(tpe)
           }
         val methodTree = DefDef(x.symbol.asTerm, methodBody)
         ctx.debuglog(s"found a lazy val ${x.show},\n rewrote with ${holderTree.show}")
@@ -124,7 +120,16 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
 
 
   override def transformStats(trees: List[tpd.Tree])(implicit ctx: Context, info: TransformerInfo): List[tpd.Tree] = {
-    val (holders, stats) = trees.partition { _.symbol.flags == containerFlags}
+    // backend requires field usage to be after field definition
+    // need to bring containers to start of method
+    val (holders, stats) =
+      atGroupEnd { implicit ctx: Context =>
+        trees.partition {
+          _.symbol.flags.&~(Flags.Touched) == containerFlags
+          // Filtering out Flags.Touched is not required currently, as there are no LazyTypes involved here
+          // but just to be more safe
+        }
+      }
     holders:::stats
   }
 
@@ -140,10 +145,10 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
       */
 
     def mkNonThreadSafeDef(target: Tree, flag: Tree, rhs: Tree)(implicit ctx: Context) = {
-      val setFlag = Assign(flag, Literal(Constants.Constant(true)))
-      val setTarget = Assign(target, rhs)
-      val init = Block(List(setFlag, setTarget), target)
-      If(flag, target, init)
+      val setFlag = flag.becomes(Literal(Constants.Constant(true)))
+      val setTarget = target.becomes(rhs)
+      val init = Block(List(setFlag, setTarget), target.ensureApplied)
+      If(flag.ensureApplied, target.ensureApplied, init)
     }
 
     /** Create non-threadsafe lazy accessor for not-nullable types  equivalent to such code
@@ -157,34 +162,36 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
     def mkDefNonThreadSafeNonNullable(target: Symbol, rhs: Tree)(implicit ctx: Context) = {
       val cond = ref(target).select(nme.eq).appliedTo(Literal(Constant(null)))
       val exp = ref(target)
-      val setTarget = Assign(exp, rhs)
+      val setTarget = exp.becomes(rhs)
       val init = Block(List(setTarget), exp)
       If(cond, init, exp)
     }
 
-    def transformFieldValDefNonVolatile(x: ValDef)(implicit ctx: Context) = x match {
-      case ValDef(name, tpt, _) if (x.mods is Flags.Lazy) =>
+    def transformMemberDefNonVolatile(x: DefDef)(implicit ctx: Context) = {
         val claz = x.symbol.owner.asClass
-        val tpe = x.tpe.widen
+        val tpe = x.tpe.widen.resultType.widen
         assert(!(x.mods is Flags.Mutable))
-        val containerName = ctx.freshName(name.toString + StdNames.nme.LAZY_LOCAL).toTermName
-        val containerSymbol = ctx.newSymbol(claz, containerName, (x.mods &~ Flags.Lazy | containerFlags).flags, tpe, coord = x.symbol.coord).enteredAfter(this)
+        val containerName = ctx.freshName(x.name ++ StdNames.nme.LAZY_LOCAL).toTermName
+        val containerSymbol = ctx.newSymbol(claz, containerName,
+          x.symbol.flags &~ containerFlagsMask | containerFlags | Flags.Private,
+          tpe, coord = x.symbol.coord
+        ).entered
 
         val containerTree = ValDef(containerSymbol, initValue(tpe))
-        if (x.tpe.isNotNull && tpe <:< defn.AnyRefType) { // can use 'null' value instead of flag
+        if (x.tpe.isNotNull && tpe <:< defn.ObjectType) { // can use 'null' value instead of flag
           val slowPath = DefDef(x.symbol.asTerm, mkDefNonThreadSafeNonNullable(containerSymbol, x.rhs))
           Thicket(List(containerTree, slowPath))
         }
         else {
-          val flagName = ctx.freshName(name.toString + StdNames.nme.BITMAP_PREFIX).toTermName
-          val flagSymbol = ctx.newSymbol(x.symbol.owner, flagName,  containerFlags, defn.BooleanType)
+          val flagName = ctx.freshName(x.name ++ StdNames.nme.BITMAP_PREFIX).toTermName
+          val flagSymbol = ctx.newSymbol(x.symbol.owner, flagName,  containerFlags | Flags.Private, defn.BooleanType).entered
           val flag = ValDef(flagSymbol, Literal(Constants.Constant(false)))
           val slowPath = DefDef(x.symbol.asTerm, mkNonThreadSafeDef(ref(containerSymbol), ref(flagSymbol), x.rhs))
           Thicket(List(containerTree, flag, slowPath))
         }
     }
 
-    /** Create non-threadsafe lazy accessor equivalent to such code
+    /** Create a threadsafe lazy accessor equivalent to such code
       *
       * def methodSymbol(): Int = {
       *   val result: Int = 0
@@ -215,39 +222,38 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
       *     }
       *   result
       * }
-      * FIXME: Don't use strings with toTermName, use predefined names instead.
       */
     def mkThreadSafeDef(methodSymbol: TermSymbol, claz: ClassSymbol, ord: Int, target: Symbol, rhs: Tree, tp: Types.Type, offset: Tree, getFlag: Tree, stateMask: Tree, casFlag: Tree, setFlagState: Tree, waitOnLock: Tree)(implicit ctx: Context) = {
       val initState = Literal(Constants.Constant(0))
       val computeState = Literal(Constants.Constant(1))
       val notifyState = Literal(Constants.Constant(2))
       val computedState = Literal(Constants.Constant(3))
-      val flagSymbol = ctx.newSymbol(methodSymbol, "flag".toTermName, containerFlags, defn.LongType)
+      val flagSymbol = ctx.newSymbol(methodSymbol, lazyNme.flag, containerFlags, defn.LongType)
       val flagDef = ValDef(flagSymbol, Literal(Constant(0L)))
 
       val thiz = This(claz)(ctx.fresh.setOwner(claz))
 
-      val resultSymbol = ctx.newSymbol(methodSymbol, "result".toTermName, containerFlags, tp)
+      val resultSymbol = ctx.newSymbol(methodSymbol, lazyNme.result, containerFlags, tp)
       val resultDef = ValDef(resultSymbol, initValue(tp))
 
-      val retrySymbol = ctx.newSymbol(methodSymbol, "retry".toTermName, containerFlags, defn.BooleanType)
+      val retrySymbol = ctx.newSymbol(methodSymbol, lazyNme.retry, containerFlags, defn.BooleanType)
       val retryDef = ValDef(retrySymbol, Literal(Constants.Constant(true)))
 
       val whileCond = ref(retrySymbol)
 
       val compute = {
-        val handlerSymbol = ctx.newSymbol(methodSymbol, "$anonfun".toTermName, Flags.Synthetic,
-          MethodType(List("x$1".toTermName), List(defn.ThrowableType), defn.IntType))
+        val handlerSymbol = ctx.newSymbol(methodSymbol, nme.ANON_FUN, Flags.Synthetic,
+          MethodType(List(nme.x_1), List(defn.ThrowableType), defn.IntType))
         val caseSymbol = ctx.newSymbol(methodSymbol, nme.DEFAULT_EXCEPTION_NAME, Flags.Synthetic, defn.ThrowableType)
         val complete = setFlagState.appliedTo(thiz, offset, initState, Literal(Constant(ord)))
         val handler = CaseDef(Bind(caseSymbol, ref(caseSymbol)), EmptyTree,
           Block(List(complete), Throw(ref(caseSymbol))
         ))
 
-        val compute = Assign(ref(resultSymbol), rhs)
+        val compute = ref(resultSymbol).becomes(rhs)
         val tr = Try(compute, List(handler), EmptyTree)
-        val assign = Assign(ref(target), ref(resultSymbol))
-        val noRetry = Assign(ref(retrySymbol), Literal(Constants.Constant(false)))
+        val assign = ref(target).becomes(ref(resultSymbol))
+        val noRetry = ref(retrySymbol).becomes(Literal(Constants.Constant(false)))
         val body = If(casFlag.appliedTo(thiz, offset, ref(flagSymbol), computeState, Literal(Constant(ord))),
           Block(tr :: assign :: complete :: noRetry :: Nil, Literal(Constant(()))),
           Literal(Constant(())))
@@ -266,38 +272,39 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
       }
 
       val computed = {
-        val noRetry = Assign(ref(retrySymbol), Literal(Constants.Constant(false)))
-        val result = Assign(ref(resultSymbol), ref(target))
+        val noRetry = ref(retrySymbol).becomes(Literal(Constants.Constant(false)))
+        val result = ref(resultSymbol).becomes(ref(target))
         val body = Block(noRetry :: result :: Nil, Literal(Constant(())))
         CaseDef(computedState, EmptyTree, body)
       }
 
+      val default = CaseDef(untpd.Ident(nme.WILDCARD).withType(defn.LongType), EmptyTree, Literal(Constant(())))
+
       val cases = Match(stateMask.appliedTo(ref(flagSymbol), Literal(Constant(ord))),
-        List(compute, waitFirst, waitSecond, computed)) //todo: annotate with @switch
+        List(compute, waitFirst, waitSecond, computed, default)) //todo: annotate with @switch
 
-      val whileBody = Block(List(Assign(ref(flagSymbol), getFlag.appliedTo(thiz, offset))), cases)
-      val cycle = untpd.WhileDo(whileCond, whileBody).withTypeUnchecked(defn.UnitType)
+      val whileBody = List(ref(flagSymbol).becomes(getFlag.appliedTo(thiz, offset)), cases)
+      val cycle = WhileDo(methodSymbol, whileCond, whileBody)
       DefDef(methodSymbol, Block(resultDef :: retryDef :: flagDef :: cycle :: Nil, ref(resultSymbol)))
     }
 
-    def transformFieldValDefVolatile(x: ValDef)(implicit ctx: Context) = x match {
-      case ValDef(name, tpt, _) if (x.mods is Flags.Lazy) =>
+    def transformMemberDefVolatile(x: DefDef)(implicit ctx: Context) = {
         assert(!(x.mods is Flags.Mutable))
 
-        val tpe = x.tpe.widen
+        val tpe = x.tpe.widen.resultType.widen
         val claz = x.symbol.owner.asClass
-        val thiz = This(claz)(ctx.fresh.setOwner(claz))
+        val thizClass = Literal(Constant(claz.info))
         val companion = claz.companionModule
         val helperModule = ctx.requiredModule("dotty.runtime.LazyVals")
-        val getOffset = Select(ref(helperModule), RLazyVals.Names.getOffset.toTermName)
+        val getOffset = Select(ref(helperModule), lazyNme.RLazyVals.getOffset)
         var offsetSymbol: TermSymbol = null
         var flag: Tree = EmptyTree
         var ord = 0
 
         // compute or create appropriate offsetSymol, bitmap and bits used by current ValDef
-        appendOffsetDefs.get(companion.name.moduleClassName) match {
+        appendOffsetDefs.get(companion.moduleClass) match {
           case Some(info) =>
-            val flagsPerLong = 64 / RLazyVals.BITS_PER_LAZY_VAL
+            val flagsPerLong = 64 / dotty.runtime.LazyVals.BITS_PER_LAZY_VAL
             info.ord += 1
             ord = info.ord % flagsPerLong
             val id = info.ord / flagsPerLong
@@ -310,7 +317,7 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
               val flagName = (StdNames.nme.BITMAP_PREFIX + id.toString).toTermName
               val flagSymbol = ctx.newSymbol(claz, flagName, containerFlags, defn.LongType).enteredAfter(this)
               flag = ValDef(flagSymbol, Literal(Constants.Constant(0L)))
-              val offsetTree = ValDef(offsetSymbol, getOffset.appliedTo(thiz, Literal(Constant(flagName.toString))))
+              val offsetTree = ValDef(offsetSymbol, getOffset.appliedTo(thizClass, Literal(Constant(flagName.toString))))
               info.defs = offsetTree :: info.defs
             }
 
@@ -319,20 +326,20 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
             val flagName = (StdNames.nme.BITMAP_PREFIX + "0").toTermName
             val flagSymbol = ctx.newSymbol(claz, flagName, containerFlags, defn.LongType).enteredAfter(this)
             flag = ValDef(flagSymbol, Literal(Constants.Constant(0L)))
-            val offsetTree = ValDef(offsetSymbol, getOffset.appliedTo(thiz, Literal(Constant(flagName.toString))))
-            appendOffsetDefs += (companion.name.moduleClassName -> new OffsetInfo(List(offsetTree), ord))
+            val offsetTree = ValDef(offsetSymbol, getOffset.appliedTo(thizClass, Literal(Constant(flagName.toString))))
+            appendOffsetDefs += (companion.moduleClass -> new OffsetInfo(List(offsetTree), ord))
         }
 
-        val containerName = ctx.freshName(name.toString + StdNames.nme.LAZY_LOCAL).toTermName
-        val containerSymbol = ctx.newSymbol(claz, containerName, (x.mods &~ Flags.Lazy | containerFlags).flags, tpe, coord = x.symbol.coord).enteredAfter(this)
+        val containerName = ctx.freshName(x.name ++ StdNames.nme.LAZY_LOCAL).toTermName
+        val containerSymbol = ctx.newSymbol(claz, containerName, (x.mods &~ containerFlagsMask | containerFlags).flags, tpe, coord = x.symbol.coord).entered
         val containerTree = ValDef(containerSymbol, initValue(tpe))
 
-        val offset = Select(ref(companion), offsetSymbol.name)
-        val getFlag = Select(ref(helperModule), RLazyVals.Names.get.toTermName)
-        val setFlag = Select(ref(helperModule), RLazyVals.Names.setFlag.toTermName)
-        val wait = Select(ref(helperModule), RLazyVals.Names.wait4Notification.toTermName)
-        val state = Select(ref(helperModule), RLazyVals.Names.state.toTermName)
-        val cas = Select(ref(helperModule), RLazyVals.Names.cas.toTermName)
+        val offset =  ref(companion).ensureApplied.select(offsetSymbol)
+        val getFlag = Select(ref(helperModule), lazyNme.RLazyVals.get)
+        val setFlag = Select(ref(helperModule), lazyNme.RLazyVals.setFlag)
+        val wait =    Select(ref(helperModule), lazyNme.RLazyVals.wait4Notification)
+        val state =   Select(ref(helperModule), lazyNme.RLazyVals.state)
+        val cas =     Select(ref(helperModule), lazyNme.RLazyVals.cas)
 
         val accessor = mkThreadSafeDef(x.symbol.asTerm, claz, ord, containerSymbol, x.rhs, tpe, offset, getFlag, state, cas, setFlag, wait)
         if (flag eq EmptyTree)
@@ -341,5 +348,24 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
     }
 }
 
+object LazyVals {
+  object lazyNme {
+    object RLazyVals {
+      import dotty.runtime.LazyVals._
+      val get               = Names.get.toTermName
+      val setFlag           = Names.setFlag.toTermName
+      val wait4Notification = Names.wait4Notification.toTermName
+      val state             = Names.state.toTermName
+      val cas               = Names.cas.toTermName
+      val getOffset         = Names.getOffset.toTermName
+    }
+    val flag        = "flag".toTermName
+    val result      = "result".toTermName
+    val value       = "value".toTermName
+    val initialized = "initialized".toTermName
+    val retry       = "retry".toTermName
+  }
+}
+
 
 
diff --git a/src/dotty/tools/dotc/transform/Memoize.scala b/src/dotty/tools/dotc/transform/Memoize.scala
index 75a1950328d4..d96a52868623 100644
--- a/src/dotty/tools/dotc/transform/Memoize.scala
+++ b/src/dotty/tools/dotc/transform/Memoize.scala
@@ -48,38 +48,26 @@ import Decorators._
     case _ =>
   }
 
-  override def prepareForDefDef(tree: DefDef)(implicit ctx: Context) = {
-    val sym = tree.symbol
-    if (sym.isGetter && !sym.is(NoFieldNeeded)) {
-      // allocate field early so that initializer has the right owner for subsequeny phases in
-      // the group.
-      val maybeMutable = if (sym is Stable) EmptyFlags else Mutable
-      val field = ctx.newSymbol(
-        owner = ctx.owner,
-        name = sym.name.asTermName.fieldName,
-        flags = Private | maybeMutable,
-        info = sym.info.resultType,
-        coord = tree.pos).enteredAfter(thisTransform)
-      tree.rhs.changeOwnerAfter(sym, field, thisTransform)
-    }
-    this
-  }
-
   override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
     val sym = tree.symbol
-    def field = {
-      val field = sym.field.asTerm
-      assert(field.exists, i"no field for ${sym.showLocated} in ${sym.owner.info.decls.toList.map{_.showDcl}}%; %")
-      field
-    }
+    
+    def newField = ctx.newSymbol(
+      owner = ctx.owner,
+      name = sym.name.asTermName.fieldName,
+      flags = Private | (if (sym is Stable) EmptyFlags else Mutable),
+      info = sym.info.resultType,
+      coord = tree.pos).enteredAfter(thisTransform)
+      
+    lazy val field = sym.field.orElse(newField).asTerm    
     if (sym.is(Accessor, butNot = NoFieldNeeded))
       if (sym.isGetter) {
+        tree.rhs.changeOwnerAfter(sym, field, thisTransform)
         val fieldDef = transformFollowing(ValDef(field, tree.rhs))
         val getterDef = cpy.DefDef(tree)(rhs = transformFollowingDeep(ref(field)))
         Thicket(fieldDef, getterDef)
       }
       else if (sym.isSetter) {
-        if (!sym.is(ParamAccessor)) { val Literal(Constant(())) = tree.rhs }
+        if (!sym.is(ParamAccessor)) { val Literal(Constant(())) = tree.rhs } // this is intended as an assertion
         val initializer = Assign(ref(field), ref(tree.vparamss.head.head.symbol))
         cpy.DefDef(tree)(rhs = transformFollowingDeep(initializer))
       }
diff --git a/src/dotty/tools/dotc/transform/Mixin.scala b/src/dotty/tools/dotc/transform/Mixin.scala
index 7e307c7360f0..e20468899c69 100644
--- a/src/dotty/tools/dotc/transform/Mixin.scala
+++ b/src/dotty/tools/dotc/transform/Mixin.scala
@@ -97,7 +97,9 @@ class Mixin extends MiniPhaseTransform with SymTransformer { thisTransform =>
     def traitDefs(stats: List[Tree]): List[Tree] = {
       val initBuf = new mutable.ListBuffer[Tree]
       stats flatMap {
-        case stat: DefDef if stat.symbol.isGetter && !stat.rhs.isEmpty =>
+        case stat: DefDef if stat.symbol.isGetter && !stat.rhs.isEmpty && !stat.symbol.is(Flags.Lazy)  =>
+          // make initializer that has all effects of previous getter,
+          // replace getter rhs with empty tree.
           val vsym = stat.symbol
           val isym = initializer(vsym)
           val rhs = Block(
@@ -150,7 +152,8 @@ class Mixin extends MiniPhaseTransform with SymTransformer { thisTransform =>
     def traitInits(mixin: ClassSymbol): List[Tree] =
       for (getter <- mixin.info.decls.filter(getr => getr.isGetter && !wasDeferred(getr)).toList)
         yield {
-        DefDef(implementation(getter.asTerm), superRef(initializer(getter)).appliedToNone)
+          // transformFollowing call is needed to make memoize & lazy vals run
+        transformFollowing(DefDef(implementation(getter.asTerm), superRef(initializer(getter)).appliedToNone))
       }
 
     def setters(mixin: ClassSymbol): List[Tree] =
@@ -163,7 +166,7 @@ class Mixin extends MiniPhaseTransform with SymTransformer { thisTransform =>
         if (cls is Trait) traitDefs(impl.body)
         else {
           val mixInits = mixins.flatMap { mixin =>
-            traitInits(mixin) ::: superCallOpt(mixin) ::: setters(mixin)
+            flatten(traitInits(mixin)) ::: superCallOpt(mixin) ::: setters(mixin)
           }
           superCallOpt(superCls) ::: mixInits ::: impl.body
         })
diff --git a/src/dotty/tools/dotc/transform/MixinOps.scala b/src/dotty/tools/dotc/transform/MixinOps.scala
index e6074323a436..1dce85eaa9e7 100644
--- a/src/dotty/tools/dotc/transform/MixinOps.scala
+++ b/src/dotty/tools/dotc/transform/MixinOps.scala
@@ -17,7 +17,7 @@ class MixinOps(cls: ClassSymbol, thisTransform: DenotTransformer)(implicit ctx:
     member.copy(
       owner = cls,
       name = member.name.stripScala2LocalSuffix,
-      flags = member.flags &~ Deferred &~ Module,
+      flags = member.flags &~ Deferred,
       info = cls.thisType.memberInfo(member)).enteredAfter(thisTransform).asTerm
 
   def superRef(target: Symbol, pos: Position = cls.pos): Tree = {
diff --git a/src/dotty/tools/dotc/transform/TreeChecker.scala b/src/dotty/tools/dotc/transform/TreeChecker.scala
index 1661f7576a55..7c8ba8432edc 100644
--- a/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -50,8 +50,7 @@ class TreeChecker extends Phase with SymTransformer {
 
   def testDuplicate(sym: Symbol, registry: mutable.Map[String, Symbol], typ: String)(implicit ctx: Context) = {
     val name = sym.fullName.toString
-    if (registry.contains(name))
-      if (this.flatClasses || !(sym.isAnonymousFunction || sym.isAnonymousClass || sym.isAnonymousModuleVal))
+    if (this.flatClasses && registry.contains(name))
         printError(s"$typ defined twice $sym ${sym.id} ${registry(name).id}")
     registry(name) = sym
   }
diff --git a/test/dotc/tests.scala b/test/dotc/tests.scala
index a653a2df0e9e..b3f6f0b8a72f 100644
--- a/test/dotc/tests.scala
+++ b/test/dotc/tests.scala
@@ -23,11 +23,8 @@ class tests extends CompilerTest {
       "-Ycheck:tailrec,resolveSuper,mixin,restoreScopes",
       "-d", defaultOutputDir
   )
-  val doEmitBytecode = List("-Ystop-before:terminal")
-  val failedbyName = List("-Ystop-before:collectEntryPoints") // #288
   val testPickling = List("-Xprint-types", "-Ytest-pickler", "-Ystop-after:pickler")
 
-  val failedOther = List("-Ystop-before:collectEntryPoints") // some non-obvious reason. need to look deeper
   val twice = List("#runs", "2")
   val staleSymbolError: List[String] = List()
 
@@ -35,7 +32,7 @@ class tests extends CompilerTest {
   val allowDoubleBindings = defaultOptions diff List("-Yno-double-bindings")
 
   val testsDir      = "./tests/"
-  val posDir        = testsDir + "pos/"  
+  val posDir        = testsDir + "pos/"
   val posSpecialDir = testsDir + "pos-special/"
   val negDir        = testsDir + "neg/"
   val newDir        = testsDir + "new/"
@@ -50,7 +47,7 @@ class tests extends CompilerTest {
   @Test def pickle_ast = compileDir(dotcDir, "ast", testPickling)
 
   //@Test def pickle_core = compileDir(dotcDir, "core", testPickling, xerrors = 2) // two spurious comparison errors in Types and TypeOps
-  
+
   @Test def pos_t2168_pat = compileFile(posDir, "t2168", twice)
   @Test def pos_erasure = compileFile(posDir, "erasure", twice)
   @Test def pos_Coder() = compileFile(posDir, "Coder", twice)
@@ -119,7 +116,7 @@ class tests extends CompilerTest {
   @Test def neg_tailcall = compileFile(negTailcallDir, "tailrec", xerrors = 7)
   @Test def neg_tailcall2 = compileFile(negTailcallDir, "tailrec-2", xerrors = 2)
   @Test def neg_tailcall3 = compileFile(negTailcallDir, "tailrec-3", xerrors = 2)
-  
+
   @Test def neg_t1279a = compileFile(negDir, "t1279a", xerrors = 1)
   @Test def neg_t1843_variances = compileFile(negDir, "t1843-variances", xerrors = 1)
   @Test def neg_t2660_ambi = compileFile(negDir, "t2660", xerrors = 2)
@@ -140,22 +137,14 @@ class tests extends CompilerTest {
   @Test def neg_instantiateAbstract = compileFile(negDir, "instantiateAbstract", xerrors = 8)
   @Test def neg_selfInheritance = compileFile(negDir, "selfInheritance", xerrors = 5)
 
-  @Test def dotc = compileDir(toolsDir, "dotc", failedOther)(allowDeepSubtypes ++ twice) // see dotc_core
-  @Test def dotc_ast = compileDir(dotcDir, "ast", failedOther ++ twice)
-    //similar to dotc_core_pickling but for another anon class. Still during firstTransform
+  @Test def dotc = compileDir(toolsDir, "dotc", "-deep" :: allowDeepSubtypes ++ twice) // note the -deep argument
+
+  @Test def dotc_ast = compileDir(dotcDir, "ast")
   @Test def dotc_config = compileDir(dotcDir, "config")
-  @Test def dotc_core = compileDir(dotcDir, "core", failedOther)("-Yno-double-bindings" :: allowDeepSubtypes)// twice omitted to make tests run faster
-    // error: error while loading ConstraintHandling$$anon$1$,
-    // class file 'target/scala-2.11/dotty_2.11-0.1-SNAPSHOT.jar(dotty/tools/dotc/core/ConstraintHandling$$anon$1.class)'
-    // has location not matching its contents: contains class $anon
+  @Test def dotc_core = compileDir(dotcDir, "core")("-Yno-double-bindings" :: allowDeepSubtypes)// twice omitted to make tests run faster
+
 
-  @Test def dotc_core_pickling = compileDir(coreDir, "pickling", failedOther)(allowDeepSubtypes)// twice omitted to make tests run faster
-    // exception caught when loading class ClassfileParser$$anon$1: dotty.tools.dotc.core.Denotations$NotDefinedHere:
-    // demanding denotation of module class ClassfileParser$$anon$1$ at phase frontend(1) outside defined interval:
-    // defined periods are Period(31..36, run = 2) Period(3..24, run = 2) Period(25..26, run = 2)
-    // Period(27..28, run = 2) Period(29..29, run = 2) Period(30..30, run = 2)
-    // inside FirstTransform    at dotty.tools.dotc.transform.FirstTransform.transform(FirstTransform.scala:33)
-    // weird.
+  @Test def dotc_core_pickling = compileDir(coreDir, "pickling")(allowDeepSubtypes)// twice omitted to make tests run faster
 
   @Test def dotc_transform = compileDir(dotcDir, "transform")// twice omitted to make tests run faster
 
@@ -165,19 +154,16 @@ class tests extends CompilerTest {
 
   @Test def dotc_reporting = compileDir(dotcDir, "reporting") // twice omitted to make tests run faster
 
-  @Test def dotc_typer = compileDir(dotcDir, "typer", failedOther)// twice omitted to make tests run faster
+  @Test def dotc_typer = compileDir(dotcDir, "typer")// twice omitted to make tests run faster
     // error: error while loading Checking$$anon$2$,
     // class file 'target/scala-2.11/dotty_2.11-0.1-SNAPSHOT.jar(dotty/tools/dotc/typer/Checking$$anon$2.class)'
     // has location not matching its contents: contains class $anon
 
-  @Test def dotc_util = compileDir(dotcDir, "util", failedOther ++ twice)
-    // java.lang.ClassCastException: dotty.tools.dotc.core.Types$NoType$ cannot be cast to dotty.tools.dotc.core.Types$ClassInfo
-    // at dotty.tools.dotc.core.SymDenotations$ClassDenotation.classInfo(SymDenotations.scala:1026)
-    // at dotty.tools.dotc.transform.ExtensionMethods.transform(ExtensionMethods.scala:38)
+  @Test def dotc_util = compileDir(dotcDir, "util") // twice omitted to make tests run faster
 
-  @Test def tools_io = compileDir(toolsDir, "io", failedOther ++ twice) // inner class has symbol <none>
+  @Test def tools_io = compileDir(toolsDir, "io") // inner class has symbol <none>
 
-  @Test def helloWorld = compileFile(posDir, "HelloWorld", twice)
+  @Test def helloWorld = compileFile(posDir, "HelloWorld")
   @Test def labels = compileFile(posDir, "Labels", twice)
   //@Test def tools = compileDir(dottyDir, "tools", "-deep" :: Nil)(allowDeepSubtypes)
 
@@ -194,6 +180,5 @@ class tests extends CompilerTest {
 
   val javaDir = "./tests/pos/java-interop/"
   @Test def java_all = compileFiles(javaDir, twice)
-
   //@Test def dotc_compilercommand = compileFile(dotcDir + "config/", "CompilerCommand")
 }
diff --git a/tests/pos/t1237.scala b/tests/disabled/t1237.scala
similarity index 100%
rename from tests/pos/t1237.scala
rename to tests/disabled/t1237.scala
diff --git a/tests/pos/t3174.scala b/tests/disabled/t3174.scala
similarity index 100%
rename from tests/pos/t3174.scala
rename to tests/disabled/t3174.scala
diff --git a/tests/pos/interfaceObject.scala b/tests/pos/interfaceObject.scala
new file mode 100644
index 000000000000..e4d8b89a8f14
--- /dev/null
+++ b/tests/pos/interfaceObject.scala
@@ -0,0 +1,6 @@
+trait A{
+  object O
+}
+class B extends A {
+  def foo = O
+}