specialized lazy vals now behave like regular lazy vals

Author: adriaanm

src/compiler/scala/tools/nsc/transform/AccessorSynthesis.scala

@@ -315,7 +315,9 @@ trait AccessorSynthesis extends Transform with ast.TreeDSL {
         * This way the inliner should optimize the fast path because the method body is small enough.
         */
       def expandLazyClassMember(lazyVar: Symbol, lazyAccessor: Symbol, transformedRhs: Tree, nullables: Map[Symbol, List[Symbol]]): Tree = {
-        def nullify(sym: Symbol) = Select(thisRef, sym.accessedOrSelf) === LIT(null)
+        // use cast so that specialization can turn null.asInstanceOf[T] into null.asInstanceOf[Long]
+        def nullify(sym: Symbol) =
+          Select(thisRef, sym.accessedOrSelf) === gen.mkAsInstanceOf(NULL, sym.info.resultType)
         val nulls = nullables.getOrElse(lazyAccessor, Nil) map nullify
 
         if (nulls.nonEmpty)

src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala

@@ -723,7 +723,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
         } else if (!sClass.isTrait && m.isMethod && m.hasFlag(LAZY)) {
           forwardToOverload(m)
 
-        } else if (m.isValue && !m.isMethod && !m.hasFlag(LAZY)) { // concrete value definition
+        } else if (m.isValue && !m.isMethod) { // concrete value definition
           def mkAccessor(field: Symbol, name: Name) = {
             val newFlags = (SPECIALIZED | m.getterIn(clazz).flags) & ~(LOCAL | CASEACCESSOR | PARAMACCESSOR)
             // we rely on the super class to initialize param accessors
@@ -744,7 +744,14 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
           enterMember(specVal)
           // create accessors
 
-          if (nme.isLocalName(m.name)) {
+          if (m.isLazy) {
+            // no getters needed (we'll specialize the compute method and accessor separately), can stay private
+            // m.setFlag(PRIVATE) -- TODO: figure out how to leave the non-specialized lazy var private
+            // (the implementation needs it to be visible while duplicating and retypechecking,
+            //  but it really could be private in bytecode)
+            specVal.setFlag(PRIVATE)
+          }
+          else if (nme.isLocalName(m.name)) {
             val specGetter = mkAccessor(specVal, specVal.getterName) setInfo MethodType(Nil, specVal.info)
             val origGetter = overrideIn(sClass, m.getterIn(clazz))
             info(origGetter) = Forward(specGetter)

test/files/run/t5552.check

@@ -1,2 +1,6 @@
+lazy: 3
 (3,3)
+(3,3)
+lazy: 3.0
+(3.0,3.0)
 (3.0,3.0)

test/files/run/t5552.scala

@@ -1,10 +1,14 @@
 class C[@specialized(Int) A](a:A) {
-  lazy val b = (a, a)
+  lazy val b = {println(s"lazy: $a"); (a, a)} // there should only be two instances of "lazy" in the output
   def c = b
 }
 object Test {
   def main(args:Array[String]) {
-    println(new C(3).c)
-    println(new C(3.0).c)
+    val cInt = new C(3)
+    println(cInt.c)
+    println(cInt.c)
+    val cFloat = new C(3.0)
+    println(cFloat.c)
+    println(cFloat.c)
   }
 }