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

@@ -854,6 +854,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,12 @@ 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 || sym.is(Module)) // @threadUnsafe object are not allowed
+          transformMemberDefThreadSafe(tree)
         else
-          transformMemberDefNonVolatile(tree)
+          transformMemberDefThreadUnsafe(tree)
       }
       else transformLocalDef(tree)
     }
@@ -196,7 +190,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 +202,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 +214,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 +225,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 +236,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 +249,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 +359,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

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

@@ -89,10 +89,10 @@ sidebar:
               url: docs/reference/other-new-features/erased-terms.html
             - title: Kind Polymorphism
               url: docs/reference/other-new-features/kind-polymorphism.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
@@ -117,6 +117,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