Inline isDefined and applyOrElse implementations in anonymous class' body

Author: allanrenucci

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

@@ -586,11 +586,13 @@ class Definitions {
   lazy val PartialFunctionType: TypeRef         = ctx.requiredClassRef("scala.PartialFunction")
   def PartialFunctionClass(implicit ctx: Context) = PartialFunctionType.symbol.asClass
 
-    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 AbstractPartialFunction_isDefinedAtR = AbstractPartialFunctionClass.requiredMethodRef(nme.isDefinedAt)
+    def AbstractPartialFunction_isDefinedAt(implicit ctx: Context) = AbstractPartialFunction_isDefinedAtR.symbol
+    lazy val AbstractPartialFunction_applyOrElseR = AbstractPartialFunctionClass.requiredMethodRef(nme.applyOrElse)
+    def AbstractPartialFunction_applyOrElse(implicit ctx: Context) = AbstractPartialFunction_applyOrElseR.symbol
+
   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,18 +73,24 @@ 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
+    val tpArgs = tpt.tpe.baseType(defn.PartialFunctionClass).argInfos
+    val parent = defn.AbstractPartialFunctionType.appliedTo(tpArgs)
+    val cls = ctx.newNormalizedClassSymbol(
+      applyDef.symbol.owner,
+      tpnme.ANON_CLASS,
+      Synthetic | Final,
+      parent :: Nil,
+      coord = tree.pos)
+
+    def overrideSym(sym: Symbol) = sym.copy(
+      owner = cls,
+      flags = sym.flags &~ Deferred | Override | Final | Synthetic,
+      info = cls.typeRef.memberInfo(sym),
+      coord = tree.pos).entered.asTerm
+    val isDefinedAtFn = overrideSym(defn.AbstractPartialFunction_isDefinedAt)
+    val applyOrElseFn = overrideSym(defn.AbstractPartialFunction_applyOrElse)
 
     def isDefinedAtRhs(paramRefss: List[List[Tree]]) = {
       val tru = Literal(Constant(true))
@@ -115,13 +121,11 @@ class ExpandSAMs extends MiniPhase {
         }
     }
 
+    val constr = ctx.newConstructor(cls, Synthetic, Nil, Nil).entered
     val isDefinedAtDef = transformFollowingDeep(DefDef(isDefinedAtFn, isDefinedAtRhs(_)))
     val applyOrElseDef = transformFollowingDeep(DefDef(applyOrElseFn, applyOrElseRhs(_)))
-
-    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)
+    val cdef = ClassDef(cls, DefDef(constr), List(isDefinedAtDef, applyOrElseDef))
+    cpy.Block(tree)(cdef :: Nil, New(cls.typeRef, Nil))
   }
 
   private def checkRefinements(tpe: Type, pos: Position)(implicit ctx: Context): Type = tpe.dealias match {