Remove unnecessary ^ in capture set syntax.

Author: noti0na1

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

@@ -91,8 +91,16 @@ object Mode {
    */
   val ImplicitExploration: Mode = newMode(12, "ImplicitExploration")
 
+  /** We are currently inside a capture set.
+   *  A term name could be a capture variable, so we need to
+   *  check that it is valid to use as type name.
+   *  Since this mode is only used during annotation typing,
+   *  we can reuse the value of `ImplicitExploration` to save bits.
+   */
+  val InCaptureSet: Mode = newMode(13, "InCaptureSet")
+
   /** We are currently unpickling Scala2 info */
-  val Scala2Unpickling: Mode = newMode(13, "Scala2Unpickling")
+  val Scala2Unpickling: Mode = newMode(14, "Scala2Unpickling")
 
   /** Signifies one of two possible situations:
    *   1. We are currently checking bounds to be non-empty, so we should not

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

@@ -1591,8 +1591,8 @@ object Parsers {
       case _ => None
     }
 
-    /** CaptureRef  ::=  { SimpleRef `.` } SimpleRef [`*`] [`.` rd]
-     *                |  [ { SimpleRef `.` } SimpleRef `.` ] id `^`
+    /** CaptureRef  ::=  { SimpleRef `.` } SimpleRef [`*`]
+     *                |  [ { SimpleRef `.` } SimpleRef `.` ] id
      */
     def captureRef(): Tree =
 
@@ -1611,12 +1611,6 @@ object Parsers {
             in.nextToken()
             derived(reachRef, nme.CC_READONLY)
           else reachRef
-        else if isIdent(nme.UPARROW) then
-          in.nextToken()
-          atSpan(startOffset(ref)):
-            convertToTypeId(ref) match
-              case ref: RefTree => makeCapsOf(ref)
-              case ref => ref
         else ref
 
       recur(simpleRef())

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

@@ -1116,7 +1116,9 @@ trait Applications extends Compatibility {
             val fun2 = Applications.retypeSignaturePolymorphicFn(fun1, methType)
             simpleApply(fun2, proto)
           case funRef: TermRef =>
-            val app = ApplyTo(tree, fun1, funRef, proto, pt)
+            // println(i"typedApply: $funRef, ${tree.args}, ${funRef.symbol.maybeOwner.isRetains}")
+            val applyCtx = if funRef.symbol.maybeOwner.isRetains then ctx.addMode(Mode.InCaptureSet) else ctx
+            val app = ApplyTo(tree, fun1, funRef, proto, pt)(using applyCtx)
             convertNewGenericArray(
               widenEnumCase(
                 postProcessByNameArgs(funRef, app).computeNullable(),

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

@@ -715,6 +715,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         && ctx.owner.owner.unforcedDecls.lookup(tree.name).exists
     then // we are in the arguments of a this(...) constructor call
       errorTree(tree, em"$tree is not accessible from constructor arguments")
+    else if ctx.mode.is(Mode.InCaptureSet) then
+      // If we are in a capture set and the identifier is not a term name,
+      // try to type it with the same name but as a type
+      typed(untpd.makeCapsOf(untpd.cpy.Ident(tree)(name.toTypeName)), pt)
     else
       errorTree(tree, MissingIdent(tree, kind, name, pt))
   end typedIdent
@@ -920,6 +924,13 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         typedCBSelect(tree0, pt, qual)
       else EmptyTree
 
+    // Otherwise, if we are in a capture set, try to type it as a capture variable
+    // reference (as selecting a type name).
+    def trySelectTypeInCaptureSet() =
+      if ctx.mode.is(Mode.InCaptureSet) && tree0.name.isTypeName then
+        typedSelectWithAdapt(untpd.cpy.Select(tree0)(qual, tree0.name.toTypeName), pt, qual)
+      else EmptyTree
+
     // Otherwise, report an error
     def reportAnError() =
       assignType(tree,
@@ -941,6 +952,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       .orElse(tryDynamic())
       .orElse(trySelectable())
       .orElse(tryCBCompanion())
+      .orElse(trySelectTypeInCaptureSet())
       .orElse(reportAnError())
   end typedSelectWithAdapt
 

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

@@ -5,7 +5,7 @@ class IO
 case class File(io: IO^)
 
 def test(io1: IO^, io2: IO^) =
-  def f[C >: CapSet^{io1} <: CapSet^](file: File^{C^}) = ???
+  def f[C >: CapSet^{io1} <: CapSet^](file: File^{C}) = ???
   val f1: File^{io1} = ???
   val f2: File^{io2} = ???
   val f3: File^{io1, io2} = ???

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

@@ -2,12 +2,11 @@ import caps.*
 
 class IO
 
-def f[C^](io: IO^{C^}) = ???
+def f[C^](io: IO^{C}) = ???
 
 def test =
   f[CapSet](???)
   f[CapSet^{}](???)
   f[CapSet^](???)
   f[Nothing](???) // error
   f[String](???) // error
-  

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

@@ -3,7 +3,7 @@ import caps.*
 trait Abstract[X^]:
   type C >: X <: CapSet^
   // Don't test the return type using Unit, because it is a pure type.
-  def boom(): AnyRef^{C^}
+  def boom(): AnyRef^{C}
 
 class Concrete extends Abstract[CapSet^{}]:
   type C = CapSet^{}
@@ -27,4 +27,3 @@ class Concrete5(a: AnyRef^, b: AnyRef^) extends Abstract[CapSet^{a}]:
 
 class Concrete6(a: AnyRef^, b: AnyRef^) extends Abstract[CapSet^{a}]:
   def boom(): AnyRef^{b} = b // error
-  

tests/neg-custom-args/captures/capture-parameters.scala

@@ -2,8 +2,7 @@ import caps.*
 
 class C
 
-def test[X^, Y^, Z >: X <: Y](x: C^{X^}, y: C^{Y^}, z: C^{Z^}) =
-  val x2z: C^{Z^} = x
-  val z2y: C^{Y^} = z
-  val x2y: C^{Y^} = x // error
-  
+def test[X^, Y^, Z >: X <: Y](x: C^{X}, y: C^{Y}, z: C^{Z}) =
+  val x2z: C^{Z} = x
+  val z2y: C^{Y} = z
+  val x2y: C^{Y} = x // error

tests/neg-custom-args/captures/capture-poly.scala

@@ -5,8 +5,8 @@ trait Foo extends Capability
 trait CaptureSet:
   type C >: CapSet <: CapSet^
 
-def capturePoly[C^](a: Foo^{C^}): Foo^{C^} = a
-def capturePoly2(c: CaptureSet)(a: Foo^{c.C^}): Foo^{c.C^} = a
+def capturePoly[C^](a: Foo^{C}): Foo^{C} = a
+def capturePoly2(c: CaptureSet)(a: Foo^{c.C}): Foo^{c.C} = a
 
 def test =
   val x: Foo^ = ???
@@ -15,8 +15,8 @@ def test =
   object X extends CaptureSet:
     type C = CapSet^{x}
 
-  val z1: Foo^{X.C^} = x
-  val z2: Foo^{X.C^} = y // error
+  val z1: Foo^{X.C} = x
+  val z2: Foo^{X.C} = y // error
 
   val z3: Foo^{x} = capturePoly(x)
   val z4: Foo^{x} = capturePoly(y) // error

tests/neg-custom-args/captures/capture-vars-subtyping.scala

@@ -3,32 +3,32 @@ import caps.*
 
 def test[C^] =
   val a: C = ???
-  val b: CapSet^{C^} = a
+  val b: CapSet^{C} = a
   val c: C = b
-  val d: CapSet^{C^, c} = a
+  val d: CapSet^{C, c} = a
 
 // TODO: make "CapSet-ness" of type variables somehow contagious?
 // Then we don't have to spell out the bounds explicitly...
 def testTrans[C^, D >: CapSet <: C, E >: CapSet <: D, F >: C <: CapSet^] =
   val d1: D = ???
-  val d2: CapSet^{D^} = d1
+  val d2: CapSet^{D} = d1
   val d3: D = d2
   val e1: E = ???
-  val e2: CapSet^{E^} = e1
+  val e2: CapSet^{E} = e1
   val e3: E = e2
   val d4: D = e1
   val c1: C = d1
   val c2: C = e1
   val f1: F = c1
-  val d_e_f1: CapSet^{D^,E^,F^} = d1
-  val d_e_f2: CapSet^{D^,E^,F^} = e1
-  val d_e_f3: CapSet^{D^,E^,F^} = f1
+  val d_e_f1: CapSet^{D,E,F} = d1
+  val d_e_f2: CapSet^{D,E,F} = e1
+  val d_e_f3: CapSet^{D,E,F} = f1
   val f2: F = d_e_f1
   val c3: C = d_e_f1 // error
   val c4: C = f1     // error
   val e4: E = f1     // error
   val e5: E = d1     // error
-  val c5: CapSet^{C^} = e1
+  val c5: CapSet^{C} = e1
 
 
 trait A[+T]
@@ -37,12 +37,12 @@ trait B[-C]
 
 def testCong[C^, D^] =
   val a: A[C] = ???
-  val b: A[CapSet^{C^}] = a
-  val c: A[CapSet^{D^}] = a // error
-  val d: A[CapSet^{C^,D^}] = a
+  val b: A[CapSet^{C}] = a
+  val c: A[CapSet^{D}] = a // error
+  val d: A[CapSet^{C,D}] = a
   val e: A[C] = d // error
   val f: B[C] = ???
-  val g: B[CapSet^{C^}] = f
+  val g: B[CapSet^{C}] = f
   val h: B[C] = g
-  val i: B[CapSet^{C^,D^}] = h // error
+  val i: B[CapSet^{C,D}] = h // error
   val j: B[C] = i