Porting recent changes & adding fixes

szymon-rd · szymon-rd · commit a1af355ad71c · 2022-05-23T10:42:40.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -33,7 +33,6 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
    */
   class OldOffsetInfo(defs: List[Tree], var ord: Int) extends OffsetInfo(defs)
   private val appendOffsetDefs = mutable.Map.empty[Symbol, OffsetInfo]
-  private val oldAppendOffsetDefs = mutable.Map.empty[Symbol, OldOffsetInfo]
 
   override def phaseName: String = LazyVals.name
 
@@ -59,9 +58,6 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     else nullables.toList
   }
 
-  private inline def isOldLazyVals(using ctx: Context): Boolean =
-    import dotty.tools.dotc.config.ScalaRelease._
-    ctx.scalaRelease <= Release3_1
 
   private def initBlock(stats: List[Tree])(using Context): Block = stats match
     case Nil => throw new IllegalArgumentException("trying to create an empty Block")
@@ -127,7 +123,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
   override def transformTemplate(template: Template)(using Context): Tree = {
     val cls = ctx.owner.asClass
     
-    (if isOldLazyVals then oldAppendOffsetDefs else appendOffsetDefs).get(cls) match {
+    appendOffsetDefs.get(cls) match {
       case None => template
       case Some(data) =>
         data.defs.foreach(_.symbol.addAnnotation(Annotation(defn.ScalaStaticAnnot)))
@@ -295,12 +291,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
 
   def transformMemberDefThreadSafe(x: ValOrDefDef)(using Context): Thicket = {
     assert(!(x.symbol is Mutable))
-    // generate old code for compatibility
-    // TODO find more meaningful names than old/new
-    if isOldLazyVals then
-      transformMemberDefThreadSafeOld(x)
-    else
-      transformMemberDefThreadSafeNew(x)
+    transformMemberDefThreadSafeNew(x)
   }
 
   /**
@@ -309,8 +300,6 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
    * private @volatile var _x: AnyRef = null
    * @tailrec def x: A =
    *    _x match
-   *    case current: A =>
-   *        current
    *    case null =>
    *        if CAS(_x, null, Evaluating) then
    *            var result: AnyRef = null // here, we need `AnyRef` to possibly assign `NULL`
@@ -331,6 +320,8 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
    *        current.awaitRelease()
    *        x
    *    case NULL => null
+   *    case current: A =>
+   *        current
    * ```
    * Where `Evaluating` and `NULL` are represented by `object`s and `Waiting` by a class that
    * allows awaiting the completion of the evaluation. Note that since tail-recursive
@@ -359,11 +350,11 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
    *       if current.isInstanceOf[Evaluating] then
    *         CAS(current, Evaluating, new Waiting)
    *       else if current.isInstanceOf[NULL] then
-   *         null
+   *         return null
    *       else if current.isInstanceOf[Waiting] then
    *         current.asInstanceOf[Waiting].awaitRelease()
    *       else
-   *         current.asInstanceOf[A]
+   *         return current.asInstanceOf[A]
    *   end while
    * ```
    * 
@@ -476,23 +467,24 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
       containerSymbol.setFlag(JavaStatic)
     val getOffset =
       if stat then
-        Select(ref(helperModule), lazyNme.RLazyVals.getStaticOffset)
+        Select(ref(helperModule), lazyNme.RLazyVals.getStaticFieldOffset)
       else
-        Select(ref(helperModule), lazyNme.RLazyVals.getOffset)
+        Select(ref(helperModule), lazyNme.RLazyVals.getOffsetStatic)
     val containerTree = ValDef(containerSymbol, nullLiteral)
-    def staticOrFieldOff: Tree = getOffset.appliedTo(thizClass, Literal(Constant(containerName.toString)))
 
     // create an offset for this lazy val
     appendOffsetDefs.get(claz) match
       case Some(info) =>
         offsetSymbol = newSymbol(claz, offsetName(info.defs.size), Synthetic, defn.LongType).enteredAfter(this)
         offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot))
-        val offsetTree = ValDef(offsetSymbol.nn, staticOrFieldOff)
+        val fieldTree = thizClass.select(lazyNme.RLazyVals.getDeclaredField).appliedTo(Literal(Constant(containerName.toString)))
+        val offsetTree = ValDef(offsetSymbol.nn, getOffset.appliedTo(fieldTree))
         info.defs = offsetTree :: info.defs
       case None =>
         offsetSymbol = newSymbol(claz, offsetName(0), Synthetic, defn.LongType).enteredAfter(this)
         offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot))
-        val offsetTree = ValDef(offsetSymbol.nn, staticOrFieldOff)
+        val fieldTree = thizClass.select(lazyNme.RLazyVals.getDeclaredField).appliedTo(Literal(Constant(containerName.toString)))
+        val offsetTree = ValDef(offsetSymbol.nn, getOffset.appliedTo(fieldTree))
         appendOffsetDefs += (claz -> new OffsetInfo(List(offsetTree)))
 
     val waiting = requiredClass(s"$runtimeModule.${lazyNme.RLazyVals.waiting}")
@@ -513,171 +505,6 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
       ref(waiting), evaluating, nullValued, swapOver)
     Thicket(containerTree, accessor)
   }
-
-  /** Create a threadsafe lazy accessor equivalent to such code
-    * ```
-    * def methodSymbol(): Int = {
-    *   while (true) {
-    *     val flag = LazyVals.get(this, bitmap_offset)
-    *     val state = LazyVals.STATE(flag, <field-id>)
-    *
-    *     if (state == <state-3>) {
-    *       return value_0
-    *     } else if (state == <state-0>) {
-    *       if (LazyVals.CAS(this, bitmap_offset, flag, <state-1>, <field-id>)) {
-    *         try {
-    *           val result = <RHS>
-    *           value_0 = result
-    *           nullable = null
-    *           LazyVals.setFlag(this, bitmap_offset, <state-3>, <field-id>)
-    *           return result
-    *         }
-    *         catch {
-    *           case ex =>
-    *             LazyVals.setFlag(this, bitmap_offset, <state-0>, <field-id>)
-    *             throw ex
-    *         }
-    *       }
-    *     } else /* if (state == <state-1> || state == <state-2>) */ {
-    *       LazyVals.wait4Notification(this, bitmap_offset, flag, <field-id>)
-    *     }
-    *   }
-    * }
-    * ```
-    */
-  def mkThreadSafeDefOld(methodSymbol: TermSymbol,
-                      claz: ClassSymbol,
-                      ord: Int,
-                      target: Symbol,
-                      rhs: Tree,
-                      tp: Type,
-                      offset: Tree,
-                      getFlag: Tree,
-                      stateMask: Tree,
-                      casFlag: Tree,
-                      setFlagState: Tree,
-                      waitOnLock: Tree)(using Context): DefDef = {
-    val initState = Literal(Constant(0))
-    val computeState = Literal(Constant(1))
-    val computedState = Literal(Constant(3))
-
-    val thiz = This(claz)
-    val fieldId = Literal(Constant(ord))
-
-    val flagSymbol = newSymbol(methodSymbol, lazyNme.flag, Synthetic, defn.LongType)
-    val flagDef = ValDef(flagSymbol, getFlag.appliedTo(thiz, offset))
-    val flagRef = ref(flagSymbol)
-
-    val stateSymbol = newSymbol(methodSymbol, lazyNme.state, Synthetic, defn.LongType)
-    val stateDef = ValDef(stateSymbol, stateMask.appliedTo(ref(flagSymbol), Literal(Constant(ord))))
-    val stateRef = ref(stateSymbol)
-
-    val compute = {
-      val resultSymbol = newSymbol(methodSymbol, lazyNme.result, Synthetic, tp)
-      val resultRef = ref(resultSymbol)
-      val stats = (
-        ValDef(resultSymbol, rhs) ::
-        ref(target).becomes(resultRef) ::
-        (nullOut(nullableFor(methodSymbol)) :+
-        setFlagState.appliedTo(thiz, offset, computedState, fieldId))
-      )
-      Block(stats, Return(resultRef, methodSymbol))
-    }
-
-    val retryCase = {
-      val caseSymbol = newSymbol(methodSymbol, nme.DEFAULT_EXCEPTION_NAME, Synthetic | Case, defn.ThrowableType)
-      val triggerRetry = setFlagState.appliedTo(thiz, offset, initState, fieldId)
-      CaseDef(
-        Bind(caseSymbol, ref(caseSymbol)),
-        EmptyTree,
-        Block(List(triggerRetry), Throw(ref(caseSymbol)))
-      )
-    }
-
-    val initialize = If(
-      casFlag.appliedTo(thiz, offset, flagRef, computeState, fieldId),
-      Try(compute, List(retryCase), EmptyTree),
-      unitLiteral
-    )
-
-    val condition = If(
-      stateRef.equal(computedState),
-      Return(ref(target), methodSymbol),
-      If(
-        stateRef.equal(initState),
-        initialize,
-        waitOnLock.appliedTo(thiz, offset, flagRef, fieldId)
-      )
-    )
-
-    val loop = WhileDo(EmptyTree, Block(List(flagDef, stateDef), condition))
-    DefDef(methodSymbol, loop)
-  }
-
-  def transformMemberDefThreadSafeOld(x: ValOrDefDef)(using Context): Thicket = {
-    val tpe = x.tpe.widen.resultType.widen
-    val claz = x.symbol.owner.asClass
-    val thizClass = Literal(Constant(claz.info))
-    val helperModule = requiredModule("scala.runtime.LazyVals")
-    val getOffset = Select(ref(helperModule), lazyNme.RLazyVals.getOffset)
-    val getOffsetStatic = Select(ref(helperModule), lazyNme.RLazyVals.getOffsetStatic)
-    var offsetSymbol: TermSymbol | Null = null
-    var flag: Tree = EmptyTree
-    var ord = 0
-
-    def offsetName(id: Int) = s"${StdNames.nme.LAZY_FIELD_OFFSET}${if (x.symbol.owner.is(Module)) "_m_" else ""}$id".toTermName
-
-    // compute or create appropriate offsetSymbol, bitmap and bits used by current ValDef
-    oldAppendOffsetDefs.get(claz) match {
-      case Some(info) =>
-        val flagsPerLong = (64 / scala.runtime.LazyVals.BITS_PER_LAZY_VAL).toInt
-        info.ord += 1
-        ord = info.ord % flagsPerLong
-        val id = info.ord / flagsPerLong
-        val offsetById = offsetName(id)
-        if (ord != 0) // there are unused bits in already existing flag
-          offsetSymbol = claz.info.decl(offsetById)
-            .suchThat(sym => sym.is(Synthetic) && sym.isTerm)
-             .symbol.asTerm
-        else { // need to create a new flag
-          offsetSymbol = newSymbol(claz, offsetById, Synthetic, defn.LongType).enteredAfter(this)
-          offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot))
-          val flagName = LazyBitMapName.fresh(id.toString.toTermName)
-          val flagSymbol = newSymbol(claz, flagName, containerFlags, defn.LongType).enteredAfter(this)
-          flag = ValDef(flagSymbol, Literal(Constant(0L)))
-          val fieldTree = thizClass.select(lazyNme.RLazyVals.getDeclaredField).appliedTo(Literal(Constant(flagName.toString)))
-          val offsetTree = ValDef(offsetSymbol.nn, getOffsetStatic.appliedTo(fieldTree))
-          info.defs = offsetTree :: info.defs
-        }
-
-      case None =>
-        offsetSymbol = newSymbol(claz, offsetName(0), Synthetic, defn.LongType).enteredAfter(this)
-        offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot))
-        val flagName = LazyBitMapName.fresh("0".toTermName)
-        val flagSymbol = newSymbol(claz, flagName, containerFlags, defn.LongType).enteredAfter(this)
-        flag = ValDef(flagSymbol, Literal(Constant(0L)))
-        val fieldTree = thizClass.select(lazyNme.RLazyVals.getDeclaredField).appliedTo(Literal(Constant(flagName.toString)))
-        val offsetTree = ValDef(offsetSymbol.nn, getOffsetStatic.appliedTo(fieldTree))
-        appendOffsetDefs += (claz -> new OffsetInfo(List(offsetTree), ord))
-    }
-
-    val containerName = LazyLocalName.fresh(x.name.asTermName)
-    val containerSymbol = newSymbol(claz, containerName, x.symbol.flags &~ containerFlagsMask | containerFlags, tpe, coord = x.symbol.coord).enteredAfter(this)
-
-    val containerTree = ValDef(containerSymbol, defaultValue(tpe))
-
-    val offset =  ref(offsetSymbol.nn)
-    val getFlag = Select(ref(helperModule), lazyNme.RLazyVals.get)
-    val setFlag = Select(ref(helperModule), lazyNme.RLazyVals.setFlag)
-    val wait =    Select(ref(helperModule), lazyNme.RLazyVals.wait4Notification)
-    val state =   Select(ref(helperModule), lazyNme.RLazyVals.state)
-    val cas =     Select(ref(helperModule), lazyNme.RLazyVals.cas)
-
-    val accessor = mkThreadSafeDefOld(x.symbol.asTerm, claz, ord, containerSymbol, x.rhs, tpe, offset, getFlag, state, cas, setFlag, wait)
-    if (flag eq EmptyTree)
-      Thicket(containerTree, accessor)
-    else Thicket(containerTree, flag, accessor)
-  }
 }
 
 object LazyVals {
@@ -694,15 +521,14 @@ object LazyVals {
       val evaluating: TermName        = N.evaluating.toTermName
       val nullValued: TermName        = N.nullValued.toTermName
       val objCas: TermName            = N.objCas.toTermName
-      val getOffset: TermName         = N.getOffset.toTermName
-      val getStaticOffset: TermName   = N.getStaticOffset.toTermName
+      val getStaticFieldOffset: TermName   = N.getStaticFieldOffset.toTermName
       val get: TermName               = N.get.toTermName
       val setFlag: TermName           = N.setFlag.toTermName
       val wait4Notification: TermName = N.wait4Notification.toTermName
       val state: TermName             = N.state.toTermName
       val cas: TermName               = N.cas.toTermName
       val getOffset: TermName         = N.getOffset.toTermName
-      val getOffsetStatic: TermName   = "getOffsetStatic".toTermName
+      val getOffsetStatic: TermName   = N.getOffsetStatic.toTermName
       val getDeclaredField: TermName  = "getDeclaredField".toTermName
 
     }
diff --git a/library/src/scala/runtime/LazyVals.scala b/library/src/scala/runtime/LazyVals.scala
@@ -141,17 +141,18 @@ 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 getStaticOffset(clz: Class[_], name: String): Long = {
-    val r = unsafe.staticFieldOffset(clz.getDeclaredField(name))
+  def getStaticFieldOffset(field: java.lang.reflect.Field): Long = {
+    val r = unsafe.staticFieldOffset(field)
     if (debug)
-      println(s"getStaticOffset($clz, $name) = $r")
+      println(s"getStaticFieldOffset(${field.getDeclaringClass}, ${field.getName}) = $r")
     r
   }
 
@@ -175,6 +176,7 @@ object LazyVals {
     final val wait4Notification = "wait4Notification"
     final val get = "get"
     final val getOffset = "getOffset"
-    final val getStaticOffset = "getStaticOffset"
+    final val getOffsetStatic = "getOffsetStatic"
+    final val getStaticFieldOffset = "getStaticFieldOffset"
   }
 }
diff --git a/project/MiMaFilters.scala b/project/MiMaFilters.scala
@@ -19,12 +19,12 @@ object MiMaFilters {
     ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#SymbolMethods.termRef"),
     ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#TypeTreeModule.ref"),
 
-    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals.getStaticOffset"),
-    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals.getStaticOffset"),
-    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.LazyVals.objCAS"),
+    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.getStaticOffset"),
+    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"),
diff --git a/tests/init/neg/promotion-loop.check b/tests/init/neg/promotion-loop.check
@@ -1,11 +1,7 @@
 -- Error: tests/init/neg/promotion-loop.scala:16:10 --------------------------------------------------------------------
 16 |  println(b)      // error
    |          ^
-<<<<<<< HEAD
-   |          Cannot prove that the value is fully-initialized. Only initialized values may be used as arguments.
-=======
    |          Cannot prove that the value is fully initialized. Only initialized values may be used as arguments.
->>>>>>> 91c03b1f7835d574290eba1ecf236e0f59fc2bf0
    |
    |          The unsafe promotion may cause the following problem:
    |          Cannot prove that the value is fully initialized. Only initialized values may be used as arguments.
diff --git a/tests/init/neg/t3273.check b/tests/init/neg/t3273.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/t3273.scala:4:42 ------------------------------------------------------------------------------
 4 |  val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error
   |                                  ^^^^^^^^^^^^^^^
-  |             Cannot prove that the value is fully-initialized. Only initialized values may be used as arguments.
+  |              Cannot prove that the value is fully initialized. Only initialized values may be used as arguments.
   |
   |              The unsafe promotion may cause the following problem:
   |              Access non-initialized value num1. Calling trace:
@@ -10,7 +10,7 @@
 -- Error: tests/init/neg/t3273.scala:5:61 ------------------------------------------------------------------------------
 5 |  val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |             Cannot prove that the value is fully-initialized. Only initialized values may be used as arguments.
+  |              Cannot prove that the value is fully initialized. Only initialized values may be used as arguments.
   |
   |              The unsafe promotion may cause the following problem:
   |              Access non-initialized value num2. Calling trace:

Original file line number	Diff line number	Diff line change
`@@ -141,17 +141,18 @@ object LazyVals {`
`141`	`141`	`unsafe.getLongVolatile(t, off)`
`142`	`142`	`}`
`143`	`143`
	`144`	`+ // kept for backward compatibility`
`144`	`145`	`def getOffset(clz: Class[_], name: String): Long = {`
`145`	`146`	`val r = unsafe.objectFieldOffset(clz.getDeclaredField(name))`
`146`	`147`	`if (debug)`
`147`	`148`	`println(s"getOffset($clz, $name) = $r")`
`148`	`149`	`r`
`149`	`150`	`}`
`150`	`151`
`151`		`- def getStaticOffset(clz: Class[_], name: String): Long = {`
`152`		`- val r = unsafe.staticFieldOffset(clz.getDeclaredField(name))`
	`152`	`+ def getStaticFieldOffset(field: java.lang.reflect.Field): Long = {`
	`153`	`+ val r = unsafe.staticFieldOffset(field)`
`153`	`154`	`if (debug)`
`154`		`- println(s"getStaticOffset($clz, $name) = $r")`
	`155`	`+ println(s"getStaticFieldOffset(${field.getDeclaringClass}, ${field.getName}) = $r")`
`155`	`156`	`r`
`156`	`157`	`}`
`157`	`158`
`@@ -175,6 +176,7 @@ object LazyVals {`
`175`	`176`	`final val wait4Notification = "wait4Notification"`
`176`	`177`	`final val get = "get"`
`177`	`178`	`final val getOffset = "getOffset"`
`178`		`- final val getStaticOffset = "getStaticOffset"`
	`179`	`+ final val getOffsetStatic = "getOffsetStatic"`
	`180`	`+ final val getStaticFieldOffset = "getStaticFieldOffset"`
`179`	`181`	`}`
`180`	`182`	`}`