Fix test

Author: noti0na1

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

@@ -536,7 +536,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     else
       val trefs =
         if refs.isEmpty then ref(defn.NothingType)
-        // TODO: choose a reduce direction
         else refs.map(SingletonTypeTree).reduce[Tree]((a, b) => makeOrType(a, b))
       annot = New(AppliedTypeTree(annot, trefs :: Nil), Nil)
       annot.putAttachment(RetainsAnnot, ())

compiler/src/dotty/tools/dotc/cc/Setup.scala

@@ -932,15 +932,10 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
    */
   private def checkWellformed(parent: Type, ann: Tree, tpt: Tree)(using Context): Unit =
     capt.println(i"checkWF post $parent ${ann.retainedSet} in $tpt")
-    var retained = ann.retainedSet.retainedElems.toArray
-    for i <- 0 until retained.length do
-      val refTree = retained(i)
-      val refs =
-        try refTree.toCaptureRefs
-        catch case ex: IllegalCaptureRef =>
-          report.error(em"Illegal capture reference: ${ex.getMessage}", refTree.srcPos)
-          Nil
-      for ref <- refs do
+    try
+      var retained = ann.retainedSet.retainedElements.toArray
+      for i <- 0 until retained.length do
+        val ref = retained(i)
         def pos =
           if ann.span.exists then ann.srcPos
           else tpt.srcPos
@@ -958,15 +953,15 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
 
         val others =
           for
-            j <- 0 until retainedRefs.length if j != i
-            r = retainedRefs(j)
+            j <- 0 until retained.length if j != i
+            r = retained(j)
             if !r.isRootCapability
           yield r
         val remaining = CaptureSet(others*)
         check(remaining, remaining)
       end for
     catch case ex: IllegalCaptureRef =>
-      report.error(em"Illegal capture reference: ${ex.getMessage.nn}", tpt.srcPos)
+      report.error(em"Illegal capture reference: ${ex.getMessage}", tpt.srcPos)
   end checkWellformed
 
   /** Check well formed at post check time. We need to wait until after

compiler/src/dotty/tools/dotc/transform/Getters.scala

@@ -89,7 +89,7 @@ class Getters extends MiniPhase with SymTransformer { thisPhase =>
       else d1 = d1.copySymDenotation(initFlags = d1.flags &~ Local)
     d1
   }
-  private val NoGetterNeededFlags = Method | Param | JavaDefined | JavaStatic
+  private val NoGetterNeededFlags = Method | Param | JavaDefined | JavaStatic | CaptureParam
 
   val newSetters = util.HashSet[Symbol]()
 

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

@@ -9,6 +9,6 @@ def test(cap1: Cap, cap2: Cap): I^{cap1} =
   def f() = if cap1 == cap1 then I() else I()
   def h(x: ->{cap} I) = x
   h(f()) // OK
-  def hh(x: -> I @retainsByName(cap1)) = x
+  def hh(x: -> I @retainsByName[cap1.type]) = x
   h(f())
 

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

@@ -2,6 +2,6 @@ object Test:
 
   def test() =
     val x: Any^ = "abc"
-    val y: Object @scala.annotation.retains(x) = ???
-    val z: Object @scala.annotation.retains(x, caps.cap) = y: Object @annotation.retains(x)
+    val y: Object @scala.annotation.retains[x.type] = ???
+    val z: Object @scala.annotation.retains[x.type | caps.cap.type] = y: Object @annotation.retains[x.type]
 

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

@@ -1,3 +1,4 @@
+import language.experimental.captureChecking
 // Showing a problem with recursive references
 object CollectionStrawMan5 {
 
@@ -17,14 +18,13 @@ object CollectionStrawMan5 {
   trait View[+A] extends Iterable[A] with IterableLike[A]
 
   case class Partition[A](val underlying: Iterable[A]^, p: A => Boolean) {
-    self: Partition[A]^{underlying, p} =>
 
     class Partitioned(expected: Boolean) extends View[A]:
-      this: Partitioned^{self} =>
+      this: Partitioned^{Partition.this} =>
       def iterator: Iterator[A]^{this} =
         underlying.iterator.filter((x: A) => p(x) == expected)
 
-    val left: Partitioned^{self} = Partitioned(true)
-    val right: Partitioned^{self} = Partitioned(false)
+    val left: Partitioned^{Partition.this} = Partitioned(true)
+    val right: Partitioned^{Partition.this} = Partitioned(false)
   }
 }

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

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

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

@@ -8,6 +8,8 @@ import annotation.tailrec
 import caps.cap
 import caps.unsafe.unsafeAssumeSeparate
 
+import language.experimental.captureChecking
+
 /** A strawman architecture for new collections. It contains some
  *  example collection classes and methods with the intent to expose
  *  some key issues. It would be good to compare this to other
@@ -448,7 +450,6 @@ object CollectionStrawMan5 {
     }
 
     case class Filter[A](val underlying: Iterable[A]^, p: A => Boolean) extends View[A] {
-      this: Filter[A]^{underlying, p} =>
       def iterator: Iterator[A]^{this} = underlying.iterator.filter(p)
     }
 
@@ -466,37 +467,31 @@ object CollectionStrawMan5 {
           case _ => new Filter(underlying, pp)
 
     case class Partition[A](val underlying: Iterable[A]^, p: A => Boolean) {
-      self: Partition[A]^{underlying, p} =>
-
       class Partitioned(expected: Boolean) extends View[A]:
-        this: Partitioned^{self} =>
+        this: Partitioned^{Partition.this} =>
         def iterator: Iterator[A]^{this} =
           underlying.iterator.filter((x: A) => p(x) == expected)
 
-      val left: Partitioned^{self} = Partitioned(true)
-      val right: Partitioned^{self} = Partitioned(false)
+      val left: Partitioned^{this} = Partitioned(true)
+      val right: Partitioned^{this} = Partitioned(false)
     }
 
     case class Drop[A](underlying: Iterable[A]^, n: Int) extends View[A] {
-      this: Drop[A]^{underlying} =>
       def iterator: Iterator[A]^{this} = underlying.iterator.drop(n)
       override def knownLength =
         if (underlying.knownLength >= 0) underlying.knownLength - n max 0 else -1
     }
 
     case class Map[A, B](underlying: Iterable[A]^, f: A => B) extends View[B] {
-      this: Map[A, B]^{underlying, f} =>
       def iterator: Iterator[B]^{this} = underlying.iterator.map(f)
       override def knownLength = underlying.knownLength
     }
 
     case class FlatMap[A, B](underlying: Iterable[A]^, f: A => IterableOnce[B]^) extends View[B] {
-      this: FlatMap[A, B]^{underlying, f} =>
       def iterator: Iterator[B]^{this} = underlying.iterator.flatMap(f)
     }
 
     case class Concat[A](underlying: Iterable[A]^, other: IterableOnce[A]^) extends View[A] {
-      this: Concat[A]^{underlying, other} =>
       def iterator: Iterator[A]^{this} = underlying.iterator ++ other
       override def knownLength = other match {
         case other: Iterable[_] if underlying.knownLength >= 0 && other.knownLength >= 0 =>
@@ -507,7 +502,6 @@ object CollectionStrawMan5 {
     }
 
     case class Zip[A, B](underlying: Iterable[A]^, other: IterableOnce[B]^) extends View[(A, B)] {
-      this: Zip[A, B]^{underlying, other} =>
       def iterator: Iterator[(A, B)]^{this} = underlying.iterator.zip(other)
       override def knownLength = other match {
         case other: Iterable[_] if underlying.knownLength >= 0 && other.knownLength >= 0 =>