Don't box arguments of any form of type cast or test

Previously, only asInstanceOf was excluded.

Author: odersky

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

@@ -573,6 +573,7 @@ extension (sym: Symbol)
     && sym != defn.Caps_unsafeBox
     && sym != defn.Caps_unsafeUnbox
     && !defn.isPolymorphicAfterErasure(sym)
+    && !defn.isTypeTestOrCast(sym)
 
   def isRefiningParamAccessor(using Context): Boolean =
     sym.is(ParamAccessor)

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

@@ -563,6 +563,17 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  The implementation picks `C` as `Cq` instead of `Cr`, if
      *   1. The argument(s) Ta are always pure
      *   2. `Cq` might subcapture `Cr`.
+     *  TODO: We could generalize this as follows:
+     *
+     *  If the function `f` does not have an `@unboxed` parameter, then
+     *  any unboxing it does would be charged to the environment of the function
+     *  so they have to appear in Cq. So another approximation of the
+     *  result capability set is `Cq u Ca` where `Ca` is the capture set of the
+     *  argument.
+     *  If the function `f` does have an `@unboxed` parameter, then it could in addition
+     *  unbox reach capabilities over its formal parameter. Therefore, the approximation
+     *  would be `Cq u dcs(Ca)` instead.
+     *  If the approximation is known to subcapture the declared result Cr, we pick it.
      */
     protected override
     def recheckApplication(tree: Apply, qualType: Type, funType: MethodType, argTypes: List[Type])(using Context): Type =

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

@@ -439,12 +439,9 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
 
         case tree @ TypeApply(fn, args) =>
           traverse(fn)
-          fn match
-            case Select(qual, nme.asInstanceOf_) =>
-              // No need to box type arguments of an asInstanceOf call. See #20224.
-            case _ =>
-              for case arg: TypeTree <- args do
-                transformTT(arg, boxed = true, exact = false) // type arguments in type applications are boxed
+          if !defn.isTypeTestOrCast(fn.symbol) then
+            for case arg: TypeTree <- args do
+              transformTT(arg, boxed = true, exact = false) // type arguments in type applications are boxed
 
         case tree: TypeDef if tree.symbol.isClass =>
           val sym = tree.symbol

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

@@ -1768,6 +1768,12 @@ class Definitions {
   def isPolymorphicAfterErasure(sym: Symbol): Boolean =
      (sym eq Any_isInstanceOf) || (sym eq Any_asInstanceOf) || (sym eq Object_synchronized)
 
+  def isTypeTestOrCast(sym: Symbol): Boolean =
+       (sym eq Any_isInstanceOf)
+    || (sym eq Any_asInstanceOf)
+    || (sym eq Any_typeTest)
+    || (sym eq Any_typeCast)
+
   /** Is this type a `TupleN` type?
    *
    * @return true if the dealiased type of `tp` is `TupleN[T1, T2, ..., Tn]`

tests/pos-custom-args/captures/opaque-inline-problem.scala

@@ -0,0 +1,12 @@
+trait Async extends caps.Capability:
+  def group: Int
+
+object Async:
+  inline def current(using async: Async): async.type = async
+  opaque type Spawn <: Async = Async
+  def blocking[T](f: Spawn => T): T = ???
+
+def main() =
+  Async.blocking: spawn =>
+    val c = Async.current(using spawn)
+    val a = c.group