Refine handling of val-bound closures

Don't treat them as level roots if they are implicit eta expansions that
don't mention `cap` explicitly.

Author: odersky

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -813,6 +813,23 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case _ => tree
   }
 
+  /** An extractor for eta expanded `mdef` an eta-expansion of a method reference? To recognize this, we use
+   *  the following criterion: A method definition is an eta expansion, if
+   *  it contains at least one term paramter, the parameter has a zero extent span,
+   *  and the right hand side is either an application or a closure with'
+   *  an anonymous method that's itself characterized as an eta expansion.
+   */
+  def isEtaExpansion(mdef: DefDef)(using Context): Boolean =
+    !rhsOfEtaExpansion(mdef).isEmpty
+
+  def rhsOfEtaExpansion(mdef: DefDef)(using Context): Tree = mdef.paramss match
+    case (param :: _) :: _ if param.asInstanceOf[Tree].span.isZeroExtent =>
+      mdef.rhs match
+        case rhs: Apply => rhs
+        case closureDef(mdef1) => rhsOfEtaExpansion(mdef1)
+        case _ => EmptyTree
+    case _ => EmptyTree
+
   /** The variables defined by a pattern, in reverse order of their appearance. */
   def patVars(tree: Tree)(using Context): List[Symbol] = {
     val acc = new TreeAccumulator[List[Symbol]] { outer =>

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

@@ -606,13 +606,6 @@ class CheckCaptures extends Recheck, SymTransformer:
       // rechecking the body.
       openClosures = (mdef.symbol, pt) :: openClosures
       try
-        def isEtaExpansion(mdef: DefDef): Boolean = mdef.paramss match
-          case (param :: _) :: _ if param.asInstanceOf[Tree].span.isZeroExtent =>
-            mdef.rhs match
-              case _: Apply => true
-              case closureDef(mdef1) => isEtaExpansion(mdef1)
-              case _ => false
-          case _ => false
         val res = recheckClosure(expr, pt, forceDependent = true)
         if !isEtaExpansion(mdef) then
           // If closure is an eta expanded method reference it's better to not constrain

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

@@ -314,10 +314,23 @@ extends tpd.TreeTraverser:
             case _ =>
               traverseChildren(tree)
       case tree @ ValDef(_, tpt: TypeTree, rhs) =>
+        def containsCap(tp: Type) = tp.existsPart:
+          case CapturingType(_, refs) => refs.isUniversal
+          case _ => false
+        def mentionsCap(tree: Tree): Boolean = tree match
+          case Apply(fn, _) => mentionsCap(fn)
+          case TypeApply(fn, args) => args.exists(mentionsCap)
+          case _: InferredTypeTree => false
+          case _: TypeTree => containsCap(expandAliases(tree.tpe))
+          case _ => false
         val mapRoots = rhs match
-          case possiblyTypedClosureDef(ddef) =>
+          case possiblyTypedClosureDef(ddef) if !mentionsCap(rhsOfEtaExpansion(ddef)) =>
             ddef.symbol.setNestingLevel(ctx.owner.nestingLevel + 1)
-              // toplevel closures bound to vals count as level owners
+              // Toplevel closures bound to vals count as level owners
+              // unless the closure is an implicit eta expansion over a type application
+              // that mentions `cap`. In that case we prefer not to silently rebind
+              // the `cap` to a local root of an invisible closure. See
+              // pos-custom-args/captures/eta-expansions.scala for examples of both cases.
             !tpt.isInstanceOf[InferredTypeTree]
               // in this case roots in inferred val type count as polymorphic
           case _ =>

tests/pos-custom-args/captures/eta-expansions.scala

@@ -0,0 +1,9 @@
+@annotation.capability class Cap
+
+def test(d: Cap) =
+  def map2(xs: List[Int])(f: Int => Int): List[Int] = xs.map(f)
+  val f1 = map2                      // capture polymorphic implicit eta expansion
+  def f2c: List[Int] => (Int => Int) => List[Int] = f1
+  val a0 = identity[Cap ->{d} Unit]  // capture monomorphic implicit eta expansion
+  val a0c: (Cap ->{d} Unit) ->{d} Cap ->{d} Unit = a0
+  val b0 = (x: Cap ->{d} Unit) => identity[Cap ->{d} Unit](x) // not an implicit eta expansion, hence capture polymorphic