Make lazy vals thread-safe by default

Previously this required using `@volatile` but that would not be
consistent with Scala 2. The old behavior of non-volatile lazy vals can
be recovered by using the newly-introduced `@threadUnsafe`.

Author: smarter

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -863,6 +863,8 @@ class Definitions {
   def TASTYLongSignatureAnnot(implicit ctx: Context): ClassSymbol = TASTYLongSignatureAnnotType.symbol.asClass
   lazy val TailrecAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.tailrec")
   def TailrecAnnot(implicit ctx: Context): ClassSymbol = TailrecAnnotType.symbol.asClass
+  lazy val ThreadUnsafeAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.threadUnsafe")
+  def ThreadUnsafeAnnot(implicit ctx: Context): ClassSymbol = ThreadUnsafeAnnotType.symbol.asClass
   lazy val TransientParamAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.constructorOnly")
   def TransientParamAnnot(implicit ctx: Context): ClassSymbol = TransientParamAnnotType.symbol.asClass
   lazy val CompileTimeOnlyAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.compileTimeOnly")

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

@@ -25,7 +25,6 @@ object AugmentScala2Traits {
  *  These symbols would have been added between Unpickling and Mixin in the Scala2 pipeline.
  *
  *  Specifically, we:
- *   - Mark all lazy val fields as @volatile to get the proper Scala 2 semantics.
  *   - Add trait setters for vals defined in traits.
  *   - Expand the names of all private getters and setters as well as super accessors in the trait and make
  *     not-private.
@@ -57,14 +56,9 @@ class AugmentScala2Traits extends MiniPhase with IdentityDenotTransformer { this
         info = MethodType(getter.info.resultType :: Nil, defn.UnitType))
 
     for (sym <- mixin.info.decls) {
-      if (sym.isGetter)
-        if (sym.is(Lazy)) {
-          if (!sym.hasAnnotation(defn.VolatileAnnot))
-            sym.addAnnotation(Annotation(defn.VolatileAnnot, Nil))
-        }
-        else if (!sym.is(Deferred) && !sym.setter.exists &&
+      if (sym.isGetter && !sym.is(LazyOrDeferred) && !sym.setter.exists &&
           !sym.info.resultType.isInstanceOf[ConstantType])
-          traitSetter(sym.asTerm).enteredAfter(thisPhase)
+        traitSetter(sym.asTerm).enteredAfter(thisPhase)
       if ((sym.is(PrivateAccessor) && !sym.name.is(ExpandedName) &&
         (sym.isGetter || sym.isSetter)) // strangely, Scala 2 fields are also methods that have Accessor set.
         || sym.isSuperAccessor) // scala2 superaccessors are pickled as private, but are compiled as public expanded

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

@@ -74,18 +74,17 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     else {
       val isField = sym.owner.isClass
       if (isField) {
-        if (sym.isVolatile ||
-           (sym.is(Module)/* || ctx.scala2Mode*/) &&
-            // TODO assume @volatile once LazyVals uses static helper constructs instead of
-            // ones in the companion object.
-           !sym.is(Synthetic))
-            // module class is user-defined.
-            // Should be threadsafe, to mimic safety guaranteed by global object
-          transformMemberDefVolatile(tree)
-        else if (sym.is(Module)) // synthetic module
+        if (sym.is(SyntheticModule))
           transformSyntheticModule(tree)
+        else if (sym.isThreadUnsafe) {
+          if (sym.is(Module)) {
+            ctx.error(em"@threadUnsafe is only supported on lazy vals", sym.sourcePos)
+            transformMemberDefThreadSafe(tree)
+          }
+          transformMemberDefThreadUnsafe(tree)
+        }
         else
-          transformMemberDefNonVolatile(tree)
+          transformMemberDefThreadSafe(tree)
       }
       else transformLocalDef(tree)
     }
@@ -196,7 +195,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
       ref(field).becomes(nullLiteral)
     }
 
-  /** Create non-threadsafe lazy accessor equivalent to such code
+  /** Create thread-unsafe lazy accessor equivalent to such code
     * ```
     * def methodSymbol() = {
     *   if (!flag) {
@@ -208,7 +207,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     * }
     * ```
     */
-  def mkNonThreadSafeDef(sym: Symbol, flag: Symbol, target: Symbol, rhs: Tree)(implicit ctx: Context): DefDef = {
+  def mkThreadUnsafeDef(sym: Symbol, flag: Symbol, target: Symbol, rhs: Tree)(implicit ctx: Context): DefDef = {
     val targetRef = ref(target)
     val flagRef = ref(flag)
     val stats = targetRef.becomes(rhs) :: flagRef.becomes(Literal(Constant(true))) :: nullOut(nullableFor(sym))
@@ -220,7 +219,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     DefDef(sym.asTerm, Block(List(init), targetRef.ensureApplied))
   }
 
-  /** Create non-threadsafe lazy accessor for not-nullable types  equivalent to such code
+  /** Create thread-unsafe lazy accessor for not-nullable types  equivalent to such code
     * ```
     * def methodSymbol() = {
     *   if (target eq null) {
@@ -231,7 +230,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     * }
     * ```
     */
-  def mkDefNonThreadSafeNonNullable(sym: Symbol, target: Symbol, rhs: Tree)(implicit ctx: Context): DefDef = {
+  def mkDefThreadUnsafeNonNullable(sym: Symbol, target: Symbol, rhs: Tree)(implicit ctx: Context): DefDef = {
     val targetRef = ref(target)
     val stats = targetRef.becomes(rhs) :: nullOut(nullableFor(sym))
     val init = If(
@@ -242,7 +241,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     DefDef(sym.asTerm, Block(List(init), targetRef.ensureApplied))
   }
 
-  def transformMemberDefNonVolatile(x: ValOrDefDef)(implicit ctx: Context): Thicket = {
+  def transformMemberDefThreadUnsafe(x: ValOrDefDef)(implicit ctx: Context): Thicket = {
     val claz = x.symbol.owner.asClass
     val tpe = x.tpe.widen.resultType.widen
     assert(!(x.symbol is Mutable))
@@ -255,13 +254,13 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     val containerTree = ValDef(containerSymbol, defaultValue(tpe))
     if (x.tpe.isNotNull && tpe <:< defn.ObjectType) {
       // can use 'null' value instead of flag
-      Thicket(containerTree, mkDefNonThreadSafeNonNullable(x.symbol, containerSymbol, x.rhs))
+      Thicket(containerTree, mkDefThreadUnsafeNonNullable(x.symbol, containerSymbol, x.rhs))
     }
     else {
       val flagName = LazyBitMapName.fresh(x.name.asTermName)
       val flagSymbol = ctx.newSymbol(x.symbol.owner, flagName,  containerFlags | Private, defn.BooleanType).enteredAfter(this)
       val flag = ValDef(flagSymbol, Literal(Constant(false)))
-      Thicket(containerTree, flag, mkNonThreadSafeDef(x.symbol, flagSymbol, containerSymbol, x.rhs))
+      Thicket(containerTree, flag, mkThreadUnsafeDef(x.symbol, flagSymbol, containerSymbol, x.rhs))
     }
   }
 
@@ -365,7 +364,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     DefDef(methodSymbol, loop)
   }
 
-  def transformMemberDefVolatile(x: ValOrDefDef)(implicit ctx: Context): Thicket = {
+  def transformMemberDefThreadSafe(x: ValOrDefDef)(implicit ctx: Context): Thicket = {
     assert(!(x.symbol is Mutable))
 
     val tpe = x.tpe.widen.resultType.widen

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

@@ -52,6 +52,8 @@ class SymUtils(val self: Symbol) extends AnyVal {
   def isTypeTestOrCast(implicit ctx: Context): Boolean =
     isTypeCast || isTypeTest
 
+  def isThreadUnsafe(implicit ctx: Context): Boolean = self.hasAnnotation(defn.ThreadUnsafeAnnot)
+
   def isVolatile(implicit ctx: Context): Boolean = self.hasAnnotation(defn.VolatileAnnot)
 
   def isAnyOverride(implicit ctx: Context): Boolean = self.is(Override) || self.is(AbsOverride)

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1472,20 +1472,10 @@ class Typer extends Namer
     val vdef1 = assignType(cpy.ValDef(vdef)(name, tpt1, rhs1), sym)
     if (sym.is(Inline, butNot = DeferredOrTermParamOrAccessor))
       checkInlineConformant(rhs1, isFinal = sym.is(Final), em"right-hand side of inline $sym")
-    patchIfLazy(vdef1)
     patchFinalVals(vdef1)
     vdef1.setDefTree
   }
 
-  /** Add a @volitile to lazy vals when rewriting from Scala2 */
-  private def patchIfLazy(vdef: ValDef)(implicit ctx: Context): Unit = {
-    val sym = vdef.symbol
-    if (sym.is(Lazy, butNot = Deferred | Module | Synthetic) && !sym.isVolatile &&
-        ctx.scala2Mode && ctx.settings.rewrite.value.isDefined &&
-        !ctx.isAfterTyper)
-      patch(Span(toUntyped(vdef).span.start), "@volatile ")
-  }
-
   /** Adds inline to final vals with idempotent rhs
    *
    *  duplicating scalac behavior: for final vals that have rhs as constant, we do not create a field

compiler/test/dotty/tools/backend/jvm/DottyBytecodeTests.scala

@@ -524,22 +524,35 @@ class TestBCode extends DottyBytecodeTest {
   }
 
   /** Test that the size of lazy field accesors is under a certain threshold
-   *
-   *  - Changed from 19 to 14
    */
   @Test def lazyFields = {
-    val source =
+    val sourceUnsafe =
+      """import scala.annotation.threadUnsafe
+        |
+        |class Test {
+        |  @threadUnsafe lazy val test = 1
+        |}
+      """.stripMargin
+
+    val sourceSafe =
       """class Test {
         |  lazy val test = 1
         |}
       """.stripMargin
 
-    checkBCode(source) { dir =>
+    checkBCode(sourceUnsafe) { dir =>
       val clsIn   = dir.lookupName("Test.class", directory = false).input
       val clsNode = loadClassNode(clsIn)
       val method  = getMethod(clsNode, "test")
       assertEquals(14, instructionsFromMethod(method).size)
     }
+
+    checkBCode(sourceSafe) { dir =>
+      val clsIn   = dir.lookupName("Test.class", directory = false).input
+      val clsNode = loadClassNode(clsIn)
+      val method  = getMethod(clsNode, "test")
+      assertEquals(94, instructionsFromMethod(method).size)
+    }
   }
 
   /* Test that objects compile to *final* classes. */

docs/docs/reference/changed-features/lazy-vals-spec.md renamed to docs/docs/reference/changed-features/lazy-vals-init.md

@@ -1,6 +1,6 @@
 ---
 layout: doc-page
-title: Changed: Lazy Vals - More Details
+title: Lazy Vals initialization
 ---
 
 Dotty implements [Version 6](https://docs.scala-lang.org/sips/improved-lazy-val-initialization.html#version-6---no-synchronization-on-this-and-concurrent-initialization-of-fields)
@@ -19,7 +19,7 @@ Given a lazy field of the form:
 
 ```scala
 class Foo {
-  @volatile lazy val bar = <RHS>
+  lazy val bar = <RHS>
 }
 ```
 
@@ -69,9 +69,8 @@ val. This id grows with the number of volatile lazy vals defined in the class.
 
 ## Note on recursive lazy vals
 
-Ideally recursive lazy vals should be flagged as an error. The current behavior for `@volatile`
-recursive lazy vals is undefined (initialization may result in a deadlock). Non `@volatile` lazy
-vals behave as in Scala 2.
+Ideally recursive lazy vals should be flagged as an error. The current behavior for
+recursive lazy vals is undefined (initialization may result in a deadlock).
 
 ## Reference
 

docs/docs/reference/changed-features/lazy-vals.md

@@ -0,0 +1,18 @@
+---
+layout: doc-page
+title: threadUnsafe annotation
+---
+
+A new annotation `@threadUnsafe` can be used on a field which defines a lazy
+val. When this annotation is used, the initialization of the lazy val will use a
+faster mechanism which is not thread-safe.
+
+### Example
+
+```scala
+import scala.annotation.threadUnsafe
+
+class Hello {
+  @threadUnsafe lazy val x: Int = 1
+}
+```

docs/docs/reference/other-new-features/threadUnsafe-annotation.md

@@ -91,10 +91,10 @@ sidebar:
               url: docs/reference/other-new-features/kind-polymorphism.html
             - title: Tupled Function
               url: docs/reference/other-new-features/tupled-function.html
+            - title: threadUnsafe Annotation
+              url: docs/reference/other-new-features/threadUnsafe-annotation.html
         - title: Other Changed Features
           subsection:
-            - title: Volatile Lazy Vals
-              url: docs/reference/changed-features/lazy-vals.html
             - title: Structural Types
               url: docs/reference/changed-features/structural-types.html
             - title: Operators
@@ -119,6 +119,8 @@ sidebar:
               url: docs/reference/changed-features/eta-expansion.html
             - title: Compiler Plugins
               url: docs/reference/changed-features/compiler-plugins.html
+            - title: Lazy Vals initialization
+              url: docs/reference/changed-features/lazy-vals-init.html
         - title: Dropped Features
           subsection:
             - title: DelayedInit

docs/sidebar.yml

@@ -0,0 +1,7 @@
+package scala.annotation
+
+/** This annotation can only be used on a field which defines a lazy val.
+ *  When this annotation is used, the initialization of the lazy val will use a
+ *  faster mechanism which is not thread-safe.
+ */
+final class threadUnsafe extends StaticAnnotation

library/src/scala/annotation/threadUnsafe.scala

@@ -10,7 +10,7 @@ trait Iterator {
     val leading = new Leading
 
     class Trailing {
-      @volatile lazy val it = leading.finish()
+      lazy val it = leading.finish()
     }
     val trailing = new Trailing
     (leading, trailing)

tests/pos/lazyvals.scala

@@ -3,7 +3,7 @@ class Sub extends T
 
 trait DT {
 
-  @volatile lazy val dx = 2
+  lazy val dx = 2
 
 }
 

tests/pos/scala2traits/dotty-subclass.scala

@@ -1,4 +1,4 @@
-object T{ @volatile lazy val s = null}
+object T{ lazy val s = null}
 object Test{
   def main(args: Array[String]): Unit = {
     T.s

tests/run/Lazies1.scala

@@ -1,5 +1,5 @@
-class T{ @volatile lazy val s = null}
-object T{ @volatile lazy val s = null}
+class T{ lazy val s = null}
+object T{ lazy val s = null}
 object Test{
   def main(args: Array[String]): Unit = {
     T.s

tests/run/Lazies2.scala

@@ -8,7 +8,7 @@ class LazyNullable(a: => Int) {
   lazy val l1 = b // null out b
 
   private[this] val c = "C"
-  @volatile lazy val l2 = c // null out c
+  lazy val l2 = c // null out c
 
   private[this] val d = "D"
   lazy val l3 = d + d // null out d (Scalac require single use?)