Fix failing testCompilation tests for new lazy vals

Pre-review lazy vals adjustments

Author: szymon-rd

bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccess.scala

@@ -27,4 +27,4 @@ class InitializedAccess {
     bh.consume(holder)
     bh.consume(holder.value)
   }
-}
+}

bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessAny.scala

@@ -27,4 +27,4 @@ class InitializedAccessAny {
     bh.consume(holder)
     bh.consume(holder.value)
   }
-}
+}

bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessGeneric.scala

@@ -27,4 +27,4 @@ class InitializedAccessGeneric {
     bh.consume(holder)
     bh.consume(holder.value)
   }
-}
+}

bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessMultiple.scala

@@ -31,4 +31,4 @@ class InitializedAccessMultiple {
       i = i + 1
     }
   }
-}
+}

bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessString.scala

@@ -27,4 +27,4 @@ class InitializedAccessString {
     bh.consume(holder)
     bh.consume(holder.value)
   }
-}
+}

bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/LazyVals.scala

@@ -50,4 +50,4 @@ object LazyVals {
             }
         }
     }
-}
+}

bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/UninitializedAccess.scala

@@ -22,4 +22,4 @@ class UninitializedAccess {
       bh.consume(holder.value)
       i = i + 1
     }
-}
+}

bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/UninitializedAccessMultiple.scala

@@ -24,4 +24,4 @@ class UninitializedAccessMultiple {
         i = i + 1
       }
     }
-}
+}

compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala

@@ -7,7 +7,6 @@ import Types._, Contexts._, Flags._
 import Symbols._, Annotations._, Trees._, Symbols._, Constants.Constant
 import Decorators._
 import dotty.tools.dotc.transform.SymUtils._
-import transform.LazyVals
 
 /** A map that applies three functions and a substitution together to a tree and
  *  makes sure they are coordinated so that the result is well-typed. The functions are

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -241,7 +241,6 @@ private sealed trait XSettings:
   val XcheckMacros: Setting[Boolean] = BooleanSetting("-Xcheck-macros", "Check some invariants of macro generated code while expanding macros", aliases = List("--Xcheck-macros"))
   val XmainClass: Setting[String] = StringSetting("-Xmain-class", "path", "Class for manifest's Main-Class entry (only useful with -d <jar>)", "")
   val XimplicitSearchLimit: Setting[Int] = IntSetting("-Ximplicit-search-limit", "Maximal number of expressions to be generated in an implicit search", 50000)
-  val XlegacyLazyVals: Setting[Boolean] = BooleanSetting("-Xlegacy-lazy-values", "Use legacy lazy vals implementations")
 
   val XmixinForceForwarders = ChoiceSetting(
     name    = "-Xmixin-force-forwarders",
@@ -331,6 +330,7 @@ private sealed trait YSettings:
   val YrecheckTest: Setting[Boolean] = BooleanSetting("-Yrecheck-test", "Run basic rechecking (internal test only)")
   val YccDebug: Setting[Boolean] = BooleanSetting("-Ycc-debug", "Used in conjunction with captureChecking language import, debug info for captured references")
   val YccNoAbbrev: Setting[Boolean] = BooleanSetting("-Ycc-no-abbrev", "Used in conjunction with captureChecking language import, suppress type abbreviations")
+  val YlightweightLazyVals: Setting[Boolean] = BooleanSetting("-Ylightweight-lazy-vals", "Use experimental lightweight implementation of lazy vals")
 
   /** Area-specific debug output */
   val YexplainLowlevel: Setting[Boolean] = BooleanSetting("-Yexplain-lowlevel", "When explaining type errors, show types at a lower level.")

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

@@ -2,21 +2,22 @@ package dotty.tools.dotc
 package transform
 
 import java.util.IdentityHashMap
-
 import ast.tpd
 import core.Annotations.Annotation
 import core.Constants.Constant
-import core.Contexts._
-import core.Decorators._
+import core.Contexts.*
+import core.Decorators.*
 import core.DenotTransformers.IdentityDenotTransformer
-import core.Flags._
-import core.NameKinds.{LazyBitMapName, LazyLocalInitName, LazyLocalName, ExpandedName}
+import core.Flags.*
+import core.NameKinds.{ExpandedName, LazyBitMapName, LazyLocalInitName, LazyLocalName}
 import core.StdNames.nme
-import core.Symbols._
-import core.Types._
+import core.Symbols.*
+import core.Types.*
 import core.{Names, StdNames}
+import dotty.tools.dotc.config.Feature
 import transform.MegaPhase.MiniPhase
-import transform.SymUtils._
+import transform.SymUtils.*
+
 import scala.collection.mutable
 
 class LazyVals extends MiniPhase with IdentityDenotTransformer {
@@ -59,9 +60,6 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     else nullables.toList
   }
 
-  private inline def isLegacyLazyVals(using ctx: Context): Boolean =
-    ctx.settings.XlegacyLazyVals.value
-
   private def needsBoxing(tp: Type)(using Context): Boolean = tp != NoType && tp != defn.UnitType && tp.classSymbol.isPrimitiveValueClass
 
   private def boxIfCan(tp: Type)(using Context): Type =
@@ -120,7 +118,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
    */
   override def transformTemplate(template: Template)(using Context): Tree = {
     val cls = ctx.owner.asClass
-    (if isLegacyLazyVals then oldAppendOffsetDefs else appendOffsetDefs).get(cls) match {
+    (if !ctx.settings.YlightweightLazyVals.value then oldAppendOffsetDefs else appendOffsetDefs).get(cls) match {
       case None => template
       case Some(data) =>
         data.defs.foreach(_.symbol.addAnnotation(Annotation(defn.ScalaStaticAnnot)))
@@ -338,10 +336,15 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
    *     val current: AnyRef = _x
    *     if current == null then
    *       if CAS(_x, null, Evaluating) then
+   *         var resultNullable: AnyRef = null
    *         var result: AnyRef = null
    *         try
+   *           resultNullable = rhs
    *           nullable = null
-   *           if result == null then result = NullValue
+   *           if resultNullable == null then
+   *             result = NullValue
+   *           else
+   *             result = resultNullable
    *           return result
    *         finally
    *            if !CAS(_x, Evaluating, result) then
@@ -417,6 +420,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     // if observed a null (uninitialized) value
     val initialize = {
       // var result: AnyRef
+      val resSymbNullable = newSymbol(lazyInitMethodSymbol, lazyNme.resultNullable, Synthetic | Mutable, defn.ObjectType)
       val resSymb = newSymbol(lazyInitMethodSymbol, lazyNme.result, Synthetic | Mutable, defn.ObjectType)
       // releasing block in finally
       val lockRel = {
@@ -430,26 +434,26 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
           objCasFlag.appliedTo(thiz, offset, evaluating, ref(resSymb)).select(nme.UNARY_!).appliedToNone,
           lockRel,
           unitLiteral
-        ) :: Nil, Return(ref(resSymb), lazyInitMethodSymbol)).withType(defn.UnitType)
+        ) :: Nil, unitLiteral).withType(defn.UnitType)
       // entire try block
       val evaluate = Try(
 
         Block(
-          (Assign(ref(resSymb), if needsBoxing(tp) && rhsMappedOwner != EmptyTree then rhsMappedOwner.ensureConforms(boxIfCan(tp)) else rhsMappedOwner) // try result = rhs
+          (Assign(ref(resSymbNullable), if needsBoxing(tp) && rhsMappedOwner != EmptyTree then rhsMappedOwner.ensureConforms(boxIfCan(tp)) else rhsMappedOwner) // try result = rhs
           :: If(
-              ref(resSymb).select(defn.Any_==).appliedTo(nullLiteral),
+              ref(resSymbNullable).select(defn.Any_==).appliedTo(nullLiteral),
               Assign(ref(resSymb), nullValue),
-              unitLiteral
+              Assign(ref(resSymb), ref(resSymbNullable))
           ) :: Nil)
           ::: nullOut(nullableFor(accessorMethodSymbol)),
-          unitLiteral),
+          Return(ref(resSymbNullable), lazyInitMethodSymbol)),
         Nil,
         fin
       )
       // if CAS(_, null, Evaluating)
       If(
         objCasFlag.appliedTo(thiz, offset, nullLiteral, evaluating),
-        Block(ValDef(resSymb, nullLiteral) :: Nil, // var result: AnyRef = null
+        Block(ValDef(resSymb, nullLiteral) :: ValDef(resSymbNullable, nullLiteral) :: Nil, // var result: AnyRef = null
           evaluate), // try ... finally ...
         unitLiteral
       ).withType(defn.UnitType)
@@ -490,10 +494,10 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
 
   def transformMemberDefThreadSafe(x: ValOrDefDef)(using Context): Thicket = {
     assert(!(x.symbol is Mutable))
-    if isLegacyLazyVals then
-      transformMemberDefThreadSafeLegacy(x)
-    else
+    if ctx.settings.YlightweightLazyVals.value then
       transformMemberDefThreadSafeNew(x)
+    else
+      transformMemberDefThreadSafeLegacy(x)
   }
 
   def transformMemberDefThreadSafeNew(x: ValOrDefDef)(using Context): Thicket = {
@@ -741,6 +745,7 @@ object LazyVals {
     val flag: TermName        = "flag".toTermName
     val state: TermName       = "state".toTermName
     val result: TermName      = "result".toTermName
+    val resultNullable: TermName      = "resultNullable".toTermName
     val value: TermName       = "value".toTermName
     val initialized: TermName = "initialized".toTermName
     val initialize: TermName  = "initialize".toTermName

compiler/test/dotc/pos-lazy-vals-tests.allowlist

@@ -0,0 +1,37 @@
+Repeated.scala
+byname-implicits-8.scala
+existentials.scala
+i1235.scala
+i13332super.scala
+i13349.scala
+i13460.scala
+i14626.scala
+i1753.scala
+i4031.scala
+i4328.scala
+i6450.scala
+i6565.scala
+i8031.scala
+i8111.scala
+i8900-unflip.scala
+lazyvals.scala
+singletons.scala
+spec-traits.scala
+spurious-overload.scala
+t1591_pos.scala
+t2910.scala
+t3411.scala
+t3420.scala
+t3452f.scala
+t3670.scala
+t3927.scala
+t4432.scala
+t4716.scala
+t4717.scala
+t5099.scala
+t5796.scala
+t6278-synth-def.scala
+t6925b.scala
+t7011.scala
+t8306.scala
+zipped.scala

compiler/test/dotc/run-from-tasty.blacklist

@@ -1,2 +1,2 @@
 # CI only: cannot reduce summonFrom with
-sip23-valueof.scala
+sip23-valueof.scala

compiler/test/dotc/run-lazy-vals-tests.allowlist

@@ -0,0 +1,66 @@
+IArrayOps.scala
+Lazies1.scala
+Lazies2.scala
+OrderingTest.scala
+anon-mirror-gen-local.scala
+byname-implicits-28.scala
+byname-implicits-30.scala
+byname-implicits-5.scala
+exports.scala
+i13146.scala
+i13146a.scala
+i13332a.scala
+i13332shapeless.scala
+i13358.scala
+i1692.scala
+i1692b.scala
+i1856.scala
+i2266.scala
+i2275.scala
+i4451.scala
+i4559.scala
+i5340.scala
+i5350.scala
+i7675.scala
+i9473.scala
+isInstanceOf-eval.scala
+lazy-exprs.scala
+lazy-impl.scala
+lazy-implicit-lists.scala
+lazy-override-run.scala
+lazy-traits.scala
+lazyVals.scala
+lazyVals_c3.0.0.scala
+lazyVals_c3.1.0.scala
+nonLocalReturns.scala
+nothing-lazy-val.scala
+null-lazy-val.scala
+patmatch-classtag.scala
+priorityQueue.scala
+serialization-new-legacy.scala
+serialization-new.scala
+singletons.scala
+statics.scala
+stream_flatmap_odds.scala
+t1535.scala
+t1591.scala
+t2333.scala
+t3038.scala
+t3670.scala
+t3699.scala
+t3877.scala
+t3895.scala
+t3980.scala
+t429.scala
+t5552.scala
+t5610a.scala
+t603.scala
+t6272.scala
+t6443-by-name.scala
+t6443-varargs.scala
+t704.scala
+t7406.scala
+t8245.scala
+unapply.scala
+unit-lazy-val.scala
+view-iterator-stream.scala

compiler/test/dotc/run-test-pickling.blacklist

@@ -43,4 +43,4 @@ i12753
 t6138
 t6138-2
 i12656.scala
-trait-static-forwarder
+trait-static-forwarder

compiler/test/dotc/run-test-recheck.excludes

@@ -10,4 +10,4 @@ i5976.scala
 tagless.scala
 safeThrowsStrawman2.scala
 t7584.scala
-function-arity.scala
+function-arity.scala

compiler/test/dotty/tools/TestSources.scala

@@ -13,21 +13,26 @@ object TestSources {
 
   def posFromTastyBlacklistFile: String = "compiler/test/dotc/pos-from-tasty.blacklist"
   def posTestPicklingBlacklistFile: String = "compiler/test/dotc/pos-test-pickling.blacklist"
-  def posTestRecheckExcludesFile = "compiler/test/dotc/pos-test-recheck.excludes"
+  def posTestRecheckExcludesFile: String = "compiler/test/dotc/pos-test-recheck.excludes"
+  def posLazyValsAllowlistFile: String = "compiler/test/dotc/pos-lazy-vals-tests.allowlist"
 
   def posFromTastyBlacklisted: List[String] = loadList(posFromTastyBlacklistFile)
   def posTestPicklingBlacklisted: List[String] = loadList(posTestPicklingBlacklistFile)
-  def posTestRecheckExcluded = loadList(posTestRecheckExcludesFile)
+  def posTestRecheckExcluded: List[String] = loadList(posTestRecheckExcludesFile)
+  def posLazyValsAllowlist: List[String] = loadList(posLazyValsAllowlistFile)
 
   // run tests lists
 
   def runFromTastyBlacklistFile: String = "compiler/test/dotc/run-from-tasty.blacklist"
   def runTestPicklingBlacklistFile: String = "compiler/test/dotc/run-test-pickling.blacklist"
-  def runTestRecheckExcludesFile = "compiler/test/dotc/run-test-recheck.excludes"
+  def runTestRecheckExcludesFile: String = "compiler/test/dotc/run-test-recheck.excludes"
+  def runLazyValsAllowlistFile: String = "compiler/test/dotc/run-lazy-vals-tests.allowlist"
+
 
   def runFromTastyBlacklisted: List[String] = loadList(runFromTastyBlacklistFile)
   def runTestPicklingBlacklisted: List[String] = loadList(runTestPicklingBlacklistFile)
-  def runTestRecheckExcluded = loadList(runTestRecheckExcludesFile)
+  def runTestRecheckExcluded: List[String] = loadList(runTestRecheckExcludesFile)
+  def runLazyValsAllowlist: List[String] = loadList(runLazyValsAllowlistFile)
 
   // load lists
 

compiler/test/dotty/tools/backend/jvm/DottyBytecodeTests.scala

@@ -597,7 +597,7 @@ class DottyBytecodeTests extends DottyBytecodeTest {
       val clsIn   = dir.lookupName("Test.class", directory = false).input
       val clsNode = loadClassNode(clsIn)
       val method  = getMethod(clsNode, "test")
-      assertEquals(118, instructionsFromMethod(method).size)
+      assertEquals(88, instructionsFromMethod(method).size)
     }
   }
 

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -43,6 +43,8 @@ class CompilationTests {
       compileFilesInDir("tests/pos-custom-args/captures", defaultOptions.and("-language:experimental.captureChecking")),
       compileFilesInDir("tests/pos-custom-args/erased", defaultOptions.and("-language:experimental.erasedDefinitions")),
       compileFilesInDir("tests/pos", defaultOptions.and("-Ysafe-init")),
+      // Run tests for experimental lightweight lazy vals
+      compileFilesInDir("tests/pos", defaultOptions.and("-Ysafe-init", "-Ylightweight-lazy-vals"), FileFilter.include(TestSources.posLazyValsAllowlist)),
       compileFilesInDir("tests/pos-deep-subtype", allowDeepSubtypes),
       compileFilesInDir("tests/pos-custom-args/no-experimental", defaultOptions.and("-Yno-experimental")),
       compileDir("tests/pos-special/java-param-names", defaultOptions.withJavacOnlyOptions("-parameters")),
@@ -215,7 +217,9 @@ class CompilationTests {
       compileDir("tests/run-custom-args/Xmacro-settings/compileTimeEnv", defaultOptions.and("-Xmacro-settings:a,b=1,c.b.a=x.y.z=1,myLogger.level=INFO")),
       compileFilesInDir("tests/run-custom-args/captures", allowDeepSubtypes.and("-language:experimental.captureChecking")),
       compileFilesInDir("tests/run-deep-subtype", allowDeepSubtypes),
-      compileFilesInDir("tests/run", defaultOptions.and("-Ysafe-init"))
+      compileFilesInDir("tests/run", defaultOptions.and("-Ysafe-init"), FileFilter.exclude("serialization-new.scala")),
+      // Run tests for experimental lightweight lazy vals and stable lazy vals.
+      compileFilesInDir("tests/run", defaultOptions.and("-Ysafe-init", "-Ylightweight-lazy-vals"), FileFilter.include(TestSources.runLazyValsAllowlist)),
     ).checkRuns()
   }