Update comments; add test cases for function type inference with union types.

Author: noti0na1

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

@@ -1921,21 +1921,21 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         NoType
     }
 
-    def instantiateInUnion(tp: Type): Unit = tp match
+    def tryToInstantiateInUnion(tp: Type): Unit = tp match
       case tp: OrType =>
-        instantiateInUnion(tp.tp1)
-        instantiateInUnion(tp.tp2)
+        tryToInstantiateInUnion(tp.tp1)
+        tryToInstantiateInUnion(tp.tp2)
       case tp: FlexibleType =>
-        instantiateInUnion(tp.hi)
+        tryToInstantiateInUnion(tp.hi)
       case tp: TypeVar =>
         isFullyDefined(tp, ForceDegree.flipBottom)
       case _ =>
 
     if untpd.isFunctionWithUnknownParamType(tree) && !calleeType.exists then
-      // try to instantiate `pt` if this is possible. If it does not
-      // work the error will be reported later in `inferredParam`,
-      // when we try to infer the parameter type.
-      instantiateInUnion(pt)
+      // Try to instantiate `pt` when possible, including type variables in union types
+      // to help finding function types. If it does not work the error will be reported
+      // later in `inferredParam`, when we try to infer the parameter type.
+      tryToInstantiateInUnion(pt)
 
     val (protoFormals, resultTpt) = decomposeProtoFunction(pt, params.length, tree.srcPos)
 

tests/pos/infer-function-type-in-union.scala

@@ -0,0 +1,32 @@
+
+def f[T](x: T): T = ???
+def f2[T](x: T | T): T = ???
+def f3[T](x: T | Null): T = ???
+def f4[T](x: Int | T): T = ???
+
+trait MyOption[+T]
+
+object MyOption:
+  def apply[T](x: T | Null): MyOption[T] = ???
+
+def test =
+  val g: AnyRef => Boolean = f {
+    x => x eq null // ok
+  }
+  val g2: AnyRef => Boolean = f2 {
+    x => x eq null // ok
+  }
+  val g3: AnyRef => Boolean = f3 {
+    x => x eq null // was error
+  }
+  val g4: AnyRef => Boolean = f4 {
+    x => x eq null // was error
+  }
+
+  val o1: MyOption[String] = MyOption(null)
+  val o2: MyOption[String => Boolean] = MyOption {
+    x => x.length > 0
+  }
+  val o3: MyOption[(String, String) => Boolean] = MyOption {
+    (x, y) => x.length > y.length
+  }