More concise syntax for capture members

Author: bracevac

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

@@ -528,12 +528,13 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     TypeApply(Select(scalaDot(nme.caps), nme.capsOf), tp :: Nil)
 
   // Capture set variable `[C^]` becomes: `[C >: CapSet <: CapSet^{cap}]`
-  def makeCapsBound()(using Context): TypeBoundsTree =
-    TypeBoundsTree(
-      Select(scalaDot(nme.caps), tpnme.CapSet),
-      makeRetaining(
-        Select(scalaDot(nme.caps), tpnme.CapSet),
-        Nil, tpnme.retainsCap))
+  def makeCapsBound(refsL: List[Tree] = Nil, refsU: List[Tree] = Nil)(using Context): TypeBoundsTree =
+    val lower = refsL match
+      case Nil => Select(scalaDot(nme.caps), tpnme.CapSet)
+      case refsL => makeRetaining(Select(scalaDot(nme.caps), tpnme.CapSet), refsL, tpnme.retains)
+    val upper =
+      makeRetaining(Select(scalaDot(nme.caps), tpnme.CapSet), refsU, if refsU.isEmpty then tpnme.retainsCap else tpnme.retains)
+    TypeBoundsTree(lower, upper)
 
   def makeConstructor(tparams: List[TypeDef], vparamss: List[List[ValDef]], rhs: Tree = EmptyTree)(using Context): DefDef =
     DefDef(nme.CONSTRUCTOR, joinParams(tparams, vparamss), TypeTree(), rhs)

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

@@ -443,6 +443,7 @@ object StdNames {
     val bytes: N                = "bytes"
     val canEqual_ : N           = "canEqual"
     val canEqualAny : N         = "canEqualAny"
+    val cap: N                  = "cap"
     val caps: N                 = "caps"
     val capsOf: N               = "capsOf"
     val captureChecking: N      = "captureChecking"

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

@@ -35,6 +35,8 @@ import config.SourceVersion.*
 import config.SourceVersion
 import dotty.tools.dotc.config.MigrationVersion
 import dotty.tools.dotc.util.chaining.*
+import dotty.tools.dotc.config.Feature.ccEnabled
+import dotty.tools.dotc.core.Types.AndType.make
 
 object Parsers {
 
@@ -256,6 +258,7 @@ object Parsers {
       || defIntroTokens.contains(in.token)
       || allowedMods.contains(in.token)
       || in.isSoftModifierInModifierPosition && !excludedSoftModifiers.contains(in.name)
+      || Feature.ccEnabled && isIdent(nme.cap) //TODO have it as proper keyword/token instead?
 
     def isStatSep: Boolean = in.isStatSep
 
@@ -1610,6 +1613,12 @@ object Parsers {
       if in.token == RBRACE then Nil else commaSeparated(captureRef)
     }
 
+    /**  CaptureSetOrRef ::=  `{` CaptureSet `}` | CaptureRef   -- under captureChecking
+     */
+    def captureSetOrRef(): List[Tree] =
+      if in.token == LBRACE then captureSet()
+      else List(captureRef())
+
     def capturesAndResult(core: () => Tree): Tree =
       if Feature.ccEnabled && in.token == LBRACE && in.offset == in.lastOffset
       then CapturesAndResult(captureSet(), core())
@@ -1951,7 +1960,8 @@ object Parsers {
 
     def typeBlockStats(): List[Tree] =
       val tdefs = new ListBuffer[Tree]
-      while in.token == TYPE do tdefs += typeBlockStat()
+      while (in.token == TYPE) do
+        tdefs += typeBlockStat()
       tdefs.toList
 
     /**  TypeBlockStat ::= ‘type’ {nl} TypeDef
@@ -2233,7 +2243,7 @@ object Parsers {
         inBraces(refineStatSeq())
 
     /** TypeBounds ::= [`>:' Type] [`<:' Type]
-     *              |  `^`                     -- under captureChecking
+     *              |  `^`                     -- under captureChecking TODO remove
      */
     def typeBounds(): TypeBoundsTree =
       atSpan(in.offset):
@@ -2247,6 +2257,19 @@ object Parsers {
       if (in.token == tok) { in.nextToken(); toplevelTyp() }
       else EmptyTree
 
+    private def capsType(refs: List[Tree], isLowerBound: Boolean = false): Tree =
+      if isLowerBound && refs.isEmpty then
+        Select(scalaDot(nme.caps), tpnme.CapSet)
+      else
+        makeRetaining(Select(scalaDot(nme.caps), tpnme.CapSet), refs, if refs.isEmpty then tpnme.retainsCap else tpnme.retains)
+
+    private def capsBound(tok: Int): Tree =
+      if (in.token == tok) then
+        in.nextToken()
+        capsType(captureSetOrRef(), isLowerBound = tok == SUPERTYPE)
+      else
+        capsType(Nil, isLowerBound = tok == SUPERTYPE)
+
     /** TypeAndCtxBounds  ::=  TypeBounds [`:` ContextBounds]
      */
     def typeAndCtxBounds(pname: TypeName): Tree = {
@@ -2256,6 +2279,15 @@ object Parsers {
       else atSpan((t.span union cbs.head.span).start) { ContextBounds(t, cbs) }
     }
 
+    /** TypeAndCtxBounds  ::=  TypeBounds [`:` ContextBounds]   -- under captureChecking
+     */
+    def captureSetAndCtxBounds(pname: TypeName): Tree = {
+      val t = TypeBoundsTree(capsBound(SUPERTYPE), capsBound(SUBTYPE))
+      val cbs = contextBounds(pname)
+      if (cbs.isEmpty) t
+      else atSpan((t.span union cbs.head.span).start) { ContextBounds(t, cbs) }
+    }
+
     /** ContextBound      ::=  Type [`as` id] */
     def contextBound(pname: TypeName): Tree =
       val t = toplevelTyp(inContextBound = true)
@@ -3848,25 +3880,29 @@ object Parsers {
      *             | var VarDef
      *             | def DefDef
      *             | type {nl} TypeDef
+     *             | cap {nl} CapDef     -- under capture checking
      *             | TmplDef
      *  EnumCase ::= `case' (id ClassConstr [`extends' ConstrApps]] | ids)
      */
-    def defOrDcl(start: Int, mods: Modifiers): Tree = in.token match {
-      case VAL =>
-        in.nextToken()
-        patDefOrDcl(start, mods)
-      case VAR =>
-        val mod = atSpan(in.skipToken()) { Mod.Var() }
-        val mod1 = addMod(mods, mod)
-        patDefOrDcl(start, mod1)
-      case DEF =>
-        defDefOrDcl(start, in.skipToken(mods))
-      case TYPE =>
-        typeDefOrDcl(start, in.skipToken(mods))
-      case CASE if inEnum =>
-        enumCase(start, mods)
-      case _ =>
-        tmplDef(start, mods)
+    def defOrDcl(start: Int, mods: Modifiers): Tree =
+      in.token match {
+        case VAL =>
+          in.nextToken()
+          patDefOrDcl(start, mods)
+        case VAR =>
+          val mod = atSpan(in.skipToken()) { Mod.Var() }
+          val mod1 = addMod(mods, mod)
+          patDefOrDcl(start, mod1)
+        case DEF =>
+          defDefOrDcl(start, in.skipToken(mods))
+        case TYPE =>
+          typeDefOrDcl(start, in.skipToken(mods))
+        case CASE if inEnum =>
+          enumCase(start, mods)
+        case _ =>
+          if Feature.ccEnabled && isIdent(nme.cap) then //TODO do we want a dedicated CAP token? TokensCommon would need a Ctx to check if ccenabled
+            capDefOrDcl(start, in.skipToken(mods))
+          else tmplDef(start, mods)
     }
 
     /** PatDef  ::=  ids [‘:’ Type] [‘=’ Expr]
@@ -4075,6 +4111,52 @@ object Parsers {
       }
     }
 
+    /** CapDef ::=  id CaptureSetAndCtxBounds [‘=’ CaptureSet]    -- under capture checking
+     */
+    def capDefOrDcl(start: Offset, mods: Modifiers): Tree =
+      newLinesOpt()
+      atSpan(start, nameStart) {
+        val nameIdent = typeIdent()
+        val tname = nameIdent.name.asTypeName
+        // val tparams = typeParamClauseOpt(ParamOwner.Hk) TODO: error message: type parameters not allowed
+        // val vparamss = funParamClauses()
+
+        def makeCapDef(refs: List[Tree] | Tree): Tree = {
+          val tdef = TypeDef(nameIdent.name.toTypeName,
+                             refs.match
+                                case refs: List[Tree] => capsType(refs)
+                                case bounds: Tree => bounds)
+
+          if (nameIdent.isBackquoted)
+            tdef.pushAttachment(Backquoted, ())
+          finalizeDef(tdef, mods, start)
+        }
+
+        in.token.match
+          case EQUALS =>
+            in.nextToken()
+            makeCapDef(captureSetOrRef())
+          case SUBTYPE | SUPERTYPE =>
+            captureSetAndCtxBounds(tname) match
+              case bounds: TypeBoundsTree if in.token == EQUALS => //TODO ask Martin: can this case even happen?
+                val eqOffset = in.skipToken()
+                var rhs = capsType(captureSetOrRef())
+                if mods.is(Opaque) then
+                   rhs = TypeBoundsTree(bounds.lo, bounds.hi, rhs)
+                else
+                  syntaxError(em"cannot combine bound and alias", eqOffset)
+                makeCapDef(rhs)
+              case bounds => makeCapDef(bounds)
+          case SEMI | NEWLINE | NEWLINES | COMMA | RBRACE | OUTDENT | EOF =>
+            makeCapDef(captureSetAndCtxBounds(tname))
+          case _ if (staged & StageKind.QuotedPattern) != 0 //TODO not sure if we need this case for capsets
+              || sourceVersion.enablesNewGivens && in.isColon =>
+            makeCapDef(captureSetAndCtxBounds(tname))
+          case _ =>
+            syntaxErrorOrIncomplete(ExpectedTypeBoundOrEquals(in.token)) //TODO change error message
+            return EmptyTree // return to avoid setting the span to EmptyTree
+      }
+
     /** TmplDef ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
      *            |  [‘case’] ‘object’ ObjectDef
      *            |  ‘enum’ EnumDef

tests/pos-custom-args/captures/cap_members.scala

@@ -0,0 +1,23 @@
+import language.experimental.captureChecking
+
+def test =
+  val x: Any^ = ???
+  val y: Any^ = ???
+  object O:
+    val z: Any^ = ???
+  trait CaptureSet:
+    cap A >: y <: x
+    cap B = x
+    cap C <: {x}
+    cap D
+    cap E <: C
+    cap F <: {C}
+    cap G <: {x, y}
+    cap H >: {x} <: {x,y}
+    cap I = {y, G, H}
+    cap J = {O.z}
+    cap K = {x, O.z}
+    cap L <: {x, y, O.z}
+    cap M >: {x, y, O.z} <: C
+    cap N >: x <: x
+    cap O >: O.z <: O.z