Fix tests

Author: jchyb

.github/workflows/ci.yaml

@@ -205,7 +205,6 @@ jobs:
       ##############################################################################################
       - name: Set JDK 17 as default
         run: echo "/usr/lib/jvm/java-17-openjdk-amd64/bin" >> $GITHUB_PATH
-        run: echo "/usr/lib/jvm/java-8-openjdk-amd64/bin" >> $GITHUB_PATH
       - name: Reset existing repo
         run: |
           git config --global --add safe.directory $GITHUB_WORKSPACE

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

@@ -491,7 +491,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     varHandleSymbol.addAnnotation(Annotation(defn.ScalaStaticAnnot, varHandleSymbol.span))
     val getVarHandle = Apply(
       Select(ref(varHandleInfo.methodHandlesLookupDef.symbol), defn.MethodHandlesLookup_FindVarHandle.name),
-      List(thizClass, Literal(Constant(containerName.toString)), Literal(Constant(defn.ObjectType)))
+      List(thizClass, Literal(Constant(containerName.mangledString)), Literal(Constant(defn.ObjectType)))
     )
     val varHandleTree = ValDef(varHandleSymbol, getVarHandle)
     val varHandle = ref(varHandleSymbol)

project/MiMaFilters.scala

@@ -138,6 +138,16 @@ object MiMaFilters {
           ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#MethodTypeMethods.isContextual"),
           ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#ImplicitsModule.searchIgnoring"),
           ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#ValDefModule.let"),
+
+          // Changes to lazy vals (added static constructors)
+          ProblemFilters.exclude[DirectMissingMethodProblem]("scala.Tuple.<clinit>"),
+          ProblemFilters.exclude[DirectMissingMethodProblem]("scala.collection.immutable.ArraySeq.<clinit>"),
+          ProblemFilters.exclude[DirectMissingMethodProblem]("scala.concurrent.ExecutionContext.<clinit>"),
+          ProblemFilters.exclude[DirectMissingMethodProblem]("scala.io.Codec.<clinit>"),
+          ProblemFilters.exclude[DirectMissingMethodProblem]("scala.math.BigDecimal.<clinit>"),
+          ProblemFilters.exclude[DirectMissingMethodProblem]("scala.sys.SystemProperties.<clinit>"),
+          ProblemFilters.exclude[DirectMissingMethodProblem]("scala.sys.process.Process.<clinit>"),
+
           // Change `experimental` annotation to a final class
           ProblemFilters.exclude[FinalClassProblem]("scala.annotation.experimental"),
 

tests/printing/transformed/lazy-vals-new.check

@@ -9,14 +9,17 @@ package <empty> {
       }
     @static private def <clinit>(): Unit =
       {
-        A.OFFSET$_m_0 =
-          scala.runtime.LazyVals.getOffsetStatic(
-            classOf[Object {...}].getDeclaredField("x$lzy1"))
+        val A$$$methodHandleLookup:
+          java.lang.invoke.MethodHandles.MethodHandles$Lookup =
+          java.lang.invoke.MethodHandles.lookup()
+        A.x$lzy1$$lzyHandle =
+          A$$$methodHandleLookup.findVarHandle(classOf[Object {...}], "x$lzy1",
+            classOf[Object])
         ()
       }
-    @static @static val OFFSET$_m_0: Long =
-      scala.runtime.LazyVals.getOffsetStatic(
-        classOf[Object {...}].getDeclaredField("x$lzy1"))
+    @static val x$lzy1$$lzyHandle: java.lang.invoke.VarHandle =
+      A.A$$$methodHandleLookup.findVarHandle(classOf[Object {...}], "x$lzy1",
+        classOf[Object])
     private def writeReplace(): Object =
       new scala.runtime.ModuleSerializationProxy(classOf[A])
     @volatile private lazy var x$lzy1: Object = null
@@ -33,7 +36,7 @@ package <empty> {
           val current: Object = A.x$lzy1
           if current eq null then
             if
-              scala.runtime.LazyVals.objCAS(this, A.OFFSET$_m_0, null,
+              scala.runtime.LazyVals.objCAS2(this, A.x$lzy1$$lzyHandle, null,
                 scala.runtime.LazyVals.Evaluating)
              then
               {
@@ -49,15 +52,15 @@ package <empty> {
                   }
                  finally
                   if
-                    scala.runtime.LazyVals.objCAS(this, A.OFFSET$_m_0,
+                    scala.runtime.LazyVals.objCAS2(this, A.x$lzy1$$lzyHandle,
                       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(this, A.OFFSET$_m_0, lock,
-                        result)
+                      scala.runtime.LazyVals.objCAS2(this, A.x$lzy1$$lzyHandle,
+                        lock, result)
                       lock.countDown()
                     }
                    else ()
@@ -71,8 +74,8 @@ package <empty> {
              then
               if current eq scala.runtime.LazyVals.Evaluating then
                 {
-                  scala.runtime.LazyVals.objCAS(this, A.OFFSET$_m_0, current,
-                    new scala.runtime.LazyVals.LazyVals$Waiting())
+                  scala.runtime.LazyVals.objCAS2(this, A.x$lzy1$$lzyHandle,
+                    current, new scala.runtime.LazyVals.LazyVals$Waiting())
                   ()
                 }
                else