Add existential capabilities, 2nd draft

Author: odersky

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

@@ -26,6 +26,8 @@ object ccConfig:
    */
   inline val allowUnsoundMaps = false
 
+  val useExistentials = false
+
   /** If true, use `sealed` as encapsulation mechanism instead of the
    *  previous global retriction that `cap` can't be boxed or unboxed.
    */
@@ -532,6 +534,33 @@ object ReachCapability extends AnnotatedCapability(defn.ReachCapabilityAnnot)
  */
 object MaybeCapability extends AnnotatedCapability(defn.MaybeCapabilityAnnot)
 
+/** Offers utility method to be used for type maps that follow aliases */
+trait ConservativeFollowAliasMap(using Context) extends TypeMap:
+
+  /** If `mapped` is a type alias, apply the map to the alias, while keeping
+   *  annotations. If the result is different, return it, otherwise return `mapped`.
+   *  Furthermore, if `original` is a LazyRef or TypeVar and the mapped result is
+   *  the same as the underlying type, keep `original`. This avoids spurious differences
+   *  which would lead to spurious dealiasing in the result
+   */
+  protected def applyToAlias(original: Type, mapped: Type) =
+    val mapped1 = mapped match
+      case t: (TypeRef | AppliedType) =>
+        val t1 = t.dealiasKeepAnnots
+        if t1 eq t then t
+        else
+          // If we see a type alias, map the alias type and keep it if it's different
+          val t2 = apply(t1)
+          if t2 ne t1 then t2 else t
+      case _ =>
+        mapped
+    original match
+      case original: (LazyRef | TypeVar) if mapped1 eq original.underlying =>
+        original
+      case _ =>
+        mapped1
+end ConservativeFollowAliasMap
+
 /** An extractor for all kinds of function types as well as method and poly types.
  *  @return  1st half: The argument types or empty if this is a type function
  *           2nd half: The result type

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

@@ -14,6 +14,7 @@ import printing.{Showable, Printer}
 import printing.Texts.*
 import util.{SimpleIdentitySet, Property}
 import typer.ErrorReporting.Addenda
+import TypeComparer.canSubsumeExistentially
 import util.common.alwaysTrue
 import scala.collection.mutable
 import CCState.*
@@ -172,6 +173,7 @@ sealed abstract class CaptureSet extends Showable:
             x.info match
               case x1: CaptureRef => x1.subsumes(y)
               case _ => false
+          case x: TermParamRef => canSubsumeExistentially(x, y)
           case _ => false
 
   /** {x} <:< this   where <:< is subcapturing, but treating all variables

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

@@ -612,10 +612,10 @@ class CheckCaptures extends Recheck, SymTransformer:
           mdef.rhs.putAttachment(ClosureBodyValue, ())
         case _ =>
 
-      // Constrain closure's parameters and result from the expected type before
-      // rechecking the body.
       openClosures = (mdef.symbol, pt) :: openClosures
       try
+        // Constrain closure's parameters and result from the expected type before
+        // rechecking the body.
         val res = recheckClosure(expr, pt, forceDependent = true)
         if !isEtaExpansion(mdef) then
           // If closure is an eta expanded method reference it's better to not constrain
@@ -699,7 +699,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         val localSet = capturedVars(sym)
         if !localSet.isAlwaysEmpty then
           curEnv = Env(sym, EnvKind.Regular, localSet, curEnv)
-        inNestedLevel:
+        inNestedLevel: // TODO: needed here?
           try checkInferredResult(super.recheckDefDef(tree, sym), tree)
           finally
             if !sym.isAnonymousFunction then
@@ -920,8 +920,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         case expected @ defn.FunctionOf(args, resultType, isContextual)
         if defn.isNonRefinedFunction(expected) =>
           actual match
-            case RefinedType(parent, nme.apply, rinfo: MethodType)
-            if defn.isFunctionNType(actual) =>
+            case defn.RefinedFunctionOf(rinfo: MethodType) =>
               depFun(args, resultType, isContextual, rinfo.paramNames)
             case _ => expected
         case _ => expected
@@ -1132,12 +1131,12 @@ class CheckCaptures extends Recheck, SymTransformer:
         *  @param sym  symbol of the field definition that is being checked
         */
         override def checkSubType(actual: Type, expected: Type)(using Context): Boolean =
-          val expected1 = alignDependentFunction(addOuterRefs(expected, actual), actual.stripCapturing)
+          val expected1 = alignDependentFunction(addOuterRefs(/*Existential.strip*/(expected), actual), actual.stripCapturing)
           val actual1 =
             val saved = curEnv
             try
               curEnv = Env(clazz, EnvKind.NestedInOwner, capturedVars(clazz), outer0 = curEnv)
-              val adapted = adaptBoxed(actual, expected1, srcPos, covariant = true, alwaysConst = true)
+              val adapted = adaptBoxed(/*Existential.strip*/(actual), expected1, srcPos, covariant = true, alwaysConst = true)
               actual match
                 case _: MethodType =>
                   // We remove the capture set resulted from box adaptation for method types,