Merge pull request #550 from dotty-staging/lazy-vals-fixes

Various fixes to LazyVals.

Author: odersky

src/dotty/runtime/LazyVals.scala

@@ -60,7 +60,10 @@ object LazyVals {
   }.toArray
 
   @inline def getMonitor(obj: Object, fieldId: Int = 0) = {
-    var id = (java.lang.System.identityHashCode(obj) + fieldId) % base
+    var id = (
+      /*java.lang.System.identityHashCode(obj) + */ // should be here, but #548
+      fieldId) % base
+
     if (id < 0) id += base
     monitors(id)
   }

src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -40,13 +40,13 @@ class PlainPrinter(_ctx: Context) extends Printer {
   def homogenize(tp: Type): Type =
     if (homogenizedView)
       tp match {
-        case tp: ThisType if tp.cls.is(Package) && !tp.cls.isEffectiveRoot => 
+        case tp: ThisType if tp.cls.is(Package) && !tp.cls.isEffectiveRoot =>
           ctx.requiredPackage(tp.cls.fullName).termRef
-        case tp: TypeVar if tp.isInstantiated => 
+        case tp: TypeVar if tp.isInstantiated =>
           homogenize(tp.instanceOpt)
-        case AndType(tp1, tp2) => 
+        case AndType(tp1, tp2) =>
           homogenize(tp1) & homogenize(tp2)
-        case OrType(tp1, tp2) => 
+        case OrType(tp1, tp2) =>
           homogenize(tp1) | homogenize(tp2)
         case _ =>
           val tp1 = tp.simplifyApply
@@ -390,7 +390,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   def toText(const: Constant): Text = const.tag match {
     case StringTag => "\"" + escapedString(const.value.toString) + "\""
-    case ClazzTag => "classOf[" ~ toText(const.tpe.firstBaseArgInfo(defn.ClassClass)) ~ "]"
+    case ClazzTag => "classOf[" ~ toText(const.typeValue.classSymbol) ~ "]"
     case CharTag => s"'${escapedChar(const.charValue)}'"
     case LongTag => const.longValue.toString + "L"
     case EnumTag => const.symbolValue.name.toString

src/dotty/tools/dotc/transform/Constructors.scala

@@ -32,6 +32,17 @@ class Constructors extends MiniPhaseTransform with SymTransformer { thisTransfor
   override def phaseName: String = "constructors"
   override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Erasure])
 
+
+  /** All initializers should be moved into constructor
+    */
+  override def checkPostCondition(tree: tpd.Tree)(implicit ctx: Context): Unit = {
+    tree match {
+      case t: ValDef if ((t.rhs ne EmptyTree) && !(t.symbol is Flags.Lazy) && t.symbol.owner.isClass) =>
+        assert(false, i"$t initializers should be moved to constructors")
+      case _ =>
+    }
+  }
+
   /** Symbols that are owned by either <local dummy> or a class field move into the
    *  primary constructor.
    */

src/dotty/tools/dotc/transform/LazyVals.scala

@@ -59,20 +59,20 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
       }
     }
 
-    /** Append offset fields to companion objects
-     */
-    override def transformTypeDef(tree: TypeDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
-      if (!tree.symbol.isClass) tree
-      else {
-        appendOffsetDefs.get(tree.symbol) match {
-          case None => tree
-          case Some(data) =>
-            val template = tree.rhs.asInstanceOf[Template]
-            val newTemplate = cpy.Template(template)(body = data.defs ::: template.body)
-            cpy.TypeDef(tree)(rhs = newTemplate) //(ctx.withMode(Mode.FutureDefsOK))
-        }
-      }
+
+  /** Append offset fields to companion objects
+    */
+  override def transformTemplate(template: tpd.Template)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
+    val cls = ctx.owner.asClass
+
+    appendOffsetDefs.get(cls) match {
+      case None => template
+      case Some(data) =>
+        cpy.Template(template)(body = data.defs ::: template.body)
     }
+
+  }
+
     /** Replace a local lazy val inside a method,
       * with a LazyHolder from
       * dotty.runtime(eg dotty.runtime.LazyInt)
@@ -109,10 +109,10 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
             tpe)
         val initTree = DefDef(initSymbol, initBody)
         val holderTree = ValDef(holderSymbol, New(holderImpl.typeRef, List()))
-        val methodBody = {
-          tpd.If(flag, EmptyTree, ref(initSymbol))
-          result.ensureApplied.ensureConforms(tpe)
-          }
+        val methodBody = tpd.If(flag.ensureApplied,
+          result.ensureApplied,
+          ref(initSymbol).ensureApplied).ensureConforms(tpe)
+
         val methodTree = DefDef(x.symbol.asTerm, methodBody)
         ctx.debuglog(s"found a lazy val ${x.show},\n rewrote with ${holderTree.show}")
         Thicket(holderTree, initTree, methodTree)