Polish cap members parsing and error messages

Author: bracevac

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

@@ -222,6 +222,8 @@ object Parsers {
     def isErased = isIdent(nme.erased) && in.erasedEnabled
     // Are we seeing an `erased` soft keyword that will not be an identifier?
     def isErasedKw = isErased && in.isSoftModifierInParamModifierPosition
+    // Are we seeing a `cap` soft keyword for declaring a capture-set member or at the beginning a capture-variable parameter list?
+    def isCapKw = Feature.ccEnabled && isIdent(nme.cap)
     def isSimpleLiteral =
       simpleLiteralTokens.contains(in.token)
       || isIdent(nme.raw.MINUS) && numericLitTokens.contains(in.lookahead.token)
@@ -258,7 +260,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?
+      || isCapKw
 
     def isStatSep: Boolean = in.isStatSep
 
@@ -2260,22 +2262,28 @@ object Parsers {
         else
           TypeBoundsTree(bound(SUPERTYPE), bound(SUBTYPE))
 
+    /** CaptureSetBounds ::= [`>:' CaptureSetOrRef ] [`<:' CaptureSetOrRef ] --- under captureChecking
+     */
+    def captureSetBounds(): TypeBoundsTree =
+      atSpan(in.offset):
+          TypeBoundsTree(capsBound(SUPERTYPE), capsBound(SUBTYPE))
+
     private def bound(tok: Int): Tree =
       if (in.token == tok) { in.nextToken(); toplevelTyp() }
       else EmptyTree
 
-    private def capsType(refs: List[Tree], isLowerBound: Boolean = false): Tree =
-      if isLowerBound && refs.isEmpty then
+    private def capsBound(refs: List[Tree], isLowerBound: Boolean = false): Tree =
+      if isLowerBound && refs.isEmpty then // lower bounds with empty capture sets become a pure CapSet
         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)
+        capsBound(captureSetOrRef(), isLowerBound = tok == SUPERTYPE)
       else
-        capsType(Nil, isLowerBound = tok == SUPERTYPE)
+        capsBound(Nil, isLowerBound = tok == SUPERTYPE)
 
     /** TypeAndCtxBounds  ::=  TypeBounds [`:` ContextBounds]
      */
@@ -2286,10 +2294,10 @@ object Parsers {
       else atSpan((t.span union cbs.head.span).start) { ContextBounds(t, cbs) }
     }
 
-    /** TypeAndCtxBounds  ::=  TypeBounds [`:` ContextBounds]   -- under captureChecking
+    /** CaptureSetAndCtxBounds  ::=  CaptureSetBounds [`:` ContextBounds]   -- under captureChecking
      */
     def captureSetAndCtxBounds(pname: TypeName): Tree = {
-      val t = TypeBoundsTree(capsBound(SUPERTYPE), capsBound(SUBTYPE))
+      val t = captureSetBounds()
       val cbs = contextBounds(pname)
       if (cbs.isEmpty) t
       else atSpan((t.span union cbs.head.span).start) { ContextBounds(t, cbs) }
@@ -3907,7 +3915,7 @@ object Parsers {
         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
+          if isCapKw then
             capDefOrDcl(start, in.skipToken(mods))
           else tmplDef(start, mods)
     }
@@ -4118,20 +4126,22 @@ object Parsers {
       }
     }
 
-    /** CapDef ::=  id CaptureSetAndCtxBounds [‘=’ CaptureSet]    -- under capture checking
+    private def concreteCapsType(refs: List[Tree]): Tree =
+      makeRetaining(Select(scalaDot(nme.caps), tpnme.CapSet), refs, tpnme.retains)
+
+    /** CapDef ::=  id CaptureSetAndCtxBounds [‘=’ CaptureSetOrRef]    -- 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()
+        if in.token == LBRACKET then syntaxError(em"'cap' declarations cannot have type parameters")
 
         def makeCapDef(refs: List[Tree] | Tree): Tree = {
           val tdef = TypeDef(nameIdent.name.toTypeName,
                              refs.match
-                                case refs: List[Tree] => capsType(refs)
+                                case refs: List[Tree] => concreteCapsType(refs)
                                 case bounds: Tree => bounds)
 
           if (nameIdent.isBackquoted)
@@ -4143,24 +4153,13 @@ object Parsers {
           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 =>
+          case SUBTYPE | SUPERTYPE | 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
+          case _ if (staged & StageKind.QuotedPattern) != 0
               || sourceVersion.enablesNewGivens && in.isColon =>
             makeCapDef(captureSetAndCtxBounds(tname))
           case _ =>
-            syntaxErrorOrIncomplete(ExpectedTypeBoundOrEquals(in.token)) //TODO change error message
+            syntaxErrorOrIncomplete(ExpectedCaptureBoundOrEquals(in.token))
             return EmptyTree // return to avoid setting the span to EmptyTree
       }
 

compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala

@@ -222,6 +222,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case EnumMayNotBeValueClassesID // errorNumber: 206
   case IllegalUnrollPlacementID // errorNumber: 207
   case ExtensionHasDefaultID // errorNumber: 208
+  case ExpectedCaptureBoundOrEqualsID // errorNumber: 209
 
   def errorNumber = ordinal - 1
 

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -1917,6 +1917,23 @@ class ExpectedTypeBoundOrEquals(found: Token)(using Context)
         |"""
 }
 
+class ExpectedCaptureBoundOrEquals(found: Token)(using Context)
+  extends SyntaxMsg(ExpectedCaptureBoundOrEqualsID) {
+  def msg(using Context) = i"${hl("=")}, ${hl(">:")}, or ${hl("<:")} expected, but ${Tokens.showToken(found)} found"
+
+  def explain(using Context) =
+    i"""Capture parameters and abstract captures may be constrained by a capture bound.
+        |Such capture bounds limit the concrete values of the capture variables and possibly
+        |reveal more information about the members of such captures.
+        |
+        |A lower type bound ${hl("B >: A")} expresses that the capture variable ${hl("B")}
+        |refers to a super capture of capture ${hl("A")}.
+        |
+        |An upper capture bound ${hl("T <: A")} declares that capture variable ${hl("T")}
+        |refers to a subcapture of ${hl("A")}.
+        |"""
+}
+
 class ClassAndCompanionNameClash(cls: Symbol, other: Symbol)(using Context)
   extends NamingMsg(ClassAndCompanionNameClashID) {
   def msg(using Context) =

tests/neg-custom-args/captures/capset-members.scala

@@ -1,29 +1,29 @@
 import caps.*
 
 trait Abstract[X^]:
-  type C >: X <: CapSet^
+  cap C >: X
   // Don't test the return type using Unit, because it is a pure type.
   def boom(): AnyRef^{C}
 
 class Concrete extends Abstract[CapSet^{}]:
-  type C = CapSet^{}
+  cap C = {}
   // TODO: Why do we get error without the return type here?
   def boom(): AnyRef = new Object
 
 class Concrete2 extends Abstract[CapSet^{}]:
-  type C = CapSet^{}
+  cap C = {}
   def boom(): AnyRef^ = new Object // error
 
 class Concrete3 extends Abstract[CapSet^{}]:
   def boom(): AnyRef = new Object
 
 class Concrete4(a: AnyRef^) extends Abstract[CapSet^{a}]:
-  type C = CapSet // error
+  cap C = {} // error
   def boom(): AnyRef^{a} = a // error
 
 class Concrete5(a: AnyRef^, b: AnyRef^) extends Abstract[CapSet^{a}]:
-  type C = CapSet^{a}
+  cap C = a
   def boom(): AnyRef^{b} = b // error
 
 class Concrete6(a: AnyRef^, b: AnyRef^) extends Abstract[CapSet^{a}]:
-  def boom(): AnyRef^{b} = b // error
+  def boom(): AnyRef^{b} = b // error

tests/neg-custom-args/captures/capset-members2.check

@@ -0,0 +1,4 @@
+-- Error: tests/neg-custom-args/captures/capset-members2.scala:4:7 -----------------------------------------------------
+4 |  cap C[T] // error
+  |       ^
+  |       'cap' declarations cannot have type parameters

tests/neg-custom-args/captures/capset-members2.scala

@@ -0,0 +1,5 @@
+import caps.*
+
+trait Foo:
+  cap C[T] // error
+

tests/neg-custom-args/captures/capset-members3.check

@@ -0,0 +1,6 @@
+-- [E209] Syntax Error: tests/neg-custom-args/captures/capset-members3.scala:4:8 ---------------------------------------
+4 |  cap C _ // error
+  |        ^
+  |        =, >:, or <: expected, but '_' found
+  |
+  | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/capset-members3.scala

@@ -0,0 +1,5 @@
+import caps.*
+
+trait Foo:
+  cap C _ // error
+

tests/pos-custom-args/captures/cap_members.scala renamed to tests/pos-custom-args/captures/capset-members.scala

@@ -1,5 +1,7 @@
 import language.experimental.captureChecking
 
+trait Ctx[T]
+
 def test =
   val x: Any^ = ???
   val y: Any^ = ???
@@ -9,11 +11,11 @@ def test =
     cap A >: y <: x
     cap B = x
     cap C <: {x}
-    cap D
+    cap D : Ctx
     cap E <: C
     cap F <: {C}
     cap G <: {x, y}
-    cap H >: {x} <: {x,y}
+    cap H >: {x} <: {x,y} : Ctx
     cap I = {y, G, H}
     cap J = {O.z}
     cap K = {x, O.z}