Support region annotation

Author: liufengyun

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

@@ -994,6 +994,7 @@ class Definitions {
   @tu lazy val ImplicitNotFoundAnnot: ClassSymbol = requiredClass("scala.annotation.implicitNotFound")
   @tu lazy val InitWidenAnnot: ClassSymbol = requiredClass("scala.annotation.init.widen")
   @tu lazy val InitExposeAnnot: ClassSymbol = requiredClass("scala.annotation.init.expose")
+  @tu lazy val InitRegionAnnot: ClassSymbol = requiredClass("scala.annotation.init.region")
   @tu lazy val InlineParamAnnot: ClassSymbol = requiredClass("scala.annotation.internal.InlineParam")
   @tu lazy val ErasedParamAnnot: ClassSymbol = requiredClass("scala.annotation.internal.ErasedParam")
   @tu lazy val InvariantBetweenAnnot: ClassSymbol = requiredClass("scala.annotation.internal.InvariantBetween")

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

@@ -82,6 +82,8 @@ object Objects:
     protected val vars: mutable.Map[Symbol, Heap.Addr] = varsMap
     protected val outers: mutable.Map[ClassSymbol, Value] = outersMap
 
+    def isObjectRef: Boolean = this.isInstanceOf[ObjectRef]
+
     def klass: ClassSymbol
 
     def valValue(sym: Symbol): Value = vals(sym)
@@ -479,6 +481,7 @@ object Objects:
     val empty: Data = Nil
     def extend(pos: SourcePosition)(using data: Data): Data = pos :: data
     def exists(pos: SourcePosition)(using data: Data): Boolean = data.indexOf(pos) >= 0
+    def show(using data: Data, ctx: Context): String = data.map(_.show).mkString("[", ", ", "]")
 
   inline def cache(using c: Cache.Data): Cache.Data = c
 
@@ -663,11 +666,17 @@ object Objects:
             else
               errorReadOtherStaticObject(State.currentObject, addr.owner)
               Bottom
+          else if ref.isObjectRef then
+            report.warning("Access uninitialized field " + field.show + ". Call trace: " + Trace.show, Trace.position)
+            Bottom
           else
             // initialization error, reported by the initialization checker
             Bottom
         else if ref.hasVal(target) then
           ref.valValue(target)
+        else if ref.isObjectRef then
+          report.warning("Access uninitialized field " + field.show + ". Call trace: " + Trace.show, Trace.position)
+          Bottom
         else
           // initialization error, reported by the initialization checker
           Bottom
@@ -865,7 +874,7 @@ object Objects:
    * @param klass       The enclosing class where the expression is located.
    * @param cacheResult It is used to reduce the size of the cache.
    */
-  def eval(expr: Tree, thisV: Value, klass: ClassSymbol, cacheResult: Boolean = false): Contextual[Value] = log("evaluating " + expr.show + ", this = " + thisV.show + " in " + klass.show, printer, (_: Value).show) {
+  def eval(expr: Tree, thisV: Value, klass: ClassSymbol, cacheResult: Boolean = false): Contextual[Value] = log("evaluating " + expr.show + ", this = " + thisV.show + ", regions = " + Regions.show + " in " + klass.show, printer, (_: Value).show) {
     cache.cachedEval(thisV, expr, cacheResult) { expr => cases(expr, thisV, klass) }
   }
 
@@ -956,6 +965,14 @@ object Objects:
       case Typed(expr, tpt) =>
         if tpt.tpe.hasAnnotation(defn.UncheckedAnnot) then
           Bottom
+        else if tpt.tpe.hasAnnotation(defn.InitRegionAnnot) then
+          val regions2 = Regions.extend(tpt.sourcePos)
+          if Regions.exists(tpt.sourcePos) then
+            report.warning("Cyclic region detected. Trace: " + Trace.show, tpt.sourcePos)
+            Bottom
+          else
+            given Regions.Data = regions2
+            eval(expr, thisV, klass)
         else
           eval(expr, thisV, klass)
 
@@ -997,8 +1014,10 @@ object Objects:
         evalExprs(cond :: thenp :: elsep :: Nil, thisV, klass).join
 
       case Annotated(arg, annot) =>
-        if (expr.tpe.hasAnnotation(defn.UncheckedAnnot)) Bottom
-        else eval(arg, thisV, klass)
+        if expr.tpe.hasAnnotation(defn.UncheckedAnnot) then
+          Bottom
+        else
+          eval(arg, thisV, klass)
 
       case Match(selector, cases) =>
         eval(selector, thisV, klass)

library/src/scala/annotation/init.scala

@@ -24,7 +24,7 @@ object init:
    *       def squre(): Int = x*x
    *
    *     object B:
-   *       val a = build(new A(10): @init.widen(1))   // <-- usage
+   *       val a = build(new A(10): @init.expose)   // <-- usage
    *
    *       def build(o: A) = new A(o.square())        // calling methods on parameter
    *
@@ -36,3 +36,27 @@ object init:
    *  It is semantically equivalent to `@init.widen(1)`.
    */
   final class expose extends StaticAnnotation
+
+  /** Mark a region context.
+   *
+   *  The same mutable field of objects in the same region have the same shape. The concept of regions is an
+   *  attempt to make context-sensitivity explainable and customizable.
+   *
+   *  Example:
+   *
+   *      trait B { def foo(): Int }
+   *      class C(var x: Int) extends B { def foo(): Int = 20 }
+   *      class D(var y: Int) extends B { def foo(): Int = A.m }
+   *      class Box(var value: B)
+   *
+   *       object A:
+   *         val box1: Box = new Box(new C(5)): @init.region
+   *         val box2: Box = new Box(new D(10)): @init.region
+   *         val m: Int = box1.value.foo()
+   *
+   *  In the above, without the two region annotation, the two objects `box1` and `box2` are of the same region.
+   *  Therefore, the field `box1.value` and `box2.value` points to both instances of `C` and `D`. Consequently,
+   *  the method call `box1.value.foo()` will be invalid, because it reaches `A.m`, which is not yet initialized.
+   *  The explicit context annotation solves the problem.
+   */
+  final class region extends StaticAnnotation

tests/init/neg/global-region1.scala

@@ -0,0 +1,11 @@
+import scala.annotation.init
+
+trait B { def foo(): Int }
+class C(var x: Int) extends B { def foo(): Int = 20 }
+class D(var y: Int) extends B { def foo(): Int = A.m }
+class Box(var value: B)
+
+object A:
+  val box1: Box = new Box(new C(5): @init.expose)
+  val box2: Box = new Box(new D(10): @init.expose)
+  val m: Int = box1.value.foo()                      // error

tests/init/pos/global-region1.scala

@@ -0,0 +1,11 @@
+import scala.annotation.init
+
+trait B { def foo(): Int }
+class C(var x: Int) extends B { def foo(): Int = 20 }
+class D(var y: Int) extends B { def foo(): Int = A.m }
+class Box(var value: B)
+
+object A:
+  val box1: Box = new Box(new C(5): @init.expose): @init.region
+  val box2: Box = new Box(new D(10): @init.expose): @init.region
+  val m: Int = box1.value.foo()                      // ok