Experimental & Tests

Author: szymon-rd

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -331,6 +331,7 @@ private sealed trait YSettings:
   val Ycc: Setting[Boolean] = BooleanSetting("-Ycc", "Check captured references (warning: extremely experimental and unstable)")
   val YccDebug: Setting[Boolean] = BooleanSetting("-Ycc-debug", "Used in conjunction with -Ycc, debug info for captured references")
   val YccNoAbbrev: Setting[Boolean] = BooleanSetting("-Ycc-no-abbrev", "Used in conjunction with -Ycc, suppress type abbreviations")
+  val YlightweightLazyVals: Setting[Boolean] = BooleanSetting("-Ylightweight-lazy-vals", "Use experimental lightweight implementation of lazy vals")
 
   /** Area-specific debug output */
   val YexplainLowlevel: Setting[Boolean] = BooleanSetting("-Yexplain-lowlevel", "When explaining type errors, show types at a lower level.")

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

@@ -2,21 +2,22 @@ package dotty.tools.dotc
 package transform
 
 import java.util.IdentityHashMap
-
 import ast.tpd
 import core.Annotations.Annotation
 import core.Constants.Constant
-import core.Contexts._
-import core.Decorators._
+import core.Contexts.*
+import core.Decorators.*
 import core.DenotTransformers.IdentityDenotTransformer
-import core.Flags._
-import core.NameKinds.{LazyBitMapName, LazyLocalInitName, LazyLocalName, ExpandedName}
+import core.Flags.*
+import core.NameKinds.{ExpandedName, LazyBitMapName, LazyLocalInitName, LazyLocalName}
 import core.StdNames.nme
-import core.Symbols._
-import core.Types._
+import core.Symbols.*
+import core.Types.*
 import core.{Names, StdNames}
+import dotty.tools.dotc.config.Feature
 import transform.MegaPhase.MiniPhase
-import transform.SymUtils._
+import transform.SymUtils.*
+
 import scala.collection.mutable
 
 class LazyVals extends MiniPhase with IdentityDenotTransformer {
@@ -59,9 +60,6 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     else nullables.toList
   }
 
-  private inline def isLegacyLazyVals(using ctx: Context): Boolean =
-    ctx.settings.XlegacyLazyVals.value
-
   private def needsBoxing(tp: Type)(using Context): Boolean = tp != NoType && tp != defn.UnitType && tp.classSymbol.isPrimitiveValueClass
 
   private def boxIfCan(tp: Type)(using Context): Type =
@@ -120,7 +118,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
    */
   override def transformTemplate(template: Template)(using Context): Tree = {
     val cls = ctx.owner.asClass
-    (if isLegacyLazyVals then oldAppendOffsetDefs else appendOffsetDefs).get(cls) match {
+    (if !ctx.settings.YlightweightLazyVals.value then oldAppendOffsetDefs else appendOffsetDefs).get(cls) match {
       case None => template
       case Some(data) =>
         data.defs.foreach(_.symbol.addAnnotation(Annotation(defn.ScalaStaticAnnot)))
@@ -496,10 +494,10 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
 
   def transformMemberDefThreadSafe(x: ValOrDefDef)(using Context): Thicket = {
     assert(!(x.symbol is Mutable))
-    if isLegacyLazyVals then
-      transformMemberDefThreadSafeLegacy(x)
-    else
+    if ctx.settings.YlightweightLazyVals.value then
       transformMemberDefThreadSafeNew(x)
+    else
+      transformMemberDefThreadSafeLegacy(x)
   }
 
   def transformMemberDefThreadSafeNew(x: ValOrDefDef)(using Context): Thicket = {

compiler/test/dotc/pos-test-pickling.blacklist

@@ -86,3 +86,5 @@ i4176-gadt.scala
 i13974a.scala
 
 java-inherited-type1
+
+lazy-vals-all

compiler/test/dotc/run-test-pickling.blacklist

@@ -44,3 +44,4 @@ t6138
 t6138-2
 i12656.scala
 trait-static-forwarder
+lazy-vals-all

compiler/test/dotc/run-test-recheck.excludes

@@ -11,3 +11,4 @@ tagless.scala
 safeThrowsStrawman2.scala
 t7584.scala
 function-arity.scala
+lazy-vals-all

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -42,7 +42,10 @@ class CompilationTests {
       compileFilesInDir("tests/pos-scala2", scala2CompatMode),
       compileFilesInDir("tests/pos-custom-args/captures", defaultOptions.and("-Ycc")),
       compileFilesInDir("tests/pos-custom-args/erased", defaultOptions.and("-language:experimental.erasedDefinitions")),
-      compileFilesInDir("tests/pos", defaultOptions.and("-Ysafe-init")),
+      compileFilesInDir("tests/pos", defaultOptions.and("-Ysafe-init"), FileFilter.exclude("lazy-vals-all")),
+      // Run tests for experimental lightweight lazy vals and stable lazy vals
+      compileFilesInDir("tests/pos/lazy-vals-all", defaultOptions.and("-Ysafe-init", "-Ylightweight-lazy-vals")),
+      compileFilesInDir("tests/pos/lazy-vals-all", defaultOptions.and("-Ysafe-init")),
       compileFilesInDir("tests/pos-deep-subtype", allowDeepSubtypes),
       compileFilesInDir("tests/pos-custom-args/no-experimental", defaultOptions.and("-Yno-experimental")),
       compileDir("tests/pos-special/java-param-names", defaultOptions.withJavacOnlyOptions("-parameters")),
@@ -215,7 +218,10 @@ class CompilationTests {
       compileDir("tests/run-custom-args/Xmacro-settings/compileTimeEnv", defaultOptions.and("-Xmacro-settings:a,b=1,c.b.a=x.y.z=1,myLogger.level=INFO")),
       compileFilesInDir("tests/run-custom-args/captures", allowDeepSubtypes.and("-Ycc")),
       compileFilesInDir("tests/run-deep-subtype", allowDeepSubtypes),
-      compileFilesInDir("tests/run", defaultOptions.and("-Ysafe-init"))
+      compileFilesInDir("tests/run", defaultOptions.and("-Ysafe-init"), FileFilter.exclude("lazy-vals-all")),
+      // Run tests for experimental lightweight lazy vals and stable lazy vals. serialization-new-legacy is kept to check all cases aside from not working transient (I removed the test that was not testing it)
+      compileFilesInDir("tests/run/lazy-vals-all", defaultOptions.and("-Ysafe-init", "-Ylightweight-lazy-vals"), FileFilter.exclude("serialization-new-legacy.scala")),
+      compileFilesInDir("tests/run/lazy-vals-all", defaultOptions.and("-Ysafe-init"), FileFilter.exclude("serialization-new.scala"))
     ).checkRuns()
   }
 

library/src/scala/runtime/LazyVals.scala

@@ -43,24 +43,28 @@ object LazyVals {
 
   /* ------------- Start of public API ------------- */
 
+  @experimental
   sealed trait LazyValControlState
 
   /**
    * Used to indicate the state of a lazy val that is being
    * evaluated and of which other threads await the result.
    */
+  @experimental
   final class Waiting extends CountDownLatch(1) with LazyValControlState
 
   /**
    * Used to indicate the state of a lazy val that is currently being
    * evaluated with no other thread awaiting its result.
    */
+  @experimental
   object Evaluating extends LazyValControlState
 
   /**
    * Used to indicate the state of a lazy val that has been evaluated to
    * `null`.
    */
+  @experimental
   object NullValue extends LazyValControlState
 
   final val BITS_PER_LAZY_VAL = 2L
@@ -80,6 +84,7 @@ object LazyVals {
     unsafe.compareAndSwapLong(t, offset, e, n)
   }
 
+  @experimental
   def objCAS(t: Object, offset: Long, exp: Object, n: Object): Boolean = {
     if (debug)
       println(s"objCAS($t, $exp, $n)")
@@ -140,6 +145,7 @@ object LazyVals {
     r
   }
 
+  @experimental
   def getStaticFieldOffset(field: java.lang.reflect.Field): Long = {
     @nowarn
     val r = unsafe.staticFieldOffset(field)