Rename Leak to Promote

Promote is more semantically correct than Leak: leaking means
something bad, but promotion is neutral or positive. A warning
may be reported if the promotion is unsafe.

Author: liufengyun

compiler/src/dotty/tools/dotc/transform/init/Checking.scala

@@ -187,37 +187,37 @@ object Checking {
       implicit val state2: State = state.withVisited(eff)
 
       eff match {
-        case Leak(pot) =>
+        case Promote(pot) =>
           pot match {
             case ThisRef(cls) =>
               assert(cls == state.thisClass, "unexpected potential " + pot.show)
 
               theCtx.warning(
-                "Leaking of this. Calling trace:\n" + state.trace,
+                "Promote `this` to be initialized while it is not. Calling trace:\n" + state.trace,
                 eff.source.sourcePos
               )
 
             case _: Cold =>
               theCtx.warning(
-                "Leaking of cold value " + eff.source.show +
+                "Promoting the value " + eff.source.show + " to be initialized while it is under initialization" +
                 ". Calling trace:\n" + state.trace,
                 eff.source.sourcePos
               )
 
             case Warm(cls, outer) =>
               theCtx.warning(
-                "Leaking of value under initialization: " + pot.source.show +
+                "Promoting the value under initialization to be initialized: " + pot.source.show +
                 ". Calling trace:\n" + state.trace,
                 eff.source.sourcePos
               )
 
             case Fun(pots, effs) =>
               effs.foreach { check(_) }
-              pots.foreach { pot => check(Leak(pot)(eff.source)) }
+              pots.foreach { pot => check(Promote(pot)(eff.source)) }
 
             case pot =>
               val pots = expand(pot)
-              pots.foreach { pot => check(Leak(pot)(eff.source)) }
+              pots.foreach { pot => check(Promote(pot)(eff.source)) }
           }
 
         case FieldAccess(pot, field) =>
@@ -303,7 +303,7 @@ object Checking {
               // TODO: assertion might be false, due to SAM
               if (sym.name.toString == "apply") {
                 effs.foreach { check(_) }
-                pots.foreach { pot => check(Leak(pot)(eff.source)) }
+                pots.foreach { pot => check(Promote(pot)(eff.source)) }
               }
               // curried, tupled, toString are harmless
 

compiler/src/dotty/tools/dotc/transform/init/Effects.scala

@@ -26,7 +26,7 @@ object Effects {
   }
 
   /** An effect means that a value that's possibly under initialization
-   *  leaks from the initializing world to fully-initialized world.
+   *  is promoted from the initializing world to the fully-initialized world.
    *
    *  Essentially, this effect enforces that the object pointed to by
    *  `potential` is fully initialized.
@@ -36,7 +36,7 @@ object Effects {
    *  - a potential is assigned (not initialize) to a field
    *  - the selection chain on a potential is too long
    */
-  case class Leak(potential: Potential)(val source: Tree) extends Effect {
+  case class Promote(potential: Potential)(val source: Tree) extends Effect {
     def size: Int = potential.size
     def show(implicit ctx: Context): String =
       potential.show + "↑"
@@ -61,8 +61,8 @@ object Effects {
 
   def asSeenFrom(eff: Effect, thisValue: Potential, currentClass: ClassSymbol, outer: Potentials)(implicit env: Env): Effects =
     trace(eff.show + " asSeenFrom " + thisValue.show + ", current = " + currentClass.show + ", outer = " + Potentials.show(outer), init, effs => show(effs.asInstanceOf[Effects])) { eff match {
-      case Leak(pot) =>
-        Potentials.asSeenFrom(pot, thisValue, currentClass, outer).leak(eff.source)
+      case Promote(pot) =>
+        Potentials.asSeenFrom(pot, thisValue, currentClass, outer).promote(eff.source)
 
       case FieldAccess(pot, field) =>
         Potentials.asSeenFrom(pot, thisValue, currentClass, outer).map { pot =>

compiler/src/dotty/tools/dotc/transform/init/Potentials.scala

@@ -150,7 +150,7 @@ object Potentials {
       // max potential length
       // TODO: it can be specified on a project basis via compiler options
       if (pot.size > 2)
-        (pots, effs + Leak(pot)(source))
+        (pots, effs + Promote(pot)(source))
       else if (symbol.isConstructor)
         (pots + pot, effs + MethodCall(pot, symbol)(source))
       else if (symbol.isOneOf(Flags.Method | Flags.Lazy))
@@ -162,7 +162,7 @@ object Potentials {
         (pots + FieldReturn(pot, symbol)(source), effs + FieldAccess(pot, symbol)(source))
     }
 
-  def (ps: Potentials) leak(source: Tree): Effects = ps.map(Leak(_)(source))
+  def (ps: Potentials) promote(source: Tree): Effects = ps.map(Promote(_)(source))
 
   def asSeenFrom(pot: Potential, thisValue: Potential, currentClass: ClassSymbol, outer: Potentials)(implicit env: Env): Potentials =
     trace(pot.show + " asSeenFrom " + thisValue.show + ", current = " + currentClass.show + ", outer = " + show(outer), init, pots => show(pots.asInstanceOf[Potentials])) { pot match {

compiler/src/dotty/tools/dotc/transform/init/Summarization.scala

@@ -70,7 +70,7 @@ object Summarization {
         val res = args.foldLeft(summary) { (sum, arg) =>
           val (pots1, effs1) = analyze(arg)
           if (ignoredCall) sum.withEffs(effs1)
-          else sum.withEffs(pots1.leak(arg) ++ effs1)
+          else sum.withEffs(pots1.promote(arg) ++ effs1)
         }
 
         if (ignoredCall) (Potentials.empty, res._2)
@@ -114,7 +114,7 @@ object Summarization {
 
       case Assign(lhs, rhs) =>
         val (pots, effs) = analyze(rhs)
-        (Potentials.empty, pots.leak(expr) ++ effs)
+        (Potentials.empty, pots.promote(expr) ++ effs)
 
       case closureDef(ddef) =>     // must be before `Block`
         val (pots, effs) = analyze(ddef.rhs)
@@ -138,7 +138,7 @@ object Summarization {
       case Match(selector, cases) =>
         // possible for switches
         val (pots, effs) = analyze(selector)
-        cases.foldLeft((Potentials.empty, pots.leak(selector) ++ effs)) { (acc, cas) =>
+        cases.foldLeft((Potentials.empty, pots.promote(selector) ++ effs)) { (acc, cas) =>
           acc union analyze(cas.body)
         }
 
@@ -170,7 +170,7 @@ object Summarization {
       case SeqLiteral(elems, elemtpt) =>
         val effsAll: Effects = elems.foldLeft(Effects.empty) { (effs, elem) =>
           val (pots1, effs1) = analyze(elem)
-          pots1.leak(expr) ++ effs1 ++ effs
+          pots1.promote(expr) ++ effs1 ++ effs
         }
         (Potentials.empty, effsAll)
 
@@ -184,7 +184,7 @@ object Summarization {
         if (vdef.symbol.owner.isClass)
           (Potentials.empty, if (vdef.symbol.is(Flags.Lazy)) Effects.empty else effs)
         else
-          (Potentials.empty, pots.leak(vdef) ++ effs)
+          (Potentials.empty, pots.promote(vdef) ++ effs)
 
       case Thicket(List()) =>
         // possible in try/catch/finally, see tests/crash/i6914.scala
@@ -194,7 +194,7 @@ object Summarization {
         val (pots, effs) = analyze(ddef.rhs)
 
         if (ddef.symbol.owner.isClass) Summary.empty
-        else (Potentials.empty, pots.leak(ddef) ++ effs)
+        else (Potentials.empty, pots.promote(ddef) ++ effs)
 
       case _: TypeDef =>
         Summary.empty

docs/docs/reference/other-new-features/safe-initialization.md

@@ -266,7 +266,7 @@ Potentials (π) represent values that are possibly under initialization.
 
 Effects are triggered from potentials:
 
-- `π↑`: leak of the potential `π`
+- `π↑`: promote the object pointed to by the potential `π` to fully-initialized
 - `π.f!`: access field `f` on the potential `π`
 - `π.m!`: call the method `m` on the potential `π`