Don't avoid elements of hidden sets

It fixes one of the problems in sep-pairs. It probably won't matter anymore for
correctness once we revise overlap calculations, but it will give better error
messages.

Author: odersky

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

@@ -17,6 +17,7 @@ import typer.ErrorReporting.Addenda
 import util.common.alwaysTrue
 import scala.collection.{mutable, immutable}
 import CCState.*
+import TypeOps.AvoidMap
 
 /** A class for capture sets. Capture sets can be constants or variables.
  *  Capture sets support inclusion constraints <:< where <:< is subcapturing.
@@ -329,6 +330,8 @@ sealed abstract class CaptureSet extends Showable:
       else BiMapped(asVar, tm, mappedElems)
     case tm: IdentityCaptRefMap =>
       this
+    case tm: AvoidMap if this.isInstanceOf[HiddenSet] =>
+      this
     case _ =>
       val mapped = mapRefs(elems, tm, tm.variance)
       if isConst then

tests/neg-custom-args/captures/sep-pairs.scala

@@ -0,0 +1,45 @@
+import caps.Mutable
+import caps.cap
+
+class Ref extends Mutable:
+  var x = 0
+  def get: Int = x
+  mut def put(y: Int): Unit = x = y
+
+class Pair[+X, +Y](val fst: X, val snd: Y)
+
+def mkPair[X](x: X): Pair[X, X] = Pair(x, x)
+
+def bad: Pair[Ref^, Ref^] =  // error: overlap at r1*, r0
+  val r0 = Ref()
+  val r1: Pair[Ref^, Ref^] = mkPair(r0) // error: overlap at r0
+  r1
+
+class SamePair[+X](val fst: X, val snd: X)
+
+def twoRefs(): Pair[Ref^, Ref^] =
+  val r1 = Ref()
+  val r2 = Ref()
+  Pair(r1, r2)
+
+def twoRefs2(): SamePair[Ref^] =
+  val r1 = Ref()
+  val r2 = Ref()
+  val r3: SamePair[Ref^] = SamePair(r1, r1) // ok
+  r3
+
+def twoRefsBad(): Pair[Ref^, Ref^] =
+  Pair(Ref(), Ref()) // error // error: universal capability cannot be included in capture set
+                     // but should work since this is morally equivalent to `twoRefs`
+
+def test(io: Object^): Unit =
+  val two = twoRefs()
+  val fst: Ref^{two.fst*} = two.fst
+  val snd: Ref^{two.snd*} = two.snd
+
+  val two2 = twoRefs2()
+  val fst2 = two.fst
+  val snd2 = two.snd
+
+  val p2: Pair[Ref^, Ref^] = Pair(fst, snd) // should be error
+