Revert "Use more context for implicit search only if no default argument"

This reverts commit be5cbda.

Author: tgodzik

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

@@ -3869,12 +3869,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
       def addImplicitArgs(using Context) =
         def hasDefaultParams = methPart(tree).symbol.hasDefaultParams
-        def findDefaultArgument(argIndex: Int): Tree =
-          def appPart(t: Tree): Tree = t match
-            case Block(_, expr)      => appPart(expr)
-            case Inlined(_, _, expr) => appPart(expr)
-            case t => t
-          defaultArgument(appPart(tree), n = argIndex, testOnly = false)
         def implicitArgs(formals: List[Type], argIndex: Int, pt: Type): List[Tree] = formals match
           case Nil => Nil
           case formal :: formals1 =>
@@ -3890,17 +3884,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
             val arg = inferImplicitArg(formal, tree.span.endPos)
 
-            lazy val defaultArg = findDefaultArgument(argIndex)
-              .showing(i"default argument: for $formal, $tree, $argIndex = $result", typr)
-            def argHasDefault = hasDefaultParams && !defaultArg.isEmpty
-
             def canProfitFromMoreConstraints =
               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.
+                    // ambiguity could be decided by more constraints
+              || !isFullyDefined(formal, ForceDegree.none)
+                    // more context might constrain type variables which could make implicit scope larger
 
             arg.tpe match
               case failed: SearchFailureType if canProfitFromMoreConstraints =>
@@ -3913,7 +3901,20 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
               case failed: AmbiguousImplicits =>
                 arg :: implicitArgs(formals1, argIndex + 1, pt)
               case failed: SearchFailureType =>
-                if argHasDefault then
+                lazy val defaultArg =
+                  def appPart(t: Tree): Tree = t match
+                    case Block(stats, expr) => appPart(expr)
+                    case Inlined(_, _, expr) => appPart(expr)
+                    case _ => t
+                  defaultArgument(appPart(tree), argIndex, testOnly = false)
+                    .showing(i"default argument: for $formal, $tree, $argIndex = $result", typr)
+                if !hasDefaultParams || defaultArg.isEmpty then
+                  // no need to search further, the adapt fails in any case
+                  // the reason why we continue inferring arguments in case of an AmbiguousImplicits
+                  // is that we need to know whether there are further errors.
+                  // If there are none, we have to propagate the ambiguity to the caller.
+                  arg :: formals1.map(dummyArg)
+                else
                   // This is tricky. On the one hand, we need the defaultArg to
                   // correctly type subsequent formal parameters in the same using
                   // clause in case there are parameter dependencies. On the other hand,
@@ -3924,12 +3925,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                   // `if propFail.exists` where we re-type the whole using clause with named
                   // arguments for all implicits that were found.
                   arg :: inferArgsAfter(defaultArg)
-                else
-                  // no need to search further, the adapt fails in any case
-                  // the reason why we continue inferring arguments in case of an AmbiguousImplicits
-                  // is that we need to know whether there are further errors.
-                  // If there are none, we have to propagate the ambiguity to the caller.
-                  arg :: formals1.map(dummyArg)
               case _ =>
                 arg :: inferArgsAfter(arg)
         end implicitArgs