Fix #4446: Inline implementation of PF methods into its anonymous class

Author: allanrenucci

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

@@ -66,15 +66,18 @@ class ExpandSAMs extends MiniPhase {
       case PartialFunctionRHS(pf) =>
         val anonSym = anon.symbol
 
+        val parents = List(defn.AbstractPartialFunctionType.appliedTo(tpe.argInfos), defn.SerializableType)
+        val pfSym = ctx.newNormalizedClassSymbol(anonSym.owner, tpnme.ANON_CLASS, Synthetic | Final, parents, coord = tree.pos)
+
         def overrideSym(sym: Symbol) = sym.copy(
-          owner = anonSym.owner,
-          flags = Synthetic | Method | Final,
+          owner = pfSym,
+          flags = Synthetic | Method | Final | Override,
           info = tpe.memberInfo(sym),
-          coord = tree.pos).asTerm
+          coord = tree.pos).asTerm.entered
         val isDefinedAtFn = overrideSym(defn.PartialFunction_isDefinedAt)
         val applyOrElseFn = overrideSym(defn.PartialFunction_applyOrElse)
 
-        def translateMatch(tree: Match, pfParam: Symbol, cases: List[CaseDef], defaultValue: Tree) = {
+        def translateMatch(tree: Match, pfParam: Symbol, cases: List[CaseDef], defaultValue: Tree)(implicit ctx: Context) = {
           val selector = tree.selector
           val selectorTpe = selector.tpe.widen
           val defaultSym = ctx.newSymbol(pfParam.owner, nme.WILDCARD, Synthetic, selectorTpe)
@@ -91,7 +94,7 @@ class ExpandSAMs extends MiniPhase {
               // And we need to update all references to 'param'
         }
 
-        def isDefinedAtRhs(paramRefss: List[List[Tree]]) = {
+        def isDefinedAtRhs(paramRefss: List[List[Tree]])(implicit ctx: Context) = {
           val tru = Literal(Constant(true))
           def translateCase(cdef: CaseDef) =
             cpy.CaseDef(cdef)(body = tru).changeOwner(anonSym, isDefinedAtFn)
@@ -100,20 +103,19 @@ class ExpandSAMs extends MiniPhase {
           translateMatch(pf, paramRef.symbol, pf.cases.map(translateCase), defaultValue)
         }
 
-        def applyOrElseRhs(paramRefss: List[List[Tree]]) = {
+        def applyOrElseRhs(paramRefss: List[List[Tree]])(implicit ctx: Context) = {
           val List(paramRef, defaultRef) = paramRefss.head
           def translateCase(cdef: CaseDef) =
-            cdef.changeOwner(anonSym, applyOrElseFn)
+            cdef.changeOwner(anonSym, applyOrElseFn)(ctx.withOwner(applyOrElseFn))
           val defaultValue = defaultRef.select(nme.apply).appliedTo(paramRef)
           translateMatch(pf, paramRef.symbol, pf.cases.map(translateCase), defaultValue)
         }
 
-        val isDefinedAtDef = transformFollowingDeep(DefDef(isDefinedAtFn, isDefinedAtRhs(_)))
-        val applyOrElseDef = transformFollowingDeep(DefDef(applyOrElseFn, applyOrElseRhs(_)))
-
-        val parents = List(defn.AbstractPartialFunctionType.appliedTo(tpe.argInfos), defn.SerializableType)
-        val anonCls = AnonClass(parents, List(isDefinedAtFn, applyOrElseFn), List(nme.isDefinedAt, nme.applyOrElse))
-        cpy.Block(tree)(List(isDefinedAtDef, applyOrElseDef), anonCls)
+        val constr = ctx.newConstructor(pfSym, Synthetic, Nil, Nil).entered
+        val isDefinedAtDef = transformFollowingDeep(DefDef(isDefinedAtFn, isDefinedAtRhs(_)(ctx.withOwner(isDefinedAtFn))))
+        val applyOrElseDef = transformFollowingDeep(DefDef(applyOrElseFn, applyOrElseRhs(_)(ctx.withOwner(applyOrElseFn))))
+        val pfDef = ClassDef(pfSym, DefDef(constr), List(isDefinedAtDef, applyOrElseDef))
+        cpy.Block(tree)(pfDef :: Nil, New(pfSym.typeRef, Nil))
 
       case _ =>
         val found = tpe.baseType(defn.FunctionClass(1))

tests/run/i4446.scala

@@ -0,0 +1,19 @@
+class Foo {
+  def foo: PartialFunction[Int, Int] = { case x => x + 1 }
+}
+
+object Test {
+  def serializeDeserialize[T <: AnyRef](obj: T): T = {
+    import java.io._
+    val buffer = new ByteArrayOutputStream
+    val out = new ObjectOutputStream(buffer)
+    out.writeObject(obj)
+    val in = new ObjectInputStream(new ByteArrayInputStream(buffer.toByteArray))
+    in.readObject.asInstanceOf[T]
+  }
+
+  def main(args: Array[String]): Unit = {
+    val adder = serializeDeserialize((new Foo).foo)
+    assert(adder(1) == 2)
+  }
+}