Fix test, make new test that breaks

The case where the left side isn't a function type/ is a type param now
works for non dependent type cases. HOWEVER, now the compiler rejects
constructions like `untupled` for dependent types, when it should accept
them.

[skip community_build]
[skip docs]
[skip test_windows_fast]
[skip mima]

Author: TheDrawingCoder-Gamer

compiler/src/dotty/tools/dotc/typer/Synthesizer.scala

@@ -178,14 +178,25 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
                   case _ => -1
           else if defn.isFunctionNType(tupled) then
             // TupledFunction[?, (...) => R]
-            dealiasedTupled.argInfos match
-              case tupledArgs :: funRet :: Nil =>
-                // TupledFunction[?, ((...)) => R]
-                tupledArgs.tupleElementTypes match
-                  case Some(args) if doesFunctionUntupleTo(dealiasedTupled, args, funRet, dealiasedFun) =>
-                    args.size
+            dealiasedTupled match
+              case defn.RefinedFunctionOf(method: MethodType) =>
+                method.argInfos match
+                  case tupledArgs :: funRet :: Nil =>
+                    // TupledFunction[?, ((...)) => R]
+                    tupledArgs.tupleElementTypes match
+                      case Some(args) if doesFunctionUntupleTo(dealiasedTupled, args, funRet, dealiasedFun) =>
+                        args.size
+                      case _ => -1
+                  case _ => -1
+              case _ =>
+                tupled.functionArgInfos match
+                  case tupledArgs :: funRet :: Nil =>
+                    // TupledFunction[?, ((...)) => R]
+                    tupledArgs.tupleElementTypes match
+                        case Some(args) if functionTypeEqual(dealiasedTupled, args, funRet, dealiasedFun) =>
+                          args.size
+                        case _ => -1
                   case _ => -1
-              case _ => -1
           else
             // TupledFunction[?, ?]
             -1

tests/run/i21808.scala

@@ -0,0 +1,23 @@
+//> using options -experimental
+
+import scala.util.TupledFunction
+object Test {
+  def main(args: Array[String]): Unit = {
+
+    val f2: (x: (Int, Long)) => x._1.type = (args: (Int, Long)) => args._1
+    val g2: (x: Int, y: Long) => x.type = f2.untupled
+    println(g2(1, 3L))
+
+  }
+
+  /** Creates an untupled version of this function: instead of a single argument of type [[scala.Tuple]] with N elements,
+    *  it accepts N arguments.
+    *
+    *  This is a generalization of [[scala.Function.untupled]] that work on functions of any arity
+    *
+    *  @tparam F the function type
+    *  @tparam Args the tuple type with the same types as the function arguments of F
+    *  @tparam R the return type of F
+    */
+  extension [F, Args <: Tuple, R](f: Args => R) def untupled(using tf: TupledFunction[F, Args => R]): F = tf.untupled(f)
+}