Introduce tracked class parameters

For a tracked class parameter we add a refinement in the constructor type that
the class member is the same as the parameter. E.g.
```scala
class C { type T }
class D(tracked val x: C) { type T = x.T }
```
This will generate the constructor type:
```scala
(x1: C): D { val x: x1.type }
```
Without `tracked` the refinement would not be added. This can solve several problems with dependent class
types where previously we lost track of type dependencies.

Author: odersky

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

@@ -437,13 +437,13 @@ object desugar {
   private def toDefParam(tparam: TypeDef, keepAnnotations: Boolean): TypeDef = {
     var mods = tparam.rawMods
     if (!keepAnnotations) mods = mods.withAnnotations(Nil)
-    tparam.withMods(mods & (EmptyFlags | Sealed) | Param)
+    tparam.withMods(mods & EmptyFlags | Param)
   }
   private def toDefParam(vparam: ValDef, keepAnnotations: Boolean, keepDefault: Boolean): ValDef = {
     var mods = vparam.rawMods
     if (!keepAnnotations) mods = mods.withAnnotations(Nil)
     val hasDefault = if keepDefault then HasDefault else EmptyFlags
-    vparam.withMods(mods & (GivenOrImplicit | Erased | hasDefault) | Param)
+    vparam.withMods(mods & (GivenOrImplicit | Erased | hasDefault | Tracked) | Param)
   }
 
   def mkApply(fn: Tree, paramss: List[ParamClause])(using Context): Tree =
@@ -529,7 +529,7 @@ object desugar {
     // but not on the constructor parameters. The reverse is true for
     // annotations on class _value_ parameters.
     val constrTparams = impliedTparams.map(toDefParam(_, keepAnnotations = false))
-    val constrVparamss =
+    def defVparamss =
       if (originalVparamss.isEmpty) { // ensure parameter list is non-empty
         if (isCaseClass)
           report.error(CaseClassMissingParamList(cdef), namePos)
@@ -540,6 +540,7 @@ object desugar {
         ListOfNil
       }
       else originalVparamss.nestedMap(toDefParam(_, keepAnnotations = true, keepDefault = true))
+    val constrVparamss = defVparamss
     val derivedTparams =
       constrTparams.zipWithConserve(impliedTparams)((tparam, impliedParam) =>
         derivedTypeParam(tparam).withAnnotations(impliedParam.mods.annotations))
@@ -614,6 +615,11 @@ object desugar {
       case _ => false
     }
 
+    def isRepeated(tree: Tree): Boolean = stripByNameType(tree) match {
+      case PostfixOp(_, Ident(tpnme.raw.STAR)) => true
+      case _ => false
+    }
+
     def appliedRef(tycon: Tree, tparams: List[TypeDef] = constrTparams, widenHK: Boolean = false) = {
       val targs = for (tparam <- tparams) yield {
         val targ = refOfDef(tparam)
@@ -630,10 +636,13 @@ object desugar {
       appliedTypeTree(tycon, targs)
     }
 
-    def isRepeated(tree: Tree): Boolean = stripByNameType(tree) match {
-      case PostfixOp(_, Ident(tpnme.raw.STAR)) => true
-      case _ => false
-    }
+    def addParamRefinements(core: Tree, paramss: List[List[ValDef]]): Tree =
+      val refinements =
+        for params <- paramss; param <- params; if param.mods.is(Tracked) yield
+          ValDef(param.name, SingletonTypeTree(TermRefTree().watching(param)), EmptyTree)
+            .withSpan(param.span)
+      if refinements.isEmpty then core
+      else RefinedTypeTree(core, refinements).showing(i"refined result: $result", Printers.desugar)
 
     // a reference to the class type bound by `cdef`, with type parameters coming from the constructor
     val classTypeRef = appliedRef(classTycon)
@@ -854,18 +863,17 @@ object desugar {
         Nil
       }
       else {
-        val defParamss = constrVparamss match {
+        val defParamss = defVparamss match
           case Nil :: paramss =>
             paramss // drop leading () that got inserted by class
                     // TODO: drop this once we do not silently insert empty class parameters anymore
           case paramss => paramss
-        }
         val finalFlag = if ctx.settings.YcompileScala2Library.value then EmptyFlags else Final
         // implicit wrapper is typechecked in same scope as constructor, so
         // we can reuse the constructor parameters; no derived params are needed.
         DefDef(
           className.toTermName, joinParams(constrTparams, defParamss),
-          classTypeRef, creatorExpr)
+          addParamRefinements(classTypeRef, defParamss), creatorExpr)
           .withMods(companionMods | mods.flags.toTermFlags & (GivenOrImplicit | Inline) | finalFlag)
           .withSpan(cdef.span) :: Nil
       }

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

@@ -231,6 +231,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Infix()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Infix)
 
+    case class Tracked()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Tracked)
+
     /** Used under pureFunctions to mark impure function types `A => B` in `FunctionWithMods` */
     case class Impure()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Impure)
   }

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

@@ -242,7 +242,7 @@ object Flags {
   val (AccessorOrSealed @ _, Accessor @ _, Sealed @ _) = newFlags(11, "<accessor>", "sealed")
 
   /** A mutable var, an open class */
-  val (MutableOrOpen @ __, Mutable @ _, Open @ _) = newFlags(12, "mutable", "open")
+  val (MutableOrOpen @ _, Mutable @ _, Open @ _) = newFlags(12, "mutable", "open")
 
   /** Symbol is local to current class (i.e. private[this] or protected[this]
    *  pre: Private or Protected are also set
@@ -377,6 +377,8 @@ object Flags {
   /** Symbol cannot be found as a member during typer */
   val (Invisible @ _, _, _) = newFlags(45, "<invisible>")
 
+  val (Tracked @ _, _, _) = newFlags(46, "tracked")
+
   // ------------ Flags following this one are not pickled ----------------------------------
 
   /** Symbol is not a member of its owner */
@@ -452,7 +454,7 @@ object Flags {
     CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed | Opaque | Open
 
   val TermSourceModifierFlags: FlagSet =
-    CommonSourceModifierFlags.toTermFlags | Inline | AbsOverride | Lazy
+    CommonSourceModifierFlags.toTermFlags | Inline | AbsOverride | Lazy | Tracked
 
   /** Flags representing modifiers that can appear in trees */
   val ModifierFlags: FlagSet =

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

@@ -15,7 +15,12 @@ object NamerOps:
    */
   def effectiveResultType(ctor: Symbol, paramss: List[List[Symbol]])(using Context): Type =
     paramss match
-      case TypeSymbols(tparams) :: _ => ctor.owner.typeRef.appliedTo(tparams.map(_.typeRef))
+      case TypeSymbols(tparams) :: _ =>
+        var resType = ctor.owner.typeRef.appliedTo(tparams.map(_.typeRef))
+        for params <- paramss; param <- params do
+          if param.is(Tracked) then
+            resType = RefinedType(resType, param.name, param.termRef)
+        resType
       case _ => ctor.owner.typeRef
 
   /** If isConstructor, make sure it has at least one non-implicit parameter list

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

@@ -623,6 +623,7 @@ object StdNames {
     val toString_ : N           = "toString"
     val toTypeConstructor: N    = "toTypeConstructor"
     val tpe : N                 = "tpe"
+    val tracked: N              = "tracked"
     val transparent : N         = "transparent"
     val tree : N                = "tree"
     val true_ : N               = "true"

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -787,6 +787,7 @@ class TreePickler(pickler: TastyPickler) {
       if (flags.is(Extension)) writeModTag(EXTENSION)
       if (flags.is(ParamAccessor)) writeModTag(PARAMsetter)
       if (flags.is(SuperParamAlias)) writeModTag(PARAMalias)
+      if (flags.is(Tracked)) writeModTag(TRACKED)
       assert(!(flags.is(Label)))
     }
     else {

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -733,6 +733,7 @@ class TreeUnpickler(reader: TastyReader,
           case INVISIBLE => addFlag(Invisible)
           case TRANSPARENT => addFlag(Transparent)
           case INFIX => addFlag(Infix)
+          case TRACKED => addFlag(Tracked)
           case PRIVATEqualified =>
             readByte()
             privateWithin = readWithin

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

@@ -3100,6 +3100,7 @@ object Parsers {
           case nme.open => Mod.Open()
           case nme.transparent => Mod.Transparent()
           case nme.infix => Mod.Infix()
+          case nme.tracked => Mod.Tracked()
         }
     }
 
@@ -3166,6 +3167,7 @@ object Parsers {
      *                  |  AccessModifier
      *                  |  override
      *                  |  opaque
+     *                  |  tracked
      *  LocalModifier  ::= abstract | final | sealed | open | implicit | lazy | erased | inline | transparent
      */
     def modifiers(allowed: BitSet = modifierTokens, start: Modifiers = Modifiers()): Modifiers = {
@@ -3427,7 +3429,8 @@ object Parsers {
                   val isParams =
                     !impliedMods.is(Given)
                     || startParamTokens.contains(in.token)
-                    || isIdent && (in.name == nme.inline || in.lookahead.isColon)
+                    || isIdent
+                        && (in.name == nme.inline || in.name == nme.tracked || in.lookahead.isColon)
                   (mods, isParams)
               (if isParams then commaSeparated(() => param())
               else contextTypes(paramOwner, numLeadParams, impliedMods)) match {
@@ -4005,7 +4008,9 @@ object Parsers {
         paramss.nestedMap: param =>
           if !param.mods.isAllOf(PrivateLocal) then
             syntaxError(em"method parameter ${param.name} may not be `a val`", param.span)
-          param.withMods(param.mods &~ (AccessFlags | ParamAccessor | Mutable) | Param)
+          if param.mods.is(Tracked) then
+            syntaxError(em"method parameter ${param.name} may not be `tracked`", param.span)
+          param.withMods(param.mods &~ (AccessFlags | ParamAccessor | Tracked | Mutable) | Param)
         .asInstanceOf[List[ParamClause]]
 
       val gdef =

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

@@ -294,7 +294,7 @@ object Tokens extends TokensCommon {
 
   final val closingParens = BitSet(RPAREN, RBRACKET, RBRACE)
 
-  final val softModifierNames = Set(nme.inline, nme.into, nme.opaque, nme.open, nme.transparent, nme.infix)
+  final val softModifierNames = Set(nme.inline, nme.into, nme.opaque, nme.open, nme.transparent, nme.infix, nme.tracked)
 
   def showTokenDetailed(token: Int): String = debugString(token)
 

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -332,11 +332,11 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
             case Select(nu: New, nme.CONSTRUCTOR) if isCheckable(nu) =>
               // need to check instantiability here, because the type of the New itself
               // might be a type constructor.
-              ctx.typer.checkClassType(tree.tpe, tree.srcPos, traitReq = false, stablePrefixReq = true)
+              ctx.typer.checkClassType(tree.tpe, tree.srcPos, traitReq = false, stablePrefixReq = true, refinementOK = true)
               if !nu.tpe.isLambdaSub then
                 // Check the constructor type as well; it could be an illegal singleton type
                 // which would not be reflected as `tree.tpe`
-                ctx.typer.checkClassType(nu.tpe, tree.srcPos, traitReq = false, stablePrefixReq = false)
+                ctx.typer.checkClassType(nu.tpe, tree.srcPos, traitReq = false, stablePrefixReq = false, refinementOK = true)
               Checking.checkInstantiable(tree.tpe, nu.tpe, nu.srcPos)
               withNoCheckNews(nu :: Nil)(app1)
             case _ =>

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

@@ -1021,16 +1021,15 @@ trait Checking {
   *   check that class prefix is stable.
    *  @return  `tp` itself if it is a class or trait ref, ObjectType if not.
    */
-  def checkClassType(tp: Type, pos: SrcPos, traitReq: Boolean, stablePrefixReq: Boolean)(using Context): Type =
-    tp.underlyingClassRef(refinementOK = false) match {
+  def checkClassType(tp: Type, pos: SrcPos, traitReq: Boolean, stablePrefixReq: Boolean, refinementOK: Boolean = false)(using Context): Type =
+    tp.underlyingClassRef(refinementOK) match
       case tref: TypeRef =>
         if (traitReq && !tref.symbol.is(Trait)) report.error(TraitIsExpected(tref.symbol), pos)
         if (stablePrefixReq && ctx.phase <= refchecksPhase) checkStable(tref.prefix, pos, "class prefix")
         tp
       case _ =>
         report.error(NotClassType(tp), pos)
         defn.ObjectType
-    }
 
   /** If `sym` is an old-style implicit conversion, check that implicit conversions are enabled.
    *  @pre  sym.is(GivenOrImplicit)
@@ -1601,7 +1600,7 @@ trait NoChecking extends ReChecking {
   override def checkNonCyclic(sym: Symbol, info: TypeBounds, reportErrors: Boolean)(using Context): Type = info
   override def checkNonCyclicInherited(joint: Type, parents: List[Type], decls: Scope, pos: SrcPos)(using Context): Unit = ()
   override def checkStable(tp: Type, pos: SrcPos, kind: String)(using Context): Unit = ()
-  override def checkClassType(tp: Type, pos: SrcPos, traitReq: Boolean, stablePrefixReq: Boolean)(using Context): Type = tp
+  override def checkClassType(tp: Type, pos: SrcPos, traitReq: Boolean, stablePrefixReq: Boolean, refinementOK: Boolean)(using Context): Type = tp
   override def checkImplicitConversionDefOK(sym: Symbol)(using Context): Unit = ()
   override def checkImplicitConversionUseOK(tree: Tree, expected: Type)(using Context): Unit = ()
   override def checkFeasibleParent(tp: Type, pos: SrcPos, where: => String = "")(using Context): Type = tp

compiler/test/dotc/pos-test-pickling.blacklist

@@ -111,3 +111,6 @@ java-inherited-type1
 
 # recursion limit exceeded
 i7445b.scala
+
+# alias types at different levels of dereferencing
+parsercombinators-givens.scala

tasty/src/dotty/tools/tasty/TastyFormat.scala

@@ -485,6 +485,7 @@ object TastyFormat {
   final val INVISIBLE = 44
   final val EMPTYCLAUSE = 45
   final val SPLITCLAUSE = 46
+  final val TRACKED = 47
 
   // Cat. 2:    tag Nat
 
@@ -662,7 +663,8 @@ object TastyFormat {
        | INVISIBLE
        | ANNOTATION
        | PRIVATEqualified
-       | PROTECTEDqualified => true
+       | PROTECTEDqualified
+       | TRACKED => true
     case _ => false
   }
 

tests/pos/parsercombinators-expanded.scala

@@ -27,8 +27,8 @@ object test:
   def apply[C, E]: apply[C, E] = new apply[C, E]
 
   class combine[A, B](
-      val f: Combinator[A],
-      val s: Combinator[B] { type Context = f.Context}
+      tracked val f: Combinator[A],
+      tracked val s: Combinator[B] { type Context = f.Context}
   ) extends Combinator[Combine[A, B]]:
     type Context = f.Context
     type Element = (f.Element, s.Element)
@@ -38,10 +38,7 @@ object test:
   def combine[A, B](
       _f: Combinator[A],
       _s: Combinator[B] { type Context = _f.Context}
-    ): combine[A, B] {
-      type Context = _f.Context
-      type Element = (_f.Element, _s.Element)
-    } = new combine[A, B](_f, _s).asInstanceOf
+    ) = new combine[A, B](_f, _s)
     // cast is needed since the type of new combine[A, B](_f, _s)
     // drops the required refinement.
 
@@ -56,12 +53,10 @@ object test:
     val n = Apply[mutable.ListBuffer[Int], Int](s => s.popFirst())
     val m = Combine(n, n)
 
-    val c = combine[
-        Apply[mutable.ListBuffer[Int], Int],
-        Apply[mutable.ListBuffer[Int], Int]
-      ](
+    val c = combine(
         apply[mutable.ListBuffer[Int], Int],
         apply[mutable.ListBuffer[Int], Int]
       )
-    val r = c.parse(m)(stream) // type mismatch, found `mutable.ListBuffer[Int]`, required `?1.Context`
+    val r = c.parse(m)(stream) // was type mismatch, now OK
+    val rc: Option[(Int, Int)] = r
   }

tests/pos/parsercombinators-givens.scala

@@ -24,9 +24,9 @@ given apply[C, E]: Combinator[Apply[C, E]] with {
   }
 }
 
-given combine[A, B, C](using
-    f: Combinator[A] { type Context = C },
-    s: Combinator[B] { type Context = C }
+given combine[A, B](using
+    tracked val f: Combinator[A],
+    tracked val s: Combinator[B] { type Context = f.Context }
 ): Combinator[Combine[A, B]] with {
   type Context = f.Context
   type Element = (f.Element, s.Element)
@@ -46,6 +46,7 @@ extension [A] (buf: mutable.ListBuffer[A]) def popFirst() =
   val n = Apply[mutable.ListBuffer[Int], Int](s => s.popFirst())
   val m = Combine(n, n)
 
-  // val r = m.parse(stream) // error: type mismatch, found `mutable.ListBuffer[Int]`, required `?1.Context`
+  val r = m.parse(stream) // error: type mismatch, found `mutable.ListBuffer[Int]`, required `?1.Context`
+  val rc: Option[(Int, Int)] = r
   // it would be great if this worked
 }