canApplyImplicits is false if not using

Author: som-snytt

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

@@ -36,6 +36,7 @@ import annotation.threadUnsafe
 
 import scala.util.control.NonFatal
 import dotty.tools.dotc.inlines.Inlines
+import dotty.tools.dotc.util.chaining.*
 
 object Applications {
   import tpd.*
@@ -602,7 +603,7 @@ trait Applications extends Compatibility {
           fail(TypeMismatch(methType.resultType, resultType, None))
 
         // match all arguments with corresponding formal parameters
-        if success then matchArgs(orderedArgs, methType.paramInfos, n=0)
+        if success then matchArgs(orderedArgs, methType.paramInfos, n = 0)
       case _ =>
         if (methType.isError) ok = false
         else fail(em"$methString does not take parameters")
@@ -757,20 +758,18 @@ trait Applications extends Compatibility {
               }
               else defaultArgument(normalizedFun, n, testOnly)
 
-            // a bug allowed empty parens to expand to implicit args, offer rewrite only on migration
+            // a bug allowed empty parens to expand to implicit args: fail empty args for rewrite on migration
             def canSupplyImplicits = methodType.isImplicitMethod
-              && (applyKind == ApplyKind.Using || {
-                if args1.isEmpty then
+              && (applyKind == ApplyKind.Using || false.tap: _ =>
+                if Application.this.args.isEmpty then
                   fail(MissingImplicitParameterInEmptyArguments(methodType.paramNames(n), methString))
-                true
-              })
-              && ctx.mode.is(Mode.ImplicitsEnabled)
+              )
 
             if !defaultArg.isEmpty then
               defaultArg.tpe.widen match
                 case _: MethodOrPoly if testOnly => matchArgs(args1, formals1, n + 1)
                 case _ => matchArgs(args1, addTyped(treeToArg(defaultArg)), n + 1)
-            else if methodType.isContextualMethod && ctx.mode.is(Mode.ImplicitsEnabled) || canSupplyImplicits then
+            else if (methodType.isContextualMethod || canSupplyImplicits) && ctx.mode.is(Mode.ImplicitsEnabled) then
               val implicitArg = implicitArgTree(formal, appPos.span)
               matchArgs(args1, addTyped(treeToArg(implicitArg)), n + 1)
             else
@@ -1190,8 +1189,7 @@ trait Applications extends Compatibility {
                 retry = true
                 rewrites.Rewrites.patch(tree.span.withStart(tree.span.point), "") // f() -> f
                 Diagnostic.Warning(err.msg, err.pos)
-              else
-                err
+              else err
             case _ => err
           case dia => dia
         retry

tests/neg/i22439.check

@@ -2,6 +2,9 @@
 7 |  f() // error f() missing arg
   |  ^^^
   |  missing argument for parameter i of method f: (implicit i: Int, j: Int): Int
+  |  This code can be rewritten automatically under -rewrite -source 3.7-migration.
+  |
+  | longer explanation available when compiling with `-explain`
 -- [E050] Type Error: tests/neg/i22439.scala:8:2 -----------------------------------------------------------------------
 8 |  g() // error g(given_Int, given_Int)() doesn't take more params
   |  ^
@@ -24,3 +27,6 @@
 21 |  val (ws, zs) = vs.unzip() // error!
    |                 ^^^^^^^^^^
    |missing argument for parameter asPair of method unzip in trait StrictOptimizedIterableOps: (implicit asPair: ((Int, Int)) => (A1, A2)): (List[A1], List[A2])
+   |This code can be rewritten automatically under -rewrite -source 3.7-migration.
+   |
+   | longer explanation available when compiling with `-explain`