Refactor detection of illegal result types in SAMs

Previously there were two separate checks for contextual function types as
result types: one in SAMType for non-PartialFunctions and one in ExpandSAM for
PartialFunctions. This is replaced by a single check (with a detailed error
message like we already had for PartialFunctions).

Author: smarter

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1504,7 +1504,7 @@ object desugar {
       DefDef(nme.ANON_FUN, paramss, if (tpt == null) TypeTree() else tpt, body)
         .withSpan(span)
         .withMods(synthetic | Artifact),
-      Closure(Nil, Ident(nme.ANON_FUN), EmptyTree))
+      Closure(Nil, Ident(nme.ANON_FUN), EmptyTree).withSpan(span.toSynthetic))
 
   /** If `nparams` == 1, expand partial function
    *

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

@@ -5552,8 +5552,7 @@ object Types {
         if (absMems.size == 1)
           absMems.head.info match {
             case mt: MethodType if !mt.isParamDependent &&
-                mt.resultType.isValueTypeOrWildcard &&
-                !defn.isContextFunctionType(mt.resultType) =>
+                mt.resultType.isValueTypeOrWildcard =>
               val cls = tp.classSymbol
 
               // Given a SAM type such as:

compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala

@@ -66,13 +66,6 @@ class ExpandSAMs extends MiniPhase:
       tree
   }
 
-  private def checkNoContextFunction(tpt: Tree)(using Context): Unit =
-    if defn.isContextFunctionType(tpt.tpe) then
-      report.error(
-        em"""Implementation restriction: cannot convert this expression to
-            |partial function with context function result type $tpt""",
-        tpt.srcPos)
-
   /** A partial function literal:
    *
    *  ```
@@ -115,8 +108,6 @@ class ExpandSAMs extends MiniPhase:
   private def toPartialFunction(tree: Block, tpe: Type)(using Context): Tree = {
     val closureDef(anon @ DefDef(_, List(List(param)), _, _)) = tree: @unchecked
 
-    checkNoContextFunction(anon.tpt)
-
     // The right hand side from which to construct the partial function. This is always a Match.
     // If the original rhs is already a Match (possibly in braces), return that.
     // Otherwise construct a match `x match case _ => rhs` where `x` is the parameter of the closure.

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

@@ -1686,6 +1686,12 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             pt.findFunctionType match {
               case pt @ SAMType(sam)
               if !defn.isFunctionType(pt) && mt <:< sam =>
+                if defn.isContextFunctionType(mt.resultType) then
+                  report.error(
+                    em"""Implementation restriction: cannot convert this expression to `$pt`
+                        |because its result type `${mt.resultType}` is a contextual function type.""",
+                    tree.srcPos)
+
                 // SAMs of the form C[?] where C is a class cannot be conversion targets.
                 // The resulting class `class $anon extends C[?] {...}` would be illegal,
                 // since type arguments to `C`'s super constructor cannot be constructed.

tests/neg/i15741.scala

@@ -1,14 +1,14 @@
   def get(using Int): String = summon[Int].toString
 
-  def pf2: PartialFunction[String, Int ?=> String] = {
-    case "hoge" => get // error
+  def pf2: PartialFunction[String, Int ?=> String] = { // error
+    case "hoge" => get
     case "huga" => get
   }
 
   type IS = Int ?=> String
 
   def pf3: PartialFunction[String, IS] = {
-    case "hoge" => get  // error
+    case "hoge" => get
     case "huga" => get
   }