New lazy vals implementation

Author: olsdavis

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

@@ -16,6 +16,8 @@
       val pathEntries = System.getenv("PATH").split(psep).toList
       System.err.printf("sun.java.command: %s\n", sys.props("sun.java.command"))
       System.err.printf("first 5 PATH entries:\n%s\n",pathEntries.take(5).mkString("\n"))
+      printf("script.path: %s\n",path.norm)
+      assert(path.endsWith("scriptPath.sc"),s"actual path [$path]")
     }
 
   extension(s: String)

compiler/test-resources/scripting/scriptPath.sc

@@ -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(122, instructionsFromMethod(method).size)
     }
   }
 

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

@@ -25,6 +25,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)
 
@@ -40,6 +41,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 = {
@@ -57,6 +93,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)")
@@ -110,6 +152,13 @@ object LazyVals {
     r
   }
 
+  def getStaticOffset(clz: Class[_], name: String): Long = {
+    val r = unsafe.staticFieldOffset(clz.getDeclaredField(name))
+    if (debug)
+      println(s"getStaticOffset($clz, $name) = $r")
+    r
+  }
+
   def getOffsetStatic(field: java.lang.reflect.Field) =
     @nowarn
     val r = unsafe.objectFieldOffset(field)
@@ -119,11 +168,18 @@ object LazyVals {
 
 
   object Names {
+    final val waiting = "Waiting"
+    final val evaluating = "Evaluating"
+    final val nullValue = "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 getStaticOffset = "getStaticOffset"
   }
 }

library/src/scala/runtime/LazyVals.scala

@@ -4,6 +4,22 @@ import com.typesafe.tools.mima.core._
 object MiMaFilters {
   val Library: Seq[ProblemFilter] = Seq(
     ProblemFilters.exclude[MissingClassProblem]("scala.annotation.internal.MappedAlternative"),
+
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals.getStaticOffset"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals.objCAS"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.evaluating"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.getStaticOffset"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.nullValue"),
+    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"),
+
     ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.pureFunctions"),
     ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.captureChecking"),
     ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$pureFunctions$"),

project/MiMaFilters.scala

@@ -12,9 +12,6 @@
   |              Access non-initialized value num1. Promotion trace:
   |              -> val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error	[ t3273.scala:4 ]
   |                                                 ^^^^
--- Error: tests/init/neg/t3273.scala:5:61 ------------------------------------------------------------------------------
-5 |  val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error
-  |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |              Cannot prove the method argument is hot. Only hot values are safe to leak.
   |              Found = Fun { this = ThisRef[object Test], owner = object Test }. Calling trace:
   |              -> object Test {	[ t3273.scala:3 ]

tests/init/neg/t3273.check

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

tests/run/lazyVals_c3.0.0.check

@@ -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.0.0.scala

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

tests/run/lazyVals_c3.1.0.check

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