Generalize search for function type in expected type

In particular, handle situations like:
  val x: (Int => Int) & (Int => Int) = x => x
which end up arising in at least one test case during
type inference after the avoidance fixes in this PR.

Author: smarter

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -1674,23 +1674,19 @@ object Types {
       case _ => resultType
     }
 
-    /** Find the function type in union.
-     *  If there are multiple function types, NoType is returned.
+    /** Determine the expected function type from the prototype. If multiple
+     *  function types are found in a union or intersection, their intersection
+     *  is returned. If no function type is found, Any is returned.
      */
-    def findFunctionTypeInUnion(using Context): Type = this match {
-      case t: OrType =>
-        val t1 = t.tp1.findFunctionTypeInUnion
-        if t1 == NoType then t.tp2.findFunctionTypeInUnion else
-          val t2 = t.tp2.findFunctionTypeInUnion
-          // Returen NoType if the union contains multiple function types
-          if t2 == NoType then t1 else NoType
+    def findFunctionType(using Context): Type = dealias match
+      case tp: AndOrType =>
+        tp.tp1.findFunctionType & tp.tp2.findFunctionType
       case t if defn.isNonRefinedFunction(t) =>
         t
       case t @ SAMType(_) =>
         t
       case _ =>
-        NoType
-    }
+        defn.AnyType
 
     /** This type seen as a TypeBounds */
     final def bounds(using Context): TypeBounds = this match {

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

@@ -1169,7 +1169,7 @@ class Typer extends Namer
     pt1 match {
       case tp: TypeParamRef =>
         decomposeProtoFunction(ctx.typerState.constraint.entry(tp).bounds.hi, defaultArity, pos)
-      case _ => pt1.findFunctionTypeInUnion match {
+      case _ => pt1.findFunctionType match {
         case pt1 if defn.isNonRefinedFunction(pt1) =>
           // if expected parameter type(s) are wildcards, approximate from below.
           // if expected result type is a wildcard, approximate from above.
@@ -1444,7 +1444,7 @@ class Typer extends Namer
       if (tree.tpt.isEmpty)
         meth1.tpe.widen match {
           case mt: MethodType =>
-            pt.findFunctionTypeInUnion match {
+            pt.findFunctionType match {
               case pt @ SAMType(sam)
               if !defn.isFunctionType(pt) && mt <:< sam =>
                 // SAMs of the form C[?] where C is a class cannot be conversion targets.

tests/neg/i11694.scala

@@ -4,12 +4,19 @@ def test1 = {
 
   def f21: (Int => Int) | Null = x => x + 1
   def f22: Null | (Int => Int) = x => x + 1
+
+  def f31: (Int => Int) | (Int => Int) = x => x + 1
+  def f32: (Int => Int) | (Int => Int) | Unit = x => x + 1
+
+  def f41: (Int => Int) & (Int => Int) = x => x + 1
+  def f42: (Int => Int) & (Int => Int) & Any = x => x + 1
 }
 
 def test2 = {
   def f1: (Int => String) | (Int => Int) | Null = x => x + 1 // error
   def f2: (Int => String) | Function[String, Int] | Null = x => "" + x // error
   def f3: Function[Int, Int] | Function[String, Int] | Null = x => x + 1 // error
+  def f4: (Int => Int) & (Int => Int) & Unit = x => x + 1 // error
 }
 
 def test3 = {