New lazy vals implementation

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(88, instructionsFromMethod(method).size)
+      assertEquals(113, instructionsFromMethod(method).size)
     }
   }
 

library/src/scala/runtime/LazyVals.scala

@@ -22,6 +22,7 @@ object LazyVals {
     val processors = java.lang.Runtime.getRuntime.nn.availableProcessors()
     8 * processors * processors
   }
+
   private[this] val monitors: Array[Object] =
     Array.tabulate(base)(_ => new Object)
 
@@ -37,6 +38,41 @@ object LazyVals {
 
   /* ------------- Start of public API ------------- */
 
+  /**
+   * Used to indicate the state of a lazy val that is being
+   * evaluated and of which other threads await the result.
+   */
+  final class Waiting:
+    private var done = false
+
+    /**
+     * Wakes up waiting threads. Called on completion of the evaluation
+     * of lazy val's right-hand side.
+     */
+    def release(): Unit = synchronized {
+      done = true
+      notifyAll()
+    }
+
+    /**
+     * Awaits the completion of the evaluation of lazy val's right-hand side.
+     */
+    def awaitRelease(): Unit = synchronized {
+      while !done do wait()
+    }
+
+  /**
+   * Used to indicate the state of a lazy val that is currently being
+   * evaluated with no other thread awaiting its result.
+   */
+  object Evaluating
+
+  /**
+   * Used to indicate the state of a lazy val that has been evaluated to
+   * `null`.
+   */
+  object NULL
+
   final val BITS_PER_LAZY_VAL = 2L
 
   def STATE(cur: Long, ord: Int): Long = {
@@ -54,6 +90,12 @@ object LazyVals {
     unsafe.compareAndSwapLong(t, offset, e, n)
   }
 
+  def objCAS(t: Object, offset: Long, exp: Object, n: Object): Boolean = {
+    if (debug)
+      println(s"objCAS($t, $exp, $n)")
+    unsafe.compareAndSwapObject(t, offset, exp, n)
+  }
+
   def setFlag(t: Object, offset: Long, v: Int, ord: Int): Unit = {
     if (debug)
       println(s"setFlag($t, $offset, $v, $ord)")
@@ -99,13 +141,21 @@ object LazyVals {
     unsafe.getLongVolatile(t, off)
   }
 
+  // kept for backward compatibility
   def getOffset(clz: Class[_], name: String): Long = {
     val r = unsafe.objectFieldOffset(clz.getDeclaredField(name))
     if (debug)
       println(s"getOffset($clz, $name) = $r")
     r
   }
 
+  def getStaticFieldOffset(field: java.lang.reflect.Field): Long = {
+    val r = unsafe.staticFieldOffset(field)
+    if (debug)
+      println(s"getStaticFieldOffset(${field.getDeclaringClass}, ${field.getName}) = $r")
+    r
+  }
+
   def getOffsetStatic(field: java.lang.reflect.Field) =
     val r = unsafe.objectFieldOffset(field)
     if (debug)
@@ -114,11 +164,19 @@ object LazyVals {
 
 
   object Names {
+    final val waiting = "Waiting"
+    final val evaluating = "Evaluating"
+    final val nullValued = "NULL"
+    final val waitingAwaitRelease = "awaitRelease"
+    final val waitingRelease = "release"
     final val state = "STATE"
     final val cas = "CAS"
+    final val objCas = "objCAS"
     final val setFlag = "setFlag"
     final val wait4Notification = "wait4Notification"
     final val get = "get"
     final val getOffset = "getOffset"
+    final val getOffsetStatic = "getOffsetStatic"
+    final val getStaticFieldOffset = "getStaticFieldOffset"
   }
 }

project/MiMaFilters.scala

@@ -11,11 +11,35 @@ object MiMaFilters {
 
     ProblemFilters.exclude[MissingClassProblem]("scala.annotation.since"),
 
+
     // APIs will be added in 3.2.0
     ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#AppliedTypeModule.apply"),
     ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#SymbolMethods.asQuotes"),
     ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#SymbolMethods.typeRef"),
     ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#SymbolMethods.termRef"),
     ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#TypeTreeModule.ref"),
+
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals.getStaticFieldOffset"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals.getOffsetStatic"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals.objCAS"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.evaluating"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.getStaticFieldOffset"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.getOffsetStatic"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.nullValued"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.objCas"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.waiting"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.waitingAwaitRelease"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.waitingRelease"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.LazyVals$Evaluating$"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.LazyVals$NULL$"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.LazyVals$Waiting"),
+    ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.LazyVals.Evaluating"),
+    ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.LazyVals.NULL"),
+
+    // Experimental `MainAnnotation` APIs. Can be added in 3.3.0 or later.
+    // MiMa bug: classes nested in an experimental object should be ignored
+    ProblemFilters.exclude[MissingClassProblem]("scala.annotation.MainAnnotation$Info"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.annotation.MainAnnotation$Parameter"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.annotation.MainAnnotation$ParameterAnnotation"),
   )
 }

tests/run/lazyVals_c3.0.0.check

@@ -0,0 +1,4 @@
+computing x
+x
+computing y
+y

tests/run/lazyVals_c3.0.0.scala

@@ -0,0 +1,13 @@
+// Compiled with 3.0.0 and run with current compiler
+class Foo:
+  lazy val x =
+    println("computing x")
+    "x"
+  lazy val y =
+    println("computing y")
+    "y"
+
+@main def Test =
+  val foo = new Foo
+  println(foo.x)
+  println(foo.y)

tests/run/lazyVals_c3.1.0.check

@@ -0,0 +1,4 @@
+computing x
+x
+computing y
+y

tests/run/lazyVals_c3.1.0.scala

@@ -0,0 +1,13 @@
+// Compiled with 3.1.0 and run with current compiler
+class Foo:
+  lazy val x =
+    println("computing x")
+    "x"
+  lazy val y =
+    println("computing y")
+    "y"
+
+@main def Test =
+  val foo = new Foo
+  println(foo.x)
+  println(foo.y)

tests/run/serialization-new.check

@@ -224,7 +224,14 @@ x = Paul
 y = Paul
 x equals y: true, y equals x: true
 
+Calculating a1
 1
+Calculating a2
 2
+Calculating a3
+3
+Calculating a1
 1
+Calculating a2
 2
+3

tests/run/serialization-new.scala

@@ -468,14 +468,26 @@ object Test7 {
 
 // Verify that transient lazy vals don't get serialized
 class WithTransient extends Serializable {
-  @transient lazy val a1 = 1
-  @transient private lazy val a2 = 2
+  @transient lazy val a1 = {
+    println("Calculating a1")
+    1
+  }
+  @transient private lazy val a2 = {
+    println("Calculating a2")
+    2
+  }
+  private lazy val a3 = {
+    println("Calculating a3")
+    3
+  }
+
   @transient object B extends Serializable
   @transient private object C extends Serializable
 
   def test = {
     println(a1)
     println(a2)
+    println(a3)
     if (B == null || C == null)
      println("Transient nested object failed to serialize properly")
   }