Fuse CapturingTypes

Author: odersky

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

@@ -12,7 +12,11 @@ object CapturingType:
 
   def apply(parent: Type, refs: CaptureSet, boxed: Boolean = false)(using Context): Type =
     if refs.isAlwaysEmpty then parent
-    else AnnotatedType(parent, CaptureAnnotation(refs, boxed)(defn.RetainsAnnot))
+    else parent match
+      case parent @ CapturingType(parent1, refs1) if boxed || !parent.isBoxed =>
+        apply(parent1, refs ++ refs1, boxed)
+      case _ =>
+        AnnotatedType(parent, CaptureAnnotation(refs, boxed)(defn.RetainsAnnot))
 
   def unapply(tp: AnnotatedType)(using Context): Option[(Type, CaptureSet)] =
     if ctx.phase == Phases.checkCapturesPhase && tp.annot.symbol == defn.RetainsAnnot then

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

@@ -28,7 +28,7 @@ extends tpd.TreeTraverser:
 
   private def box(tp: Type)(using Context): Type = tp.dealias match
     case tp @ CapturingType(parent, refs) if !tp.isBoxed =>
-      CapturingType(parent, refs, boxed = true)
+      tp.boxed
     case tp1 @ AppliedType(tycon, args) if defn.isNonRefinedFunction(tp1) =>
       val res = args.last
       val boxedRes = box(res)

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

@@ -531,7 +531,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         case _ =>
           expected
       val normActual = adaptBoxed(actual, expected1, tree.srcPos)
-      //println(i"check conforms $actual1 <<< $expected1")
+      //println(i"check conforms $normActual <<< $expected1")
       super.checkConformsExpr(normActual, expected1, tree)
 
     /** Adapt `actual` type to `expected` type by inserting boxing and unboxing conversions */

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

@@ -19,7 +19,7 @@ def handle[E <: Exception, R <: Top](op: CanThrow[E] => R)(handler: E => R): R =
   catch case ex: E => handler(ex)
 
 def test =
-  val a = handle[Exception, CanThrow[Exception]] { // error !!! was for 2nd arg
+  val a = handle[Exception, CanThrow[Exception]] { // error
     (x: CanThrow[Exception]) => x
   }{
     (ex: Exception) => ???

tests/pos-custom-args/captures/lazylists-mono.scala

@@ -24,4 +24,4 @@ def test(E: Cap) =
       if xs.isEmpty then LazyNil
       else
         val cons = () => (f(xs.head), xs.tail.map(f))
-        new LazyCons(cons.asInstanceOf) // !!!
+        LazyCons(cons)

tests/run-custom-args/captures/colltest5/Test_2.scala

@@ -78,13 +78,9 @@ object Test {
     val x5 = xs.to(List)
     val y5: {x5} List[Int] = x5
     val (xs6, xs7) = xs.partition(isEven)
-      .asInstanceOf[({xs, isEven} View[Int], {xs, isEven} View[Int])]
-        // !!! fails deep subtyping test without the cast
     val ys6: {xs6, isEven} View[Int] = xs6
     val ys7: {xs7, isEven} View[Int] = xs7
     val (xs6a, xs7a) = xs.partition(_ % 2 == 0)
-      .asInstanceOf[({xs} View[Int], {xs} View[Int])]
-        // !!! fails deep subtyping test without the cast
     val ys6a: {xs6} View[Int] = xs6
     val ys7a: {xs7} View[Int] = xs7
     val xs8 = xs.drop(2)