Refactored mkThreadSafeDef method in LazyVals

Author: szymon-rd

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

@@ -352,29 +352,29 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
    *   end while
    * ```
    * 
-   * @param methodSymbol  the symbol of the new method
+   * @param memberDef     the transformed lazy field member definition
    * @param claz          the class containing this lazy val field
    * @param target        the target synthetic field
-   * @param rhs           the right-hand side expression of the lazy val
-   * @param tp            the type of the lazy val
    * @param offset        the offset of the field in the bitmap
-   * @param getFlag       a flag for the volatile get function
-   * @param objCasFlag    a flag for the CAS function operating on objects
-   * @param waiting       a reference to the `Waiting` runtime class
-   * @param evaluating    a reference to the `Evaluating` runtime object
-   * @param nullValued    a reference to the `NULL` runtime object
+   * @param thiz          a reference to the `NULL` runtime object
+   * @param helperModule  the symbol of the runtime LazyVals helper module
+   * @param runtimeModule the runtime LazyVals module path
+
    */
-  def mkThreadSafeDef(methodSymbol: TermSymbol,
+  def mkThreadSafeDef(memberDef: ValOrDefDef,
                       claz: ClassSymbol,
                       target: Symbol,
-                      rhs: Tree,
-                      tp: Type,
                       offset: Tree,
-                      objCasFlag: Tree,
-                      waiting: Tree,
-                      evaluating: Tree,
-                      nullValued: Tree,
-                      thiz: Tree)(using Context): DefDef = {
+                      thiz: Tree,
+                      helperModule: TermSymbol,
+                      runtimeModule: String)(using Context): DefDef = {
+    val tp = memberDef.tpe.widen.resultType.widen
+    val waiting = ref(requiredClass(s"$runtimeModule.${lazyNme.RLazyVals.waiting}"))
+    val evaluating = Select(ref(helperModule), lazyNme.RLazyVals.evaluating)
+    val nullValued = Select(ref(helperModule), lazyNme.RLazyVals.nullValued)
+    val objCasFlag = Select(ref(helperModule), lazyNme.RLazyVals.objCas)
+    val methodSymbol = memberDef.symbol.asTerm
+    val rhs = memberDef.rhs
     val discardSymb = newSymbol(methodSymbol, lazyNme.discard, Method | Synthetic, MethodType(Nil)(_ => Nil, _ => defn.UnitType))
     val discardDef = DefDef(discardSymb, initBlock(
       objCasFlag.appliedTo(thiz, offset, evaluating, Select(New(waiting), StdNames.nme.CONSTRUCTOR).ensureApplied)
@@ -447,7 +447,6 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     assert(!(x.symbol is Mutable))
 
     val runtimeModule = "scala.runtime.LazyVals"
-    val tpe = x.tpe.widen.resultType.widen
     val claz = x.symbol.owner.asClass
     val thizClass = Literal(Constant(claz.info))
     val helperModule = requiredModule(runtimeModule)
@@ -482,11 +481,6 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
         val fieldTree = thizClass.select(lazyNme.RLazyVals.getDeclaredField).appliedTo(Literal(Constant(containerName.mangledString)))
         val offsetTree = ValDef(offsetSymbol.nn, getOffset.appliedTo(fieldTree))
         appendOffsetDefs += (claz -> new OffsetInfo(List(offsetTree)))
-
-    val waiting = requiredClass(s"$runtimeModule.${lazyNme.RLazyVals.waiting}")
-    val evaluating = Select(ref(helperModule), lazyNme.RLazyVals.evaluating)
-    val nullValued = Select(ref(helperModule), lazyNme.RLazyVals.nullValued)
-    val objCas = Select(ref(helperModule), lazyNme.RLazyVals.objCas)
 
     val offset = ref(offsetSymbol.nn)
 
@@ -496,9 +490,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
       else
         This(claz)
 
-    val methodSymbol = x.symbol.asTerm
-    val accessor = mkThreadSafeDef(methodSymbol, claz, containerSymbol, x.rhs, tpe, offset, objCas, 
-      ref(waiting), evaluating, nullValued, swapOver)
+    val accessor = mkThreadSafeDef(x, claz, containerSymbol, offset, swapOver, helperModule, runtimeModule)
     Thicket(containerTree, accessor)
   }
 }