Infer more self types automatically

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 types 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:
@@ -1178,7 +1174,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.
      */
@@ -1208,23 +1204,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

@@ -1197,7 +1197,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)

tests/neg-custom-args/captures/cc-this4.check

@@ -1,6 +1,7 @@
--- Error: tests/neg-custom-args/captures/cc-this4.scala:1:11 -----------------------------------------------------------
-1 |open class C: // error
-  |           ^
-  |           class C needs an explicitly declared self type since its
-  |           inferred self type C^{}
-  |           is not visible in other compilation units that define subclasses.
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/cc-this4.scala:2:13 --------------------------------------
+2 |  val x: C = this  // error
+  |             ^^^^
+  |             Found:    (C.this : C^)
+  |             Required: C
+  |
+  | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/cc-this4.scala

@@ -1,5 +1,5 @@
-open class C: // error
-  val x: C = this
+open class C:
+  val x: C = this  // error
 
 open class D:
   this: D =>

tests/pos-custom-args/captures/colltest.scala

@@ -3,22 +3,18 @@ object CollectionStrawMan5 {
 
   /** Base trait for generic collections */
   trait Iterable[+A] extends IterableLike[A] {
-    this: Iterable[A]^ =>
     def iterator: Iterator[A]^{this}
     def coll: Iterable[A]^{this} = this
   }
 
   trait IterableLike[+A]:
-    this: IterableLike[A]^ =>
     def coll: Iterable[A]^{this}
     def partition(p: A => Boolean): Unit =
       val pn = Partition(coll, p)
       ()
 
   /** Concrete collection type: View */
-  trait View[+A] extends Iterable[A] with IterableLike[A] {
-    this: View[A]^ =>
-  }
+  trait View[+A] extends Iterable[A] with IterableLike[A]
 
   case class Partition[A](val underlying: Iterable[A]^, p: A => Boolean) {
     self: Partition[A]^{underlying, p} =>

tests/pos-custom-args/captures/future-traverse.scala

@@ -5,7 +5,7 @@ trait BuildFrom[-From, -A, +C] {
   def newBuilder(from: From): Builder[A, C]
 }
 
-trait Future[+T] { this: Future[T]^ =>
+trait Future[+T] {
   import Future.*
   def foldLeft[R](r: R): R = r
   def traverse[A, B, M[X] <: IterableOnce[X]](in: M[A]^, bf: BuildFrom[M[A]^, B, M[B]^]): Unit =

tests/pos-custom-args/captures/hk-param.scala

@@ -12,6 +12,5 @@ trait Itable[+A] extends ItableOnce[A] with ILike[A, Itable^]
 
 /** Iterator can be used only once */
 trait ItableOnce[+A] {
-  this: ItableOnce[A]^ =>
   def iterator: Iterator[A]^{this}
 }

tests/pos-custom-args/captures/iterators.scala

@@ -1,7 +1,6 @@
 package cctest
 
 trait IterableOnce[A]:
-  this: IterableOnce[A]^ =>
   def iterator: Iterator[A]^{this}
 
 abstract class Iterator[T]: