Fix glb logic involving capturing types

Author: odersky

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

@@ -227,6 +227,14 @@ extension (tp: Type)
       case tp: OrType => tp.tp1.isBoxedCapturing || tp.tp2.isBoxedCapturing
       case _ => false
 
+  /** Is the box status of `tp` and `tp2` compatible? I.ee  they are
+   *  box boxed, or both unboxed, or one of them has an empty capture set.
+   */
+  def isBoxCompatibleWith(tp2: Type)(using Context): Boolean =
+    isBoxedCapturing == tp2.isBoxedCapturing
+    || tp.captureSet.isAlwaysEmpty
+    || tp2.captureSet.isAlwaysEmpty
+
   /** If this type is a capturing type, the version with boxed statues as given by `boxed`.
    *  If it is a TermRef of a capturing type, and the box status flips, widen to a capturing
    *  type that captures the TermRef.

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

@@ -2403,7 +2403,8 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     else
       def mergedGlb(tp1: Type, tp2: Type): Type =
         val tp1a = dropIfSuper(tp1, tp2)
-        if tp1a ne tp1 then glb(tp1a, tp2)
+        if tp1a ne tp1 then
+          glb(tp1a, tp2)
         else
           val tp2a = dropIfSuper(tp2, tp1)
           if tp2a ne tp2 then glb(tp1, tp2a)
@@ -2721,11 +2722,11 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     case tp1: TypeVar if tp1.isInstantiated =>
       tp1.underlying & tp2
     case CapturingType(parent1, refs1) =>
-      val refs2 = tp2.captureSet
-      if subCaptures(refs2, refs1, frozen = true).isOK
-        && tp1.isBoxedCapturing == tp2.isBoxedCapturing
-      then (parent1 & tp2).capturing(refs2)
-      else tp1.derivedCapturingType(parent1 & tp2, refs1)
+      val jointRefs = refs1 ** tp2.captureSet
+      if jointRefs.isAlwaysEmpty then parent1 & tp2
+      else if tp1.isBoxCompatibleWith(tp2) then
+        tp1.derivedCapturingType(parent1 & tp2, jointRefs)
+      else NoType
     case tp1: AnnotatedType if !tp1.isRefining =>
       tp1.underlying & tp2
     case _ =>

tests/pos/gears-probem-1.scala

@@ -0,0 +1,24 @@
+import language.experimental.captureChecking
+
+trait Future[+T]:
+  def await: T
+
+trait Channel[+T]:
+  def read(): Ok[T]
+
+class Collector[T](val futures: Seq[Future[T]^]):
+  val results: Channel[Future[T]^{futures*}] = ???
+end Collector
+
+class Result[+T, +E]:
+  def get: T = ???
+
+case class Err[+E](e: E) extends Result[Nothing, E]
+case class Ok[+T](x: T) extends Result[T, Nothing]
+
+extension [T](fs: Seq[Future[T]^])
+  def awaitAll =
+    val collector//: Collector[T]{val futures: Seq[Future[T]^{fs*}]}
+       = Collector(fs)
+    // val ch = collector.results // also errors
+    val fut: Future[T]^{fs*} = collector.results.read().get // found ...^{caps.cap}

tests/pos/gears-probem.scala

@@ -0,0 +1,18 @@
+import language.experimental.captureChecking
+
+trait Future[+T]:
+  def await: T
+
+trait Channel[T]:
+  def read(): Either[Nothing, T]
+
+class Collector[T](val futures: Seq[Future[T]^]):
+  val results: Channel[Future[T]^{futures*}] = ???
+end Collector
+
+extension [T](fs: Seq[Future[T]^])
+  def awaitAll =
+    val collector: Collector[T]{val futures: Seq[Future[T]^{fs*}]}
+       = Collector(fs)
+    // val ch = collector.results // also errors
+    val fut: Future[T]^{fs*} = collector.results.read().right.get // found ...^{caps.cap}