WIP

Author: odersky

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

@@ -443,7 +443,7 @@ object desugar {
     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 =
@@ -614,6 +614,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,13 +635,20 @@ object desugar {
       appliedTypeTree(tycon, targs)
     }
 
-    def isRepeated(tree: Tree): Boolean = stripByNameType(tree) match {
-      case PostfixOp(_, Ident(tpnme.raw.STAR)) => true
-      case _ => false
-    }
+    def addRefinements(core: Tree): Tree =
+      val refinements =
+        for
+          params <- constrVparamss
+          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")
 
     // a reference to the class type bound by `cdef`, with type parameters coming from the constructor
-    val classTypeRef = appliedRef(classTycon)
+    val classTypeRef = addRefinements(appliedRef(classTycon))
 
     // a reference to `enumClass`, with type parameters coming from the case constructor
     lazy val enumClassTypeRef =

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/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/typer/Checking.scala

@@ -1022,7 +1022,7 @@ trait Checking {
    *  @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 {
+    tp.underlyingClassRef(refinementOK = true) 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")

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
 }