Revert "Constrain by deepening results in more implicit searches"

This reverts commit a1813d1.

Author: tgodzik

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

@@ -29,12 +29,12 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
 
   val synthesizedClassTag: SpecialHandler = (formal, span) =>
     def instArg(tp: Type): Type = tp.dealias match
+      // Special case to avoid instantiating `Int & S` to `Int & Nothing` in
+      // i16328.scala. The intersection comes from an earlier instantiation
+      // to an upper bound.
+      // The dual situation with unions is harder to trigger because lower
+      // bounds are usually widened during instantiation.
       case tp: AndOrType if tp.tp1 =:= tp.tp2 =>
-        // Special case to avoid instantiating `Int & S` to `Int & Nothing` in
-        // i16328.scala. The intersection comes from an earlier instantiation
-        // to an upper bound.
-        // The dual situation with unions is harder to trigger because lower
-        // bounds are usually widened during instantiation.
         instArg(tp.tp1)
       case tvar: TypeVar if ctx.typerState.constraint.contains(tvar) =>
         // If tvar has a lower or upper bound:

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

@@ -3883,23 +3883,12 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
               implicitArgs(formals2, argIndex + 1, pt)
 
             val arg = inferImplicitArg(formal, tree.span.endPos)
-
-            def canProfitFromMoreConstraints =
-              arg.tpe.isInstanceOf[AmbiguousImplicits]
-                    // 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 =>
+              case failed: AmbiguousImplicits =>
                 val pt1 = pt.deepenProtoTrans
                 if (pt1 `ne` pt) && (pt1 ne sharpenedPt) && constrainResult(tree.symbol, wtp, pt1)
-                then return implicitArgs(formals, argIndex, pt1)
-              case _ =>
-
-            arg.tpe match
-              case failed: AmbiguousImplicits =>
-                arg :: implicitArgs(formals1, argIndex + 1, pt)
+                then implicitArgs(formals, argIndex, pt1)
+                else arg :: implicitArgs(formals1, argIndex + 1, pt1)
               case failed: SearchFailureType =>
                 lazy val defaultArg =
                   def appPart(t: Tree): Tree = t match

tests/neg/i9568.check

@@ -4,10 +4,13 @@
    |          No given instance of type => Monad[F] was found for parameter ev of method blaMonad in object Test.
    |          I found:
    |
-   |              Test.blaMonad[F², S]
+   |              Test.blaMonad[F², S](Test.blaMonad[F³, S²])
    |
-   |          But method blaMonad in object Test does not match type => Monad[F]
+   |          But method blaMonad in object Test does not match type => Monad[F²]
    |
    |          where:    F  is a type variable with constraint <: [_] =>> Any
    |                    F² is a type variable with constraint <: [_] =>> Any
+   |                    F³ is a type variable with constraint <: [_] =>> Any
+   |                    S  is a type variable
+   |                    S² is a type variable
    |          .