Don't retypecheck erroneous arguments when fixing function

Don't retypecheck erroneous arguments when trying conversions or extensions
on the function part.

Generally, we should avoid typechecking untyped trees several times, this can quickly
explode exponentially.

Fixes #12941

Author: odersky

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

@@ -908,8 +908,9 @@ trait Applications extends Compatibility {
        *  part. Return an optional value to indicate success.
        */
       def tryWithImplicitOnQualifier(fun1: Tree, proto: FunProto)(using Context): Option[Tree] =
-        if (ctx.mode.is(Mode.SynthesizeExtMethodReceiver))
+        if ctx.mode.is(Mode.SynthesizeExtMethodReceiver) || proto.hasErrorArg then
           // Suppress insertion of apply or implicit conversion on extension method receiver
+          // or if argument is erroneous by itself.
           None
         else
           tryInsertImplicitOnQualifier(fun1, proto, ctx.typerState.ownedVars) flatMap { fun2 =>

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

@@ -8,7 +8,7 @@ import Contexts._, Types._, Denotations._, Names._, StdNames._, NameOps._, Symbo
 import NameKinds.DepParamName
 import Trees._
 import Constants._
-import util.{Stats, SimpleIdentityMap}
+import util.{Stats, SimpleIdentityMap, SimpleIdentitySet}
 import Decorators._
 import Uniques._
 import config.Printers.typr
@@ -282,6 +282,9 @@ object ProtoTypes {
     /** A map in which typed arguments can be stored to be later integrated in `typedArgs`. */
     var typedArg: SimpleIdentityMap[untpd.Tree, Tree] = SimpleIdentityMap.empty
 
+    /** The argument that produced errors during typing */
+    var errorArgs: SimpleIdentitySet[untpd.Tree] = SimpleIdentitySet.empty
+
     /** The tupled or untupled version of this prototype, if it has been computed */
     var tupledDual: Type = NoType
 
@@ -341,6 +344,9 @@ object ProtoTypes {
       case _ => false
     }
 
+    /** Did an argument produce an error when typing? */
+    def hasErrorArg = !state.errorArgs.isEmpty
+
     private def cacheTypedArg(arg: untpd.Tree, typerFn: untpd.Tree => Tree, force: Boolean)(using Context): Tree = {
       var targ = state.typedArg(arg)
       if (targ == null)
@@ -357,8 +363,11 @@ object ProtoTypes {
             targ = arg.withType(WildcardType)
           case _ =>
             targ = typerFn(arg)
-            if (!ctx.reporter.hasUnreportedErrors)
+            if ctx.reporter.hasUnreportedErrors then
+              state.errorArgs += arg
+            else
               state.typedArg = state.typedArg.updated(arg, targ)
+              state.errorArgs -= arg
         }
       targ
     }

tests/neg-custom-args/deprecation/t3235-minimal-v2.check

@@ -0,0 +1,8 @@
+-- Error: tests/neg-custom-args/deprecation/t3235-minimal-v2.scala:3:16 ------------------------------------------------
+3 |    assert(math.round(123456789) == 123456789) // error
+  |           ^^^^^^^^^^
+  |method round in package scala.math is deprecated since 2.11.0: This is an integer type; there is no reason to round it. Perhaps you meant to call this with a floating-point value?
+-- Error: tests/neg-custom-args/deprecation/t3235-minimal-v2.scala:4:16 ------------------------------------------------
+4 |    assert(math.round(1234567890123456789L) == 1234567890123456789L) // error
+  |           ^^^^^^^^^^
+  |method round in package scala.math is deprecated since 2.11.0: This is an integer type; there is no reason to round it. Perhaps you meant to call this with a floating-point value?

tests/neg-custom-args/deprecation/t3235-minimal-v2.scala

@@ -0,0 +1,6 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    assert(math.round(123456789) == 123456789) // error
+    assert(math.round(1234567890123456789L) == 1234567890123456789L) // error
+  }
+}

tests/neg-custom-args/deprecation/t3235-minimal-v3.scala

@@ -0,0 +1,5 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    assert(1234567890123456789L.round == 1234567890123456789L) // error
+  }
+}

tests/neg-custom-args/deprecation/t3235-minimal.check

@@ -0,0 +1,4 @@
+-- Error: tests/neg-custom-args/deprecation/t3235-minimal.scala:3:21 ---------------------------------------------------
+3 |    assert(123456789.round == 123456789) // error
+  |           ^^^^^^^^^^^^^^^
+  |method round in class RichInt is deprecated since 2.11.0: this is an integer type; there is no reason to round it.  Perhaps you meant to call this on a floating-point value?

tests/neg-custom-args/deprecation/t3235-minimal.scala

@@ -1,8 +1,5 @@
 object Test {
   def main(args: Array[String]): Unit = {
     assert(123456789.round == 123456789) // error
-    assert(math.round(123456789) == 123456789) // error
-    assert(1234567890123456789L.round == 1234567890123456789L) // error
-    assert(math.round(1234567890123456789L) == 1234567890123456789L) // error
   }
 }

tests/neg/i12941.scala

@@ -0,0 +1,28 @@
+object A:
+  def myFun(op: String ?=> Unit) = ()
+
+@main def func: Unit =
+  A.myFun {
+    val res: String = summon[String]
+    println(ress)  // error
+  }
+
+class I:
+  def runSth: Int = 1
+
+abstract class A:
+  def myFun(op: I ?=> Unit) =
+    op(using I())
+    1
+
+class B extends A
+
+def assertEquals(x: String, y: Int, z: Int): Unit = ()
+
+@main def hello: Unit =
+
+  B().myFun {
+    val res = summon[I].runSth
+    assertEquals("", 1, res, "asd") // error
+    println("Hello!")
+  }

tests/neg/i903.check

@@ -0,0 +1,7 @@
+-- [E007] Type Mismatch Error: tests/neg/i903.scala:3:16 ---------------------------------------------------------------
+3 |    "".contains("", (_: Int)) // error
+  |                ^^^^^^^^^^^^
+  |                Found:    (String, Int)
+  |                Required: CharSequence
+
+longer explanation available when compiling with `-explain`

tests/neg/i903.scala

@@ -0,0 +1,4 @@
+object Test {
+  def test2 =
+    "".contains("", (_: Int)) // error
+}