Merge pull request #10917 from dotty-staging/fix-#10871

Refine SAM handling in SuperAccessors.

Author: liufengyun

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

@@ -22,15 +22,23 @@ import dotty.tools.dotc.util.Spans.Span
  *
  *  However, implicit function types do not count as SAM types.
  */
-class ExpandSAMs extends MiniPhase {
-  override def phaseName: String = "expandSAMs"
-
-  import ast.tpd._
+object ExpandSAMs:
+  val name: String = "expandSAMs"
 
   /** Is the SAMType `cls` also a SAM under the rules of the platform? */
   def isPlatformSam(cls: ClassSymbol)(using Context): Boolean =
     ctx.platform.isSam(cls)
 
+  def needsWrapperClass(tpe: Type)(using Context): Boolean =
+    tpe.classSymbol match
+      case cls: ClassSymbol => !isPlatformSam(cls) || cls == defn.PartialFunctionClass
+      case _ => false
+
+class ExpandSAMs extends MiniPhase:
+  import ast.tpd._
+
+  override def phaseName: String = ExpandSAMs.name
+
   override def transformBlock(tree: Block)(using Context): Tree = tree match {
     case Block(stats @ (fn: DefDef) :: Nil, Closure(_, fnRef, tpt)) if fnRef.symbol == fn.symbol =>
       tpt.tpe match {
@@ -41,7 +49,7 @@ class ExpandSAMs extends MiniPhase {
         case tpe @ SAMType(_) if tpe.isRef(defn.PartialFunctionClass) =>
           val tpe1 = checkRefinements(tpe, fn)
           toPartialFunction(tree, tpe1)
-        case tpe @ SAMType(_) if isPlatformSam(tpe.classSymbol.asClass) =>
+        case tpe @ SAMType(_) if ExpandSAMs.isPlatformSam(tpe.classSymbol.asClass) =>
           checkRefinements(tpe, fn)
           tree
         case tpe =>
@@ -176,5 +184,5 @@ class ExpandSAMs extends MiniPhase {
     case tpe =>
       tpe
   }
-}
+end ExpandSAMs
 

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

@@ -411,6 +411,8 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
             super.transform(selector),
             cases.mapConserve(tranformIgnoringBoundsCheck)
           )
+        case Block(_, Closure(_, _, tpt)) if ExpandSAMs.needsWrapperClass(tpt.tpe) =>
+          superAcc.withInvalidCurrentClass(super.transform(tree))
         case tree =>
           super.transform(tree)
       }

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

@@ -36,7 +36,6 @@ class SuperAccessors(thisPhase: DenotTransformer) {
 
   import tpd._
 
-
   /** Some parts of trees will get a new owner in subsequent phases.
     *  These are value class methods, which will become extension methods.
     *  (By-name arguments used to be included also, but these
@@ -51,9 +50,9 @@ class SuperAccessors(thisPhase: DenotTransformer) {
     */
   private var invalidEnclClass: Symbol = NoSymbol
 
-  private def withInvalidCurrentClass[A](trans: => A)(using Context): A = {
+  def withInvalidCurrentClass[A](trans: => A)(using Context): A = {
     val saved = invalidEnclClass
-    invalidEnclClass = ctx.owner
+    invalidEnclClass = ctx.owner.enclosingClass
     try trans
     finally invalidEnclClass = saved
   }
@@ -156,12 +155,8 @@ class SuperAccessors(thisPhase: DenotTransformer) {
         }
     }
 
-    val needAccessor = name.isTermName && {
-      mix.name.isEmpty && (clazz.is(Trait) || clazz != currentClass || !validCurrentClass) ||
-      // SI-8803. If we access super[A] from an inner class (!= currentClass) or closure (validCurrentClass),
-      // where A is the superclass we need an accessor.
-      !mix.name.isEmpty && (clazz != currentClass || !validCurrentClass)
-    }
+    val needAccessor = name.isTermName && (
+      clazz != currentClass || !validCurrentClass || mix.name.isEmpty && clazz.is(Trait))
 
     if (needAccessor) atPhase(thisPhase.next)(superAccessorCall(sel, mix.name))
     else sel

tests/pos/i10871.scala

@@ -0,0 +1,19 @@
+trait A { def i = 1 }
+class B extends A {
+  class C {
+    val x = B.super.i  // needs accessor
+  }
+  val f: Int => Int =
+    _ => super.i // OK
+  trait Sammy {
+    def run(x: Int): Int
+  }
+  val s1: Sammy = (x: Int) => super.i // OK
+  abstract class Sam {
+    def run(x: Int): Int
+  }
+  val s2: Sam = (x: Int) => super.i // needs accessor
+  val p: PartialFunction[Int, Int] = {
+    case _ => super.i // needs accessor
+  }
+}