Switch to AnnotatedType representation of CapturingTypes

Author: odersky

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

@@ -53,4 +53,10 @@ case class CaptureAnnotation(refs: CaptureSet) extends Annotation:
 
   override def toText(printer: Printer): Text = refs.toText(printer)
 
+  override def hash: Int = refs.hashCode
+
+  override def eql(that: Annotation) = that match
+    case that: CaptureAnnotation => this.refs eq that.refs
+    case _ => false
+
 end CaptureAnnotation

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

@@ -64,6 +64,7 @@ extension (tp: Type)
         case TypeBounds(lo, _) => lo.needsBox
         case _ => false
     case tp: RefinedOrRecType => tp.parent.needsBox
+    case CapturingType(_, _) => false
     case tp: AnnotatedType => tp.parent.needsBox
     case tp: LazyRef => tp.ref.needsBox
     case tp: AndType => tp.tp1.needsBox || tp.tp2.needsBox

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

@@ -7,15 +7,11 @@ import Types.*, Symbols.*, Contexts.*
 
 object CapturingType:
 
-  private val old = true
-
   def apply(parent: Type, refs: CaptureSet)(using Context): Type =
-    if old then CapturingTypeMaker(parent, refs)
-    else if refs.isAlwaysEmpty then parent
+    if refs.isAlwaysEmpty then parent
     else AnnotatedType(parent, CaptureAnnotation(refs))
 
   def unapply(tp: Type)(using Context) = tp match
-    case tp: CapturingType => Some((tp.parent, tp.captureSet))
     case tp: AnnotatedType => tp.annot match
       case ann: CaptureAnnotation =>
         Some((tp.parent, ann.refs))

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

@@ -79,6 +79,10 @@ object Annotations {
 
     def sameAnnotation(that: Annotation)(using Context): Boolean =
       symbol == that.symbol && tree.sameTree(that.tree)
+
+    /** Operations for hash-consing, can be overridden */
+    def hash: Int = System.identityHashCode(this)
+    def eql(that: Annotation) = this eq that
   }
 
   case class ConcreteAnnotation(t: Tree) extends Annotation {

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

@@ -1511,7 +1511,7 @@ object SymDenotations {
       case tp: AppliedType => hasSkolems(tp.tycon) || tp.args.exists(hasSkolems)
       case tp: LambdaType => tp.paramInfos.exists(hasSkolems) || hasSkolems(tp.resType)
       case tp: AndOrType => hasSkolems(tp.tp1) || hasSkolems(tp.tp2)
-      case tp: AnnotOrCaptType => hasSkolems(tp.parent)
+      case tp: AnnotatedType => hasSkolems(tp.parent)
       case _ => false
     }
 

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

@@ -327,6 +327,8 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         compareWild
       case tp2: LazyRef =>
         isBottom(tp1) || !tp2.evaluating && recur(tp1, tp2.ref)
+      case CapturingType(_, _) =>
+        secondTry
       case tp2: AnnotatedType if !tp2.isRefining =>
         recur(tp1, tp2.parent)
       case tp2: ThisType =>
@@ -741,11 +743,11 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             false
         }
         compareTypeBounds
+      case CapturingType(parent2, _) =>
+        recur(tp1, parent2) || fourthTry
       case tp2: AnnotatedType if tp2.isRefining =>
         (tp1.derivesAnnotWith(tp2.annot.sameAnnotation) || tp1.isBottomType) &&
         recur(tp1, tp2.parent)
-      case tp2: CapturingType =>
-        recur(tp1, tp2.parent) || fourthTry
       case ClassInfo(pre2, cls2, _, _, _) =>
         def compareClassInfo = tp1 match {
           case ClassInfo(pre1, cls1, _, _, _) =>

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

@@ -73,8 +73,7 @@ object Types {
    *        |              +- AppliedType
    *        |              +- TypeBounds
    *        |              +- ExprType
-   *        |              +- AnnotOrCaptType -+-- AnnotatedType
-   *        |              |                   +-- CapturingType
+   *        |              +- AnnotatedType
    *        |              +- TypeVar
    *        |              +- HKTypeLambda
    *        |              +- MatchType
@@ -176,7 +175,6 @@ object Types {
         // not on types. Allowing it on types is a Scala 3 extension. See:
         // https://www.scala-lang.org/files/archive/spec/2.11/11-annotations.html#scala-compiler-annotations
         tp.annot.symbol == defn.UncheckedStableAnnot || tp.parent.isStable
-      case tp: CapturingType => tp.parent.isStable
       case tp: AndType =>
         // TODO: fix And type check when tp contains type parames for explicit-nulls flow-typing
         // see: tests/explicit-nulls/pos/flow-stable.scala.disabled
@@ -205,6 +203,8 @@ object Types {
         else this1.underlying.isRef(sym, skipRefined)
       case this1: TypeVar =>
         this1.instanceOpt.isRef(sym, skipRefined)
+      case CapturingType(_, _) =>
+        false
       case this1: AnnotatedType =>
         this1.parent.isRef(sym, skipRefined)
       case _ => false
@@ -1467,7 +1467,7 @@ object Types {
       case tp: AppliedType =>
         if (tp.tycon.isLambdaSub) NoType
         else tp.superType.underlyingClassRef(refinementOK)
-      case tp: AnnotOrCaptType =>
+      case tp: AnnotatedType =>
         tp.parent.underlyingClassRef(refinementOK)
       case tp: RefinedType =>
         if (refinementOK) tp.underlying.underlyingClassRef(refinementOK) else NoType
@@ -5142,12 +5142,8 @@ object Types {
 
   // ----- Annotated and Import types -----------------------------------------------
 
-  abstract class AnnotOrCaptType extends CachedProxyType with ValueType:
-    def parent: Type
-    override def stripped(using Context): Type = parent.stripped
-
   /** An annotated type tpe @ annot */
-  abstract case class AnnotatedType(parent: Type, annot: Annotation) extends AnnotOrCaptType {
+  abstract case class AnnotatedType(parent: Type, annot: Annotation) extends CachedProxyType, ValueType {
 
     override def underlying(using Context): Type = parent
 
@@ -5160,6 +5156,8 @@ object Types {
 
     override def stripAnnots(using Context): Type = parent.stripAnnots
 
+    override def stripped(using Context): Type = parent.stripped
+
     private var isRefiningKnown = false
     private var isRefiningCache: Boolean = _
 
@@ -5174,16 +5172,16 @@ object Types {
     // equals comes from case class; no matching override is needed
 
     override def computeHash(bs: Binders): Int =
-      doHash(bs, System.identityHashCode(annot), parent)
+      doHash(bs, annot.hash, parent)
     override def hashIsStable: Boolean =
       parent.hashIsStable
 
     override def eql(that: Type): Boolean = that match
-      case that: AnnotatedType => (parent eq that.parent) && (annot eq that.annot)
+      case that: AnnotatedType => (parent eq that.parent) && (annot eql that.annot)
       case _ => false
 
     override def iso(that: Any, bs: BinderPairs): Boolean = that match
-      case that: AnnotatedType => parent.equals(that.parent, bs) && (annot eq that.annot)
+      case that: AnnotatedType => parent.equals(that.parent, bs) && (annot eql that.annot)
       case _ => false
   }
 
@@ -5196,37 +5194,6 @@ object Types {
       unique(CachedAnnotatedType(parent, annot))
   end AnnotatedType
 
-  abstract class CapturingType(val parent: Type, private val refs: CaptureSet) extends AnnotOrCaptType:
-    override def underlying(using Context): Type = parent
-
-    override def captureSet(using Context) = refs
-
-    def derivedCapturingType(parent: Type, refs: CaptureSet)(using Context): Type =
-      if (parent eq this.parent) && (refs eq this.refs) then this
-      else CapturingType(parent, refs)
-
-    // equals comes from case class; no matching override is needed
-
-    override def computeHash(bs: Binders): Int =
-      doHash(bs, refs, parent)
-    override def hashIsStable: Boolean =
-      parent.hashIsStable
-
-    override def eql(that: Type): Boolean = that match
-      case that: CapturingType => (parent eq that.parent) && (refs eq that.refs)
-      case _ => false
-
-    override def iso(that: Any, bs: BinderPairs): Boolean = that match
-      case that: CapturingType => parent.equals(that.parent, bs) && (refs eq that.refs)
-      case _ => false
-
-  class CachedCapturingType(parent: Type, refs: CaptureSet) extends CapturingType(parent, refs)
-
-  object CapturingTypeMaker:
-    def apply(parent: Type, refs: CaptureSet)(using Context): Type =
-      if refs.isAlwaysEmpty then parent
-      else unique(CachedCapturingType(parent, refs))
-
   // Special type objects and classes -----------------------------------------------------
 
   /** The type of an erased array */
@@ -5363,7 +5330,7 @@ object Types {
         zeroParamClass(tp.underlying)
       case tp: TypeVar =>
         zeroParamClass(tp.underlying)
-      case tp: AnnotOrCaptType =>
+      case tp: AnnotatedType =>
         zeroParamClass(tp.underlying)
       case _ =>
         NoType

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

@@ -347,7 +347,7 @@ object GenericSignatures {
           if (toplevel) polyParamSig(tParams)
           superSig(ci.typeSymbol, ci.parents)
 
-        case tp: AnnotOrCaptType =>
+        case tp: AnnotatedType =>
           jsig(tp.parent, toplevel, primitiveOK)
 
         case hktl: HKTypeLambda =>
@@ -469,7 +469,7 @@ object GenericSignatures {
             true
           case ClassInfo(_, _, parents, _, _) =>
             foldOver(tp.typeParams.nonEmpty, parents)
-          case tp: AnnotOrCaptType =>
+          case tp: AnnotatedType =>
             foldOver(x, tp.parent)
           case _ =>
             foldOver(x, tp)

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

@@ -148,7 +148,7 @@ object TypeTestsCasts {
         }
       case AndType(tp1, tp2)    => recur(X, tp1) && recur(X, tp2)
       case OrType(tp1, tp2)     => recur(X, tp1) && recur(X, tp2)
-      case tp: AnnotOrCaptType  => recur(X, tp.parent)
+      case tp: AnnotatedType    => recur(X, tp.parent)
       case _: RefinedType       => false
       case _                    => true
     })

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

@@ -108,7 +108,8 @@ class CheckCaptures extends Recheck:
 
       val mapType = new TypeMap:
         def apply(t: Type) = t match
-          case AnnotatedType(parent, annot) if annot.symbol == defn.RetainsAnnot =>
+          case AnnotatedType(parent, annot)
+          if annot.symbol == defn.RetainsAnnot && !annot.isInstanceOf[CaptureAnnotation] =>
             CapturingType(this(parent), annot.tree.toCaptureSet)
           case t @ RefinedType(core, nme.apply, appInfo) =>
             mapRefined(t, this(core), this(appInfo))
@@ -118,7 +119,8 @@ class CheckCaptures extends Recheck:
       def reinfer(tp: Type): Type =
         val cleanType = new TypeMap:
           def apply(t: Type) = t match
-            case AnnotatedType(parent, annot) if annot.symbol == defn.RetainsAnnot =>
+            case AnnotatedType(parent, annot)
+            if annot.symbol == defn.RetainsAnnot =>
               parent
             case _ =>
               mapOver(t)

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

@@ -309,7 +309,7 @@ object Checking {
             case AndType(tp1, tp2) => isInteresting(tp1) || isInteresting(tp2)
             case OrType(tp1, tp2) => isInteresting(tp1) && isInteresting(tp2)
             case _: RefinedOrRecType | _: AppliedType => true
-            case tp: AnnotOrCaptType => isInteresting(tp.parent)
+            case tp: AnnotatedType => isInteresting(tp.parent)
             case _ => false
           }
 

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

@@ -127,7 +127,7 @@ object Inferencing {
       couldInstantiateTypeVar(parent)
     case tp: AndOrType =>
       couldInstantiateTypeVar(tp.tp1) || couldInstantiateTypeVar(tp.tp2)
-    case tp: AnnotOrCaptType =>
+    case tp: AnnotatedType =>
       couldInstantiateTypeVar(tp.parent)
     case _ =>
       false

tests/neg-custom-args/captures/capt-depfun2.scala

@@ -5,6 +5,6 @@ def f(y: Cap, z: Cap) =
   def g(): C @retains(y, z) = ???
   val ac: ((x: Cap) => Array[String @retains(x)]) = ???
   val dc = ac(g()) // error: Needs explicit type Array[? >: String <: {y, z} String]
-                   // This is a shotcoming of rechecking since the originally inferred
+                   // This is a shortcoming of rechecking since the originally inferred
                    // type is `Array[String]` and the actual type after rechecking
                    // cannot be expressed as `Array[C String]` for any capture set C