Align syntax with paper

Author: liufengyun

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

@@ -995,9 +995,6 @@ class Definitions {
   @tu lazy val DeprecatedOverridingAnnot: ClassSymbol = requiredClass("scala.deprecatedOverriding")
   @tu lazy val ImplicitAmbiguousAnnot: ClassSymbol = requiredClass("scala.annotation.implicitAmbiguous")
   @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")
@@ -1048,6 +1045,11 @@ class Definitions {
 
   @tu lazy val JavaRepeatableAnnot: ClassSymbol = requiredClass("java.lang.annotation.Repeatable")
 
+  // Initialization annotations
+  @tu lazy val InitModule: Symbol = requiredModule("scala.annotation.init")
+    @tu lazy val InitWidenAnnot: ClassSymbol = InitModule.requiredClass("widen")
+    @tu lazy val InitRegionMethod: Symbol = InitModule.requiredMethod("region")
+
   // A list of meta-annotations that are relevant for fields and accessors
   @tu lazy val NonBeanMetaAnnots: Set[Symbol] =
     Set(FieldMetaAnnot, GetterMetaAnnot, ParamMetaAnnot, SetterMetaAnnot, CompanionClassMetaAnnot, CompanionMethodMetaAnnot)

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

@@ -376,6 +376,15 @@ object Types {
       case _ => false
     }
 
+    /** Returns the annoation that is an instance of `cls` carried by the type. */
+    @tailrec final def getAnnotation(cls: ClassSymbol)(using Context): Option[Annotation] = stripTypeVar match {
+      case AnnotatedType(tp, annot) =>
+        if annot.matches(cls) then Some(annot)
+        else tp.getAnnotation(cls)
+      case _ =>
+        None
+    }
+
     /** Does this type have a supertype with an annotation satisfying given predicate `p`? */
     def derivesAnnotWith(p: Annotation => Boolean)(using Context): Boolean = this match {
       case tp: AnnotatedType => p(tp.annot) || tp.parent.derivesAnnotWith(p)

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

@@ -911,6 +911,15 @@ object Objects:
           instantiate(outer, cls, ctor, args)
         }
 
+      case Apply(ref, arg :: Nil) if ref.symbol == defn.InitRegionMethod =>
+        val regions2 = Regions.extend(expr.sourcePos)
+        if Regions.exists(expr.sourcePos) then
+          report.warning("Cyclic region detected. Trace: " + Trace.show, expr)
+          Bottom
+        else
+          given Regions.Data = regions2
+          eval(arg, thisV, klass)
+
       case Call(ref, argss) =>
         // check args
         val args = evalArgs(argss.flatten, thisV, klass)
@@ -963,14 +972,6 @@ 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)
 
@@ -1144,11 +1145,21 @@ object Objects:
         else
           eval(arg.tree, thisV, klass)
 
-      // TODO: handle @widen(n)
       val widened =
-        if arg.tree.tpe.hasAnnotation(defn.InitExposeAnnot) then
-          res.widen(1)
-        else
+        arg.tree.tpe.getAnnotation(defn.InitWidenAnnot) match
+        case Some(annot) =>
+          annot.argument(0).get match
+          case arg @ Literal(c: Constants.Constant) =>
+            val height = c.intValue
+            if height < 0 then
+              report.error("The argument should be positive", arg)
+              res.widen(1)
+            else
+              res.widen(c.intValue)
+          case arg =>
+            report.error("The argument should be a constant integer value", arg)
+            res.widen(1)
+        case _ =>
           res.widen(1)
 
       argInfos += TraceValue(widened, trace.add(arg.tree))

library/src/scala/annotation/init.scala

@@ -8,15 +8,6 @@ package scala.annotation
 object init:
 
   /** Widen the abstract value of the argument so that its height is below the specified height.
-   *
-   *  This is an advanced version of `@init.expose`, where we tell the compiler the annotated method or
-   *  constructor argument are not cold aliases and its abstract value may have a maximum height of the
-   *  specified value.
-   */
-  final class widen(hight: Int) extends StaticAnnotation
-
-  /** Expose the method argument or constructor argument so that it may be actively used during the
-   *  initialization of static objects.
    *
    *  It can be used to mark method or constructor arguments, as the following example shows:
    *
@@ -28,19 +19,15 @@ object init:
    *
    *       def build(o: A) = new A(o.square())        // calling methods on parameter
    *
-   *  By default, method and constructor arguments are cold aliases, which means they may not be actively
-   *  used --- calling methods or accessing fields on them are forbidden. By using `@expose` to the
-   *  method argument, we tell the compiler that the argument is not a cold alias. As a result, we may
-   *  call methods on the parameter.
-   *
-   *  It is semantically equivalent to `@init.widen(1)`.
+   *  By default, method and constructor arguments are widened to height 1.
    */
-  final class expose extends StaticAnnotation
+  final class widen(hight: Int) extends StaticAnnotation
 
-  /** Mark a region context.
+  /** Introduce a region context.
+   *
+   *  The same mutable field in the same region have the same abstract representation.
    *
-   *  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.
+   *  The concept of regions is intended to make context-sensitivity tuable for complex use cases.
    *
    *  Example:
    *
@@ -50,13 +37,13 @@ object init:
    *      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 box1: Box = region { new Box(new C(5))  }
+   *         val box2: Box = region { new Box(new D(10)) }
    *         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.
+   *  In the above, without the two region annotation, the two objects `box1` and `box2` are in 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
+  def region[T](v: T): T = v

tests/init-global/pos/global-region1.scala

@@ -1,11 +1,11 @@
-import scala.annotation.init
+import scala.annotation.init.region
 
 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 box1: Box = region { new Box(new C(5)) }
+  val box2: Box = region { new Box(new D(10)) }
   val m: Int = box1.value.foo()                      // ok