Also treat explicit capturing type arguments as boxed

Author: odersky

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

@@ -30,9 +30,12 @@ extension (tree: Tree)
         tree.putAttachment(Captures, refs)
         refs
 
-  def isBoxedCapturing(using Context) =
+  def isBoxedCapturing(using Context): Boolean =
     tree.hasAttachment(IsBoxed)
 
+  def setBoxedCapturing()(using Context): Unit =
+    tree.putAttachment(IsBoxed, ())
+
 extension (tp: Type)
 
   def derivedCapturingType(parent: Type, refs: CaptureSet)(using Context): Type = tp match

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

@@ -44,7 +44,7 @@ abstract class Recheck extends Phase, IdentityDenotTransformer:
 
   def run(using Context): Unit =
     val rechecker = newRechecker()
-    rechecker.reinferAll.traverse(ctx.compilationUnit.tpdTree)
+    rechecker.transformTypes.traverse(ctx.compilationUnit.tpdTree)
     rechecker.checkUnit(ctx.compilationUnit)
 
   def newRechecker()(using Context): Rechecker
@@ -72,15 +72,15 @@ abstract class Recheck extends Phase, IdentityDenotTransformer:
     def knownType(tree: Tree) =
       tree.attachmentOrElse(RecheckedType, tree.tpe)
 
-    def reinfer(tp: Type)(using Context): Type = tp
+    def transformType(tp: Type, inferred: Boolean)(using Context): Type = tp
 
-    object reinferAll extends TreeTraverser:
+    object transformTypes extends TreeTraverser:
       def traverse(tree: Tree)(using Context) =
         traverseChildren(tree)
         tree match
-          case tree: InferredTypeTree =>
-            reinfer(tree.tpe).rememberFor(tree)
-          case tree: ValOrDefDef if tree.tpt.isInstanceOf[InferredTypeTree] =>
+          case tree: TypeTree =>
+            transformType(tree.tpe, tree.isInstanceOf[InferredTypeTree]).rememberFor(tree)
+          case tree: ValOrDefDef if tree.tpt.hasAttachment(RecheckedType) =>
             val sym = tree.symbol
             def integrateRT(restp: Type, info: Type, psymss: List[List[Symbol]]): Type = info match
               case info: MethodOrPoly =>
@@ -96,9 +96,9 @@ abstract class Recheck extends Phase, IdentityDenotTransformer:
               sym.updateInfo(info1)
           case tree: Bind =>
             val sym = tree.symbol
-            sym.updateInfo(reinfer(sym.info))
+            sym.updateInfo(transformType(sym.info, inferred = true))
           case _ =>
-    end reinferAll
+    end transformTypes
 
     def constFold(tree: Tree, tp: Type)(using Context): Type =
       val tree1 = tree.withType(tp)

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

@@ -99,17 +99,17 @@ class CheckCaptures extends Recheck:
   class CaptureChecker(ictx: Context) extends Rechecker(ictx):
     import ast.tpd.*
 
-    override def reinfer(tp: Type)(using Context): Type =
+    override def transformType(tp: Type, inferred: Boolean)(using Context): Type =
 
-      def mapRefined(tp: RefinedType, core1: Type, rinfo1: Type): Type =
-        if (rinfo1 ne tp.refinedInfo) && defn.isFunctionType(tp)
-        then rinfo1.toFunctionType(isJava = false, alwaysDependent = true)
-        else tp.derivedRefinedType(core1, tp.refinedName, rinfo1)
-
-      val cleanType = new TypeMap:
+      val prepare = new TypeMap:
         def apply(t: Type) = t match
-          case AnnotatedType(parent, annot) if annot.symbol == defn.RetainsAnnot =>
+          case AnnotatedType(parent, annot) if inferred && annot.symbol == defn.RetainsAnnot =>
             apply(parent)
+          case AppliedType(tycon, args) if false && !inferred && !defn.isNonRefinedFunction(t) =>
+            for case AnnotatedType(parent, annot) <- args do
+              if annot.symbol == defn.RetainsAnnot then
+                annot.tree.setBoxedCapturing()
+            mapOver(t)
           case _ =>
             mapOver(t)
 
@@ -180,9 +180,28 @@ class CheckCaptures extends Recheck:
         then CapturingType(tp2, CaptureSet.Var(), boxed)
         else tp2
 
-      addVars(addFunctionRefinements(cleanType(tp)))
-        .showing(i"reinfer $tp --> $result", capt)
-    end reinfer
+      if inferred then
+        val cleanup = new TypeMap:
+          def apply(t: Type) = t match
+            case AnnotatedType(parent, annot) if annot.symbol == defn.RetainsAnnot =>
+              apply(parent)
+            case _ =>
+              mapOver(t)
+        addVars(addFunctionRefinements(cleanup(tp)))
+          .showing(i"reinfer $tp --> $result", capt)
+      else
+        val addBoxes = new TypeTraverser:
+          def traverse(t: Type) =
+            t match
+              case AppliedType(tycon, args) if !defn.isNonRefinedFunction(t) =>
+                for case AnnotatedType(parent, annot) <- args do
+                  if annot.symbol == defn.RetainsAnnot then
+                    annot.tree.setBoxedCapturing()
+              case _ =>
+            traverseChildren(t)
+        addBoxes.traverse(tp)
+        tp
+    end transformType
 
     private var curEnv: Env = Env(NoSymbol, CaptureSet.empty, false, null)
 

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

@@ -47,9 +47,9 @@ def test(c: Cap, d: Cap) =
 
   val a0 = identity[{d, y} Cap => Unit]
   val a1 = zs.map[{d, y} Cap => Unit](a0)
-//  val a2 = zs.map[{d, y} Cap => Unit](identity[{d, y} Cap => Unit])
-//  val a3 = zs.map(identity[{d, y} Cap => Unit])
-//  val a4 = zs.map(identity)
-//  val a2 = map(identity)(zs)
-//  val a3 = m1(identity)(zs)
+  //val a2 = zs.map[{d, y} Cap => Unit](identity[{d, y} Cap => Unit]) // fails
+  val a3 = zs.map(identity[{d, y} Cap => Unit])
+  //val a4 = zs.map(identity) // fails
+  val a5 = map(identity)(zs)
+  val a6 = m1(identity)(zs)