Fix static lazy field holder for GraalVM

Author: szymon-rd

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

@@ -0,0 +1,30 @@
+package dotty.tools.benchmarks.lazyvals
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import LazyVals.LazyIntHolder
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Array(Mode.AverageTime))
+@Fork(2)
+@Threads(1)
+@Warmup(iterations = 5)
+@Measurement(iterations = 5)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Benchmark)
+class InitializedAccessInt {
+
+  var holder: LazyIntHolder = _
+
+  @Setup
+  def prepare: Unit = {
+    holder = new LazyIntHolder
+    holder.value
+  }
+
+  @Benchmark
+  def measureInitialized(bh: Blackhole) = {
+    bh.consume(holder)
+    bh.consume(holder.value)
+  }
+}

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

@@ -0,0 +1,22 @@
+package dotty.tools.benchmarks.lazyvals
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import LazyVals.ObjectHolder
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Array(Mode.AverageTime))
+@Fork(2)
+@Threads(1)
+@Warmup(iterations = 5)
+@Measurement(iterations = 5)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Benchmark)
+class InitializedObject {
+
+  @Benchmark
+  def measureInitialized(bh: Blackhole) = {
+    bh.consume(ObjectHolder)
+    bh.consume(ObjectHolder.value)
+  }
+}

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

@@ -50,4 +50,22 @@ object LazyVals {
             }
         }
     }
+
+    class LazyIntHolder {
+        lazy val value: Int = {
+            (System.nanoTime() % 1000).toInt
+        }
+    }
+
+    object ObjectHolder {
+        lazy val value: String = {
+            System.nanoTime() % 5 match {
+                case 0 => "abc"
+                case 1 => "def"
+                case 2 => "ghi"
+                case 3 => "jkl"
+                case 4 => "mno"
+            }
+        }
+    }
 }

compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala

@@ -151,7 +151,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
 
         // !!! Part of this logic is duplicated in JSCodeGen.genCompilationUnit
         claszSymbol.info.decls.foreach { f =>
-          if f.isField && !f.name.is(LazyBitMapName) then
+          if f.isField && !f.name.is(LazyBitMapName) && !f.name.is(LazyLocalName) then
             f.setFlag(JavaStatic)
         }
 

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -22,7 +22,7 @@ import dotty.tools.dotc.report
 import tpd._
 
 import StdNames.nme
-import NameKinds.LazyBitMapName
+import NameKinds.{LazyBitMapName, LazyLocalName}
 import Names.Name
 
 class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap: ReadOnlyMap[Symbol, Set[ClassSymbol]])(using val ctx: Context) {
@@ -129,10 +129,11 @@ object DottyBackendInterface {
        *        the new lazy val encoding: https://github.com/lampepfl/dotty/issues/7140
        */
       def isStaticModuleField(using Context): Boolean =
-        sym.owner.isStaticModuleClass && sym.isField && !sym.name.is(LazyBitMapName)
+        sym.owner.isStaticModuleClass && sym.isField && !sym.name.is(LazyBitMapName) && !sym.name.is(LazyLocalName)
 
       def isStaticMember(using Context): Boolean = (sym ne NoSymbol) &&
-        (sym.is(JavaStatic) || sym.isScalaStatic || sym.isStaticModuleField)
+          (sym.is(JavaStatic) || sym.isScalaStatic || sym.isStaticModuleField)
+
         // guard against no sumbol cause this code is executed to select which call type(static\dynamic) to use to call array.clone
 
       /**

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

@@ -466,13 +466,9 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     val containerSymbol = newSymbol(claz, containerName, x.symbol.flags &~ containerFlagsMask | containerFlags | Private, defn.ObjectType, coord = x.symbol.coord).enteredAfter(this)
     containerSymbol.addAnnotation(Annotation(defn.VolatileAnnot, containerSymbol.span)) // private @volatile var _x: AnyRef
     containerSymbol.addAnnotations(x.symbol.annotations) // pass annotations from original definition
-    val stat = x.symbol.isStatic
-    if stat then
-      containerSymbol.setFlag(JavaStatic)
+    containerSymbol.removeAnnotation(defn.ScalaStaticAnnot)
+    containerSymbol.resetFlag(JavaStatic)
     val getOffset =
-      if stat then
-        Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.getStaticFieldOffset)
-      else
         Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.getOffsetStatic)
     val containerTree = ValDef(containerSymbol, nullLiteral)
 
@@ -490,9 +486,6 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     val offset = ref(offsetSymbol.nn)
 
     val swapOver =
-      if stat then
-        tpd.clsOf(x.symbol.owner.typeRef)
-      else
         This(claz)
 
     val (accessorDef, initMethodDef) = mkThreadSafeDef(x, claz, containerSymbol, offset, swapOver)