Improve rewrite of inserted apply

Author: som-snytt

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -509,9 +509,9 @@ object Trees {
 
   /** The kind of application */
   enum ApplyKind:
-    case Regular      // r.f(x)
-    case Using        // r.f(using x)
-    case InfixTuple   // r f (x1, ..., xN) where N != 1;  needs to be treated specially for an error message in typedApply
+    case Regular    // r.f(x)
+    case Using      // r.f(using x)
+    case InfixTuple // r f (x1, ..., xN) where N != 1; needs to be treated specially for an error message in typedApply
 
   /** fun(args) */
   case class Apply[+T <: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])(implicit @constructorOnly src: SourceFile)

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

@@ -1102,6 +1102,21 @@ trait Applications extends Compatibility {
         then originalProto.tupledDual
         else originalProto
 
+      /* TODO (*) Get rid of this case. It is still syntax-based, therefore unreliable.
+       * It is necessary for things like `someDynamic[T](...)`, because in that case,
+       * somehow typedFunPart returns a tree that was typed as `TryDynamicCallType`,
+       * so clearly with the view that an apply insertion was necessary, but doesn't
+       * actually insert the apply!
+       * This is probably something wrong in apply insertion, but I (@sjrd) am out of
+       * my depth there.
+       * In the meantime, this makes tests pass.
+       */
+      def isInsertedApply = fun1 match
+        case Select(_, nme.apply) => fun1.span.isSynthetic
+        case TypeApply(sel @ Select(_, nme.apply), _) => sel.span.isSynthetic
+        case TypeApply(fun, _) => !fun.isInstanceOf[Select] // (*) see explanatory comment
+        case _ => false
+
       /** Type application where arguments come from prototype, and no implicits are inserted */
       def simpleApply(fun1: Tree, proto: FunProto)(using Context): Tree =
         methPart(fun1).tpe match {
@@ -1178,6 +1193,11 @@ trait Applications extends Compatibility {
           case _ => ()
 
       def maybePatchBadParensForImplicit(failedState: TyperState)(using Context): Boolean =
+        def rewrite(): Unit =
+          val replace =
+            if isInsertedApply then ".apply" // x() -> x.apply
+            else "" // f() -> f where fun1.span.end == tree.span.point
+          rewrites.Rewrites.patch(tree.span.withStart(fun1.span.end), replace)
         var retry = false
         failedState.reporter.mapBufferedMessages: dia =>
           dia match
@@ -1187,7 +1207,7 @@ trait Applications extends Compatibility {
               val mv = MigrationVersion.ImplicitParamsWithoutUsing
               if mv.needsPatch then
                 retry = true
-                rewrites.Rewrites.patch(tree.span.withStart(tree.span.point), "") // f() -> f
+                rewrite()
                 Diagnostic.Warning(err.msg, err.pos)
               else err
             case _ => err
@@ -1197,21 +1217,6 @@ trait Applications extends Compatibility {
       val result = fun1.tpe match {
         case err: ErrorType => cpy.Apply(tree)(fun1, proto.typedArgs()).withType(err)
         case TryDynamicCallType =>
-          val isInsertedApply = fun1 match {
-            case Select(_, nme.apply) => fun1.span.isSynthetic
-            case TypeApply(sel @ Select(_, nme.apply), _) => sel.span.isSynthetic
-            /* TODO Get rid of this case. It is still syntax-based, therefore unreliable.
-             * It is necessary for things like `someDynamic[T](...)`, because in that case,
-             * somehow typedFunPart returns a tree that was typed as `TryDynamicCallType`,
-             * so clearly with the view that an apply insertion was necessary, but doesn't
-             * actually insert the apply!
-             * This is probably something wrong in apply insertion, but I (@sjrd) am out of
-             * my depth there.
-             * In the meantime, this makes tests pass.
-             */
-            case TypeApply(fun, _) => !fun.isInstanceOf[Select]
-            case _ => false
-          }
           val tree1 = fun1 match
             case Select(_, nme.apply) => tree
             case _ => untpd.Apply(fun1, tree.args)

tests/rewrites/i22792.check

@@ -8,4 +8,8 @@ class Foo:
 given Permit = ???
 @main def Test = new Foo().run
 
-def otherSyntax = Foo()
+def ctorProxy = Foo().run
+
+def otherSyntax = new Foo().apply // Foo().apply does not work
+
+def kwazySyntax = new Foo() . run // that was fun

tests/rewrites/i22792.scala

@@ -8,4 +8,8 @@ class Foo:
 given Permit = ???
 @main def Test = new Foo().run()
 
-def otherSyntax = Foo()()
+def ctorProxy = Foo().run()
+
+def otherSyntax = new Foo()() // Foo().apply does not work
+
+def kwazySyntax = new Foo() . run  (  /* your args here! */  ) // that was fun