Implementing stricter rule for callee type inference

Author: noti0na1

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

@@ -1857,19 +1857,24 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       case Typed(arg1, _) if untpd.isWildcardStarArg(arg) => refersTo(arg1, param)
       case _ => false
 
+    def containsParamRef(tree: untpd.Tree, params: List[untpd.ValDef]): Boolean =
+      import dotty.tools.dotc.ast.untpd.existsSubTree
+      tree.existsSubTree {
+        case Ident(name) => params.exists(_.name == name)
+        case _ => false
+      }
+
     /** If parameter `param` appears exactly once as an argument in `args`,
      *  the singleton list consisting of its position in `args`, otherwise `Nil`.
      */
-    def paramIndices(param: untpd.ValDef, args: List[untpd.Tree]): List[Int] = {
-      def loop(args: List[untpd.Tree], start: Int): List[Int] = args match {
+    def paramIndices(param: untpd.ValDef, args: List[untpd.Tree]): List[Int] =
+      def loop(args: List[untpd.Tree], start: Int): List[Int] = args match
         case arg :: args1 =>
           val others = loop(args1, start + 1)
           if (refersTo(arg, param)) start :: others else others
         case _ => Nil
-      }
       val allIndices = loop(args, 0)
-      if (allIndices.length == 1) allIndices else Nil
-    }
+      if allIndices.length == 1 then allIndices else Nil
 
     /** A map from parameter names to unique positions where the parameter
      *  appears in the argument list of an application.
@@ -1905,25 +1910,22 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           fnBody = untpd.TypedSplice(ident1)
           tp.select(nme.apply)
         else NoType
-      case app @ Apply(expr, args) =>
+      case app @ Apply(expr, args) if !containsParamRef(expr, params) =>
         paramIndex = {
           for (param <- params; idx <- paramIndices(param, args))
           yield param.name -> idx
         }.toMap
+        // println(i"paramIndex = $paramIndex, paramIndex.size = ${paramIndex.size}, params.length = ${params.length}")
         if (paramIndex.size == params.length)
           expr match
             case untpd.TypedSplice(expr1) =>
               expr1.tpe
             case _ =>
               val outerCtx = ctx
-              // Create placeholder symbols for function parameters to shadow outer bindings.
-              // This ensures that when typing `expr`, references in it won't incorrectly
-              // resolve to outer scope variables with the same names as the parameters.
-              val paramSyms = params.map(p =>
-                newSymbol(ctx.owner, p.name, Flags.Param, WildcardType, coord = p.span))
-              val nestedCtx = outerCtx.fresh.setNewTyperState().setScope(newScopeWith(paramSyms*))
+              val nestedCtx = outerCtx.fresh.setNewTyperState()
               inContext(nestedCtx) {
-                val protoArgs = args.map(_.withType(WildcardType))
+                // create a placeholder tree for each prototype argument
+                val protoArgs = args.map(arg => untpd.TypedSplice(TypeTree(WildcardType).withSpan(arg.span)))
                 val callProto = FunProto(protoArgs, WildcardType)(this, app.applyKind)
                 val expr1 = typedExpr(expr, callProto)
                 if nestedCtx.reporter.hasErrors then NoType