only create boxed environment for function values and references

Author: Linyxus

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

@@ -507,14 +507,28 @@ class CheckCaptures extends Recheck, SymTransformer:
       recheckFinish(result, arg, pt)
     */
 
+    extension (tree: Tree)
+      private def isFunctionLiteral(using Context): Boolean = tree match
+        case Block((defTree @ DefDef(_, _, _, _)) :: Nil, Closure(_, meth, _)) =>
+          val defSym = defTree.symbol
+          val methSym = meth.symbol
+          defSym.eq(methSym)
+        case _ =>
+          false
+
+      private def isIdent: Boolean = tree match
+        case Ident(_) => true
+        case _        => false
+
     /** If expected type `pt` is boxed, don't propagate free variables.
      *  Otherwise, if the result type is boxed, simulate an unboxing by
      *  adding all references in the boxed capture set to the current environment.
      */
     override def recheck(tree: Tree, pt: Type = WildcardType)(using Context): Type =
       if tree.isTerm && pt.isBoxedCapturing then
         val saved = curEnv
-        curEnv = Env(curEnv.owner, nestedInOwner = false, CaptureSet.Var(), isBoxed = true, curEnv)
+        if tree.isIdent || tree.isFunctionLiteral then
+          curEnv = Env(curEnv.owner, nestedInOwner = false, CaptureSet.Var(), isBoxed = true, curEnv)
         try super.recheck(tree, pt)
         finally curEnv = saved
       else

tests/neg-custom-args/captures/i16114.scala

@@ -0,0 +1,46 @@
+trait Cap { def use(): Int; def close(): Unit }
+def mkCap(): {*} Cap = ???
+
+def expect[T](x: T): x.type = x
+
+def withCap[T](op: ({*} Cap) => T): T = {
+  val cap: {*} Cap = mkCap()
+  val result = op(cap)
+  cap.close()
+  result
+}
+
+def main(fs: {*} Cap): Unit = {
+  def badOp(io: {*} Cap): {} Unit -> Unit = {
+    val op1: {io} Unit -> Unit = (x: Unit) =>  // error // limitation
+      expect[{*} Cap] {
+        io.use()
+        fs
+      }
+
+    val op2: {fs} Unit -> Unit = (x: Unit) =>  // error // limitation
+      expect[{*} Cap] {
+        fs.use()
+        io
+      }
+
+    val op3: {io} Unit -> Unit = (x: Unit) =>  // ok
+      expect[{*} Cap] {
+        io.use()
+        io
+      }
+
+    val op4: {} Unit -> Unit = (x: Unit) =>  // ok
+      expect[{*} Cap](io)
+
+    val op: {} Unit -> Unit = (x: Unit) =>  // error
+      expect[{*} Cap] {
+        io.use()
+        io
+      }
+    op
+  }
+
+  val leaked: {} Unit -> Unit = withCap(badOp)
+  leaked(())
+}