Fix calleeType

This one will bring back previously fixed regressions that have to be looked at separately.

Author: odersky

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

@@ -1876,6 +1876,17 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
      */
     var paramIndex = Map[Name, Int]()
 
+    def containsParamRef(tree: untpd.Tree, params: List[untpd.ValDef]): Boolean =
+      import untpd.*
+      val acc = new UntypedTreeAccumulator[Boolean]:
+        def apply(x: Boolean, t: Tree)(using Context) =
+          if x then true
+          else t match
+            case _: untpd.TypedSplice => false
+            case Ident(name) => params.exists(_.name == name)
+            case _ => foldOver(x, t)
+      acc(false, tree)
+
     /** Infer parameter type from the body of the function
      *
      *  1. If function is of the form
@@ -1910,24 +1921,25 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           for (param <- params; idx <- paramIndices(param, args))
           yield param.name -> idx
         }.toMap
-        if (paramIndex.size == params.length)
+        if (paramIndex.size == params.length) then
           expr match
             case untpd.TypedSplice(expr1) =>
               expr1.tpe
-            case _ =>
+            case _ if !containsParamRef(expr, params) =>
               val outerCtx = ctx
               val nestedCtx = outerCtx.fresh.setNewTyperState()
-              inContext(nestedCtx) {
-                val protoArgs = args.map(_.withType(WildcardType))
+              inContext(nestedCtx):
+                // try to type expr with fresh unknown arguments.
+                val protoArgs = args.map(arg => untpd.Ident(UniqueName.fresh()).withSpan(arg.span))
                 val callProto = FunProto(protoArgs, WildcardType)(this, app.applyKind)
                 val expr1 = typedExpr(expr, callProto)
                 if nestedCtx.reporter.hasErrors then NoType
-                else inContext(outerCtx) {
+                else inContext(outerCtx):
                   nestedCtx.typerState.commit()
                   fnBody = cpy.Apply(fnBody)(untpd.TypedSplice(expr1), args)
                   expr1.tpe
-                }
-              }
+            case _ =>
+              NoType
         else NoType
       case _ =>
         NoType

tests/pos/i12679.scala

@@ -7,3 +7,11 @@ object Example:
 
   def example[F[_]](maybeQux: Option[String], bool: Boolean) =
     maybeQux.fold(foo[F](bool))(foo[F](_))
+
+object Example2:
+  def foo(qux: String, quux: String = ""): Unit = ???
+
+  def foo(qux: Boolean): Unit = ???
+
+  def example(maybeQux: Option[String], bool: Boolean) =
+    maybeQux.fold(foo(bool))(s => foo(s))

tests/pos/i24686.scala

@@ -0,0 +1,20 @@
+def Test = Seq.empty[DenseMatrix[Double]].reduce(DenseMatrix.horzcat(_, _))
+
+trait Matrix[T]
+trait DenseMatrix[T] extends Matrix[T]
+
+object DenseMatrix:
+    def horzcat[M, V](matrices: M*)(using OpSet.InPlaceImpl2[DenseMatrix[V], M]): DenseMatrix[V] = ???
+
+object OpSet extends HasOps:
+  trait InPlaceImpl2[V1, V2]
+
+trait HasOps
+object HasOps extends DenseMatrixExpandedOps with DensMatrixLowPriority
+
+trait DenseMatrixExpandedOps:
+  given OpSet.InPlaceImpl2[DenseMatrix[Double], DenseMatrix[Double]] = ???
+
+trait DensMatrixLowPriority extends LowPriorityDenseMatrix1
+trait LowPriorityDenseMatrix1:
+  given [V]: OpSet.InPlaceImpl2[DenseMatrix[V], Matrix[V]] = ???

tests/pos/i24689a.scala

@@ -0,0 +1,13 @@
+import java.io.*
+import java.nio.file.*
+
+abstract class Using[Source, A]:
+  def apply[R](src: Source)(f: A => R): R = ???
+
+object Using:
+  val fileInputStream: Using[Path, InputStream] = ???
+
+def transfer(in: Path, out: OutputStream): Unit =
+  Using.fileInputStream(in)(in => transfer(in, out))
+
+def transfer(in: InputStream, out: OutputStream): Unit = ???

tests/pos/i24689b.scala

@@ -0,0 +1,18 @@
+trait A
+trait B
+
+object Test1:
+  def foo(f: B => Unit) = ???
+  def transfer(in: A): Unit =
+    foo(in => transfer(in))
+    foo(transfer)
+    foo(transfer(_))
+  def transfer(in: B): Unit = ???
+
+object Test2:
+  def foo[T <: (B => Unit)](f: T) = ???
+  def transfer(in: A): Unit =
+    foo(in => transfer(in))
+    foo(transfer)
+    foo(transfer(_))
+  def transfer(in: B): Unit = ???

tests/pos/i24694/A_1.scala

@@ -0,0 +1,17 @@
+trait Show[T]
+object Show:
+  given [A: Show]: Show[List[A]] = ???
+
+trait Eq[A] extends Any, Serializable
+object Eq:
+  def fromUniversalEquals[A]: Eq[A] = ???
+
+object expect:
+  def same[A](expected: A, found: A)(using
+      eqA: Eq[A] = Eq.fromUniversalEquals[A],
+      showA: Show[A]
+  ): Unit = ???
+
+sealed trait XmlEvent
+object XmlEvent:
+  given Show[XmlEvent] = ???

tests/pos/i24694/B_2.scala

@@ -0,0 +1,5 @@
+def test(input: Option[List[XmlEvent]]) =
+  val works =
+    expect.same(List.empty[XmlEvent], input.get)
+  val fails = input.map: tokens =>
+    expect.same(List.empty[XmlEvent], tokens)

tests/pos/i24696.scala

@@ -0,0 +1,18 @@
+trait Schema[A]
+object Schema:
+    final case class Either[A, B](left: Schema[A], right: Schema[B]) extends Schema[scala.util.Either[A, B]]
+trait DecodeError
+
+object DynamicValue:
+  final case class LeftValue(value: DynamicValue) extends DynamicValue
+  final case class RightValue(value: DynamicValue) extends DynamicValue
+
+sealed trait DynamicValue:
+  self =>
+    def toTypedValueLazyError[A](using schema: Schema[A]): Either[DecodeError, A] =
+      (self, schema) match
+        case (DynamicValue.LeftValue(value), Schema.Either(schema1, _)) =>
+          value.toTypedValueLazyError(using schema1).map(Left(_))
+        case (DynamicValue.RightValue(value), Schema.Either(_, schema1)) =>
+          value.toTypedValueLazyError(using schema1).map(Right(_))
+        case _ => ???