Treat added class refinements as inferred types for further processing

Without that step, class refinements can contain references to the generic
root `cap`.

Author: odersky

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

@@ -166,26 +166,27 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     *     pos.../lists.scala and pos/...curried-shorthands.scala fail.
     *     Need to figure out why.
     *  3. Refine other class types C by adding capture set variables to their parameter getters
-    *     (see addCaptureRefinements)
+    *     (see addCaptureRefinements), provided `refine` is true.
     *  4. Add capture set variables to all types that can be tracked
     *
     *  Polytype bounds are only cleaned using step 1, but not otherwise transformed.
     */
-  private def mapInferred(using Context) = new TypeMap:
+  private def mapInferred(refine: Boolean)(using Context): TypeMap = new TypeMap:
     override def toString = "map inferred"
 
     /** Refine a possibly applied class type C where the class has tracked parameters
      *  x_1: T_1, ..., x_n: T_n to C { val x_1: CV_1 T_1, ..., val x_n: CV_n T_n }
      *  where CV_1, ..., CV_n are fresh capture sets.
      */
     def addCaptureRefinements(tp: Type): Type = tp match
-      case _: TypeRef | _: AppliedType if tp.typeParams.isEmpty =>
+      case _: TypeRef | _: AppliedType if refine && tp.typeParams.isEmpty =>
         tp.typeSymbol match
           case cls: ClassSymbol
           if !defn.isFunctionClass(cls) && cls.is(CaptureChecked) =>
             cls.paramGetters.foldLeft(tp) { (core, getter) =>
               if atPhase(thisPhase.next)(getter.termRef.isTracked) then
-                val getterType = tp.memberInfo(getter).strippedDealias
+                val getterType =
+                  mapInferred(refine = false)(tp.memberInfo(getter)).strippedDealias
                 RefinedType(core, getter.name,
                     CapturingType(getterType, CaptureSet.RefiningVar(NoSymbol, getter)))
                   .showing(i"add capture refinement $tp --> $result", ccSetup)
@@ -254,7 +255,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
   end mapInferred
 
   private def transformInferredType(tp: Type)(using Context): Type =
-    mapInferred(tp)
+    mapInferred(refine = true)(tp)
 
   private def transformExplicitType(tp: Type, rootTarget: Symbol, tptToCheck: Option[Tree] = None)(using Context): Type =
     val expandAliases = new DeepTypeMap:

tests/neg-custom-args/captures/i15772.check

@@ -6,8 +6,8 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:20:46 ---------------------------------------
 20 |    val boxed1 : ((C^) => Unit) -> Unit = box1(c)  // error
    |                                          ^^^^^^^
-   |      Found:    (C{val arg: C^{cap[C]}}^{c} ->{'cap[main1..boxed1](from instantiating box1), c} Unit) ->{c} Unit
-   |      Required: (C^{cap[boxed1]} ->{cap[boxed1]} Unit) -> Unit
+   |  Found:    (C{val arg: C^{cap[main1]}}^{c} ->{'cap[main1..boxed1](from instantiating box1), c} Unit) ->{c} Unit
+   |  Required: (C^{cap[boxed1]} ->{cap[boxed1]} Unit) -> Unit
    |
    | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/i15772.scala:26:26 ------------------------------------------------------------
@@ -18,15 +18,15 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:27:35 ---------------------------------------
 27 |    val boxed2 : Observe[C^] = box2(c)  // error
    |                               ^^^^^^^
-   |      Found:    (C{val arg: C^{cap[C]}}^{c} ->{'cap[main2..boxed2](from instantiating box2), c} Unit) ->{c} Unit
-   |      Required: (C^{cap[boxed2]} ->{cap[boxed2]} Unit) -> Unit
+   |  Found:    (C{val arg: C^{cap[main2]}}^{c} ->{'cap[main2..boxed2](from instantiating box2), c} Unit) ->{c} Unit
+   |  Required: (C^{cap[boxed2]} ->{cap[boxed2]} Unit) -> Unit
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:33:33 ---------------------------------------
 33 |  val boxed2 : Observe[C]^ = box2(c) // error
    |                             ^^^^^^^
-   |                         Found:    (C{val arg: C^{cap[C]}}^{cap[main3]} ->{cap[main3]} Unit) ->{cap[main3]} Unit
-   |                         Required: (C ->{cap[boxed2]} Unit) ->{cap[boxed2]} Unit
+   |                     Found:    (C{val arg: C^{cap[main3]}}^{cap[main3]} ->{cap[main3]} Unit) ->{cap[main3]} Unit
+   |                     Required: (C ->{cap[boxed2]} Unit) ->{cap[boxed2]} Unit
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:44:2 ----------------------------------------

tests/neg-custom-args/captures/lazylist.check

@@ -8,8 +8,8 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylist.scala:35:29 -------------------------------------
 35 |  val ref1c: LazyList[Int] = ref1 // error
    |                             ^^^^
-   |                 Found:    (ref1 : lazylists.LazyCons[Int]{val xs: () ->{cap1} lazylists.LazyList[Int]^}^{cap1})
-   |                 Required: lazylists.LazyList[Int]
+   |                         Found:    lazylists.LazyCons[Int]{val xs: () ->{cap1} lazylists.LazyList[Int]^?}^{ref1}
+   |                         Required: lazylists.LazyList[Int]
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylist.scala:37:36 -------------------------------------

tests/neg-custom-args/captures/lazyref.check

@@ -1,28 +1,28 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazyref.scala:19:28 --------------------------------------
 19 |  val ref1c: LazyRef[Int] = ref1 // error
    |                            ^^^^
-   |                            Found:    (ref1 : LazyRef[Int]{val elem: () ->{cap1} Int}^{cap1})
+   |                            Found:    LazyRef[Int]{val elem: () ->{cap1} Int}^{ref1}
    |                            Required: LazyRef[Int]
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazyref.scala:21:35 --------------------------------------
 21 |  val ref2c: LazyRef[Int]^{cap2} = ref2 // error
    |                                   ^^^^
-   |                                  Found:    (ref2 : LazyRef[Int]{val elem: () ->{cap[<root>]} Int}^{cap2, ref1})
-   |                                  Required: LazyRef[Int]^{cap2}
+   |                                   Found:    LazyRef[Int]{val elem: () ->{cap[test]} Int}^{ref2}
+   |                                   Required: LazyRef[Int]^{cap2}
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazyref.scala:23:35 --------------------------------------
 23 |  val ref3c: LazyRef[Int]^{ref1} = ref3 // error
    |                                   ^^^^
-   |                                  Found:    (ref3 : LazyRef[Int]{val elem: () ->{cap[<root>]} Int}^{cap2, ref1})
-   |                                  Required: LazyRef[Int]^{ref1}
+   |                                   Found:    LazyRef[Int]{val elem: () ->{cap[test]} Int}^{ref3}
+   |                                   Required: LazyRef[Int]^{ref1}
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazyref.scala:25:35 --------------------------------------
 25 |  val ref4c: LazyRef[Int]^{cap1} = ref4 // error
    |                                   ^^^^
-   |                                  Found:    (ref4 : LazyRef[Int]{val elem: () ->{cap[<root>]} Int}^{cap2, cap1})
-   |                                  Required: LazyRef[Int]^{cap1}
+   |                                   Found:    LazyRef[Int]{val elem: () ->{cap[test]} Int}^{ref4}
+   |                                   Required: LazyRef[Int]^{cap1}
    |
    | longer explanation available when compiling with `-explain`

tests/pos-custom-args/captures/nested-classes-2.scala

@@ -0,0 +1,25 @@
+
+def f(x: (() => Unit)): (() => Unit) => (() => Unit) =
+  def g(y: (() => Unit)): (() => Unit) = x
+  g
+
+def test1(x: (() => Unit)): Unit =
+  def test2(y: (() => Unit)) =
+    val a: (() => Unit) => (() => Unit) = f(y)
+    a(x)            // OK, but should be error
+  test2(() => ())
+
+def test2(x1: (() => Unit), x2: (() => Unit) => Unit) =
+  class C1(x1: (() => Unit), xx2: (() => Unit) => Unit):
+    def c2(y1: (() => Unit), y2: (() => Unit) => Unit): C2^{cap} = C2(y1, y2)
+    class C2(y1: (() => Unit), y2: (() => Unit) => Unit):
+      val a: (() => Unit) => (() => Unit) = f(y1)
+      a(x1)            //OK, but should be error
+    C2(() => (), x => ())
+
+  def test3(y1: (() => Unit), y2: (() => Unit) => Unit) =
+    val cc1/*: C1^{cap[test3]}*/ = C1(y1, y2)  // error (but should be OK)
+    val cc2 = cc1.c2(x1, x2)         // error (but should be OK)
+    ()
+    //val cc3: cc1.C2^{cap[test2]} = cc2
+

tests/pos/functorial-functors.scala

@@ -0,0 +1,14 @@
+class Common:
+
+  trait Functor:
+    type F[X]
+    extension [A](x: F[A]) def map[B](f: A => B): F[B]
+
+  trait Monad extends Functor:
+    extension [A](x: F[A])
+      def flatMap[B](f: A => F[B]): F[B]
+      def map[B](f: A => B) = x.flatMap(f `andThen` pure)
+
+    def pure[A](x: A): F[A]
+end Common
+