Drop old existential handling

Author: odersky

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

@@ -204,8 +204,7 @@ extension (tp: Type)
    *    - annotated types that represent reach or maybe capabilities
    */
   final def isTrackableRef(using Context): Boolean = tp match
-    case _: ThisType => true
-    case tp: TermParamRef => !Existential.isBinderOLD(tp)
+    case _: (ThisType | TermParamRef) => true
     case tp: TermRef =>
       ((tp.prefix eq NoPrefix)
       || tp.symbol.isField && !tp.symbol.isStatic && tp.prefix.isTrackableRef
@@ -215,7 +214,6 @@ extension (tp: Type)
       tp.symbol.isType && tp.derivesFrom(defn.Caps_CapSet)
     case tp: TypeParamRef =>
       tp.derivesFrom(defn.Caps_CapSet)
-    case Existential.VarOLD(_) => true
     case Existential.Vble(_) => true
     case AnnotatedType(parent, annot) =>
       defn.capabilityWrapperAnnots.contains(annot.symbol) && parent.isTrackableRef
@@ -542,8 +540,6 @@ extension (tp: Type)
             // Also map existentials in results to reach capabilities if all
             // preceding arguments are known to be always pure
             t.derivedFunctionOrMethod(args, apply(Existential.toCap(res)))
-          case Existential(_, _) =>
-            t
           case _ =>
             mapOver(t)
     end narrowCaps
@@ -571,8 +567,6 @@ extension (tp: Type)
           case t @ AnnotatedType(parent, ann) =>
             // Don't traverse annotations, which includes capture sets
             this(x, parent)
-          case Existential(_, _) =>
-            false
           case _ =>
             foldOver(x, t)
     acc(false, tp)

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

@@ -6,7 +6,6 @@ import core.*
 import Types.*, Symbols.*, Contexts.*, Decorators.*
 import util.{SimpleIdentitySet, Property}
 import typer.ErrorReporting.Addenda
-import TypeComparer.subsumesExistentiallyOLD
 import util.common.alwaysTrue
 import scala.collection.mutable
 import CCState.*
@@ -110,7 +109,6 @@ trait CaptureRef extends TypeProxy, ValueType:
    */
   final def isMaxCapability(using Context): Boolean = this match
     case tp: TermRef => tp.isCap || tp.info.derivesFrom(defn.Caps_Exists)
-    case Existential.VarOLD(_) => true
     case Existential.Vble(_) => true
     case Fresh(_) => true
     case ReadOnlyCapability(tp1) => tp1.isMaxCapability
@@ -229,7 +227,6 @@ trait CaptureRef extends TypeProxy, ValueType:
         case _ => false
     || this.match
         case ReachCapability(x1) => x1.subsumes(y.stripReach)
-        case Existential.VarOLD(bv) => subsumesExistentiallyOLD(bv, y)
         case x: TermRef => viaInfo(x.info)(subsumingRefs(_, y))
         case x: TypeRef if assumedContainsOf(x).contains(y) => true
         case x: TypeRef if x.derivesFrom(defn.Caps_CapSet) =>

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

@@ -104,7 +104,6 @@ sealed abstract class CaptureSet extends Showable:
 
   final def isUnboxable(using Context) =
     elems.exists:
-      case Existential.VarOLD(_) => true
       case Existential.Vble(_) => true
       case elem => elem.isRootCapability
 
@@ -548,8 +547,6 @@ object CaptureSet:
     final def addThisElem(elem: CaptureRef)(using Context, VarState): CompareResult =
       if isConst || !recordElemsState() then // Fail if variable is solved or given VarState is frozen
         addIfHiddenOrFail(elem)
-      else if Existential.isBadExistentialOLD(elem) then // Fail if `elem` is an out-of-scope existential
-        CompareResult.Fail(this :: Nil)
       else if !levelOK(elem) then
         CompareResult.LevelError(this, elem)    // or `elem` is not visible at the level of the set.
       else
@@ -573,14 +570,9 @@ object CaptureSet:
       if elem.isRootCapability then
         !noUniversal
       else elem match
-        case Existential.VarOLD(bv) =>
-          !noUniversal
-          && !TypeComparer.isOpenedExistential(bv)
-            // Opened existentials on the left cannot be added to nested capture sets on the right
-            // of a comparison. Test case is open-existential.scala.
         case elem @ Existential.Vble(mt) =>
           !noUniversal
-          && !TypeComparer.isOpenedExistential(elem)
+          && !CCState.openedFreshBinders.contains(elem)
             // Opened existentials on the left cannot be added to nested capture sets on the right
             // of a comparison. Test case is open-existential.scala.
         case elem: TermRef if level.isDefined =>
@@ -636,7 +628,6 @@ object CaptureSet:
         try
           val approx = computeApprox(origin).ensuring(_.isConst)
           if approx.elems.exists:
-            case Existential.VarOLD(_) => true
             case Existential.Vble(_) => true
             case _ => false
           then
@@ -1325,8 +1316,6 @@ object CaptureSet:
         case tp: (TypeRef | TypeParamRef) =>
           if tp.derivesFrom(defn.Caps_CapSet) then tp.captureSet
           else empty
-        case tp @ Existential.VarOLD(_) =>
-          tp.captureSet
         case tp @ Existential.Vble(_) =>
           tp.captureSet
         case CapturingType(parent, refs) =>
@@ -1393,8 +1382,6 @@ object CaptureSet:
           case t @ FunctionOrMethod(args, res) =>
             if args.forall(_.isAlwaysPure) then this(cs, Existential.toCap(res))
             else cs
-          case t @ Existential(_, _) =>
-            cs
           case _ =>
             foldOver(cs, t)
     collect(CaptureSet.empty, tp)

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

@@ -23,7 +23,6 @@ import CCState.*
 import StdNames.nme
 import NameKinds.{DefaultGetterName, WildcardParamName, UniqueNameKind}
 import reporting.{trace, Message, OverrideError}
-import Existential.derivedExistentialTypeOLD
 import Annotations.Annotation
 
 /** The capture checker */
@@ -869,8 +868,6 @@ class CheckCaptures extends Recheck, SymTransformer:
           // can happen for curried constructors if instantiate of a previous step
           // added capture set to result.
           augmentConstructorType(parent, initCs ++ refs)
-        case core @ Existential(boundVar, core1) =>
-          core.derivedExistentialTypeOLD(augmentConstructorType(core1, initCs))
         case _ =>
           val (refined, cs) = addParamArgRefinements(core, initCs)
           refined.capturing(cs)
@@ -942,8 +939,8 @@ class CheckCaptures extends Recheck, SymTransformer:
           // which are less intelligible. An example is the line `a = x` in
           // neg-custom-args/captures/vars.scala. That's why this code is conditioned.
           // to apply only to closures that are not eta expansions.
-          val res1 = Existential.toCapDeeply(res) // TODO: why toCapDeeply?
-          val pt1 = Existential.toCapDeeply(pt)
+          val res1 = Existential.toCap(res, deep = true) // TODO: why deep = true?
+          val pt1 = Existential.toCap(pt, deep = true)
             // We need to open existentials here in order not to get vars mixed up in them
             // We do the proper check with existentials when we are finished with the closure block.
           capt.println(i"pre-check closure $expr of type $res1 against $pt1")
@@ -1450,17 +1447,9 @@ class CheckCaptures extends Recheck, SymTransformer:
 
         def adaptStr = i"adapting $actual ${if covariant then "~~>" else "<~~"} $expected"
 
-        // Get existentials and wildcards out of the way
-        actual match
-          case actual @ Existential(_, actualUnpacked) =>
-            return Existential.derivedExistentialTypeOLD(actual):
-                recur(actualUnpacked, expected, covariant)
-          case _ =>
+        // Get wildcards out of the way
         expected match
-          case expected @ Existential(_, expectedUnpacked) =>
-            return recur(actual, expectedUnpacked, covariant)
-          case _: WildcardType =>
-            return actual
+          case _: WildcardType => return actual
           case _ =>
 
         trace(adaptStr, capt, show = true) {

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

@@ -210,41 +210,6 @@ Expansion of ^:
 */
 object Existential:
 
-  type CarrierOLD = RefinedType
-
-  def unapply(tp: CarrierOLD)(using Context): Option[(TermParamRef, Type)] =
-    tp.refinedInfo match
-      case mt: MethodType
-      if isExistentialMethodOLD(mt) && defn.isNonRefinedFunction(tp.parent) =>
-        Some(mt.paramRefs.head, mt.resultType)
-      case _ => None
-
-  /** Create method type in the refinement of an existential type */
-  private def exMethodTypeOLD(using Context)(
-      mk: TermParamRef => Type,
-      boundName: TermName = ExistentialBinderName.fresh()
-    ): MethodType =
-    MethodType(boundName :: Nil)(
-      mt => defn.Caps_Exists.typeRef :: Nil,
-      mt => mk(mt.paramRefs.head))
-
-  /** Create existential */
-  def applyOLD(mk: TermParamRef => Type)(using Context): Type =
-    exMethodTypeOLD(mk).toFunctionType(alwaysDependent = true)
-
-  /** The (super-) type of existentially bound references */
-  type VarOLD = AnnotatedType
-
-  /** An extractor for existentially bound references of the form ex @existential
-   *  where ex is a TermParamRef of type Exists
-   */
-  object VarOLD:
-    def apply(boundVar: TermParamRef)(using Context): VarOLD =
-      AnnotatedType(boundVar, Annotation(defn.ExistentialAnnot, NoSpan))
-    def unapply(tp: VarOLD)(using Context): Option[TermParamRef] = tp match
-      case AnnotatedType(bv: TermParamRef, ann) if ann.symbol == defn.ExistentialAnnot => Some(bv)
-      case _ => None
-
   /** The (super-) type of existentially bound references */
   type Vble = AnnotatedType
 
@@ -260,44 +225,6 @@ object Existential:
           case _ => None
       case _ => None
 
-  /** Create existential if bound variable appears in result of `mk` */
-  def wrapOLD(mk: TermParamRef => Type)(using Context): Type =
-    val mt = exMethodTypeOLD(mk)
-    if mt.isResultDependent then mt.toFunctionType() else mt.resType
-
-  extension (tp: CarrierOLD)
-    def derivedExistentialTypeOLD(core: Type)(using Context): Type = tp match
-      case Existential(boundVar, unpacked) =>
-        if core eq unpacked then tp
-        else applyOLD(bv => core.substParam(boundVar, bv))
-      case _ =>
-        core
-
-  /** Map existentially bound references referring to `boundVar` one-to-one
-   *  to Fresh instances (OLD)
-   */
-  def boundVarToCapOLD(boundVar: TermParamRef, tp: Type)(using Context) =
-    val subst = new IdempotentCaptRefMap:
-      val seen = EqHashMap[Annotation, CaptureRef]()
-      def apply(t: Type): Type = t match
-        case t @ VarOLD(`boundVar`) =>
-          seen.getOrElseUpdate(t.annot, Fresh(NoSymbol))
-        case _ =>
-          mapOver(t)
-    subst(tp)
-
-  /** Map existentially bound references referring to `boundVar` one-to-one
-   *  to Fresh instances
-   */
-  def toCapOLD(tp: Type)(using Context): Type = tp.dealiasKeepAnnots match
-    case Existential(boundVar, unpacked) => // (OLD)
-      boundVarToCapOLD(boundVar, unpacked)
-    case tp1 @ CapturingType(parent, refs) =>
-      tp1.derivedCapturingType(toCap(parent), refs)
-    case tp1 @ AnnotatedType(parent, ann) =>
-      tp1.derivedAnnotatedType(toCap(parent), ann)
-    case _ => tp
-
   /** Map top-level free existential variables one-to-one to Fresh instances */
   def toCap(tp: Type, deep: Boolean = false)(using Context): Type =
     val subst = new IdempotentCaptRefMap:
@@ -320,26 +247,8 @@ object Existential:
         case _ =>
           mapOver(t)
 
-    if ccConfig.newScheme then subst(tp)
-    else toCapOLD(tp)
-
-  /** Map existentials at the top-level and in all nested result types to `Fresh`
-   */
-  def toCapDeeplyOLD(tp: Type)(using Context): Type = tp.dealiasKeepAnnots match
-    case Existential(boundVar, unpacked) =>
-      toCapDeeplyOLD(boundVarToCapOLD(boundVar, unpacked))
-    case tp1 @ FunctionOrMethod(args, res) =>
-      val tp2 = tp1.derivedFunctionOrMethod(args, toCapDeeplyOLD(res))
-      if tp2 ne tp1 then tp2 else tp
-    case tp1 @ CapturingType(parent, refs) =>
-      tp1.derivedCapturingType(toCapDeeplyOLD(parent), refs)
-    case tp1 @ AnnotatedType(parent, ann) =>
-      tp1.derivedAnnotatedType(toCapDeeplyOLD(parent), ann)
-    case _ => tp
-
-  def toCapDeeply(tp: Type)(using Context): Type =
-    if ccConfig.newScheme then toCap(tp, deep = true)
-    else toCapDeeplyOLD(tp)
+    subst(tp)
+  end toCap
 
   /** Knowing that `tp` is a function type, is it an alias to a function other
    *  than `=>`?
@@ -348,75 +257,6 @@ object Existential:
     case AppliedType(tycon, _) => !defn.isFunctionSymbol(tycon.typeSymbol)
     case _ => false
 
-  /** Replace all occurrences of `cap` (or fresh) in parts of this type by an existentially bound
-   *  variable. If there are such occurrences, or there might be in the future due to embedded
-   *  capture set variables, create an existential with the variable wrapping the type.
-   *  Stop at function or method types since these have been mapped before.
-   */
-  def mapCapOLD(tp: Type, fail: Message => Unit)(using Context): Type =
-    var needsWrap = false
-
-    abstract class CapMap extends BiTypeMap:
-      override def mapOver(t: Type): Type = t match
-        case t @ FunctionOrMethod(args, res) if variance > 0 && !isAliasFun(t) =>
-          t // `t` should be mapped in this case by a different call to `mapCap`.
-        case Existential(_, _) =>
-          t
-        case t: (LazyRef | TypeVar) =>
-          mapConserveSuper(t)
-        case _ =>
-          super.mapOver(t)
-
-    class Wrap(boundVar: TermParamRef) extends CapMap:
-      private val seen = EqHashMap[CaptureRef, VarOLD]()
-
-      def apply(t: Type) = t match
-        case t: CaptureRef if t.isCapOrFresh =>
-          if variance > 0 then
-            needsWrap = true
-            seen.getOrElseUpdate(t, VarOLD(boundVar))
-          else
-            if variance == 0 then
-              fail(em"""$tp captures the root capability `cap` in invariant position""")
-            // we accept variance < 0, and leave the cap as it is
-            super.mapOver(t)
-        case t @ CapturingType(parent, refs: CaptureSet.Var) =>
-          if variance > 0 then needsWrap = true
-          super.mapOver(t)
-        case defn.FunctionNOf(args, res, contextual) if t.typeSymbol.name.isImpureFunction =>
-          if variance > 0 then
-            needsWrap = true
-            super.mapOver:
-              defn.FunctionNOf(args, res, contextual)
-                .capturing(VarOLD(boundVar).singletonCaptureSet)
-          else mapOver(t)
-        case _ =>
-          mapOver(t)
-        //.showing(i"mapcap $t = $result")
-
-      lazy val inverse = new BiTypeMap:
-        def apply(t: Type) = t match
-          case t @ VarOLD(`boundVar`) =>
-            // do a reverse getOrElseUpdate on `seen` to produce the
-            // `Fresh` assosicated with `t`
-            val it = seen.iterator
-            var ref: CaptureRef | Null = null
-            while it.hasNext && ref == null do
-              val (k, v) = it.next
-              if v.annot eq t.annot then ref = k
-            if ref == null then
-              ref = Fresh(NoSymbol)
-              seen(ref) = t
-            ref
-          case _ => mapOver(t)
-        def inverse = Wrap.this
-        override def toString = "Wrap.inverse"
-    end Wrap
-
-    val wrapped = applyOLD(Wrap(_)(tp))
-    if needsWrap then wrapped else tp
-  end mapCapOLD
-
   /** Replace all occurrences of `cap` (or fresh) in parts of this type by an existentially bound
    *  variable bound by `mt`.
    *  Stop at function or method types since these have been mapped before.
@@ -486,37 +326,13 @@ object Existential:
         else t
       case t: MethodType if variance > 0 && t.isFreshBinder =>
         val t1 = mapOver(t).asInstanceOf[MethodType]
-        t1.derivedLambdaType(resType =
-          if ccConfig.newScheme then mapCap(t1.resType, t1, fail)
-          else mapCapOLD(t1.resType, fail))
+        t1.derivedLambdaType(resType = mapCap(t1.resType, t1, fail))
       case CapturingType(parent, refs) =>
         t.derivedCapturingType(this(parent), refs)
-      case Existential(_, _) =>
-        t
       case t: (LazyRef | TypeVar) =>
         mapConserveSuper(t)
       case _ =>
         mapFollowingAliases(t)
   end mapCapInResults
 
-  /** Is `mt` a method represnting an existential type when used in a refinement? */
-  def isExistentialMethodOLD(mt: TermLambda)(using Context): Boolean = mt.paramInfos match
-    case (info: TypeRef) :: rest => info.symbol == defn.Caps_Exists && rest.isEmpty
-    case _ => false
-
-  /** Is `ref` a TermParamRef representing existentially bound variables? */
-  def isBinderOLD(ref: CaptureRef)(using Context) = ref match
-    case ref: TermParamRef => isExistentialMethodOLD(ref.binder)
-    case _ => false
-
-  /** An value signalling an out-of-scope existential that should
-   *  lead to a compare failure.
-   */
-  def badExistentialOLD(using Context): TermParamRef =
-    exMethodTypeOLD(identity, nme.OOS_EXISTENTIAL).paramRefs.head
-
-  def isBadExistentialOLD(ref: CaptureRef) = ref match
-    case ref: TermParamRef => ref.paramName == nme.OOS_EXISTENTIAL
-    case _ => false
-
 end Existential