Change treatment of SAMs in overloading resolution

Always consider a function type A as conforming to a corresponding SAM type B, unless
B is a subtype of A.

The unless... part is so that `PartialFunction[A, B]` is seen as strictly better than `A => B`.

This is an alternate fix for #11938 that does not treat FunctionalInterfaces specifically.

Author: odersky

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

@@ -629,6 +629,18 @@ trait Applications extends Compatibility {
 
     def applyKind = ApplyKind.Regular
 
+    /** Is `tp1` a function type that can be converted by a SAM comversion to `tp2`,
+     *  and that is not at the same time a supertype of `tp2`?
+     */
+    private def isSamCompatible(tp1: Type, tp2: Type)(using Context): Boolean =
+      defn.isFunctionType(tp1)
+      && {
+        tp2.match
+          case SAMType(sam) => tp1 <:< sam.toFunctionType(isJava = tp2.classSymbol.is(JavaDefined))
+          case _ => false
+        }
+      && !(tp2 relaxed_<:< tp1)
+
     protected def argOK(arg: TypedArg, formal: Type): Boolean = argType(arg, formal) match
       case ref: TermRef if ref.denot.isOverloaded =>
         // in this case we could not resolve overloading because no alternative
@@ -641,10 +653,11 @@ trait Applications extends Compatibility {
             case SAMType(sam) => argtpe <:< sam.toFunctionType(isJava = formal.classSymbol.is(JavaDefined))
             case _ => false
         if argMatch == ArgMatch.SubType then
-          (argtpe relaxed_<:< formal.widenExpr) || SAMargOK(onlyFunctionalInterface = true)
+          (argtpe relaxed_<:< formal.widenExpr)
+          || isSamCompatible(argtpe.widen, formal)
         else
           isCompatible(argtpe, formal)
-          || ctx.mode.is(Mode.ImplicitsEnabled) && SAMargOK(onlyFunctionalInterface = false)
+          || isSamCompatible(argtpe.widen, formal)
           || argMatch == ArgMatch.CompatibleCAP
               && {
                 val argtpe1 = argtpe.widen