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,10 +4588,12 @@ 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
+              // avoid warning if method is old-style implicit that context bounds will be contextual
+              val needsUsing = wtp.isContextualMethod || wtp.match
                 case MethodType(ContextBoundParamName(_) :: _) => sourceVersion.isAtLeast(`3.4`)
                 case _ => false
+              // it is benign to always set apply kind; typedApply may redundantly search missing implicits
+              // because it doesn't distinguish adaptNoArgs from explicit application
               if needsUsing then 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`

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)