Always requires hats on capture var definitions

Author: noti0na1

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

@@ -1132,7 +1132,7 @@ class Namer { typer: Typer =>
       ensureUpToDate(sym.typeRef, dummyInfo1)
       if (dummyInfo2 `ne` dummyInfo1) ensureUpToDate(sym.typeRef, dummyInfo2)
 
-      if sym.info.derivesFrom(defn.Caps_CapSet) then
+      if original.hasAttachment(Trees.CaptureVar) then
         addDummyTermCaptureParam(sym)(using ictx)
 
       sym.info

tests/neg-custom-args/captures/branding.scala

@@ -11,7 +11,7 @@ def main() =
     def log(msg: String): Unit
 
   // we can close over anything subsumed by the 'trusted' brand capability, but nothing else
-  def runSecure[C >: {trusted} <: {trusted}](block: () ->{C} Unit): Unit = block()
+  def runSecure[C^ >: {trusted} <: {trusted}](block: () ->{C} Unit): Unit = block()
 
   // This is a 'brand" capability to mark what can be mentioned in trusted code
   object trusted extends caps.Capability

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

@@ -7,7 +7,6 @@ case class File(io: IO^)
 
 def test(io1: IO^, io2: IO^) =
   def f[C^ >: {io1}](file: File^{C}) = ???
-  def g[C >: {io1}](file: File^{C}) = ???
   val f1: File^{io1} = ???
   val f2: File^{io2} = ???
   val f3: File^{io1, io2} = ???
@@ -17,11 +16,4 @@ def test(io1: IO^, io2: IO^) =
   f[{io2}](f2) // error
   f[{io1, io2}](f1)
   f[{io1, io2}](f2)
-  f[{io1, io2}](f3)
-  g[{io1}](f1)
-  g[{io1}](f2) // error
-  g[{io1}](f3) // error
-  g[{io2}](f2) // error
-  g[{io1, io2}](f1)
-  g[{io1, io2}](f2)
-  g[{io1, io2}](f3)
+  f[{io1, io2}](f3)

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

@@ -2,7 +2,7 @@ import language.experimental.captureChecking
 import caps.*
 
 trait Abstract[X^]:
-  type C >: {X}
+  type C^ >: {X}
   // Don't test the return type using Unit, because it is a pure type.
   def boom(): AnyRef^{C}
 

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

@@ -8,7 +8,7 @@ def test =
   def onlyWithZ[C^](using c: Contains[C, z.type]) = ???
 
   trait Foo:
-    type C >: {z,x} <: {x,y,z}
+    type C^ >: {z,x} <: {x,y,z}
 
   val foo: Foo = ???
   onlyWithZ[{foo.C}]

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

@@ -10,22 +10,22 @@ 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 // error
-    type E <: {C}
-    type F <: {C}
-    type G <: {x, y}
-    type H >: {x} <: {x,y} : Ctx // error
+    type E^ <: {C}
+    type F^ <: {C}
+    type G^ <: {x, y}
+    type H^ >: {x} <: {x,y} : Ctx // error
     type I^ = {y, G, H}
     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 P >: {B,D} // error
-    type Q >: {E} <: Int // error
+    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} // error
+    type Q^ >: {E} <: Int // error
     type R^ >: {E} <: Int // error
     type S^ >: Nothing <: Int // error
     type T >: Nothing <: Int

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

@@ -2,7 +2,7 @@ import caps.*
 
 class C
 
-def test[X^, Y^, Z >: X <: Y](x: C^{X}, y: C^{Y}, z: C^{Z}) =
+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/pos-custom-args/captures/cap-paramlist8-desugared.scala

@@ -11,14 +11,14 @@
         val z: Any^{cap} = ???
       }
       val baz3:
-        Int -> [C >: caps.CapSet <: caps.CapSet^,
-          D >: caps.CapSet <: caps.CapSet^{C}, E >: caps.CapSet <:
-          caps.CapSet^{C, x}] => () -> [F >: caps.CapSet^{x, y} <:
+        Int -> [C^ >: caps.CapSet <: caps.CapSet^,
+          D^ >: caps.CapSet <: caps.CapSet^{C}, E^ >: caps.CapSet <:
+          caps.CapSet^{C, x}] => () -> [F^ >: caps.CapSet^{x, y} <:
           caps.CapSet^{C, E}] => (x: Int) -> (Ctx[F]) ?-> Int
         = (i: Int) => [
-        C >: _root_.scala.caps.CapSet <: _root_.scala.caps.CapSet^{cap},
-        D >: _root_.scala.caps.CapSet <: _root_.scala.caps.CapSet^{C},
-        E >: _root_.scala.caps.CapSet <: _root_.scala.caps.CapSet^{C, x}] =>
+        C^ >: _root_.scala.caps.CapSet <: _root_.scala.caps.CapSet^{cap},
+        D^ >: _root_.scala.caps.CapSet <: _root_.scala.caps.CapSet^{C},
+        E^ >: _root_.scala.caps.CapSet <: _root_.scala.caps.CapSet^{C, x}] =>
         () => [
         F
             >: _root_.scala.caps.CapSet^{x, y} <:

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

@@ -5,17 +5,17 @@ def test =
   val y: Any^ = ???
   object O:
     val z: Any^ = ???
-  def foo[A >: {y} <: {x},
+  def foo[A^ >: {y} <: {x},
           B^,
-          C <: {x},
+          C^ <: {x},
           D^,
-          E <: {C},
-          F <: {C},
-          G <: {x, y},
-          H >: {x} <: {x,y}, 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},
-                                            N >: {x} <: {x},
-                                            O >: {O.z} <: {O.z}] = ???
+          E^ <: {C},
+          F^ <: {C},
+          G^ <: {x, y},
+          H^ >: {x} <: {x,y}, 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},
+                                            N^ >: {x} <: {x},
+                                            O^ >: {O.z} <: {O.z}] = ???

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

@@ -7,18 +7,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^
-    type E <: {C}
-    type F <: {C}
-    type G <: {x, y}
-    type H >: {x} <: {x,y}
+    type E^ <: {C}
+    type F^ <: {C}
+    type G^ <: {x, y}
+    type H^ >: {x} <: {x,y}
     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 P >: {B,D}
+    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}

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

@@ -2,13 +2,13 @@ import language.experimental.captureChecking
 import caps.*
 
 trait AbstractWrong:
-  type C <: CapSet // no longer an error, the lower bound becomes CapSet now
+  type C^ <: CapSet // no longer an error, the lower bound becomes CapSet now
   def f(): Unit^{C}
 
 trait Abstract1:
-  type C >: CapSet <: CapSet^
+  type C^ >: CapSet <: CapSet^
   def f(): Unit^{C}
 
 trait Abstract2:
-  type C <: {cap}
+  type C^ <: {cap}
   def f(): Unit^{C}

tests/pos-custom-args/captures/invariant-cc.scala.disabled renamed to tests/pos-custom-args/captures/invariant-cc.scala

@@ -3,8 +3,6 @@ import scala.annotation.unchecked.uncheckedVariance
 
 trait IterableFactory[+CC[_]] extends Pure:
 
-  // TODO: elem.type is not a singleton type
-
   def fill[A](n: Int)(elem: => A): CC[A]^{elem} = ???
   def fill[A](n1: Int, n2: Int)(elem: => A): CC[(CC[A]^{elem}) @uncheckedVariance]^{elem} =
   	fill[CC[A]^{elem}](n1)(fill(n2)(elem))

tests/pos/i22257.scala

@@ -24,3 +24,11 @@ type Bound5 <: FP5
 type Node6   = NodeK { type FBound <: Bound6 }
 type Bound6 <: FP6
 type FP6     = Fixed[Node6]
+
+// type X^
+// type Y^
+// type Z >: X <: Y
+// val Z
+
+
+// type C <: