Fixing tests, mima and synchronization in new lazy vals

szymon-rd · szymon-rd · commit 4629ec17e702 · 2022-10-07T16:57:01.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -422,7 +422,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     // if observed a null (uninitialized) value
     val initialize = {
       // var result: AnyRef
-      val resSymbNullable = newSymbol(lazyInitMethodSymbol, lazyNme.result, Synthetic | Mutable, defn.ObjectType)
+      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 = {
@@ -747,6 +747,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
diff --git a/compiler/test/dotty/tools/backend/jvm/DottyBytecodeTests.scala b/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(36, instructionsFromMethod(method).size)
     }
   }
 
diff --git a/library/src/scala/runtime/LazyVals.scala b/library/src/scala/runtime/LazyVals.scala
@@ -141,6 +141,7 @@ object LazyVals {
   }
 
   def getStaticFieldOffset(field: java.lang.reflect.Field): Long = {
+    @nowarn
     val r = unsafe.staticFieldOffset(field)
     if (debug)
       println(s"getStaticFieldOffset(${field.getDeclaringClass}, ${field.getName}) = $r")
diff --git a/project/MiMaFilters.scala b/project/MiMaFilters.scala
@@ -4,6 +4,9 @@ import com.typesafe.tools.mima.core._
 object MiMaFilters {
   val Library: Seq[ProblemFilter] = Seq(
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals.getStaticOffset"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.getOffsetStatic"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals.getStaticFieldOffset"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.getStaticFieldOffset"),
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals.objCAS"),
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.evaluating"),
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.getStaticOffset"),
@@ -12,10 +15,12 @@ object MiMaFilters {
     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$LazyValControlState"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals#Names.controlState"),
     ProblemFilters.exclude[MissingClassProblem]("scala.runtime.LazyVals$Evaluating$"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.LazyVals$NULL$"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.LazyVals$NullValue$"),
     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.LazyVals.NullValue"),
   )
 }
diff --git a/tests/printing/transformed/lazy-vals-new.check b/tests/printing/transformed/lazy-vals-new.check
@@ -24,6 +24,14 @@ package <empty> {
       new scala.runtime.ModuleSerializationProxy(classOf[A])
     @volatile lazy <static> var x$lzy1: Object = null
     lazy def x(): Int = 
+      {
+        var result: Object = A#x$lzy1
+        if result.isInstanceOf[Int] then return scala.Int.unbox(result) else 
+          if result.==(scala.runtime.LazyVals.NullValue) then 
+            return scala.Int.unbox(null)
+           else return scala.Int.unbox(A.x$lzyINIT1())
+      }
+    private def x$lzyINIT1(): Object = 
       while <empty> do 
         {
           val current: Object = A#x$lzy1
@@ -35,49 +43,64 @@ package <empty> {
              then 
               {
                 var result: Object = null
+                var resultNullable: Object = null
                 try 
                   {
-                    result = scala.Int.box(2)
-                    if result.==(null) then 
+                    resultNullable = scala.Int.box(2)
+                    if resultNullable.==(null) then 
                       result = scala.runtime.LazyVals.NullValue
+                     else result = resultNullable
+                    return resultNullable
                   }
                  finally 
-                  if 
-                    scala.runtime.LazyVals.objCAS(classOf[A], A.OFFSET$_m_0, 
-                      scala.runtime.LazyVals.Evaluating
-                    , result).unary_!()
-                   then 
-                    {
-                      val lock: scala.runtime.LazyVals.LazyVals$Waiting = 
-                        A#x$lzy1.asInstanceOf[
-                          scala.runtime.LazyVals.LazyVals$Waiting
-                        ]
+                  {
+                    if 
                       scala.runtime.LazyVals.objCAS(classOf[A], A.OFFSET$_m_0, 
-                        lock
-                      , result)
-                      lock.countDown()
-                    }
+                        scala.runtime.LazyVals.Evaluating
+                      , result).unary_!()
+                     then 
+                      {
+                        val lock: scala.runtime.LazyVals.LazyVals$Waiting = 
+                          A#x$lzy1.asInstanceOf[
+                            scala.runtime.LazyVals.LazyVals$Waiting
+                          ]
+                        scala.runtime.LazyVals.objCAS(classOf[A], A.OFFSET$_m_0
+                          , 
+                        lock, result)
+                        lock.countDown()
+                      }
+                     else ()
+                    ()
+                  }
               }
+             else ()
            else 
-            if current.isInstanceOf[scala.runtime.LazyVals.Evaluating] then 
-              {
-                scala.runtime.LazyVals.objCAS(classOf[A], A.OFFSET$_m_0, 
-                  scala.runtime.LazyVals.Evaluating
-                , new scala.runtime.LazyVals.LazyVals$Waiting())
-                ()
-              }
-             else 
-              if current.isInstanceOf[scala.runtime.LazyVals.NullValue] then 
-                return 0
+            if 
+              current.isInstanceOf[
+                scala.runtime.LazyVals.LazyVals$LazyValControlState
+              ]
+             then 
+              if current.==(scala.runtime.LazyVals.Evaluating) then 
+                {
+                  scala.runtime.LazyVals.objCAS(classOf[A], A.OFFSET$_m_0, 
+                    scala.runtime.LazyVals.Evaluating
+                  , new scala.runtime.LazyVals.LazyVals$Waiting())
+                  ()
+                }
                else 
                 if current.isInstanceOf[scala.runtime.LazyVals.LazyVals$Waiting]
                    then
                  
                   current.asInstanceOf[scala.runtime.LazyVals.LazyVals$Waiting].
                     await
                   ()
-                 else return scala.Int.unbox(current)
+                 else 
+                  if current.==(scala.runtime.LazyVals.NullValue) then 
+                    return null
+                   else ()
+             else return current
         }
   }
   final lazy module val A: A = new A()
-} 
+}
+

Original file line number	Diff line number	Diff line change
`@@ -597,7 +597,7 @@ class DottyBytecodeTests extends DottyBytecodeTest {`
`597`	`597`	`val clsIn = dir.lookupName("Test.class", directory = false).input`
`598`	`598`	`val clsNode = loadClassNode(clsIn)`
`599`	`599`	`val method = getMethod(clsNode, "test")`
`600`		`- assertEquals(118, instructionsFromMethod(method).size)`
	`600`	`+ assertEquals(36, instructionsFromMethod(method).size)`
`601`	`601`	`}`
`602`	`602`	`}`
`603`	`603`
Original file line number	Diff line number	Diff line change
`@@ -141,6 +141,7 @@ object LazyVals {`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`def getStaticFieldOffset(field: java.lang.reflect.Field): Long = {`
	`144`	`+ @nowarn`
`144`	`145`	`val r = unsafe.staticFieldOffset(field)`
`145`	`146`	`if (debug)`
`146`	`147`	`println(s"getStaticFieldOffset(${field.getDeclaringClass}, ${field.getName}) = $r")`