CC: Infer more self types automatically (#19425)

Fixes #19398 

Clean up the logic how we infer self types, and add a new clause:

> If we have an externally extensible class that itself does not have a
declared self type itself and also not in any of its base classes,
assume {cap} as the self type. Previously we would install a capture
set but then check after the fact that that capture set is indeed {cap}.
So it's less verbose to just assume that from the start.

Author: odersky

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

@@ -236,19 +236,19 @@ extension (tp: Type)
    *  (2) all covariant occurrences of cap replaced by `x*`, provided there
    *  are no occurrences in `T` at other variances. (1) is standard, whereas
    *  (2) is new.
-   * 
+   *
    *  For (2), multiple-flipped covariant occurrences of cap won't be replaced.
    *  In other words,
    *
    *    - For xs: List[File^]  ==>  List[File^{xs*}], the cap is replaced;
    *    - while f: [R] -> (op: File^ => R) -> R remains unchanged.
-   * 
+   *
    *  Without this restriction, the signature of functions like withFile:
-   * 
+   *
    *    (path: String) -> [R] -> (op: File^ => R) -> R
    *
    *  could be refined to
-   * 
+   *
    *    (path: String) -> [R] -> (op: File^{withFile*} => R) -> R
    *
    *  which is clearly unsound.
@@ -315,6 +315,15 @@ extension (cls: ClassSymbol)
                                  // and err on the side of impure.
               && selfType.exists && selfType.captureSet.isAlwaysEmpty
 
+  def baseClassHasExplicitSelfType(using Context): Boolean =
+    cls.baseClasses.exists: bc =>
+      bc.is(CaptureChecked) && bc.givenSelfType.exists
+
+  def matchesExplicitRefsInBaseClass(refs: CaptureSet)(using Context): Boolean =
+    cls.baseClasses.tail.exists: bc =>
+      val selfType = bc.givenSelfType
+      bc.is(CaptureChecked) && selfType.exists && selfType.captureSet.elems == refs.elems
+
 extension (sym: Symbol)
 
   /** A class is pure if:

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

@@ -672,17 +672,13 @@ class CheckCaptures extends Recheck, SymTransformer:
     def checkInferredResult(tp: Type, tree: ValOrDefDef)(using Context): Type =
       val sym = tree.symbol
 
-      def isLocal =
-        sym.owner.ownersIterator.exists(_.isTerm)
-        || sym.accessBoundary(defn.RootClass).isContainedIn(sym.topLevelClass)
-
       def canUseInferred =    // If canUseInferred is false, all capturing types in the type of `sym` need to be given explicitly
         sym.is(Private)                   // private symbols can always have inferred types
         || sym.name.is(DefaultGetterName) // default getters are exempted since otherwise it would be
                                           // too annoying. This is a hole since a defualt getter's result type
                                           // might leak into a type variable.
         ||                                // non-local symbols cannot have inferred types since external capture types are not inferred
-          isLocal                         // local symbols still need explicit types if
+          sym.isLocalToCompilationUnit    // local symbols still need explicit types if
           && !sym.owner.is(Trait)         // they are defined in a trait, since we do OverridingPairs checking before capture inference
 
       def addenda(expected: Type) = new Addenda:
@@ -1182,7 +1178,7 @@ class CheckCaptures extends Recheck, SymTransformer:
     /** Check that self types of subclasses conform to self types of super classes.
      *  (See comment below how this is achieved). The check assumes that classes
      *  without an explicit self type have the universal capture set `{cap}` on the
-     *  self type. If a class without explicit self type is not `effectivelyFinal`
+     *  self type. If a class without explicit self type is not `effectivelySealed`
      *  it is checked that the inferred self type is universal, in order to assure
      *  that joint and separate compilation give the same result.
      */
@@ -1212,23 +1208,20 @@ class CheckCaptures extends Recheck, SymTransformer:
             checkSelfAgainstParents(root, root.baseClasses)
             val selfType = root.asClass.classInfo.selfType
             interpolator(startingVariance = -1).traverse(selfType)
-            if !root.isEffectivelySealed  then
-              def matchesExplicitRefsInBaseClass(refs: CaptureSet, cls: ClassSymbol): Boolean =
-                cls.baseClasses.tail.exists { psym =>
-                  val selfType = psym.asClass.givenSelfType
-                  selfType.exists && selfType.captureSet.elems == refs.elems
-                }
-              selfType match
-                case CapturingType(_, refs: CaptureSet.Var)
-                if !refs.elems.exists(_.isRootCapability) && !matchesExplicitRefsInBaseClass(refs, root) =>
-                  // Forbid inferred self types unless they are already implied by an explicit
-                  // self type in a parent.
-                  report.error(
-                    em"""$root needs an explicitly declared self type since its
-                        |inferred self type $selfType
-                        |is not visible in other compilation units that define subclasses.""",
-                    root.srcPos)
-                case _ =>
+            selfType match
+              case CapturingType(_, refs: CaptureSet.Var)
+              if !root.isEffectivelySealed
+                  && !refs.elems.exists(_.isRootCapability)
+                  && !root.matchesExplicitRefsInBaseClass(refs)
+              =>
+                // Forbid inferred self types unless they are already implied by an explicit
+                // self type in a parent.
+                report.error(
+                  em"""$root needs an explicitly declared self type since its
+                      |inferred self type $selfType
+                      |is not visible in other compilation units that define subclasses.""",
+                  root.srcPos)
+              case _ =>
             parentTrees -= root
             capt.println(i"checked $root with $selfType")
     end checkSelfTypes

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

@@ -517,21 +517,34 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         tree.symbol match
           case cls: ClassSymbol =>
             val cinfo @ ClassInfo(prefix, _, ps, decls, selfInfo) = cls.classInfo
-            if ((selfInfo eq NoType) || cls.is(ModuleClass) && !cls.isStatic)
-              && !cls.isPureClass
-            then
-              // add capture set to self type of nested classes if no self type is given explicitly.
-              val newSelfType = CapturingType(cinfo.selfType, CaptureSet.Var(cls))
-              val ps1 = inContext(ctx.withOwner(cls)):
-                ps.mapConserve(transformExplicitType(_))
-              val newInfo = ClassInfo(prefix, cls, ps1, decls, newSelfType)
+            def innerModule = cls.is(ModuleClass) && !cls.isStatic
+            val selfInfo1 =
+              if (selfInfo ne NoType) && !innerModule then
+                // if selfInfo is explicitly given then use that one, except if
+                // self info applies to non-static modules, these still need to be inferred
+                selfInfo
+              else if cls.isPureClass then
+                // is cls is known to be pure, nothing needs to be added to self type
+                selfInfo
+              else if !cls.isEffectivelySealed && !cls.baseClassHasExplicitSelfType then
+                // assume {cap} for completely unconstrained self types of publicly extensible classes
+                CapturingType(cinfo.selfType, CaptureSet.universal)
+              else
+                // Infer the self type for the rest, which is all classes without explicit
+                // self types (to which we also add nested module classes), provided they are
+                // neither pure, nor are publicily extensible with an unconstrained self type.
+                CapturingType(cinfo.selfType, CaptureSet.Var(cls))
+            val ps1 = inContext(ctx.withOwner(cls)):
+              ps.mapConserve(transformExplicitType(_))
+            if (selfInfo1 ne selfInfo) || (ps1 ne ps) then
+              val newInfo = ClassInfo(prefix, cls, ps1, decls, selfInfo1)
               updateInfo(cls, newInfo)
               capt.println(i"update class info of $cls with parents $ps selfinfo $selfInfo to $newInfo")
               cls.thisType.asInstanceOf[ThisType].invalidateCaches()
               if cls.is(ModuleClass) then
                 // if it's a module, the capture set of the module reference is the capture set of the self type
                 val modul = cls.sourceModule
-                updateInfo(modul, CapturingType(modul.info, newSelfType.captureSet))
+                updateInfo(modul, CapturingType(modul.info, selfInfo1.asInstanceOf[Type].captureSet))
                 modul.termRef.invalidateCaches()
           case _ =>
       case _ =>

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

@@ -1202,7 +1202,14 @@ object SymDenotations {
      *  is defined in Scala 3 and is neither abstract nor open.
      */
     final def isEffectivelySealed(using Context): Boolean =
-      isOneOf(FinalOrSealed) || isClass && !isOneOf(EffectivelyOpenFlags)
+      isOneOf(FinalOrSealed)
+      || isClass && (!isOneOf(EffectivelyOpenFlags)
+      || isLocalToCompilationUnit)
+
+    final def isLocalToCompilationUnit(using Context): Boolean =
+      is(Private)
+      || owner.ownersIterator.exists(_.isTerm)
+      || accessBoundary(defn.RootClass).isContainedIn(symbol.topLevelClass)
 
     final def isTransparentClass(using Context): Boolean =
       is(TransparentType)

scala2-library-cc/src/scala/collection/IndexedSeqView.scala

@@ -55,7 +55,6 @@ object IndexedSeqView {
 
   @SerialVersionUID(3L)
   private[collection] class IndexedSeqViewIterator[A](self: IndexedSeqView[A]^) extends AbstractIterator[A] with Serializable {
-    this: IndexedSeqViewIterator[A]^ =>
     private[this] var current = 0
     private[this] var remainder = self.length
     override def knownSize: Int = remainder
@@ -90,7 +89,6 @@ object IndexedSeqView {
   }
   @SerialVersionUID(3L)
   private[collection] class IndexedSeqViewReverseIterator[A](self: IndexedSeqView[A]^) extends AbstractIterator[A] with Serializable {
-    this: IndexedSeqViewReverseIterator[A]^ =>
     private[this] var remainder = self.length
     private[this] var pos = remainder - 1
     @inline private[this] def _hasNext: Boolean = remainder > 0

scala2-library-cc/src/scala/collection/Iterable.scala

@@ -9,7 +9,6 @@
  * See the NOTICE file distributed with this work for
  * additional information regarding copyright ownership.
  */
-
 package scala
 package collection
 
@@ -29,7 +28,6 @@ import language.experimental.captureChecking
 trait Iterable[+A] extends IterableOnce[A]
   with IterableOps[A, Iterable, Iterable[A]]
   with IterableFactoryDefaults[A, Iterable] {
-  this: Iterable[A]^ =>
 
   // The collection itself
   @deprecated("toIterable is internal and will be made protected; its name is similar to `toList` or `toSeq`, but it doesn't copy non-immutable collections", "2.13.7")
@@ -134,7 +132,6 @@ trait Iterable[+A] extends IterableOnce[A]
   *  and may be nondeterministic.
   */
 trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] with IterableOnceOps[A, CC, C] {
-  this: IterableOps[A, CC, C]^ =>
 
   /**
     * @return This collection as an `Iterable[A]`. No new collection will be built if `this` is already an `Iterable[A]`.

scala2-library-cc/src/scala/collection/IterableOnce.scala

@@ -43,7 +43,6 @@ import language.experimental.captureChecking
   * @define coll collection
   */
 trait IterableOnce[+A] extends Any {
-  this: IterableOnce[A]^ =>
 
   /** Iterator can be used only once */
   def iterator: Iterator[A]^{this}

scala2-library-cc/src/scala/collection/Iterator.scala

@@ -1302,5 +1302,4 @@ object Iterator extends IterableFactory[Iterator] {
 }
 
 /** Explicit instantiation of the `Iterator` trait to reduce class file size in subclasses. */
-abstract class AbstractIterator[+A] extends Iterator[A]:
-  this: Iterator[A]^ =>
+abstract class AbstractIterator[+A] extends Iterator[A]

scala2-library-cc/src/scala/collection/Map.scala

@@ -104,7 +104,6 @@ trait Map[K, +V]
 trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
   extends IterableOps[(K, V), Iterable, C]
     with PartialFunction[K, V] {
-  this: MapOps[K, V, CC, C]^ =>
 
   override def view: MapView[K, V]^{this} = new MapView.Id(this)
 

scala2-library-cc/src/scala/collection/MapView.scala

@@ -21,7 +21,6 @@ import caps.unsafe.unsafeAssumePure
 trait MapView[K, +V]
   extends MapOps[K, V, ({ type l[X, Y] = View[(X, Y)] })#l, View[(K, V)]]
     with View[(K, V)] {
-  this: MapView[K, V]^ =>
 
   override def view: MapView[K, V]^{this} = this
 
@@ -191,6 +190,5 @@ trait MapViewFactory extends collection.MapFactory[({ type l[X, Y] = View[(X, Y)
 
 /** Explicit instantiation of the `MapView` trait to reduce class file size in subclasses. */
 @SerialVersionUID(3L)
-abstract class AbstractMapView[K, +V] extends AbstractView[(K, V)] with MapView[K, V]:
-  this: AbstractMapView[K, V]^ =>
+abstract class AbstractMapView[K, +V] extends AbstractView[(K, V)] with MapView[K, V]