Bugfix: More lenient definition when an inferred type is OK for visible definition

We now allow an inferred type of the form `{C.this} T` if `C` is a pure class.
This is OK since such a type is equivalent to `T`.

Author: odersky

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

@@ -168,6 +168,17 @@ extension (tp: Type)
 
 extension (sym: Symbol)
 
+  /** A class is pure if one of its base types has an explicitly declared self type
+   *  with an empty capture set.
+   */
+  def isPureClass(using Context): Boolean = sym match
+    case cls: ClassSymbol =>
+      cls.baseClasses.exists(bc =>
+        val selfType = bc.givenSelfType
+        selfType.exists && selfType.captureSet.isAlwaysEmpty)
+    case _ =>
+      false
+
   /** Does this symbol allow results carrying the universal capability?
    *  Currently this is true only for function type applies (since their
    *  results are unboxed) and `erasedValue` since this function is magic in

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

@@ -877,10 +877,15 @@ class CheckCaptures extends Recheck, SymTransformer:
               isLocal                               // local symbols still need an explicit types if
               && !sym.owner.is(Trait)               //   - they are defined in a trait, since we do OverridingPairs checking before capture inference
               && !sym.allOverriddenSymbols.nonEmpty //   - they override some other symbol, since we do override checking before capture inference
+          def isNotPureThis(ref: CaptureRef) = ref match {
+            case ref: ThisType => !ref.cls.isPureClass
+            case _ => true
+          }
           if !canUseInferred then
             val inferred = t.tpt.knownType
             def checkPure(tp: Type) = tp match
-              case CapturingType(_, refs) if !refs.elems.isEmpty =>
+              case CapturingType(_, refs)
+              if !refs.elems.filter(isNotPureThis).isEmpty =>
                 val resultStr = if t.isInstanceOf[DefDef] then " result" else ""
                 report.error(
                   em"""Non-local $sym cannot have an inferred$resultStr type

compiler/test/dotc/pos-test-pickling.blacklist

@@ -84,7 +84,6 @@ boxmap-paper.scala
 # Function types print differnt after unpickling since test mispredicts Feature.preFundsEnabled
 caps-universal.scala
 
-
 # GADT cast applied to singleton type difference
 i4176-gadt.scala
 

tests/pos-custom-args/captures/capt-test.scala

@@ -21,6 +21,9 @@ def map[A, B](f: A => B)(xs: LIST[A]): LIST[B] =
 class C
 type Cap = {*} C
 
+class Foo(x: Cap):
+  this: {x} Foo =>
+
 def test(c: Cap, d: Cap) =
   def f(x: Cap): Unit = if c == x then ()
   def g(x: Cap): Unit = if d == x then ()

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

@@ -0,0 +1,10 @@
+  trait A:
+    self: A =>
+    def foo: Int
+
+  abstract class B extends A:
+    def foo: Int
+
+  class C extends B:
+    def foo = 1
+    def derived = this