Implement tracked members

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1007,12 +1007,13 @@ object desugar {
       if mods.isAllOf(Given | Inline | Transparent) then
         report.error("inline given instances cannot be trasparent", cdef)
       var classMods = if mods.is(Given) then mods &~ (Inline | Transparent) | Synthetic else mods
-      if vparamAccessors.exists(_.mods.is(Tracked)) then
+      val newBody = tparamAccessors ::: vparamAccessors ::: normalizedBody ::: caseClassMeths
+      if newBody.collect { case d: ValOrDefDef => d }.exists(_.mods.is(Tracked)) then
         classMods |= Dependent
       cpy.TypeDef(cdef: TypeDef)(
         name = className,
         rhs = cpy.Template(impl)(constr, parents1, clsDerived, self1,
-          tparamAccessors ::: vparamAccessors ::: normalizedBody ::: caseClassMeths)
+          newBody)
       ).withMods(classMods)
     }
 
@@ -1480,6 +1481,12 @@ object desugar {
       rhsOK(rhs)
   }
 
+  val legalTracked: Context ?=> MemberDefTest = {
+    case valdef @ ValDef(_, _, _) =>
+      val sym = valdef.symbol
+      !ctx.owner.exists || ctx.owner.isClass || ctx.owner.is(Case) || ctx.owner.isConstructor || valdef.mods.is(Param) || valdef.mods.is(ParamAccessor)
+  }
+
   def checkOpaqueAlias(tree: MemberDef)(using Context): MemberDef =
     def check(rhs: Tree): MemberDef = rhs match
       case bounds: TypeBoundsTree if bounds.alias.isEmpty =>
@@ -1505,6 +1512,7 @@ object desugar {
         } else tested
       tested = checkOpaqueAlias(tested)
       tested = checkApplicable(Opaque, legalOpaque)
+      tested = checkApplicable(Tracked, legalTracked)
       tested
     case _ =>
       tree

compiler/src/dotty/tools/dotc/parsing/Scanners.scala

@@ -212,6 +212,7 @@ object Scanners {
 
     def featureEnabled(name: TermName) = Feature.enabled(name)(using languageImportContext)
     def erasedEnabled = featureEnabled(Feature.erasedDefinitions)
+    def trackedEnabled = featureEnabled(Feature.modularity)
 
     private var postfixOpsEnabledCache = false
     private var postfixOpsEnabledCtx: Context = NoContext
@@ -1195,7 +1196,7 @@ object Scanners {
 
     def isSoftModifier: Boolean =
       token == IDENTIFIER
-      && (softModifierNames.contains(name) || name == nme.erased && erasedEnabled)
+      && (softModifierNames.contains(name) || name == nme.erased && erasedEnabled || name == nme.tracked && trackedEnabled)
 
     def isSoftModifierInModifierPosition: Boolean =
       isSoftModifier && inModifierPosition()

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

@@ -877,16 +877,16 @@ class Namer { typer: Typer =>
     protected def addAnnotations(sym: Symbol): Unit = original match {
       case original: untpd.MemberDef =>
         lazy val annotCtx = annotContext(original, sym)
-        original.setMods: 
+        original.setMods:
           original.mods.withAnnotations :
-            original.mods.annotations.mapConserve: annotTree =>  
+            original.mods.annotations.mapConserve: annotTree =>
               val cls = typedAheadAnnotationClass(annotTree)(using annotCtx)
               if (cls eq sym)
                 report.error(em"An annotation class cannot be annotated with iself", annotTree.srcPos)
                 annotTree
               else
-                val ann = 
-                  if cls.is(JavaDefined) then Checking.checkNamedArgumentForJavaAnnotation(annotTree, cls.asClass) 
+                val ann =
+                  if cls.is(JavaDefined) then Checking.checkNamedArgumentForJavaAnnotation(annotTree, cls.asClass)
                   else annotTree
                 val ann1 = Annotation.deferred(cls)(typedAheadExpr(ann)(using annotCtx))
                 sym.addAnnotation(ann1)

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

@@ -2411,7 +2411,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         else if ctx.reporter.errorsReported then UnspecifiedErrorType
         else errorType(em"cannot infer type; expected type $pt is not fully defined", tree.srcPos))
 
-  def typedTypeTree(tree: untpd.TypeTree, pt: Type)(using Context): Tree =
+  def typedTypeTree(tree: untpd.TypeTree, pt: Type)(using Context): Tree = {
     tree match
       case tree: untpd.DerivedTypeTree =>
         tree.ensureCompletions
@@ -2427,6 +2427,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         }
       case _ =>
         completeTypeTree(InferredTypeTree(), pt, tree)
+  }
 
   def typedInLambdaTypeTree(tree: untpd.InLambdaTypeTree, pt: Type)(using Context): Tree =
     val tp =
@@ -2833,11 +2834,19 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       case rhs =>
         excludeDeferredGiven(rhs, sym):
           typedExpr(_, tpt1.tpe.widenExpr)
-    val vdef1 = assignType(cpy.ValDef(vdef)(name, tpt1, rhs1), sym)
-    postProcessInfo(vdef1, sym)
-    vdef1.setDefTree
+    setAbstractTrackedInfo(sym, rhs1, tpt)
+    val tpt2 = if sym.flags.is(Tracked) && tpt.isEmpty && !sym.flags.is(ParamAccessor) && !sym.flags.is(Param) then TypeTree(rhs1.tpe) else tpt1
+    val vdef2 = assignType(cpy.ValDef(vdef)(name, tpt2, rhs1), sym)
+    postProcessInfo(vdef2, sym)
+    vdef2.setDefTree
   }
 
+  private def setAbstractTrackedInfo(sym: Symbol, rhs: Tree, tpt: untpd.Tree)(using Context): Unit =
+    if sym.allOverriddenSymbols.exists(_.flags.is(Tracked)) && !sym.flags.is(ParamAccessor) && !sym.flags.is(Param) then
+      sym.setFlag(Tracked)
+      if tpt.isEmpty then
+        sym.info = rhs.tpe
+
   private def retractDefDef(sym: Symbol)(using Context): Tree =
     // it's a discarded method (synthetic case class method or synthetic java record constructor or overridden member), drop it
     val canBeInvalidated: Boolean =
@@ -3628,7 +3637,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   }
 
   /** Typecheck and adapt tree, returning a typed tree. Parameters as for `typedUnadapted` */
-  def typed(tree: untpd.Tree, pt: Type, locked: TypeVars)(using Context): Tree =
+  def typed(tree: untpd.Tree, pt: Type, locked: TypeVars)(using Context): Tree = {
     trace(i"typing $tree, pt = $pt", typr, show = true) {
       record(s"typed $getClass")
       record("typed total")
@@ -3640,6 +3649,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         tree.withType(WildcardType)
       else adapt(typedUnadapted(tree, pt, locked), pt, locked)
     }
+  }
 
   def typed(tree: untpd.Tree, pt: Type = WildcardType)(using Context): Tree =
     typed(tree, pt, ctx.typerState.ownedVars)
@@ -3755,7 +3765,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   def typedExpr(tree: untpd.Tree, pt: Type = WildcardType)(using Context): Tree =
     withoutMode(Mode.PatternOrTypeBits)(typed(tree, pt))
 
-  def typedType(tree: untpd.Tree, pt: Type = WildcardType, mapPatternBounds: Boolean = false)(using Context): Tree =
+  def typedType(tree: untpd.Tree, pt: Type = WildcardType, mapPatternBounds: Boolean = false)(using Context): Tree = {
     val tree1 = withMode(Mode.Type) { typed(tree, pt) }
     if mapPatternBounds && ctx.mode.is(Mode.Pattern) && !ctx.isAfterTyper then
       tree1 match
@@ -3771,6 +3781,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         case tree1 =>
           tree1
     else tree1
+  }
 
   def typedPattern(tree: untpd.Tree, selType: Type = WildcardType)(using Context): Tree =
     withMode(Mode.Pattern)(typed(tree, selType))

tests/neg/abstract-tracked.check

@@ -0,0 +1,20 @@
+-- [E156] Syntax Error: tests/neg/abstract-tracked.scala:4:14 ----------------------------------------------------------
+4 |tracked trait F // error
+  |^^^^^^^^^^^^^^^
+  |Modifier tracked is not allowed for this definition
+-- [E156] Syntax Error: tests/neg/abstract-tracked.scala:9:15 ----------------------------------------------------------
+9 |tracked object O // error
+  |^^^^^^^^^^^^^^^^
+  |Modifier tracked is not allowed for this definition
+-- [E156] Syntax Error: tests/neg/abstract-tracked.scala:11:14 ---------------------------------------------------------
+11 |tracked class C // error
+   |^^^^^^^^^^^^^^^
+   |Modifier tracked is not allowed for this definition
+-- [E156] Syntax Error: tests/neg/abstract-tracked.scala:7:14 ----------------------------------------------------------
+7 |  tracked def f: F // error
+  |  ^^^^^^^^^^^^^^^^
+  |  Modifier tracked is not allowed for this definition
+-- [E156] Syntax Error: tests/neg/abstract-tracked.scala:14:14 ---------------------------------------------------------
+14 |  tracked val x = 1 // error
+   |  ^^^^^^^^^^^^^^^^^
+   |  Modifier tracked is not allowed for this definition

tests/neg/abstract-tracked.scala

@@ -0,0 +1,14 @@
+import scala.language.experimental.modularity
+import scala.language.future
+
+tracked trait F // error
+
+trait G:
+  tracked def f: F // error
+
+tracked object O // error
+
+tracked class C // error
+
+def f =
+  tracked val x = 1 // error

tests/neg/tracked.check

@@ -6,22 +6,6 @@
 7 |  def foo(tracked a: Int) = // error
   |                  ^
   |                  ':' expected, but identifier found
--- Error: tests/neg/tracked.scala:8:12 ---------------------------------------------------------------------------------
-8 |    tracked val b: Int = 2 // error
-  |            ^^^
-  |            end of statement expected but 'val' found
--- Error: tests/neg/tracked.scala:11:10 --------------------------------------------------------------------------------
-11 |  tracked object Foo // error // error
-   |          ^^^^^^
-   |          end of statement expected but 'object' found
--- Error: tests/neg/tracked.scala:14:10 --------------------------------------------------------------------------------
-14 |  tracked class D // error // error
-   |          ^^^^^
-   |          end of statement expected but 'class' found
--- Error: tests/neg/tracked.scala:17:10 --------------------------------------------------------------------------------
-17 |  tracked type T = Int // error // error
-   |          ^^^^
-   |          end of statement expected but 'type' found
 -- Error: tests/neg/tracked.scala:20:25 --------------------------------------------------------------------------------
 20 |  given g2: (tracked val x: Int) => C = C(x) // error
    |             ^^^^^^^^^^^^^^^^^^
@@ -30,21 +14,19 @@
 4 |class C2(tracked var x: Int) // error
   |                     ^
   |                     mutable variables may not be `tracked`
--- [E006] Not Found Error: tests/neg/tracked.scala:11:2 ----------------------------------------------------------------
-11 |  tracked object Foo // error // error
-   |  ^^^^^^^
-   |  Not found: tracked
-   |
-   | longer explanation available when compiling with `-explain`
--- [E006] Not Found Error: tests/neg/tracked.scala:14:2 ----------------------------------------------------------------
-14 |  tracked class D // error // error
-   |  ^^^^^^^
-   |  Not found: tracked
-   |
-   | longer explanation available when compiling with `-explain`
--- [E006] Not Found Error: tests/neg/tracked.scala:17:2 ----------------------------------------------------------------
-17 |  tracked type T = Int // error // error
-   |  ^^^^^^^
-   |  Not found: tracked
-   |
-   | longer explanation available when compiling with `-explain`
+-- [E156] Syntax Error: tests/neg/tracked.scala:8:16 -------------------------------------------------------------------
+8 |    tracked val b: Int = 2 // error
+  |    ^^^^^^^^^^^^^^^^^^^^^^
+  |    Modifier tracked is not allowed for this definition
+-- [E156] Syntax Error: tests/neg/tracked.scala:11:17 ------------------------------------------------------------------
+11 |  tracked object Foo // error
+   |  ^^^^^^^^^^^^^^^^^^
+   |  Modifier tracked is not allowed for this definition
+-- [E156] Syntax Error: tests/neg/tracked.scala:14:16 ------------------------------------------------------------------
+14 |  tracked class D // error
+   |  ^^^^^^^^^^^^^^^
+   |  Modifier tracked is not allowed for this definition
+-- [E156] Syntax Error: tests/neg/tracked.scala:17:15 ------------------------------------------------------------------
+17 |  tracked type T = Int // error
+   |  ^^^^^^^^^^^^^^^^^^^^
+   |  Modifier tracked is not allowed for this definition

tests/neg/tracked.scala

@@ -8,13 +8,13 @@ object A:
     tracked val b: Int = 2 // error
 
 object B:
-  tracked object Foo // error // error
+  tracked object Foo // error
 
 object C:
-  tracked class D // error // error
+  tracked class D // error
 
 object D:
-  tracked type T = Int // error // error
+  tracked type T = Int // error
 
 object E:
   given g2: (tracked val x: Int) => C = C(x) // error

tests/pos/abstract-tracked.scala

@@ -0,0 +1,40 @@
+import scala.language.experimental.modularity
+import scala.language.future
+
+trait F:
+  tracked val x: Int
+
+trait G:
+  tracked val y: Int
+
+trait H:
+  tracked val z: Int = 3
+
+trait I extends F
+
+trait J extends F:
+  val x: Int = 1
+
+class K(tracked val x: Int)
+
+object Test:
+  // val f : F(1) /*: F { val x: 1 }*/ = new F:
+  //   val x: 1 = 1
+  val f = new F:
+    val x = 1
+  val g = new G:
+    val y: 2 = 2
+  val h = new H:
+    override val z = 4
+  val i = new I:
+    val x = 5
+  val j = new J:
+    override val x = 6
+  val k = new K(7)
+
+  summon[f.x.type <:< 1]
+  summon[g.y.type <:< 2]
+  summon[h.z.type <:< 4]
+  summon[i.x.type <:< 5]
+  summon[j.x.type <:< 6]
+  summon[k.x.type <:< 7]