Only generate isDefined and applyOrElse for partial function literals

This is done by extending `scala.runtime.AbstractPartialFunction`.

Author: allanrenucci

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

@@ -282,11 +282,11 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     val parents1 =
       if (parents.head.classSymbol.is(Trait)) parents.head.parents.head :: parents
       else parents
-    val cls = ctx.newNormalizedClassSymbol(owner, tpnme.ANON_CLASS, Synthetic, parents1,
+    val cls = ctx.newNormalizedClassSymbol(owner, tpnme.ANON_CLASS, Synthetic | Final, parents1,
         coord = fns.map(_.pos).reduceLeft(_ union _))
     val constr = ctx.newConstructor(cls, Synthetic, Nil, Nil).entered
     def forwarder(fn: TermSymbol, name: TermName) = {
-      var flags = Synthetic | Method
+      var flags = Synthetic | Method | Final
       def isOverriden(denot: SingleDenotation) = fn.info.overrides(denot.info, matchLoosely = true)
       val isOverride = parents.exists(_.member(name).hasAltWith(isOverriden))
       if (isOverride) flags = flags | Override

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

@@ -585,12 +585,14 @@ class Definitions {
 
   lazy val PartialFunctionType: TypeRef         = ctx.requiredClassRef("scala.PartialFunction")
   def PartialFunctionClass(implicit ctx: Context) = PartialFunctionType.symbol.asClass
-
+    lazy val PartialFunction_isDefinedAtR = PartialFunctionClass.requiredMethodRef(nme.isDefinedAt)
+    def PartialFunction_isDefinedAt(implicit ctx: Context) = PartialFunction_isDefinedAtR.symbol
     lazy val PartialFunction_applyOrElseR = PartialFunctionClass.requiredMethodRef(nme.applyOrElse)
     def PartialFunction_applyOrElse(implicit ctx: Context) = PartialFunction_applyOrElseR.symbol
 
   lazy val AbstractPartialFunctionType: TypeRef = ctx.requiredClassRef("scala.runtime.AbstractPartialFunction")
   def AbstractPartialFunctionClass(implicit ctx: Context) = AbstractPartialFunctionType.symbol.asClass
+
   lazy val FunctionXXLType: TypeRef         = ctx.requiredClassRef("scala.FunctionXXL")
   def FunctionXXLClass(implicit ctx: Context) = FunctionXXLType.symbol.asClass
 

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

@@ -73,24 +73,21 @@ class ExpandSAMs extends MiniPhase {
     }
 
     val applyRhs = applyDef.rhs
-    val applyFn = applyDef.symbol.asTerm
+    val applyFn = applyDef.symbol
 
-    val MethodTpe(paramNames, paramTypes, _) = applyFn.info
-    val isDefinedAtFn = applyFn.copy(
-        name  = nme.isDefinedAt,
-        flags = Synthetic | Method,
-        info = MethodType(paramNames, paramTypes, defn.BooleanType)).asTerm
-
-    val applyOrElseFn = applyFn.copy(
-        name  = nme.applyOrElse,
-        flags = Synthetic | Method,
-        info = tpt.tpe.memberInfo(defn.PartialFunction_applyOrElse)).asTerm
+    def overrideSym(sym: Symbol) = sym.copy(
+      owner = applyFn.owner,
+      flags = Synthetic | Method | Final | Private,
+      info = tpt.tpe.memberInfo(sym),
+      coord = tree.pos).asTerm
+    val isDefinedAtFn = overrideSym(defn.PartialFunction_isDefinedAt)
+    val applyOrElseFn = overrideSym(defn.PartialFunction_applyOrElse)
 
     def isDefinedAtRhs(paramRefss: List[List[Tree]]) = {
       val tru = Literal(Constant(true))
       applyRhs match {
         case tree @ Match(_, cases) =>
-          def translateCase(cdef: CaseDef)=
+          def translateCase(cdef: CaseDef) =
             cpy.CaseDef(cdef)(body = tru).changeOwner(applyFn, isDefinedAtFn)
           val paramRef = paramRefss.head.head
           val defaultValue = Literal(Constant(false))
@@ -109,15 +106,19 @@ class ExpandSAMs extends MiniPhase {
           val defaultValue = defaultRef.select(nme.apply).appliedTo(paramRef)
           translateMatch(tree, paramRef, cases.map(translateCase), defaultValue)
         case _ =>
-          ref(applyFn).appliedTo(paramRef)
+          applyRhs
+            .changeOwner(applyFn, applyOrElseFn)
+            .subst(param.symbol :: Nil, paramRef.symbol :: Nil)
         }
     }
 
     val isDefinedAtDef = transformFollowingDeep(DefDef(isDefinedAtFn, isDefinedAtRhs(_)))
     val applyOrElseDef = transformFollowingDeep(DefDef(applyOrElseFn, applyOrElseRhs(_)))
 
-    val anonCls = AnonClass(tpt.tpe :: Nil, List(applyFn, isDefinedAtFn, applyOrElseFn), List(nme.apply, nme.isDefinedAt, nme.applyOrElse))
-    cpy.Block(tree)(List(applyDef, isDefinedAtDef, applyOrElseDef), anonCls)
+    val tpArgs = tpt.tpe.baseType(defn.PartialFunctionClass).argInfos
+    val parent = defn.AbstractPartialFunctionType.appliedTo(tpArgs)
+    val anonCls = AnonClass(parent :: Nil, List(isDefinedAtFn, applyOrElseFn), List(nme.isDefinedAt, nme.applyOrElse))
+    cpy.Block(tree)(List(isDefinedAtDef, applyOrElseDef), anonCls)
   }
 
   private def checkRefinements(tpe: Type, pos: Position)(implicit ctx: Context): Type = tpe.dealias match {

tests/pos/i4177.scala

@@ -11,5 +11,10 @@ class Test {
     val e: PartialFunction[String, String] = { case x @ "abc" => x }
     val f: PartialFunction[String, String] = x => x match { case "abc" => x }
     val g: PartialFunction[String, String] = x => x match { case "abc" if x.isEmpty => x }
+
+    type P = PartialFunction[String,String]
+    val h: P = { case x => x.toString }
+
+    val i: PartialFunction[Int, Int] = { x => x match { case x => x } }
   }
 }