Several fixes to boxing

 1. Update info of TypeDef symbols to account for boxing. Previously, the
    changes were made to the tree, but were not propagated to the symbol.
 2. Maintain alias types when adding boxes.
 3. Don't accidentally widen in addResultBoxes. The boxmap pos test started
    failing after (1), (2) before the fix (3) was added.

Fixes #15749

Author: odersky

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

@@ -49,6 +49,8 @@ extends tpd.TreeTraverser:
     def apply(t: Type) = mapOver(t) match
       case t1 @ AppliedType(tycon, args) if !defn.isNonRefinedFunction(t1) =>
         t1.derivedAppliedType(tycon, args.mapConserve(box))
+      case t1: AliasingBounds =>
+        t1.derivedAlias(t1.alias)
       case t1 @ TypeBounds(lo, hi) =>
         t1.derivedTypeBounds(box(lo), box(hi))
       case t1 =>
@@ -337,6 +339,9 @@ extends tpd.TreeTraverser:
       then transformInferredType(tree.tpe, boxed)
       else transformExplicitType(tree.tpe, boxed))
 
+  private def updateInfo(sym: Symbol, tpe: Type)(using Context) =
+    sym.updateInfoBetween(preRecheckPhase, thisPhase, tpe)
+
   def traverse(tree: Tree)(using Context): Unit =
     tree match
       case tree: DefDef if isExcluded(tree.symbol) =>
@@ -388,11 +393,10 @@ extends tpd.TreeTraverser:
               def complete(denot: SymDenotation)(using Context) =
                 denot.info = newInfo
                 recheckDef(tree, sym)
-            sym.updateInfoBetween(preRecheckPhase, thisPhase, completer)
+            updateInfo(sym, completer)
       case tree: Bind =>
         val sym = tree.symbol
-        sym.updateInfoBetween(preRecheckPhase, thisPhase,
-          transformInferredType(sym.info, boxed = false))
+        updateInfo(sym, transformInferredType(sym.info, boxed = false))
       case tree: TypeDef if tree.symbol.isClass =>
         val cls = tree.symbol.asClass
         val cinfo @ ClassInfo(prefix, _, ps, decls, selfInfo) = cls.classInfo
@@ -401,12 +405,18 @@ extends tpd.TreeTraverser:
           val newInfo = ClassInfo(prefix, cls, ps, decls,
             CapturingType(cinfo.selfType, localRefs)
               .showing(i"inferred self type for $cls: $result", capt))
-          cls.updateInfoBetween(preRecheckPhase, thisPhase, newInfo)
+          updateInfo(cls, newInfo)
           cls.thisType.asInstanceOf[ThisType].invalidateCaches()
           if cls.is(ModuleClass) then
             val modul = cls.sourceModule
-            modul.updateInfoBetween(preRecheckPhase, thisPhase,
-              CapturingType(modul.info, localRefs))
+            updateInfo(modul, CapturingType(modul.info, localRefs))
             modul.termRef.invalidateCaches()
+      case tree: TypeDef =>
+        val info = atPhase(preRecheckPhase)(tree.symbol.info)
+        val newInfo = transformExplicitType(info, boxed = false)
+        if newInfo ne info then
+          updateInfo(tree.symbol, newInfo)
+          capt.println(i"update info of ${tree.symbol} from $info to $newInfo")
+
       case _ =>
 end Setup

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

@@ -138,7 +138,7 @@ abstract class Recheck extends Phase, SymTransformer:
             excluded = if tree.symbol.is(Private) then EmptyFlags else Private
           ).suchThat(tree.symbol == _)
         constFold(tree, qualType.select(name, mbr))
-          //.showing(i"recheck select $qualType . $name : ${mbr.symbol.info} = $result")
+          //.showing(i"recheck select $qualType . $name : ${mbr.info} = $result")
 
     def recheckBind(tree: Bind, pt: Type)(using Context): Type = tree match
       case Bind(name, body) =>
@@ -204,6 +204,7 @@ abstract class Recheck extends Phase, SymTransformer:
               Nil
           val argTypes = recheckArgs(tree.args, formals, fntpe.paramRefs)
           constFold(tree, instantiate(fntpe, argTypes, tree.fun.symbol))
+            //.showing(i"typed app $tree : $fntpe with ${tree.args}%, % : $argTypes%, % = $result")
 
     def recheckTypeApply(tree: TypeApply, pt: Type)(using Context): Type =
       recheck(tree.fun).widen match

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

@@ -207,19 +207,19 @@ class CheckCaptures extends Recheck, SymTransformer:
      */
     def addResultBoxes(tp: Type)(using Context): Type =
       def includeBoxed(res: Type) = tp.capturing(res.boxedCaptured)
-      val tpw = tp.widen
-      val boxedTpw = tpw.dealias match
+      val tp1 = tp.dealias
+      val boxedTp = tp1 match
         case tp1 @ AppliedType(_, args) if defn.isNonRefinedFunction(tp1) =>
           includeBoxed(args.last)
         case tp1 @ RefinedType(_, _, rinfo) if defn.isFunctionType(tp1) =>
           includeBoxed(rinfo.finalResultType)
         case tp1 @ CapturingType(parent, refs) =>
           val boxedParent = addResultBoxes(parent)
-          if boxedParent eq parent then tpw
+          if boxedParent eq parent then tp1
           else boxedParent.capturing(refs)
         case _ =>
-          tpw
-      if boxedTpw eq tpw then tp else boxedTpw
+          tp1
+      if boxedTp eq tp1 then tp else boxedTp
     end addResultBoxes
 
     def assertSub(cs1: CaptureSet, cs2: CaptureSet)(using Context) =
@@ -255,7 +255,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         selType
       else
         val qualCs = qualType.captureSet
-        //println(i"intersect $qualType, ${selType.widen}, $qualCs, $selCs")
+        capt.println(i"intersect $qualType, ${selType.widen}, $qualCs, $selCs in $tree")
         if qualCs.mightSubcapture(selCs) then
           selType.widen.stripCapturing.capturing(qualCs)
         else

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

@@ -0,0 +1,15 @@
+class Unit
+object unit extends Unit
+
+type Top = {*} Any
+
+type LazyVal[T] = {*} Unit -> T
+
+class Foo[T](val x: T)
+
+// Foo[□ {*} Unit -> T]
+type BoxedLazyVal[T] = Foo[LazyVal[T]]
+
+def force[A](v: BoxedLazyVal[A]): A =
+  // Γ ⊢ v.x : □ {*} Unit -> A
+  v.x(unit)  // error: (unbox v.x)(unit), where (unbox v.x) should be untypable