From b1ce9c260fba3bac1c57886b6d8039feb635740f Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Wed, 22 Apr 2015 13:42:27 +0200
Subject: [PATCH 01/47] Mixin: needs to call transformFollowing to make memoize
 run on traitInits.

---
 src/dotty/tools/dotc/transform/Mixin.scala | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/Mixin.scala b/src/dotty/tools/dotc/transform/Mixin.scala
index 7e307c7360f0..7950149d6bca 100644
--- a/src/dotty/tools/dotc/transform/Mixin.scala
+++ b/src/dotty/tools/dotc/transform/Mixin.scala
@@ -150,7 +150,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 +164,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
         })

From e1c482a98b5d07b227f6415aac9aaff0ab06e8ff Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Thu, 23 Apr 2015 11:22:56 +0200
Subject: [PATCH 02/47] Make Memoize not depend on prepareForDefDef.

[@darkdimius] I see no good reason for this, as it creates tight coupling between `ifs` in two methods.
[@odersky] The reason is probably in the deleted comment:

     // allocate field early so that initializer has the right owner for subsequent phases in
     // the group.

We now transform the rhs in subsequent phases with the getter as owner, where before it was the field.
It is not clear to me whether this matters or not.

[Update] We figured out the problem: It was a missing changeOwnerAfter in Constructor. Added to next commit.
---
 src/dotty/tools/dotc/transform/Memoize.scala | 34 +++++++-------------
 1 file changed, 11 insertions(+), 23 deletions(-)

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))
       }

From b50d209d52f066e5bcf415d9def6ea503b8aea5d Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Thu, 23 Apr 2015 17:57:35 +0200
Subject: [PATCH 03/47] Make Constructors change owners.

---
 src/dotty/tools/dotc/transform/Constructors.scala | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/Constructors.scala b/src/dotty/tools/dotc/transform/Constructors.scala
index cd64497e9a26..6842e14d73ae 100644
--- a/src/dotty/tools/dotc/transform/Constructors.scala
+++ b/src/dotty/tools/dotc/transform/Constructors.scala
@@ -95,9 +95,9 @@ 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 = {
+      def apply(tree: Tree, prevOwner: Symbol, inSuperCall: Boolean = false)(implicit ctx: Context): Tree = {
         this.excluded = if (inSuperCall) EmptyFlags else Mutable
-        transform(tree)
+        transform(tree).changeOwnerAfter(prevOwner, constr.symbol, thisTransform)
       }
     }
 
@@ -153,19 +153,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 =>

From de67c05e45f3d8234dedf4e41250366a47a6ba77 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 23 Apr 2015 12:56:10 +0200
Subject: [PATCH 04/47] Allow FutureDefs in changeOwner

Without it, the previous commit make LazyVals blow up wgen compiling dotc/transform. I could not fugure out why, but here is the stacktrace I saw.

dotty.tools.dotc.core.Denotations$NotDefinedHere: demanding denotation of method $anonfun at phase seqLiterals(17) outside defined interval: defined periods are Period(22..22, run = 2)
	at dotty.tools.dotc.core.Denotations$SingleDenotation.current(Denotations.scala:598)
	at dotty.tools.dotc.core.Types$NamedType.computeDenot(Types.scala:1221)
	at dotty.tools.dotc.core.Types$NamedType.denotAt(Types.scala:1206)
	at dotty.tools.dotc.core.Types$NamedType.denot(Types.scala:1194)
	at dotty.tools.dotc.ast.Trees$DenotingTree.denot(Trees.scala:270)
	at dotty.tools.dotc.ast.Trees$Tree.symbol(Trees.scala:187)
	at dotty.tools.dotc.ast.TypedTreeInfo$$anonfun$localSyms$1.apply(TreeInfo.scala:437)
	at dotty.tools.dotc.ast.TypedTreeInfo$$anonfun$localSyms$1.apply(TreeInfo.scala:437)
	at scala.collection.TraversableLike$WithFilter$$anonfun$map$2.apply(TraversableLike.scala:728)
	at scala.collection.immutable.List.foreach(List.scala:381)
	at scala.collection.TraversableLike$WithFilter.map(TraversableLike.scala:727)
	at dotty.tools.dotc.ast.TypedTreeInfo$class.localSyms(TreeInfo.scala:437)
	at dotty.tools.dotc.ast.tpd$.localSyms(tpd.scala:19)
	at dotty.tools.dotc.ast.TreeTypeMap.transformDefs(TreeTypeMap.scala:116)
	at dotty.tools.dotc.ast.TreeTypeMap.transform(TreeTypeMap.scala:98)
	at dotty.tools.dotc.ast.Trees$Instance$TreeMap$$anonfun$transform$2.apply(Trees.scala:1181)
	at dotty.tools.dotc.ast.Trees$Instance$TreeMap$$anonfun$transform$2.apply(Trees.scala:1181)
	at scala.collection.immutable.List.loop$1(List.scala:172)
	at scala.collection.immutable.List.mapConserve(List.scala:188)
	at dotty.tools.dotc.ast.Trees$Instance$TreeMap.transform(Trees.scala:1181)
	at dotty.tools.dotc.ast.Trees$Instance$TreeMap.transform(Trees.scala:1100)
	at dotty.tools.dotc.ast.TreeTypeMap.transform(TreeTypeMap.scala:108)
	at dotty.tools.dotc.ast.Trees$Instance$TreeMap$$anonfun$transform$2.apply(Trees.scala:1181)
	at dotty.tools.dotc.ast.Trees$Instance$TreeMap$$anonfun$transform$2.apply(Trees.scala:1181)
	at scala.collection.immutable.List.loop$1(List.scala:172)
	at scala.collection.immutable.List.mapConserve(List.scala:188)
	at dotty.tools.dotc.ast.Trees$Instance$TreeMap.transform(Trees.scala:1181)
	at dotty.tools.dotc.ast.Trees$Instance$TreeMap.transform(Trees.scala:1100)
	at dotty.tools.dotc.ast.TreeTypeMap.transform(TreeTypeMap.scala:108)
	at dotty.tools.dotc.ast.Trees$Instance$TreeMap.transform(Trees.scala:1100)
	at dotty.tools.dotc.ast.TreeTypeMap.transform(TreeTypeMap.scala:108)
	at dotty.tools.dotc.ast.Trees$Instance$TreeMap.transform(Trees.scala:1094)
	at dotty.tools.dotc.ast.TreeTypeMap.transform(TreeTypeMap.scala:108)
	at dotty.tools.dotc.ast.Trees$Instance$TreeMap.transform(Trees.scala:1100)
	at dotty.tools.dotc.ast.TreeTypeMap.transform(TreeTypeMap.scala:108)
	at dotty.tools.dotc.ast.TreeTypeMap.apply(TreeTypeMap.scala:129)
	at dotty.tools.dotc.ast.tpd$TreeOps$.loop$1(tpd.scala:565)
	at dotty.tools.dotc.ast.tpd$TreeOps$.changeOwner$extension(tpd.scala:568)
	at dotty.tools.dotc.transform.LazyVals.transformLocalValDef(LazyVals.scala:110)
	at dotty.tools.dotc.transform.LazyVals.transformValDef(LazyVals.scala:64)
---
 src/dotty/tools/dotc/ast/tpd.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index 0a1611b61acd..3bcfc2ddaa70 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -563,7 +563,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)

From ebb3917fe33041586160fd1ff4b904ac65aeed5c Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 23 Apr 2015 12:57:27 +0200
Subject: [PATCH 05/47] Reset some flags for bridges.

Bridges are never accessors, deferred, or lazy. Scalac removes these flags, I guess
this was dropped as an oversight. The change is needed to make the next commit work.
---
 src/dotty/tools/dotc/transform/Erasure.scala | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

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")
 

From 979ee0ff41c2a957b22e886ea43ad4f070a9777d Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 23 Apr 2015 15:15:20 +0200
Subject: [PATCH 06/47] Fix changeOwnerAfter by adding transformDenotations
 method.

With the previous commit, we get a bad owner for the "typedArgs" var
in `dotc.typer.Applications`. What happens is the following (@DarkDimius
figured it out):

Here's the code in question:

      val result = {
         var typedArg = ...
         (code that captures typedArg)
      }

There's an interplay between 3 mini-phases, which run in interleaved succession in the same
group:

    Memoize
    CapturedVars
    Constructors

The following events happen in the order they are written:

1. typedArg is noted to be captured, so prepareValDef in CapturedVars
   installs a new denotation, valid after CapturedVars, with a Ref type.

2. Memoize in transformDefDef creates a field for `result` and changes
   the owner of all definitions in the right-hand side to the field,
   using `changeOwnerAfter`. This gives `typedArg` a new denotation
   with the owner being the field `result$local` and a validity period
   from Memoize + 1 to CapturedVars + 1 (because CapturedVars has already
   installed a new denotation).

3. Constructors runs intoConstructor which changes the owner again. All code
   with the field as current owner becomes owned by the constructor. But
   unfortunately `typedArg` is owned by the getter `result`, because that's
   the denotation installed by the preceding phase, CapturedVars. So its
   owner stays the `getter` even though its definition is now part of the
   constructor. Boom, -Ycheck fails.

The fix applied here adds a new method `transformAfter` which can transform
all future denotations of a symbol. `changeOwnerAfter` uses this method to become
insensitive to the order in which denotations are installed.

Morale: State is hard.
---
 src/dotty/tools/dotc/ast/tpd.scala            |  7 ++--
 src/dotty/tools/dotc/core/Denotations.scala   | 36 ++++++++++++++-----
 .../tools/dotc/core/SymDenotations.scala      |  6 ++++
 3 files changed, 39 insertions(+), 10 deletions(-)

diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index 3bcfc2ddaa70..56d916bdd858 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -578,8 +578,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..aa1442769029 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,31 @@ 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 ne symbol.current)) 
+        current = current.nextInRun
+      while (current.validFor.firstPhaseId >= phase.id) {
+        val current1: SingleDenotation = f(current.asSymDenotation)
+        if (current1 ne current) {
+          current1.validFor = current.validFor
+          current1.replaceDenotation(current)
+        }
+        current = current.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

From bcc6bf711d2a0110db7c9dc091a8e81697ae6a3c Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 23 Apr 2015 15:20:25 +0200
Subject: [PATCH 07/47] Remove dead code in Constructors

The intoConstr method is never called with argument inSuperCall = true.
So code dependent on it can be dropped.
---
 src/dotty/tools/dotc/transform/Constructors.scala | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/Constructors.scala b/src/dotty/tools/dotc/transform/Constructors.scala
index 6842e14d73ae..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,8 +94,7 @@ class Constructors extends MiniPhaseTransform with SymTransformer { thisTransfor
           if (noDirectRefsFrom(tree)) tree else super.transform(tree)
       }
 
-      def apply(tree: Tree, prevOwner: Symbol, inSuperCall: Boolean = false)(implicit ctx: Context): Tree = {
-        this.excluded = if (inSuperCall) EmptyFlags else Mutable
+      def apply(tree: Tree, prevOwner: Symbol)(implicit ctx: Context): Tree = {
         transform(tree).changeOwnerAfter(prevOwner, constr.symbol, thisTransform)
       }
     }

From a2813d2ef76cea23ff8a503af8a4a8c6c84f2fa3 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Wed, 22 Apr 2015 13:42:43 +0200
Subject: [PATCH 08/47] Mixin: do not remove Module Flag.

---
 src/dotty/tools/dotc/transform/MixinOps.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 = {

From 5937b881a0e169e0b6f8d583924528f4a9773d91 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Wed, 22 Apr 2015 13:45:04 +0200
Subject: [PATCH 09/47] Make LazyVals implement non-static modules. Move LV
 after erasure.

---
 src/dotty/tools/dotc/Compiler.scala           |  4 +-
 src/dotty/tools/dotc/transform/LazyVals.scala | 75 +++++++++----------
 2 files changed, 39 insertions(+), 40 deletions(-)

diff --git a/src/dotty/tools/dotc/Compiler.scala b/src/dotty/tools/dotc/Compiler.scala
index 1657adbbb739..b4be19799c5f 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,6 +57,7 @@ class Compiler {
            new ResolveSuper),
       List(new Erasure),
       List(new Mixin,
+           new LazyVals,
            new Memoize,
            new CapturedVars,
            new Constructors,
diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index a28102d7b744..160333fdf1cc 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -21,26 +21,17 @@ import dotty.tools.dotc.core.Denotations.SingleDenotation
 import dotty.tools.dotc.core.SymDenotations.SymDenotation
 import dotty.tools.dotc.core.DenotTransformers.{SymTransformer, IdentityDenotTransformer, DenotTransformer}
 
-class LazyVals extends MiniPhaseTransform with SymTransformer {
+class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
 
   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 containerFlagsMask = Flags.Lazy | Flags.Accessor
+
   /** 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)
@@ -52,16 +43,22 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
       * before this phase starts processing same tree */
     // override def ensureAfter: Set[String] = Set("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
       else {
-        val isField = tree.symbol.owner.isClass
-
-        if (isField) {
-          if (tree.symbol.isVolatile) transformFieldValDefVolatile(tree)
-          else transformFieldValDefNonVolatile(tree)
+        if (tree.symbol is Flags.Module) {
+          val field = ctx.newSymbol(tree.symbol.owner, tree.symbol.name ++ StdNames.nme.MODULE_VAR_SUFFIX, containerFlags, tree.symbol.info.resultType, coord = tree.symbol.pos)
+          tpd.This(tree.symbol.enclosingClass.asClass).select(defn.Object_synchronized).appliedTo(
+            mkDefNonThreadSafeNonNullable(field, tree.rhs).ensureConforms(tree.tpe.widen.resultType.widen))
+        } else {
+          val isField = tree.symbol.owner.isClass
+
+          if (isField) {
+            if (tree.symbol.isVolatile) transformFieldValDefVolatile(tree)
+            else transformFieldValDefNonVolatile(tree)
+          }
+          else transformLocalValDef(tree)
         }
-        else transformLocalValDef(tree)
       }
     }
 
@@ -82,12 +79,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 transformLocalValDef(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"
@@ -124,7 +120,12 @@ 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}
+    val (holders, stats) =
+      atGroupEnd { implicit ctx: Context =>
+        trees.partition {
+          _.symbol.flags == containerFlags
+        }
+      }
     holders:::stats
   }
 
@@ -162,13 +163,12 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
       If(cond, init, exp)
     }
 
-    def transformFieldValDefNonVolatile(x: ValDef)(implicit ctx: Context) = x match {
-      case ValDef(name, tpt, _) if (x.mods is Flags.Lazy) =>
+    def transformFieldValDefNonVolatile(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.mods &~ containerFlagsMask | containerFlags).flags, tpe, coord = x.symbol.coord).enteredAfter(this)
 
         val containerTree = ValDef(containerSymbol, initValue(tpe))
         if (x.tpe.isNotNull && tpe <:< defn.AnyRefType) { // can use 'null' value instead of flag
@@ -176,7 +176,7 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
           Thicket(List(containerTree, slowPath))
         }
         else {
-          val flagName = ctx.freshName(name.toString + StdNames.nme.BITMAP_PREFIX).toTermName
+          val flagName = ctx.freshName(x.name ++ StdNames.nme.BITMAP_PREFIX).toTermName
           val flagSymbol = ctx.newSymbol(x.symbol.owner, flagName,  containerFlags, defn.BooleanType)
           val flag = ValDef(flagSymbol, Literal(Constants.Constant(false)))
           val slowPath = DefDef(x.symbol.asTerm, mkNonThreadSafeDef(ref(containerSymbol), ref(flagSymbol), x.rhs))
@@ -184,7 +184,7 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
         }
     }
 
-    /** 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
@@ -280,11 +280,10 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
       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 transformFieldValDefVolatile(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 companion = claz.companionModule
@@ -323,8 +322,8 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
             appendOffsetDefs += (companion.name.moduleClassName -> 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).enteredAfter(this)
         val containerTree = ValDef(containerSymbol, initValue(tpe))
 
         val offset = Select(ref(companion), offsetSymbol.name)

From fe8c717be04397efba4fff43acdc62d7b6dd14f2 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Wed, 22 Apr 2015 13:48:41 +0200
Subject: [PATCH 10/47] Add a test for a deferred object in interface.

---
 tests/pos/interfaceObject.scala | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 tests/pos/interfaceObject.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
+}

From 9c150c572ee7bb308e87cf4f0ae51a6fef22c00b Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Wed, 22 Apr 2015 13:42:00 +0200
Subject: [PATCH 11/47] Getters now also makes getters for lazy vals.

---
 src/dotty/tools/dotc/transform/Getters.scala | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

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

From a274d8dfc86d95e359c45e8f13db58983a2f041b Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Fri, 24 Apr 2015 11:12:34 +0200
Subject: [PATCH 12/47] Generate getters for modules in LV.

---
 src/dotty/tools/dotc/transform/LazyVals.scala | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index 160333fdf1cc..8fb47f416ba6 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -48,8 +48,11 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
       else {
         if (tree.symbol is Flags.Module) {
           val field = ctx.newSymbol(tree.symbol.owner, tree.symbol.name ++ StdNames.nme.MODULE_VAR_SUFFIX, containerFlags, tree.symbol.info.resultType, coord = tree.symbol.pos)
-          tpd.This(tree.symbol.enclosingClass.asClass).select(defn.Object_synchronized).appliedTo(
-            mkDefNonThreadSafeNonNullable(field, tree.rhs).ensureConforms(tree.tpe.widen.resultType.widen))
+          val getter =
+            tpd.DefDef(tree.symbol.asTerm, tpd.This(tree.symbol.enclosingClass.asClass).select(defn.Object_synchronized).appliedTo(
+              mkDefNonThreadSafeNonNullable(field, tree.rhs).ensureConforms(tree.tpe.widen.resultType.widen)))
+          val fieldVal = tpd.ValDef(field.asTerm, initValue(field.info.widen))
+          Thicket(fieldVal, getter)
         } else {
           val isField = tree.symbol.owner.isClass
 
@@ -105,8 +108,8 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
         val flag = ref(holderSymbol).select("initialized".toTermName)
         val initer = valueInitter.changeOwner(x.symbol, initSymbol)
         val initBody =
-          ref(holderSymbol).select(defn.Object_synchronized).appliedToType(tpe).appliedTo(
-          mkNonThreadSafeDef(result, flag, initer).ensureConforms(tpe))
+          ref(holderSymbol).select(defn.Object_synchronized).appliedTo(
+          mkNonThreadSafeDef(result, flag, initer)).ensureConforms(tpe)
         val initTree = DefDef(initSymbol, initBody)
         val holderTree = ValDef(holderSymbol, New(holderImpl.typeRef, List()))
         val methodBody = {

From cf4ee1dda912125f19a891062112e2c71b7fc907 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Fri, 24 Apr 2015 11:12:56 +0200
Subject: [PATCH 13/47] LV runs after memoize. Use setters.

---
 src/dotty/tools/dotc/transform/LazyVals.scala | 26 +++++++++----------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index 8fb47f416ba6..d2f4b6ee3268 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -50,7 +50,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
           val field = ctx.newSymbol(tree.symbol.owner, tree.symbol.name ++ StdNames.nme.MODULE_VAR_SUFFIX, containerFlags, tree.symbol.info.resultType, coord = tree.symbol.pos)
           val getter =
             tpd.DefDef(tree.symbol.asTerm, tpd.This(tree.symbol.enclosingClass.asClass).select(defn.Object_synchronized).appliedTo(
-              mkDefNonThreadSafeNonNullable(field, tree.rhs).ensureConforms(tree.tpe.widen.resultType.widen)))
+              mkDefNonThreadSafeNonNullable(field, tree.rhs).ensureConforms(tree.tpe.widen.resultType.widen)).ensureConforms(tree.tpe.widen.resultType.widen))
           val fieldVal = tpd.ValDef(field.asTerm, initValue(field.info.widen))
           Thicket(fieldVal, getter)
         } else {
@@ -114,7 +114,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
         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}")
@@ -144,10 +144,10 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
       */
 
     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
@@ -161,7 +161,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
     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)
     }
@@ -247,10 +247,10 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
           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(())))
@@ -269,8 +269,8 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
       }
 
       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)
       }
@@ -278,7 +278,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
       val cases = Match(stateMask.appliedTo(ref(flagSymbol), Literal(Constant(ord))),
         List(compute, waitFirst, waitSecond, computed)) //todo: annotate with @switch
 
-      val whileBody = Block(List(Assign(ref(flagSymbol), getFlag.appliedTo(thiz, offset))), cases)
+      val whileBody = Block(List(ref(flagSymbol).becomes(getFlag.appliedTo(thiz, offset))), cases)
       val cycle = untpd.WhileDo(whileCond, whileBody).withTypeUnchecked(defn.UnitType)
       DefDef(methodSymbol, Block(resultDef :: retryDef :: flagDef :: cycle :: Nil, ref(resultSymbol)))
     }

From a049c82093c02c471e0cd44e9de916fd1c1c0724 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Fri, 24 Apr 2015 11:25:48 +0200
Subject: [PATCH 14/47] Fix two infinite cycles in transformAfter.

if symbol is defining starting from this phase
current.validFor.firstPhaseId < phase.id is always true.
If additionally f changes the initial symbol,
(current ne symbol.current) will always be true.

Else if a symbol has a single denotation that spawns all periods,
which is changed, second cycle becomes infinite.
---
 src/dotty/tools/dotc/core/Denotations.scala | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/dotty/tools/dotc/core/Denotations.scala b/src/dotty/tools/dotc/core/Denotations.scala
index aa1442769029..fc8bbc84fba3 100644
--- a/src/dotty/tools/dotc/core/Denotations.scala
+++ b/src/dotty/tools/dotc/core/Denotations.scala
@@ -637,9 +637,9 @@ object Denotations {
      */
     protected def transformAfter(phase: DenotTransformer, f: SymDenotation => SymDenotation)(implicit ctx: Context): Unit = {
       var current = symbol.current
-      while (current.validFor.firstPhaseId < phase.id && (current ne symbol.current)) 
+      while (current.validFor.firstPhaseId < phase.id && (current.nextInRun.validFor.code > current.validFor.code))
         current = current.nextInRun
-      while (current.validFor.firstPhaseId >= phase.id) {
+      while ((current.validFor.firstPhaseId >= phase.id) && (current.nextInRun.validFor.code > current.validFor.code)) {
         val current1: SingleDenotation = f(current.asSymDenotation)
         if (current1 ne current) {
           current1.validFor = current.validFor
@@ -648,7 +648,7 @@ object Denotations {
         current = current.nextInRun
       }
     }
-    
+
     private def replaceDenotation(current: SingleDenotation): Unit = {
       var prev = current
       while (prev.nextInRun ne current) prev = prev.nextInRun

From f9a15df76853071b8643c30509a92321040047de Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Apr 2015 18:03:43 +0200
Subject: [PATCH 15/47] Mixing should make initialisers out of lazy vals.

---
 src/dotty/tools/dotc/transform/Mixin.scala | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/Mixin.scala b/src/dotty/tools/dotc/transform/Mixin.scala
index 7950149d6bca..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(

From d0f9d6df8bfa185019004740ea8dd6472f3e7ed9 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Apr 2015 18:04:46 +0200
Subject: [PATCH 16/47] Compiler: add comment on problems in late phases.

---
 src/dotty/tools/dotc/Compiler.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/dotty/tools/dotc/Compiler.scala b/src/dotty/tools/dotc/Compiler.scala
index b4be19799c5f..102d99347c92 100644
--- a/src/dotty/tools/dotc/Compiler.scala
+++ b/src/dotty/tools/dotc/Compiler.scala
@@ -59,10 +59,10 @@ class Compiler {
       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),

From 75588e966906ddb89edb1ffde9ea7af8d6185dab Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Apr 2015 18:33:07 +0200
Subject: [PATCH 17/47] tpd.WhileDo helper.

---
 src/dotty/tools/dotc/ast/tpd.scala | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index 56d916bdd858..03feafafa49b 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -243,6 +243,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))
 

From 74054a4221a6e79feb212db9ae82fe64cbeeac12 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Apr 2015 18:52:18 +0200
Subject: [PATCH 18/47] LazyVals needs to run after Mixin.

---
 src/dotty/tools/dotc/transform/LazyVals.scala | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index d2f4b6ee3268..43697f276461 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -39,9 +39,9 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
 
   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 transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
       if (!(tree.symbol is Flags.Lazy)) tree

From c201309b99cf96784e42e659e7a9405ed2dc99bb Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Apr 2015 18:52:52 +0200
Subject: [PATCH 19/47] LazyVals: filter out flag combinations that do not make
 sense.

---
 src/dotty/tools/dotc/transform/LazyVals.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index 43697f276461..b216326af561 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -28,9 +28,9 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
   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.Lazy | Flags.Accessor
+  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 */

From 7517d992f3fe10c3c4fe00ad89abfe4f1576978b Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Apr 2015 18:54:24 +0200
Subject: [PATCH 20/47] LazyVals: create less names.

---
 src/dotty/tools/dotc/transform/LazyVals.scala | 44 ++++++++++++-------
 1 file changed, 29 insertions(+), 15 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index b216326af561..b6a12940a7f8 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -104,8 +104,8 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
 
         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(nme_value)
+        val flag = ref(holderSymbol).select(nme_initialized)
         val initer = valueInitter.changeOwner(x.symbol, initSymbol)
         val initBody =
           ref(holderSymbol).select(defn.Object_synchronized).appliedTo(
@@ -218,29 +218,28 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
       *     }
       *   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, nme_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, nme_result, containerFlags, tp)
       val resultDef = ValDef(resultSymbol, initValue(tp))
 
-      val retrySymbol = ctx.newSymbol(methodSymbol, "retry".toTermName, containerFlags, defn.BooleanType)
+      val retrySymbol = ctx.newSymbol(methodSymbol, nme_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,
@@ -291,7 +290,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
         val thiz = This(claz)(ctx.fresh.setOwner(claz))
         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), RLazyValsNames_getOffset)
         var offsetSymbol: TermSymbol = null
         var flag: Tree = EmptyTree
         var ord = 0
@@ -329,12 +328,12 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
         val containerSymbol = ctx.newSymbol(claz, containerName, (x.mods &~ containerFlagsMask | containerFlags).flags, tpe, coord = x.symbol.coord).enteredAfter(this)
         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 =  Select(ref(companion), offsetSymbol.name)
+        val getFlag = Select(ref(helperModule), RLazyValsNames_get)
+        val setFlag = Select(ref(helperModule), RLazyValsNames_setFlag)
+        val wait =    Select(ref(helperModule), RLazyValsNames_wait4Notification)
+        val state =   Select(ref(helperModule), RLazyValsNames_state)
+        val cas =     Select(ref(helperModule), RLazyValsNames_cas)
 
         val accessor = mkThreadSafeDef(x.symbol.asTerm, claz, ord, containerSymbol, x.rhs, tpe, offset, getFlag, state, cas, setFlag, wait)
         if (flag eq EmptyTree)
@@ -343,5 +342,20 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
     }
 }
 
+object LazyVals {
+  val RLazyValsNames_get               = RLazyVals.Names.get.toTermName
+  val RLazyValsNames_setFlag           = RLazyVals.Names.setFlag.toTermName
+  val RLazyValsNames_wait4Notification = RLazyVals.Names.wait4Notification.toTermName
+  val RLazyValsNames_state             = RLazyVals.Names.state.toTermName
+  val RLazyValsNames_cas               = RLazyVals.Names.cas.toTermName
+  val RLazyValsNames_getOffset         = RLazyVals.Names.getOffset.toTermName
+  val nme_flag                         = "flag".toTermName
+  val nme_result                       = "result".toTermName
+  val nme_value                        = "value".toTermName
+  val nme_initialized                  = "initialized".toTermName
+  val nme_retry                        = "retry".toTermName
+
+}
+
 
 

From f8f908f6580d123d402f9850fdbace31b361bdb3 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Apr 2015 18:57:14 +0200
Subject: [PATCH 21/47] LazyVals: Emitting switch instruction requires default
 case.

---
 src/dotty/tools/dotc/transform/LazyVals.scala | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index b6a12940a7f8..5b85c3d50d35 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -274,8 +274,10 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
         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(ref(flagSymbol).becomes(getFlag.appliedTo(thiz, offset))), cases)
       val cycle = untpd.WhileDo(whileCond, whileBody).withTypeUnchecked(defn.UnitType)

From 4615f76b21e55ba84a1036b751f4ff41f4a72014 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Apr 2015 18:57:58 +0200
Subject: [PATCH 22/47] Make LazyVals.getOffset work on j.l.Class instead of
 taking the instance.

---
 src/dotty/runtime/LazyVals.scala              | 2 +-
 src/dotty/tools/dotc/transform/LazyVals.scala | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/dotty/runtime/LazyVals.scala b/src/dotty/runtime/LazyVals.scala
index 4130d4d60335..a248be49114c 100644
--- a/src/dotty/runtime/LazyVals.scala
+++ b/src/dotty/runtime/LazyVals.scala
@@ -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/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index 5b85c3d50d35..b7e97fafc1db 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -289,7 +289,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
 
         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), RLazyValsNames_getOffset)
@@ -313,7 +313,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
               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
             }
 
@@ -322,7 +322,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
             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))))
+            val offsetTree = ValDef(offsetSymbol, getOffset.appliedTo(thizClass, Literal(Constant(flagName.toString))))
             appendOffsetDefs += (companion.name.moduleClassName -> new OffsetInfo(List(offsetTree), ord))
         }
 

From d75d8721bc86ae99c487228fa9d6175098c19197 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Apr 2015 19:00:24 +0200
Subject: [PATCH 23/47] Remove code duplication in LazyVals.

Also fixes problem with capturedVars, as no local vars are created.
---
 src/dotty/tools/dotc/transform/LazyVals.scala | 20 +++++++------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index b7e97fafc1db..1afee6b0e8ee 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._
@@ -22,6 +24,7 @@ import dotty.tools.dotc.core.SymDenotations.SymDenotation
 import dotty.tools.dotc.core.DenotTransformers.{SymTransformer, IdentityDenotTransformer, DenotTransformer}
 
 class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
+  import LazyVals._
 
   import tpd._
 
@@ -44,24 +47,15 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
   override def runsAfter = Set(classOf[Mixin])
 
     override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
-      if (!(tree.symbol is Flags.Lazy)) tree
+      if (!(tree.symbol is Flags.Lazy) || tree.symbol.owner.is(Flags.Trait)) tree
       else {
-        if (tree.symbol is Flags.Module) {
-          val field = ctx.newSymbol(tree.symbol.owner, tree.symbol.name ++ StdNames.nme.MODULE_VAR_SUFFIX, containerFlags, tree.symbol.info.resultType, coord = tree.symbol.pos)
-          val getter =
-            tpd.DefDef(tree.symbol.asTerm, tpd.This(tree.symbol.enclosingClass.asClass).select(defn.Object_synchronized).appliedTo(
-              mkDefNonThreadSafeNonNullable(field, tree.rhs).ensureConforms(tree.tpe.widen.resultType.widen)).ensureConforms(tree.tpe.widen.resultType.widen))
-          val fieldVal = tpd.ValDef(field.asTerm, initValue(field.info.widen))
-          Thicket(fieldVal, getter)
-        } else {
           val isField = tree.symbol.owner.isClass
 
           if (isField) {
-            if (tree.symbol.isVolatile) transformFieldValDefVolatile(tree)
+            if (tree.symbol.isVolatile || tree.symbol.is(Flags.Module)) transformFieldValDefVolatile(tree)
             else transformFieldValDefNonVolatile(tree)
           }
           else transformLocalValDef(tree)
-        }
       }
     }
 
@@ -279,8 +273,8 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
       val cases = Match(stateMask.appliedTo(ref(flagSymbol), Literal(Constant(ord))),
         List(compute, waitFirst, waitSecond, computed, default)) //todo: annotate with @switch
 
-      val whileBody = Block(List(ref(flagSymbol).becomes(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)))
     }
 

From f322c989c6e7919662a151421cb96c96eefe5251 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Apr 2015 19:01:00 +0200
Subject: [PATCH 24/47] LazyValues: minor post-erasure changes.

---
 src/dotty/tools/dotc/transform/LazyVals.scala | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index 1afee6b0e8ee..9972efc90777 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -68,7 +68,8 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
           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))
         }
       }
     }
@@ -168,7 +169,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
         val containerSymbol = ctx.newSymbol(claz, containerName, (x.mods &~ containerFlagsMask | containerFlags).flags, tpe, coord = x.symbol.coord).enteredAfter(this)
 
         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))
         }

From ca11f55fdd906881e57188946d32f237117d4fa3 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Apr 2015 19:01:48 +0200
Subject: [PATCH 25/47] Make Lazy-vals generated fields private.

---
 src/dotty/tools/dotc/transform/LazyVals.scala | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index 9972efc90777..9f772ba6bebd 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -166,7 +166,10 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
         val tpe = x.tpe.widen.resultType.widen
         assert(!(x.mods is Flags.Mutable))
         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).enteredAfter(this)
+        val containerSymbol = ctx.newSymbol(claz, containerName,
+          x.symbol.flags &~ containerFlagsMask | containerFlags | Flags.Private,
+          tpe, coord = x.symbol.coord
+        ).enteredAfter(this)
 
         val containerTree = ValDef(containerSymbol, initValue(tpe))
         if (x.tpe.isNotNull && tpe <:< defn.ObjectType) { // can use 'null' value instead of flag
@@ -175,7 +178,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
         }
         else {
           val flagName = ctx.freshName(x.name ++ StdNames.nme.BITMAP_PREFIX).toTermName
-          val flagSymbol = ctx.newSymbol(x.symbol.owner, flagName,  containerFlags, defn.BooleanType)
+          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))

From fc205564f964b7d8dc284b78129d27b62edb2e7e Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Apr 2015 19:02:52 +0200
Subject: [PATCH 26/47] Fix tpd.ref(sum) to work after erasure.

Erasure finishes work done by Explicit outer, and registers a post condition that This(outer) is not allowed.
---
 src/dotty/tools/dotc/ast/tpd.scala | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index 03feafafa49b..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._
@@ -299,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
 

From f892614dd6ebc6008687175555143a2eff0f3845 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Apr 2015 19:03:53 +0200
Subject: [PATCH 27/47] Update comment on ExplicitOuter.

---
 src/dotty/tools/dotc/transform/ExplicitOuter.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 =>

From dd65b3ebb391e89a8a6f32230c8e91c9d6f670bd Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Apr 2015 19:04:51 +0200
Subject: [PATCH 28/47] We do not plan to have more than Int.MaxValue of lazy
 vals.

---
 src/dotty/runtime/LazyVals.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/runtime/LazyVals.scala b/src/dotty/runtime/LazyVals.scala
index a248be49114c..d662f049acb2 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
     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)

From 086b1c29af6014c1a714276bf87fcd3c6505aafe Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Apr 2015 19:05:29 +0200
Subject: [PATCH 29/47] LazyVals: expected value of flag takes only tree
 values, no need to use long.

---
 src/dotty/runtime/LazyVals.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/runtime/LazyVals.scala b/src/dotty/runtime/LazyVals.scala
index d662f049acb2..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 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)

From 7ef1bd5464f63fcb1873349d2fc13f58476d9a27 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 28 Apr 2015 10:06:52 +0200
Subject: [PATCH 30/47] Disable failing tests. See #503

---
 tests/{pos => disabled}/t1237.scala | 0
 tests/{pos => disabled}/t3174.scala | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/{pos => disabled}/t1237.scala (100%)
 rename tests/{pos => disabled}/t3174.scala (100%)

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

From e24a24ded594817e40e13ca9fb98a19d1feeb24f Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 28 Apr 2015 10:44:29 +0200
Subject: [PATCH 31/47] LazyVals - do not rely on absence of name clashes in
 scope.

Was creating correct code, but was assuming that all objects with the same name share
same bits. No need to do it.
---
 src/dotty/tools/dotc/transform/LazyVals.scala | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index 9f772ba6bebd..1564d4dfea34 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -38,7 +38,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
   /** 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"
 
@@ -64,7 +64,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
     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]
@@ -296,7 +296,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
         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
             info.ord += 1

From 4a379ecc5f3d75b6c09370290a4025233dcb806d Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 28 Apr 2015 10:45:20 +0200
Subject: [PATCH 32/47] LazyVals: Synchronized is `Object => Object` after
 erasure, #505

---
 src/dotty/tools/dotc/transform/LazyVals.scala | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index 1564d4dfea34..b10e08a96f27 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -22,6 +22,7 @@ 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 IdentityDenotTransformer {
   import LazyVals._
@@ -103,8 +104,10 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
         val flag = ref(holderSymbol).select(nme_initialized)
         val initer = valueInitter.changeOwner(x.symbol, initSymbol)
         val initBody =
-          ref(holderSymbol).select(defn.Object_synchronized).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 = {

From 52c56a275561cd43e7ed06a2bc70084e87d1b18e Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 28 Apr 2015 10:45:54 +0200
Subject: [PATCH 33/47] LazyVals: eagerly enter private symbols.

---
 src/dotty/tools/dotc/transform/LazyVals.scala | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index b10e08a96f27..151eb519253d 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -172,7 +172,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
         val containerSymbol = ctx.newSymbol(claz, containerName,
           x.symbol.flags &~ containerFlagsMask | containerFlags | Flags.Private,
           tpe, coord = x.symbol.coord
-        ).enteredAfter(this)
+        ).entered
 
         val containerTree = ValDef(containerSymbol, initValue(tpe))
         if (x.tpe.isNotNull && tpe <:< defn.ObjectType) { // can use 'null' value instead of flag
@@ -312,7 +312,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
             } else { // need to create a new flag
               offsetSymbol = ctx.newSymbol(companion.moduleClass, (StdNames.nme.LAZY_FIELD_OFFSET + id.toString).toTermName, Flags.Synthetic, defn.LongType).enteredAfter(this)
               val flagName = (StdNames.nme.BITMAP_PREFIX + id.toString).toTermName
-              val flagSymbol = ctx.newSymbol(claz, flagName, containerFlags, defn.LongType).enteredAfter(this)
+              val flagSymbol = ctx.newSymbol(claz, flagName, containerFlags, defn.LongType).entered
               flag = ValDef(flagSymbol, Literal(Constants.Constant(0L)))
               val offsetTree = ValDef(offsetSymbol, getOffset.appliedTo(thizClass, Literal(Constant(flagName.toString))))
               info.defs = offsetTree :: info.defs
@@ -321,17 +321,17 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
           case None =>
             offsetSymbol = ctx.newSymbol(companion.moduleClass, (StdNames.nme.LAZY_FIELD_OFFSET + "0").toTermName, Flags.Synthetic, defn.LongType).enteredAfter(this)
             val flagName = (StdNames.nme.BITMAP_PREFIX + "0").toTermName
-            val flagSymbol = ctx.newSymbol(claz, flagName, containerFlags, defn.LongType).enteredAfter(this)
+            val flagSymbol = ctx.newSymbol(claz, flagName, containerFlags, defn.LongType).entered
             flag = ValDef(flagSymbol, Literal(Constants.Constant(0L)))
             val offsetTree = ValDef(offsetSymbol, getOffset.appliedTo(thizClass, Literal(Constant(flagName.toString))))
-            appendOffsetDefs += (companion.name.moduleClassName -> new OffsetInfo(List(offsetTree), ord))
+            appendOffsetDefs += (companion.moduleClass -> new OffsetInfo(List(offsetTree), ord))
         }
 
         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).enteredAfter(this)
+        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 offset =  ref(companion).ensureApplied.select(offsetSymbol)
         val getFlag = Select(ref(helperModule), RLazyValsNames_get)
         val setFlag = Select(ref(helperModule), RLazyValsNames_setFlag)
         val wait =    Select(ref(helperModule), RLazyValsNames_wait4Notification)

From 19c82207f5e42e10c48299658f3863bf1da4eb8b Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 28 Apr 2015 11:20:17 +0200
Subject: [PATCH 34/47] fix a bug in transformAfter: iterate over a new
 denotation instead of an old one.

---
 src/dotty/tools/dotc/core/Denotations.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/core/Denotations.scala b/src/dotty/tools/dotc/core/Denotations.scala
index fc8bbc84fba3..cbf5c6f09032 100644
--- a/src/dotty/tools/dotc/core/Denotations.scala
+++ b/src/dotty/tools/dotc/core/Denotations.scala
@@ -645,7 +645,7 @@ object Denotations {
           current1.validFor = current.validFor
           current1.replaceDenotation(current)
         }
-        current = current.nextInRun
+        current = current1.nextInRun
       }
     }
 

From 56195fcd64432078a5ddb5e7669614bb694f86aa Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 28 Apr 2015 11:20:59 +0200
Subject: [PATCH 35/47] Fix bug in transformAfter: transform the last
 denotation in cycle.

---
 src/dotty/tools/dotc/core/Denotations.scala | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/core/Denotations.scala b/src/dotty/tools/dotc/core/Denotations.scala
index cbf5c6f09032..6502c4a400a3 100644
--- a/src/dotty/tools/dotc/core/Denotations.scala
+++ b/src/dotty/tools/dotc/core/Denotations.scala
@@ -639,12 +639,14 @@ object Denotations {
       var current = symbol.current
       while (current.validFor.firstPhaseId < phase.id && (current.nextInRun.validFor.code > current.validFor.code))
         current = current.nextInRun
-      while ((current.validFor.firstPhaseId >= phase.id) && (current.nextInRun.validFor.code > current.validFor.code)) {
+      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
       }
     }

From 4e277dcf4b60931776f6d38f6545382777de8891 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 28 Apr 2015 11:32:04 +0200
Subject: [PATCH 36/47] Fix spurious warnings in TreeChecker.

---
 src/dotty/tools/dotc/transform/TreeChecker.scala | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

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
   }

From 9bf697cd31a3897735cd9bcca258ac0ebd8c7f8a Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 28 Apr 2015 12:50:58 +0200
Subject: [PATCH 37/47] LazyVals: last fix that allows to compile -deep dotc.

---
 src/dotty/tools/dotc/transform/LazyVals.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index 151eb519253d..596d10050ef6 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -321,7 +321,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
           case None =>
             offsetSymbol = ctx.newSymbol(companion.moduleClass, (StdNames.nme.LAZY_FIELD_OFFSET + "0").toTermName, Flags.Synthetic, defn.LongType).enteredAfter(this)
             val flagName = (StdNames.nme.BITMAP_PREFIX + "0").toTermName
-            val flagSymbol = ctx.newSymbol(claz, flagName, containerFlags, defn.LongType).entered
+            val flagSymbol = ctx.newSymbol(claz, flagName, containerFlags, defn.LongType).enteredAfter(this)
             flag = ValDef(flagSymbol, Literal(Constants.Constant(0L)))
             val offsetTree = ValDef(offsetSymbol, getOffset.appliedTo(thizClass, Literal(Constant(flagName.toString))))
             appendOffsetDefs += (companion.moduleClass -> new OffsetInfo(List(offsetTree), ord))

From b5f76e56ebb112de35106057d1013ee1be997689 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 28 Apr 2015 12:51:30 +0200
Subject: [PATCH 38/47] Enable emmiting byte code for all tests. Compile Dotty.

Hurray!
---
 test/dotc/tests.scala | 41 +++++++++++++----------------------------
 1 file changed, 13 insertions(+), 28 deletions(-)

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")
 }

From 3b4c230d6a9fe9dd926b369831fbd6f3a8fa749a Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 28 Apr 2015 14:21:25 +0200
Subject: [PATCH 39/47] Increase heap and stack size on travis.

---
 project/Build.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project/Build.scala b/project/Build.scala
index 4dd86fa01d10..9d145c2c9f5a 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -79,7 +79,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)}", "-Xmx1g", "-Xss2m")
          else
            List()
 

From c4b61af8b20dd9f763ffa34e27625e3ffd966f5c Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Thu, 30 Apr 2015 14:50:03 +0200
Subject: [PATCH 40/47] DottyBackendInterface: interface members cannot be
 final

---
 src/dotty/tools/backend/jvm/DottyBackendInterface.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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)

From 10d05f34a8c3f006c6a0aabed04c47cb7566cc46 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Thu, 30 Apr 2015 15:07:52 +0200
Subject: [PATCH 41/47] Decrease default sizes of buffers.

Values are the ones that I got as maximum values for compiling dotty itself.
---
 src/dotty/tools/dotc/core/pickling/NameBuffer.scala      | 2 +-
 src/dotty/tools/dotc/core/pickling/PositionPickler.scala | 2 +-
 src/dotty/tools/dotc/core/pickling/TreeBuffer.scala      | 3 +--
 3 files changed, 3 insertions(+), 4 deletions(-)

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/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)

From ceb2eddd75882106105b36a8db24ddb555b4cfb2 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Thu, 30 Apr 2015 15:18:55 +0200
Subject: [PATCH 42/47] Fix two ArrayIndexOutOfBoundsExceptions in TastyBuffer.

---
 src/dotty/tools/dotc/core/pickling/TastyBuffer.scala | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

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

From dc21d958f07f8bd750cb729a0d783fb5269d15fd Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Thu, 30 Apr 2015 15:26:36 +0200
Subject: [PATCH 43/47] Leave traces for future profiling.

---
 project/Build.scala | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/project/Build.scala b/project/Build.scala
index 9d145c2c9f5a..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)}", "-Xmx1g", "-Xss2m")
+           List(s"-D$TRAVIS_BUILD=${sys.props(TRAVIS_BUILD)}") ::: travisMemLimit
          else
            List()
 

From 98f8ab8537043a0a611158ee7deb01abbb07ff5f Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Thu, 30 Apr 2015 15:28:41 +0200
Subject: [PATCH 44/47] LV: Rename methods.

---
 src/dotty/tools/dotc/transform/LazyVals.scala | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index 596d10050ef6..503b1c277db2 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -53,10 +53,10 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
           val isField = tree.symbol.owner.isClass
 
           if (isField) {
-            if (tree.symbol.isVolatile || tree.symbol.is(Flags.Module)) transformFieldValDefVolatile(tree)
-            else transformFieldValDefNonVolatile(tree)
+            if (tree.symbol.isVolatile || tree.symbol.is(Flags.Module)) transformMemberDefVolatile(tree)
+            else transformMemberDefNonVolatile(tree)
           }
-          else transformLocalValDef(tree)
+          else transformLocalDef(tree)
       }
     }
 
@@ -78,7 +78,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
       * with a LazyHolder from
       * dotty.runtime(eg dotty.runtime.LazyInt)
       */
-    def transformLocalValDef(x: DefDef)(implicit ctx: Context) = {
+    def transformLocalDef(x: DefDef)(implicit ctx: Context) = {
         val valueInitter = x.rhs
         val holderName = ctx.freshName(x.name ++ StdNames.nme.LAZY_LOCAL).toTermName
         val initName = ctx.freshName(x.name ++ StdNames.nme.LAZY_LOCAL_INIT).toTermName
@@ -164,7 +164,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
       If(cond, init, exp)
     }
 
-    def transformFieldValDefNonVolatile(x: DefDef)(implicit ctx: Context) = {
+    def transformMemberDefNonVolatile(x: DefDef)(implicit ctx: Context) = {
         val claz = x.symbol.owner.asClass
         val tpe = x.tpe.widen.resultType.widen
         assert(!(x.mods is Flags.Mutable))
@@ -285,7 +285,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
       DefDef(methodSymbol, Block(resultDef :: retryDef :: flagDef :: cycle :: Nil, ref(resultSymbol)))
     }
 
-    def transformFieldValDefVolatile(x: DefDef)(implicit ctx: Context) = {
+    def transformMemberDefVolatile(x: DefDef)(implicit ctx: Context) = {
         assert(!(x.mods is Flags.Mutable))
 
         val tpe = x.tpe.widen.resultType.widen

From 61f0517d17b2dab40643d26f2bd1c111ad3792e9 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Thu, 30 Apr 2015 15:42:07 +0200
Subject: [PATCH 45/47] Comment why LazyVals needs to reorder stats in blocks.

---
 src/dotty/tools/dotc/transform/LazyVals.scala | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index 503b1c277db2..cc8ad8cdc53f 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -121,10 +121,14 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
 
 
   override def transformStats(trees: List[tpd.Tree])(implicit ctx: Context, info: TransformerInfo): List[tpd.Tree] = {
+    // 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 == containerFlags
+          _.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

From 3964a181906c68e59a5af1d7bb023a0db7acb490 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Thu, 30 Apr 2015 15:42:36 +0200
Subject: [PATCH 46/47] LV: change naming convention.

---
 src/dotty/tools/dotc/transform/LazyVals.scala | 53 ++++++++++---------
 1 file changed, 28 insertions(+), 25 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index cc8ad8cdc53f..c20da7601102 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -16,7 +16,6 @@ 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
@@ -100,8 +99,8 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
 
         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(nme_value)
-        val flag = ref(holderSymbol).select(nme_initialized)
+        val result = ref(holderSymbol).select(lazyNme.value)
+        val flag = ref(holderSymbol).select(lazyNme.initialized)
         val initer = valueInitter.changeOwner(x.symbol, initSymbol)
         val initBody =
           adaptToType(
@@ -229,15 +228,15 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
       val computeState = Literal(Constants.Constant(1))
       val notifyState = Literal(Constants.Constant(2))
       val computedState = Literal(Constants.Constant(3))
-      val flagSymbol = ctx.newSymbol(methodSymbol, nme_flag, 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, nme_result, containerFlags, tp)
+      val resultSymbol = ctx.newSymbol(methodSymbol, lazyNme.result, containerFlags, tp)
       val resultDef = ValDef(resultSymbol, initValue(tp))
 
-      val retrySymbol = ctx.newSymbol(methodSymbol, nme_retry, 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)
@@ -297,7 +296,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
         val thizClass = Literal(Constant(claz.info))
         val companion = claz.companionModule
         val helperModule = ctx.requiredModule("dotty.runtime.LazyVals")
-        val getOffset = Select(ref(helperModule), RLazyValsNames_getOffset)
+        val getOffset = Select(ref(helperModule), lazyNme.RLazyVals.getOffset)
         var offsetSymbol: TermSymbol = null
         var flag: Tree = EmptyTree
         var ord = 0
@@ -305,7 +304,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
         // compute or create appropriate offsetSymol, bitmap and bits used by current ValDef
         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
@@ -336,11 +335,11 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
         val containerTree = ValDef(containerSymbol, initValue(tpe))
 
         val offset =  ref(companion).ensureApplied.select(offsetSymbol)
-        val getFlag = Select(ref(helperModule), RLazyValsNames_get)
-        val setFlag = Select(ref(helperModule), RLazyValsNames_setFlag)
-        val wait =    Select(ref(helperModule), RLazyValsNames_wait4Notification)
-        val state =   Select(ref(helperModule), RLazyValsNames_state)
-        val cas =     Select(ref(helperModule), RLazyValsNames_cas)
+        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)
@@ -350,18 +349,22 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
 }
 
 object LazyVals {
-  val RLazyValsNames_get               = RLazyVals.Names.get.toTermName
-  val RLazyValsNames_setFlag           = RLazyVals.Names.setFlag.toTermName
-  val RLazyValsNames_wait4Notification = RLazyVals.Names.wait4Notification.toTermName
-  val RLazyValsNames_state             = RLazyVals.Names.state.toTermName
-  val RLazyValsNames_cas               = RLazyVals.Names.cas.toTermName
-  val RLazyValsNames_getOffset         = RLazyVals.Names.getOffset.toTermName
-  val nme_flag                         = "flag".toTermName
-  val nme_result                       = "result".toTermName
-  val nme_value                        = "value".toTermName
-  val nme_initialized                  = "initialized".toTermName
-  val nme_retry                        = "retry".toTermName
-
+  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
+  }
 }
 
 

From d23e71a42de6713ceda4b28dfd2f1bb83d051304 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Thu, 30 Apr 2015 16:34:12 +0200
Subject: [PATCH 47/47] Replace .entered by .enteredAfter in LazyVals.

Does not fail tests anymore.
---
 src/dotty/tools/dotc/transform/LazyVals.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index c20da7601102..62dc2f085531 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -315,7 +315,7 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
             } else { // need to create a new flag
               offsetSymbol = ctx.newSymbol(companion.moduleClass, (StdNames.nme.LAZY_FIELD_OFFSET + id.toString).toTermName, Flags.Synthetic, defn.LongType).enteredAfter(this)
               val flagName = (StdNames.nme.BITMAP_PREFIX + id.toString).toTermName
-              val flagSymbol = ctx.newSymbol(claz, flagName, containerFlags, defn.LongType).entered
+              val flagSymbol = ctx.newSymbol(claz, flagName, containerFlags, defn.LongType).enteredAfter(this)
               flag = ValDef(flagSymbol, Literal(Constants.Constant(0L)))
               val offsetTree = ValDef(offsetSymbol, getOffset.appliedTo(thizClass, Literal(Constant(flagName.toString))))
               info.defs = offsetTree :: info.defs