Make ^ optional in more scenarios for cap vars

Author: bracevac

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

@@ -35,6 +35,7 @@ import config.SourceVersion.*
 import config.SourceVersion
 import dotty.tools.dotc.config.MigrationVersion
 import dotty.tools.dotc.util.chaining.*
+import dotty.tools.dotc.config.Printers.variances
 
 object Parsers {
 
@@ -2285,11 +2286,29 @@ object Parsers {
 
     /** TypeBounds ::= [`>:' TypeBound ] [`<:' TypeBound ]
      *  TypeBound  ::= Type
-     *              |  CaptureSet -- under captureChecking
+     *               | CaptureSet -- under captureChecking
      */
     def typeBounds(isCapParamOrMem: Boolean = false): TypeBoundsTree =
+      def isCapsBound(t: Tree): Boolean =
+        t match
+          case Select(qual, tpnme.CapSet) => true
+          case Annotated(Select(qual, tpnme.CapSet), _) => true
+          case _ => false
+
       atSpan(in.offset):
-        TypeBoundsTree(bound(SUPERTYPE, isCapParamOrMem), bound(SUBTYPE, isCapParamOrMem))
+        var lbound = bound(SUPERTYPE, isCapParamOrMem)
+        var ubound = bound(SUBTYPE, isCapParamOrMem)
+        if Feature.ccEnabled && !isCapParamOrMem then
+          /* We haven't annotated the `^` to a type parameter/member,
+             but an explicit capture-set bound makes it a capture parameter, so we make sure
+             to add the missing other CapSet bound. */
+          if lbound.isEmpty && isCapsBound(ubound) then
+            lbound = capsBound(Nil, isLowerBound = true)
+          if ubound.isEmpty && isCapsBound(lbound) then
+            ubound = capsBound(Nil, isLowerBound = false)
+        end if
+        TypeBoundsTree(lbound, ubound)
+    end typeBounds
 
     private def bound(tok: Int, isCapParamOrMem: Boolean = false): Tree =
       if (in.token == tok) then
@@ -2298,7 +2317,8 @@ object Parsers {
           capsBound(captureSet(), isLowerBound = tok == SUPERTYPE)
         else toplevelTyp()
       else if Feature.ccEnabled && isCapParamOrMem then
-        capsBound(Nil, isLowerBound = tok == SUPERTYPE) // FIXME: should we avoid the CapSet^{} lower bound and make it Nothing?
+        // we hit this case if we have annotated a post-fix `^` but no bounds to a type parameter/member
+        capsBound(Nil, isLowerBound = tok == SUPERTYPE)
       else EmptyTree
 
     private def capsBound(refs: List[Tree], isLowerBound: Boolean = false): Tree =

tests/pos-custom-args/captures/cap-paramlists.scala

@@ -9,15 +9,15 @@ def test =
     val z: Any^ = ???
   def foo[A >: {y} <: {x},
           B^,
-          C^ <: {x},
+          C <: {x},
           D^ : Ctx,
-          E^ <: {C},
-          F^ <: {C},
-          G^ <: {x, y},
-          H >: {x} <: {x,y} : Ctx, T, U]()[I^ <: {y, G, H},
-                                               J^ <: {O.z},
-                                               K^ <: {x, O.z},
-                                               L^ <: {x, y, O.z},
-                                               M^ >: {x, y, O.z} <: {C} : Ctx,
-                                               N^ >: {x} <: {x},
-                                               O^ >: {O.z} <: {O.z}] = ???
+          E <: {C},
+          F <: {C},
+          G <: {x, y},
+          H >: {x} <: {x,y} : Ctx, T, U >: {x}]()[I^ <: {y, G, H},
+                                               J <: {O.z},
+                                               K <: {x, O.z},
+                                               L <: {x, y, O.z},
+                                               M >: {x, y, O.z} <: {C} : Ctx,
+                                               N >: {x} <: {x},
+                                               O >: {O.z} <: {O.z}] = ???

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

@@ -9,17 +9,18 @@ def test =
     val z: Any^ = ???
   trait CaptureSet:
     type A^ >: {y} <: {x}
-    type B^ = {x}
-    type C^ <: {x}
+    type B = {x}
+    type C <: {x}
     type D^ : Ctx
-    type E^ <: {C}
-    type F^ <: {C}
-    type G^ <: {x, y}
-    type H^ >: {x} <: {x,y} : Ctx
+    type E <: {C}
+    type F <: {C}
+    type G <: {x, y}
+    type H >: {x} <: {x,y} : Ctx
     type I^ = {y, G, H}
-    type J^ = {O.z}
+    type J = {O.z}
     type K^ = {x, O.z}
-    type L^ <: {x, y, O.z}
-    type M^ >: {x, y, O.z} <: {C}
-    type N^ >: {x} <: {x}
-    type O^ >: {O.z} <: {O.z}
+    type L <: {x, y, O.z}
+    type M >: {x, y, O.z} <: {C}
+    type N >: {x} <: {x}
+    type O >: {O.z} <: {O.z}
+    type P >: {B,D}