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/transform/ExpandSAMs.scala

@@ -90,7 +90,7 @@ class ExpandSAMs extends MiniPhase {
       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 +109,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 } }
   }
 }