Don't dealias TypeRefs when transforming explicit types

Author: odersky

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

@@ -16,6 +16,9 @@ import collection.mutable
 
 private val Captures: Key[CaptureSet] = Key()
 
+/** RetainingType will be boxed when it gets turned into a capturing type */
+private val NeedsBox: Key[Unit] = Key()
+
 object ccConfig:
 
   /** Switch whether unpickled function types and byname types should be mapped to
@@ -234,7 +237,7 @@ extension (tp: Type)
     case _ =>
       false
 
-  def isCapabilityClassRef(using Context) = tp match
+  def isCapabilityClassRef(using Context) = tp.dealiasKeepAnnots match
     case _: TypeRef | _: AppliedType => tp.typeSymbol.hasAnnotation(defn.CapabilityAnnot)
     case _ => false
 
@@ -255,7 +258,7 @@ extension (cls: ClassSymbol)
       defn.pureBaseClasses.contains(bc)
       || bc.givenSelfType.dealiasKeepAnnots.match
           case CapturingType(_, refs) => refs.isAlwaysEmpty
-          case RetainingType(_, refs) => refs.isEmpty // TODO: Better: test at phase cc instead?
+          case RetainingType(_, refs) => refs.isEmpty
           case selfType => selfType.exists && selfType.captureSet.isAlwaysEmpty
     else None
 
@@ -372,4 +375,4 @@ extension (tp: AnnotatedType)
   /** Is this a boxed capturing type? */
   def isBoxed(using Context): Boolean = tp.annot match
     case ann: CaptureAnnotation => ann.boxed
-    case _ => false
+    case ann => ann.tree.hasAttachment(NeedsBox)

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

@@ -156,7 +156,7 @@ object CheckCaptures:
             else recur(encl.owner.enclosingMethodOrClass)
           recur(encl)
       def traverse(t: Type) =
-        t match
+        t.dealiasKeepAnnots match
           case t: TypeRef =>
             capt.println(i"disallow $t, $tp, $what, ${t.symbol.is(Sealed)}")
             t.info match
@@ -724,13 +724,6 @@ class CheckCaptures extends Recheck, SymTransformer:
         markFree(res.boxedCaptureSet, tree.srcPos)
       res
 
-    /** If `tree` is a reference or an application where the result type refers
-     *  to an enclosing class or method parameter of the reference, check that the result type
-     *  does not capture the universal capability. This is justified since the
-     *  result type would have to be implicitly unboxed.
-     *  TODO: Can we find a cleaner way to achieve this? Logically, this should be part
-     *  of simulated boxing and unboxing.
-     */
     override def recheckFinish(tpe: Type, tree: Tree, pt: Type)(using Context): Type =
       def needsUniversalCheck = tree match
         case _: RefTree | _: Apply | _: TypeApply => tree.symbol.unboxesResult

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

@@ -121,9 +121,14 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
    *  convert it to be boxed.
    */
   private def box(tp: Type)(using Context): Type =
-    def recur(tp: Type): Type = tp.dealias match
-      case tp @ CapturingType(parent, refs) if !tp.isBoxed =>
-        tp.boxed
+    def recur(tp: Type): Type = tp.dealiasKeepAnnots match
+      case tp @ CapturingType(parent, refs) =>
+        if tp.isBoxed then tp else tp.boxed
+      case tp @ AnnotatedType(parent, ann) =>
+        if ann.symbol == defn.RetainsAnnot then
+          ann.tree.putAttachment(NeedsBox, ())
+          tp
+        else tp.derivedAnnotatedType(box(parent), ann)
       case tp1 @ AppliedType(tycon, args) if defn.isNonRefinedFunction(tp1) =>
         val res = args.last
         val boxedRes = recur(res)
@@ -229,7 +234,6 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
               resType = this(tp.resType))
           case tp: TypeLambda =>
             // Don't recurse into parameter bounds, just cleanup any stray retains annotations
-            // !!! TODO we should also map roots to rootvars here
             tp.derivedLambdaType(
               paramInfos = tp.paramInfos.mapConserve(_.dropAllRetains.bounds),
               resType = this(tp.resType))
@@ -291,18 +295,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         val t2 = expandCapabilityClass(t)
         if t2 ne t then return t2
         t match
-          case t: TypeRef =>
-            val sym = t.symbol
-            if sym.isClass then t
-            else t.info match
-              case TypeAlias(alias) =>
-                val transformed = this(alias)
-                  // TODO: Do we need an eager expansion, presumably, we need that only for normalizeCaptures
-                if transformed ne alias then transformed else t
-                  //.showing(i"EXPAND $t with ${t.info} to $result in ${t.symbol.owner}/${ctx.owner}")
-              case _ =>
-                recur(t)
-          case t @ AppliedType(tycon: TypeProxy, args) if true =>
+          case t @ AppliedType(tycon: TypeProxy, args) =>
             tycon.underlying match
               case TypeAlias(aliasTycon) =>
                 val args1 =
@@ -327,7 +320,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
               for tpt <- tptToCheck do
                 checkQualifiedRoots(ann.tree)
                 checkWellformedLater(parent1, ann.tree, tpt)
-              CapturingType(parent1, ann.tree.toCaptureSet)
+              CapturingType(parent1, ann.tree.toCaptureSet, boxed = ann.tree.hasAttachment(NeedsBox))
             else
               t.derivedAnnotatedType(this(parent), ann)
           case Box(t1) =>
@@ -632,6 +625,11 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         needsVariable(parent)
         && refs.isConst       // if refs is a variable, no need to add another
         && !refs.containsRoot // if refs is {cap}, an added variable would not change anything
+      case RetainingType(parent, refs) =>
+        needsVariable(parent)
+        && !refs.tpes.exists:
+            case ref: TermRef => ref.isUniversalRootCapability
+            case _ => false
       case AnnotatedType(parent, _) =>
         needsVariable(parent)
       case _ =>

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

@@ -8,6 +8,6 @@ object test {
 
   val foo: C[Tree^] = ??? // error
   type T = C[Tree^] // error
-  val bar: T -> T = ???  // error
+  val bar: T -> T = ???
   val baz: C[Tree^] -> Unit = ??? // error
 }

tests/neg-custom-args/captures/outer-var.check

@@ -28,7 +28,7 @@
    |        Found:    () ->{q} Unit
    |        Required: () ->{p} Unit
    |
-   |        Note that reference (q : () => Unit), defined in method inner
+   |        Note that reference (q : Proc), defined in method inner
    |        cannot be included in outer capture set {p} of variable y which is associated with method test
    |
    | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/outer-var.scala

@@ -3,9 +3,9 @@ type Cap = CC^
 
 type Proc = () => Unit
 
-def test(p: Proc) =
+def test(p: Proc, q: () => Unit) =
   var x: () ->{cap[test]} Unit = p
-  var y = p
+  var y = p // OK, y has type () ->{p} Proc
 
   def inner(q: Proc) =
     x = q           // error

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

@@ -1,17 +1,17 @@
 -- Error: tests/neg-custom-args/captures/vars.scala:22:14 --------------------------------------------------------------
 22 |    a = x => g(x)      // error
    |             ^^^^
-   |             reference (cap3 : CC^) is not included in the allowed capture set {cap1} of variable a
+   |             reference (cap3 : Cap) is not included in the allowed capture set {cap1} of variable a
    |
-   |             Note that reference (cap3 : CC^), defined in method scope
+   |             Note that reference (cap3 : Cap), defined in method scope
    |             cannot be included in outer capture set {cap1} of variable a which is associated with method test
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars.scala:23:8 ------------------------------------------
 23 |    a = g      // error
    |        ^
    |        Found:    (x: String) ->{cap3} String
    |        Required: (x$0: String) ->{cap1} String
    |
-   |        Note that reference (cap3 : CC^), defined in method scope
+   |        Note that reference (cap3 : Cap), defined in method scope
    |        cannot be included in outer capture set {cap1} of variable a which is associated with method test
    |
    | longer explanation available when compiling with `-explain`