Fix guarding & converting SAM result type to a function type

In decomposeProtoFunction I wanted to reuse WithFunctionType by running
toFunctionType on the whole SAM and then dropping the first parameters.
But with result dependent functions that results in a refined type,
which is composed of:
  * the function with a result that is a non-depedent approximation
  * the original, non-function, method type

So I went back to calling toFunctionType on the method result type
specifically, like it used to be.

Which means I stopped using the SAMType.WithFunctionType extract, so I
merged it with its remaining usage with subtype checking and called the
SAMType.isSamCompatible.

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

@@ -5569,16 +5569,15 @@ object Types {
       }
       else None
 
-    object WithFunctionType:
-      def unapply(tp: Type)(using Context): Option[(MethodType, Type)] = tp match
-        case SAMType(mt) if !isParamDependentRec(mt) =>
-          Some((mt, mt.toFunctionType(isJava = tp.classSymbol.is(JavaDefined))))
-        case _ => None
+    def isSamCompatible(lhs: Type, rhs: Type)(using Context): Boolean = rhs match
+      case SAMType(mt) if !isParamDependentRec(mt) =>
+        lhs <:< mt.toFunctionType(isJava = rhs.classSymbol.is(JavaDefined))
+      case _ => false
 
-      private def isParamDependentRec(mt: MethodType)(using Context): Boolean =
-        mt.isParamDependent || mt.resultType.match
-          case mt: MethodType => isParamDependentRec(mt)
-          case _              => false
+    def isParamDependentRec(mt: MethodType)(using Context): Boolean =
+      mt.isParamDependent || mt.resultType.match
+        case mt: MethodType => isParamDependentRec(mt)
+        case _              => false
   }
 
   // ----- TypeMaps --------------------------------------------------------------------

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

@@ -695,9 +695,7 @@ trait Applications extends Compatibility {
         val argtpe1 = argtpe.widen
 
         def SAMargOK =
-          defn.isFunctionType(argtpe1) && formal.match
-            case SAMType.WithFunctionType(_, fntpe) => argtpe <:< fntpe
-            case _ => false
+          defn.isFunctionType(argtpe1) && SAMType.isSamCompatible(argtpe, formal)
 
         isCompatible(argtpe, formal)
         // Only allow SAM-conversion to PartialFunction if implicit conversions

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

@@ -1335,7 +1335,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         case RefinedType(parent, nme.apply, mt @ MethodTpe(_, formals, restpe))
         if (defn.isNonRefinedFunction(parent) || defn.isErasedFunctionType(parent)) && formals.length == defaultArity =>
           (formals, untpd.DependentTypeTree(syms => restpe.substParams(mt, syms.map(_.termRef))))
-        case SAMType.WithFunctionType(mt @ MethodTpe(_, formals, _), defn.FunctionOf(_, restpe, _)) =>
+        case pt1 @ SAMType(mt @ MethodTpe(_, formals, _)) if !SAMType.isParamDependentRec(mt) =>
+          val restpe = mt.resultType match
+            case mt: MethodType => mt.toFunctionType(isJava = pt1.classSymbol.is(JavaDefined))
+            case tp => tp
           (formals,
            if (mt.isResultDependent)
              untpd.DependentTypeTree(syms => restpe.substParams(mt, syms.map(_.termRef)))
@@ -4126,17 +4129,12 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       // convert function literal to SAM closure
       tree match {
         case closure(Nil, id @ Ident(nme.ANON_FUN), _)
-        if defn.isFunctionType(wtp) && !defn.isFunctionType(pt) =>
-          pt match {
-            case SAMType.WithFunctionType(_, fntpe)
-            if wtp <:< fntpe =>
-              // was ... && isFullyDefined(pt, ForceDegree.flipBottom)
-              // but this prevents case blocks from implementing polymorphic partial functions,
-              // since we do not know the result parameter a priori. Have to wait until the
-              // body is typechecked.
-              return toSAM(tree)
-            case _ =>
-          }
+        if defn.isFunctionType(wtp) && !defn.isFunctionType(pt) && SAMType.isSamCompatible(wtp, pt) =>
+          // was ... && isFullyDefined(pt, ForceDegree.flipBottom)
+          // but this prevents case blocks from implementing polymorphic partial functions,
+          // since we do not know the result parameter a priori. Have to wait until the
+          // body is typechecked.
+          return toSAM(tree)
         case _ =>
       }