Auto-boxing of arguments of applied types

Author: odersky

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

@@ -43,7 +43,11 @@ extension (tp: Type)
 
   def boxed(using Context): Type = tp.dealias match
     case tp @ CapturingType(parent, refs) =>
-      def boxedTp = CapturingType(parent, refs, boxed = true)
+      def boxedTp = parent.boxed match
+        case CapturingType(parent1, refs1) =>
+          CapturingType(parent1, refs ++ refs1, boxed = true)
+        case parent1 =>
+          CapturingType(parent1, refs, boxed = true)
       if tp.isBoxed || refs.isAlwaysEmpty then tp
       else tp.annot match
         case ann: CaptureAnnotation =>
@@ -57,6 +61,12 @@ extension (tp: Type)
     case _ =>
       tp
 
+  def boxedUnlessFun(tycon: Type)(using Context) =
+    if ctx.phase != Phases.checkCapturesPhase || defn.isFunctionClass(tycon.typeSymbol)
+    then tp
+    else tp.boxed
+        //.showing(i"boxedUF $tp in $tycon = $result")
+
   /** The boxed capture set of a type */
   def boxedCaptured(using Context): CaptureSet =
     def getBoxed(tp: Type): CaptureSet = tp match

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -246,5 +246,5 @@ object Config {
    */
   inline val ccAllowUnsoundMaps = false
 
-  @annotation.internal.sharable var checkBoxes = true
+  val checkBoxes = true
 }

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

@@ -12,6 +12,7 @@ import Names._
 import Flags.{Module, Provisional}
 import dotty.tools.dotc.config.Config
 import cc.CaptureSet.IdentityCaptRefMap
+import cc.boxedUnlessFun
 
 object TypeApplications {
 
@@ -494,7 +495,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  Existential types in arguments are returned as TypeBounds instances.
    */
   final def argInfos(using Context): List[Type] = self.stripped match {
-    case AppliedType(tycon, args) => args
+    case AppliedType(tycon, args) => args.mapconserve(_.boxedUnlessFun(tycon))
     case _ => Nil
   }
 

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

@@ -23,7 +23,7 @@ import typer.ProtoTypes.constrained
 import typer.Applications.productSelectorTypes
 import reporting.trace
 import annotation.constructorOnly
-import cc.{CapturingType, derivedCapturingType, CaptureSet, stripCapturing, isBoxedCapturing}
+import cc.{CapturingType, derivedCapturingType, CaptureSet, stripCapturing, isBoxedCapturing, boxedUnlessFun}
 
 /** Provides methods to compare types.
  */
@@ -1635,7 +1635,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
                 else if v > 0 then isSubType(arg1, arg2)
                 else isSameType(arg2, arg1)
 
-        isSubArg(args1.head, args2.head)
+        isSubArg(args1.head.boxedUnlessFun(tp1), args2.head.boxedUnlessFun(tp1))
       } && recurArgs(args1.tail, args2.tail, tparams2.tail)
 
     recurArgs(args1, args2, tparams2)

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

@@ -36,7 +36,7 @@ import config.Printers.{core, typr, matchTypes}
 import reporting.{trace, Message}
 import java.lang.ref.WeakReference
 import compiletime.uninitialized
-import cc.{CapturingType, CaptureSet, derivedCapturingType, retainedElems, isBoxedCapturing, EventuallyCapturingType}
+import cc.{CapturingType, CaptureSet, derivedCapturingType, retainedElems, isBoxedCapturing, EventuallyCapturingType, boxedUnlessFun}
 import CaptureSet.{CompareResult, IdempotentCaptRefMap, IdentityCaptRefMap}
 
 import scala.annotation.internal.sharable
@@ -2538,15 +2538,15 @@ object Types {
       val cls = tparam.owner
       val base = pre.baseType(cls)
       base.stripped match {
-        case AppliedType(_, allArgs) =>
+        case AppliedType(tycon, allArgs) =>
           var tparams = cls.typeParams
           var args = allArgs
           var idx = 0
           while (tparams.nonEmpty && args.nonEmpty) {
             if (tparams.head.eq(tparam))
               return args.head match {
                 case _: TypeBounds if !widenAbstract => TypeRef(pre, tparam)
-                case arg => arg
+                case arg => arg.boxedUnlessFun(tycon)
               }
             tparams = tparams.tail
             args = args.tail

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

@@ -121,9 +121,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           // ^^^ TODO: Can we avoid doing overrides checks twice?
           // We need to do them here since only at this phase CaptureTypes are relevant
           // But maybe we can then elide the check during the RefChecks phase if -Ycc is set?
-          Config.checkBoxes = false // !!!
           checkAllOverrides(ctx.owner.asClass)
-          Config.checkBoxes = true // !!!
         case _ =>
       traverseChildren(t)
 

tests/neg-custom-args/captures/vars.check

@@ -15,13 +15,6 @@
    |  ^^^^^^
    |  The expression's type box {*} String -> String is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars.scala:21:13 -----------------------------------------
-21 |    b = List(g) // error !!! Probably spurious due to box comparison
-   |             ^
-   |             Found:    Seq[{cap3} String -> ? String]
-   |             Required: Seq[box {cap3} (x$0: ? String) -> ? String]
-   |
-   | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/vars.scala:30:8 ---------------------------------------------------------------
 30 |  local { cap3 => // error
    |  ^

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

@@ -18,7 +18,7 @@ def test(cap1: Cap, cap2: Cap) =
     val cap3: Cap = CC()
     def g(x: String): String = if cap3 == cap3 then "" else "a"
     a = g
-    b = List(g) // error !!! Probably spurious due to box comparison
+    b = List(g)
     val gc = g
     g