Avoid more constraints in result if trying views (#24369)

In `canProfitFromMoreConstraints`, balk if
`mode.is(ImplicitExploration)`.

The failing case was due to the `constrainResult` "up the stack" in
`adaptNoArgs`, which drove type comparisons and completions, including a
conversion. The `FunProto` context had a console reporter that emitted
the errors encountered, not an exploring reporter.

The justification is that "more constraints" is motivated by arg
inference, so if the arg is already involved in views, further
information in the result is not needed, especially at the cost of
spurious exploratory errors using a context that doesn't reflect the
current mode.

Fixes #24192

Author: odersky

compiler/src/dotty/tools/dotc/core/Contexts.scala

@@ -810,11 +810,11 @@ object Contexts {
     final def addMode(mode: Mode): c.type = c.setMode(c.mode | mode)
     final def retractMode(mode: Mode): c.type = c.setMode(c.mode &~ mode)
 
-  /** Run `op` with a pool-allocated context that has an ExporeTyperState. */
+  /** Run `op` with a pool-allocated context that has an ExploreTyperState. */
   inline def explore[T](inline op: Context ?=> T)(using Context): T =
     exploreInFreshCtx(op)
 
-  /** Run `op` with a pool-allocated FreshContext that has an ExporeTyperState. */
+  /** Run `op` with a pool-allocated FreshContext that has an ExploreTyperState. */
   inline def exploreInFreshCtx[T](inline op: FreshContext ?=> T)(using Context): T =
     val pool = ctx.base.exploreContextPool
     val nestedCtx = pool.next()

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -2312,7 +2312,7 @@ object Types extends TypeUtils {
 
   /** A trait for proto-types, used as expected types in typer */
   trait ProtoType extends Type {
-    def isMatchedBy(tp: Type, keepConstraint: Boolean = false)(using Context): Boolean
+    def isMatchedBy(tp: Type, keepConstraint: Boolean)(using Context): Boolean
     def fold[T](x: T, ta: TypeAccumulator[T])(using Context): T
     def map(tm: TypeMap)(using Context): ProtoType
 

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

@@ -1207,7 +1207,7 @@ trait Implicits:
 
               def tryConversionForSelection(using Context) =
                 val converted = tryConversion
-                if !ctx.reporter.hasErrors && !selProto.isMatchedBy(converted.tpe) then
+                if !ctx.reporter.hasErrors && !selProto.isMatchedBy(converted.tpe, keepConstraint = false) then
                   // this check is needed since adapting relative to a `SelectionProto` can succeed
                   // even if the term is not a subtype of the `SelectionProto`
                   err.typeMismatch(converted, selProto)

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

@@ -185,7 +185,7 @@ trait ImportSuggestions:
             // To regain precision, test both sides separately.
             test(ViewProto(argType, rt1)) || test(ViewProto(argType, rt2))
           case pt: ViewProto =>
-            pt.isMatchedBy(ref)
+            pt.isMatchedBy(ref, keepConstraint = false)
           case _ =>
             normalize(ref, pt) <:< pt
         test(pt)

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

@@ -133,7 +133,7 @@ object ProtoTypes {
 
       constFoldException(pt) || {
         if Inlines.isInlineable(meth) then
-          // Stricter behavisour in 3.4+: do not apply `wildApprox` to non-transparent inlines
+          // Stricter behaviour in 3.4+: do not apply `wildApprox` to non-transparent inlines
           // unless their return type is a MatchType. In this case there's no reason
           // not to constrain type variables in the expected type. For transparent inlines
           // we do not want to constrain type variables in the expected type since the

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

@@ -4174,7 +4174,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           Some(adapt(tree, pt, locked))
         else
           val selProto = SelectionProto(name, pt, NoViewsAllowed, privateOK = false, tree.nameSpan)
-          if selProto.isMatchedBy(qual.tpe) || tree.hasAttachment(InsertedImplicitOnQualifier) then
+          if selProto.isMatchedBy(qual.tpe, keepConstraint = false) || tree.hasAttachment(InsertedImplicitOnQualifier)
+          then
             None
           else
             tryEither {
@@ -4472,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
@@ -4491,7 +4495,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             arg.tpe match
               case failed: SearchFailureType if canProfitFromMoreConstraints =>
                 val pt1 = pt.deepenProtoTrans
-                if (pt1 `ne` pt) && (pt1 ne sharpenedPt) && tryConstrainResult(pt1) then
+                if (pt1 ne pt) && (pt1 ne sharpenedPt) && tryConstrainResult(pt1) then
                   return implicitArgs(formals, argIndex, pt1)
               case _ =>
 
@@ -4584,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.
@@ -4605,13 +4607,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             // Reset context in case it was set to a supercall context before.
             // otherwise the invariant for taking another this or super call context is not met.
             // Test case is i20483.scala
-            tree match
-              case tree: Block =>
-                readaptSimplified(tpd.Block(tree.stats, tpd.Apply(tree.expr, args)))
-              case tree: NamedArg =>
-                readaptSimplified(tpd.NamedArg(tree.name, tpd.Apply(tree.arg, args)))
-              case _ =>
-                readaptSimplified(tpd.Apply(tree, args))
+            val cpy = tree match
+              case tree: Block    => tpd.Block(tree.stats, tpd.Apply(tree.expr, args))
+              case tree: NamedArg => tpd.NamedArg(tree.name, tpd.Apply(tree.arg, args))
+              case _              => tpd.Apply(tree, args)
+            readaptSimplified(cpy)
       end addImplicitArgs
 
       pt.revealIgnored match {

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/pos/i24192.scala

@@ -0,0 +1,27 @@
+import scala.language.implicitConversions
+
+// https://github.com/scala/scala-collection-contrib/blob/main/src/main/scala/scala/collection/decorators/package.scala
+object decorators {
+  trait IsMap[A]
+  implicit def mapDecorator[C](coll: C)(implicit map: IsMap[C]): Map[C, map.type] = ???
+}
+import decorators.mapDecorator // unused, required to reproduce
+
+trait Eq[T]
+trait Applicative[F[_]]
+given Applicative[Option] = ???
+
+trait Traverse[F[_]]:
+  // context bound required to reproduce
+  def sequence[G[_]: Applicative, A](fga: F[G[A]]): G[F[A]] = ???
+
+object Traverse:
+  def apply[F[_]]: Traverse[F] = ???
+
+trait Segment[Element: Eq]
+
+case class MergeResult[Element: Eq] private (segments: Seq[Segment[Element]]):
+  def thisFailsToCompile(): Option[MergeResult[Element]] =
+    Traverse[Seq]
+      .sequence(Seq.empty[Option[Segment[Element]]])
+      .map(MergeResult.apply) // no error

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