Improve fluidify

 - Also add Fluid to function types
 - Add Fluid recursively in arguments of fluidified types
 - But stop when a capturing type is encountered

Also, fix needsVariable for FromJavaObject. FromJavaObject should behave like
Any (i.e. no capture set variable needs to be added).

Author: odersky

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

@@ -291,20 +291,23 @@ class CheckCaptures extends Recheck, SymTransformer:
       if sym.exists && curEnv.isOpen then markFree(capturedVars(sym), pos)
 
     private def handleBackwardsCompat(tp: Type, sym: Symbol, initialVariance: Int = 1)(using Context): Type =
-      val fluidify = new TypeMap:
+      val fluidify = new TypeMap with IdempotentCaptRefMap:
         variance = initialVariance
         def apply(t: Type): Type = t match
-          case tp: MethodType =>
-            mapOver(tp)
-          case tp: TypeLambda =>
-            tp.derivedLambdaType(resType = this(tp.resType))
-          case tp @ RefinedType(parent, rname, rinfo: MethodType) if defn.isFunctionType(tp) =>
-            tp.derivedRefinedType(parent, rname, this(rinfo))
-          case tp @ AppliedType(tycon, args) if defn.isNonRefinedFunction(tp) =>
-            mapOver(tp)
+          case t: MethodType =>
+            mapOver(t)
+          case t: TypeLambda =>
+            t.derivedLambdaType(resType = this(t.resType))
+          case CapturingType(_, _) =>
+            t
           case _ =>
-            if variance > 0 then t
-            else Setup.decorate(t, Function.const(CaptureSet.Fluid))
+            val t1  = t match
+              case t @ RefinedType(parent, rname, rinfo: MethodType) if defn.isFunctionType(t) =>
+                t.derivedRefinedType(parent, rname, this(rinfo))
+              case _ =>
+                mapOver(t)
+            if variance > 0 then t1
+            else Setup.decorate(t1, Function.const(CaptureSet.Fluid))
 
       def isPreCC(sym: Symbol): Boolean =
         sym.isTerm && sym.maybeOwner.isClass

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

@@ -418,15 +418,17 @@ object Setup:
   def needsVariable(tp: Type)(using Context): Boolean = {
     tp.typeParams.isEmpty && tp.match
       case tp: (TypeRef | AppliedType) =>
-        val tp1 = tp.dealias
-        if tp1 ne tp then needsVariable(tp1)
+        val sym = tp.typeSymbol
+        if sym.isClass then
+          !sym.isPureClass && sym != defn.AnyClass
         else
-          val sym = tp1.typeSymbol
-          if sym.isClass then
-            !sym.isPureClass
-            && sym != defn.AnyClass
-            && sym != defn.FromJavaObjectSymbol
-          else superTypeIsImpure(tp1)
+          sym != defn.FromJavaObjectSymbol
+            // For capture checking, we assume Object from Java is the same as Any
+          && {
+            val tp1 = tp.dealias
+            if tp1 ne tp then needsVariable(tp1)
+            else superTypeIsImpure(tp1)
+          }
       case tp: (RefinedOrRecType | MatchType) =>
         needsVariable(tp.underlying)
       case tp: AndType =>

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

@@ -1,4 +1,3 @@
-import caps.unsafe.*
 def test =
   val tasks = new collection.mutable.ArrayBuffer[() => Unit]
-  val _: Unit = tasks.foreach(((task: () => Unit) => task()).unsafeBoxFunArg)
+  val _: Unit = tasks.foreach(((task: () => Unit) => task()))

tests/pos/cc-backwards-compat/A.scala

@@ -1,4 +1,5 @@
 package p
-class A:
+class A(f: Int => Int):
+  def foo(f: Int => Int) = ???
   def map(other: Iter): Iter = other
   def pair[T](x: T): (T, T) = (x, x)

tests/pos/cc-backwards-compat/Iter.scala

@@ -5,6 +5,8 @@ class Iter:
   self: Iter^ =>
 
 def test(it: Iter^) =
-  val a = A()
-  //val b = a.map(it)   // does not work yet
+  val f: Int ->{it} Int = ???
+  val a = new A(f)
+  val b = a.map(it)   // does not work yet
   val c = a.pair(it)
+  val d = a.foo(f)