Fix dependent function setup for capture checking (#16542)

Fixes #15925.

This issue is caused by a bug in `mapInferred` during CC `Setup`. In
this function we convert all top-level non-dependent functions to its
dependent counterpart. However, it does not correctly handle the case
when the type is an alias to function types. The problematic case in the
pattern matching:
```scala
case tp @ AppliedType(tycon, args) =>
  val tycon1 = this(tycon)
  if defn.isNonRefinedFunction(tp) then
    // Convert toplevel generic function types to dependent functions
    val args0 = args.init
    var res0 = args.last
    val args1 = mapNested(args0)
    val res1 = this(res0)
    // ... do the conversion
```
It retrieves the argument and the result type of the function directly
from the applied type arguments. This works for function classes.
However, if the type here is a type alias to the function, e.g. `type
Lazy[X] = Unit => X`, it is still recognized as a function (since
`defn.isNonRefinedFunction` does dealiasing) but it is incorrect to get
the argument and result type of the function from the type parameter
list here (which is just `X :: Nil`).

To fix this, we will dealias the type and recurse when it is an alias to
the function type.

Author: odersky

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

@@ -212,17 +212,22 @@ extends tpd.TreeTraverser:
           val tycon1 = this(tycon)
           if defn.isNonRefinedFunction(tp) then
             // Convert toplevel generic function types to dependent functions
-            val args0 = args.init
-            var res0 = args.last
-            val args1 = mapNested(args0)
-            val res1 = this(res0)
-            if isTopLevel then
-              depFun(tycon1, args1, res1)
-                .showing(i"add function refinement $tp --> $result", capt)
-            else if (tycon1 eq tycon) && (args1 eq args0) && (res1 eq res0) then
-              tp
+            if !defn.isFunctionSymbol(tp.typeSymbol) && (tp.dealias ne tp) then
+              // This type is a function after dealiasing, so we dealias and recurse.
+              // See #15925.
+              this(tp.dealias)
             else
-              tp.derivedAppliedType(tycon1, args1 :+ res1)
+              val args0 = args.init
+              var res0 = args.last
+              val args1 = mapNested(args0)
+              val res1 = this(res0)
+              if isTopLevel then
+                depFun(tycon1, args1, res1)
+                  .showing(i"add function refinement $tp ($tycon1, $args1, $res1) (${tp.dealias}) --> $result", capt)
+              else if (tycon1 eq tycon) && (args1 eq args0) && (res1 eq res0) then
+                tp
+              else
+                tp.derivedAppliedType(tycon1, args1 :+ res1)
           else
             tp.derivedAppliedType(tycon1, args.mapConserve(arg => this(arg)))
         case tp @ RefinedType(core, rname, rinfo) if defn.isFunctionType(tp) =>

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

@@ -0,0 +1,13 @@
+import language.experimental.captureChecking
+
+class Unit
+object unit extends Unit
+
+type Foo[X] = [T] -> (op: X => T) -> T
+type Lazy[X] = Unit => X
+
+def force[X](fx: Foo[Lazy[X]]): X =
+  fx[X](f => f(unit))  // error
+
+def force2[X](fx: Foo[Unit => X]): X =
+  fx[X](f => f(unit))  // error