Avoid more constraints in result if trying views

Author: som-snytt

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

@@ -4473,12 +4473,15 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             def argHasDefault = hasDefaultParams && !defaultArg.isEmpty
 
             def canProfitFromMoreConstraints =
+              !ctx.mode.is(Mode.ImplicitExploration)
+              && {
               arg.tpe.isInstanceOf[AmbiguousImplicits]
                     // Ambiguity could be decided by more constraints
               || !isFullyDefined(formal, ForceDegree.none) && !argHasDefault
                     // More context might constrain type variables which could make implicit scope larger.
                     // But in this case we should search with additional arguments typed only if there
                     // is no default argument.
+              }
 
             // Try to constrain the result using `pt1`, but back out if a BadTyperStateAssertion
             // is thrown. TODO Find out why the bad typer state arises and prevent it. The try-catch
@@ -4585,11 +4588,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
               issueErrors(tree, args, failureType)
             else
               val app = cpy.Apply(tree)(untpd.TypedSplice(tree), namedArgs)
-              // old-style implicit needs to be marked using so that implicits are searched
-              val needsUsing = wtp.isImplicitMethod || wtp.match
-                case MethodType(ContextBoundParamName(_) :: _) => sourceVersion.isAtLeast(`3.4`)
-                case _ => false
-              if needsUsing then app.setApplyKind(ApplyKind.Using)
+              // avoid warning if method is old-style implicit that context bounds will be contextual
+              // also required for correctly reporting implicit not found
+              app.setApplyKind(ApplyKind.Using)
               typr.println(i"try with default implicit args $app")
               // If the retyped tree still has an error type and is an `Apply`
               // node, we can report the errors for each argument nicely.

tests/neg/i19594.check

@@ -18,3 +18,7 @@
 26 |  h(true, 1) // error
    |  ^^^^^^^^^^
    |  No given instance of type String was found
+-- [E172] Type Error: tests/neg/i19594.scala:31:11 ---------------------------------------------------------------------
+31 |  competing(true, 42) // error when the default is in the same param list as the missing implicit
+   |  ^^^^^^^^^^^^^^^^^^^
+   |  Can you see me?!

tests/neg/i19594.scala

@@ -24,3 +24,8 @@ object updated:
 
   def h[A, B](a: A, b: B)(using c: Compare[A, B] = Compare.any, s: String) = ()
   h(true, 1) // error
+
+  class X
+  val defx = X()
+  def competing[A, B](a: A, b: B)(implicit x: X = defx, cmp: Compare[A, B]) = ()
+  competing(true, 42) // error when the default is in the same param list as the missing implicit

tests/warn/i19506.scala

@@ -0,0 +1,13 @@
+//> using options -source 3.4
+
+trait Reader[T]
+def read[T: Reader](s: String, trace: Boolean = false)(implicit i: Int = 42): T = ???
+
+// if apply kind is not using when retrying to insert the default arg, it will warn:
+// Context bounds will map to context parameters.
+// A `using` clause is needed to pass explicit arguments to them.
+// The method to invoke (read) might have been compiled under 3.3,
+// or (as above) the contextual parameter may have been merged with an existing implicit param list.
+def Test =
+  implicit def reader: Reader[Object] = new Reader[Object]{}
+  read[Object]("") // no warn

tests/warn/i22439.scala

@@ -0,0 +1,11 @@
+@main def test() =
+  given Int = 42
+
+  locally:
+    given String = "y"
+    def ff(implicit i: Int, s: String = "x") = s * i
+    def gg(using i: Int, s: String = "x") = s * i
+    ff(using i = 10) // warn uses default arg
+    gg(using i = 10) // warn
+    ff(i = 10) // warn should use using
+    gg(i = 10) // remarkably, augmentString(gg(given_Int, given_String)).apply(i = 10)