Merge pull request #509 from dotty-staging/add/expandSAMs

Expand SAM closures to anonymous classes if needed

Author: DarkDimius

src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -647,7 +647,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
     }
     def parentSymbols: List[Symbol] = toDenot(sym).info.parents.map(_.typeSymbol)
     def superClass: Symbol =  {
-      val t = toDenot(sym).superClass
+      val t = toDenot(sym).asClass.superClass
       if (t.exists) t
       else if (sym is Flags.ModuleClass) {
         // workaround #371
@@ -712,7 +712,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
      * All interfaces implemented by a class, except for those inherited through the superclass.
      *
      */
-    def superInterfaces: List[Symbol] = decorateSymbol(sym).superInterfaces
+    def superInterfaces: List[Symbol] = decorateSymbol(sym).directlyInheritedTraits
 
     /**
      * True for module classes of package level objects. The backend will generate a mirror class for

src/dotty/tools/dotc/Compiler.scala

@@ -45,6 +45,7 @@ class Compiler {
            new ElimRepeated,
            new NormalizeFlags,
            new ExtensionMethods,
+           new ExpandSAMs,
            new TailRec),
       List(new PatternMatcher,
            new ExplicitOuter,

src/dotty/tools/dotc/Run.scala

@@ -33,7 +33,7 @@ class Run(comp: Compiler)(implicit ctx: Context) {
     compileSources(sources)
   } catch {
     case NonFatal(ex) =>
-      println(s"exception occurred while compiling $units%, %")
+      println(i"exception occurred while compiling $units%, %")
       throw ex
   }
 

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

@@ -210,7 +210,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     ta.assignType(untpd.TypeDef(sym.name, TypeTree(sym.info)), sym)
 
   def ClassDef(cls: ClassSymbol, constr: DefDef, body: List[Tree], superArgs: List[Tree] = Nil)(implicit ctx: Context): TypeDef = {
-    val firstParent :: otherParents = cls.info.parents
+    val firstParentRef :: otherParentRefs = cls.info.parents
+    val firstParent = cls.typeRef.baseTypeWithArgs(firstParentRef.symbol)
     val superRef =
       if (cls is Trait) TypeTree(firstParent)
       else {
@@ -225,7 +226,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         val constr = firstParent.decl(nme.CONSTRUCTOR).suchThat(constr => isApplicable(constr.info))
         New(firstParent, constr.symbol.asTerm, superArgs)
       }
-    val parents = superRef :: otherParents.map(TypeTree(_))
+    val parents = superRef :: otherParentRefs.map(TypeTree(_))
 
     val selfType =
       if (cls.classInfo.selfInfo ne NoType) ValDef(ctx.newSelfSym(cls))
@@ -244,6 +245,33 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     ta.assignType(untpd.TypeDef(cls.name, impl), cls)
   }
 
+  /** An anonymous class
+   *
+   *      new parents { forwarders }
+   *
+   *  where `forwarders` contains forwarders for all functions in `fns`.
+   *  @param parents    a non-empty list of class types
+   *  @param fns        a non-empty of functions for which forwarders should be defined in the class.
+   *  The class has the same owner as the first function in `fns`.
+   *  Its position is the union of all functions in `fns`.
+   */
+  def AnonClass(parents: List[Type], fns: List[TermSymbol], methNames: List[TermName])(implicit ctx: Context): Block = {
+    val owner = fns.head.owner
+    val parents1 =
+      if (parents.head.classSymbol.is(Trait)) defn.ObjectClass.typeRef :: parents
+      else parents
+    val cls = ctx.newNormalizedClassSymbol(owner, tpnme.ANON_FUN, Synthetic, parents1,
+        coord = fns.map(_.pos).reduceLeft(_ union _))
+    val constr = ctx.newConstructor(cls, Synthetic, Nil, Nil).entered
+    def forwarder(fn: TermSymbol, name: TermName) = {
+      val fwdMeth = fn.copy(cls, name, Synthetic | Method).entered.asTerm
+      DefDef(fwdMeth, prefss => ref(fn).appliedToArgss(prefss))
+    }
+    val forwarders = (fns, methNames).zipped.map(forwarder)
+    val cdef = ClassDef(cls, DefDef(constr), forwarders)
+    Block(cdef :: Nil, New(cls.typeRef, Nil))
+  }
+
   // { <label> def while$(): Unit = if (cond) { body; while$() } ; while$() }
   def WhileDo(owner: Symbol, cond: Tree, body: List[Tree])(implicit ctx: Context): Tree = {
     val sym = ctx.newSymbol(owner, nme.WHILE_PREFIX, Flags.Label | Flags.Synthetic,
@@ -254,7 +282,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     Block(List(DefDef(sym, rhs)), call)
   }
 
-
   def Import(expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import =
     ta.assignType(untpd.Import(expr, selectors), ctx.newImportSymbol(ctx.owner, expr))
 

src/dotty/tools/dotc/core/Flags.scala

@@ -332,7 +332,7 @@ object Flags {
   final val JavaStaticTerm = JavaStatic.toTermFlags
   final val JavaStaticType = JavaStatic.toTypeFlags
 
-  /** Trait is not an interface, but does not have fields or initialization code */
+  /** Trait does not have fields or initialization code */
   final val NoInits = typeFlag(32, "<noInits>")
 
   /** Variable is accessed from nested function. */

src/dotty/tools/dotc/core/StdNames.scala

@@ -418,6 +418,7 @@ object StdNames {
     val isArray: N              = "isArray"
     val isDefined: N            = "isDefined"
     val isDefinedAt: N          = "isDefinedAt"
+    val isDefinedAtImpl: N      = "$isDefinedAt"
     val isEmpty: N              = "isEmpty"
     val isInstanceOf_ : N       = "isInstanceOf"
     val java: N                 = "java"

src/dotty/tools/dotc/core/Symbols.scala

@@ -109,6 +109,30 @@ trait Symbols { this: Context =>
         ClassInfo(owner.thisType, _, parents, decls, selfInfo),
         privateWithin, coord, assocFile)
 
+  /** Same as `newCompleteClassSymbol` except that `parents` can be a list of arbitary
+   *  types which get normalized into type refs and parameter bindings.
+   */
+  def newNormalizedClassSymbol(
+      owner: Symbol,
+      name: TypeName,
+      flags: FlagSet,
+      parentTypes: List[Type],
+      decls: Scope = newScope,
+      selfInfo: Type = NoType,
+      privateWithin: Symbol = NoSymbol,
+      coord: Coord = NoCoord,
+      assocFile: AbstractFile = null): ClassSymbol = {
+    def completer = new LazyType {
+      def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
+        val cls = denot.asClass.classSymbol
+        val decls = newScope
+        val parentRefs: List[TypeRef] = normalizeToClassRefs(parentTypes, cls, decls)
+        denot.info = ClassInfo(owner.thisType, cls, parentRefs, decls)
+      }
+    }
+    newClassSymbol(owner, name, flags, completer, privateWithin, coord, assocFile)
+  }
+
   /** Create a module symbol with associated module class
    *  from its non-info fields and a function producing the info
    *  of the module class (this info may be lazy).

src/dotty/tools/dotc/core/Types.scala

@@ -545,6 +545,11 @@ object Types {
         (name, buf) => buf ++= member(name).altsWith(x => x.isClass))
     }
 
+    final def fields(implicit ctx: Context): Seq[SingleDenotation] = track("fields") {
+      memberDenots(fieldFilter,
+        (name, buf) => buf ++= member(name).altsWith(x => !x.is(Method)))
+    }
+
     /** The set of members  of this type  having at least one of `requiredFlags` but none of  `excludedFlags` set */
     final def membersBasedOnFlags(requiredFlags: FlagSet, excludedFlags: FlagSet)(implicit ctx: Context): Seq[SingleDenotation] = track("implicitMembers") {
       memberDenots(takeAllFilter,
@@ -3049,6 +3054,11 @@ object Types {
     def apply(pre: Type, name: Name)(implicit ctx: Context): Boolean = name.isTypeName
   }
 
+  object fieldFilter extends NameFilter {
+    def apply(pre: Type, name: Name)(implicit ctx: Context): Boolean =
+      name.isTermName && (pre member name).hasAltWith(!_.symbol.is(Method))
+  }
+
   object takeAllFilter extends NameFilter {
     def apply(pre: Type, name: Name)(implicit ctx: Context): Boolean = true
   }

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

@@ -0,0 +1,88 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Contexts._, Symbols._, Types._, Flags._, Decorators._, StdNames._, Constants._
+import SymDenotations.SymDenotation
+import TreeTransforms._
+import SymUtils._
+import ast.untpd
+import ast.Trees._
+
+/** Expand SAM closures that cannot be represented by the JVM as lambdas to anonymous classes.
+ *  These fall into five categories
+ *
+ *   1. Partial function closures, we need to generate a isDefinedAt method for these.
+ *   2. Closures implementing non-trait classes.
+ *   3. Closures implementing classes that inherit from a class other than Object
+ *      (a lambda cannot not be a run-time subtype of such a class)
+ *   4. Closures that implement traits which run initialization code.
+ *   5. Closures that get synthesized abstract methods in the transformation pipeline. These methods can be
+ *      (1) superaccessors, (2) outer references, (3) accessors for fields.
+ */
+class ExpandSAMs extends MiniPhaseTransform { thisTransformer =>
+  override def phaseName = "expandSAMs"
+
+  import ast.tpd._
+
+  def noJvmSam(cls: ClassSymbol)(implicit ctx: Context): Boolean =
+    !cls.is(Trait) ||
+    cls.superClass != defn.ObjectClass ||
+    !cls.is(NoInits) ||
+    !cls.directlyInheritedTraits.forall(_.is(NoInits)) ||
+    ExplicitOuter.needsOuterIfReferenced(cls) ||
+    cls.typeRef.fields.nonEmpty // Superaccessors already show up as abstract methods here, so no test necessary
+
+
+  override def transformBlock(tree: Block)(implicit ctx: Context, info: TransformerInfo): Tree = tree match {
+    case Block(stats @ (fn: DefDef) :: Nil, Closure(_, fnRef, tpt)) if fnRef.symbol == fn.symbol =>
+      tpt.tpe match {
+        case NoType => tree // it's a plain function
+        case tpe @ SAMType(_) if !noJvmSam(tpe.classSymbol.asClass) =>
+          if (tpe isRef defn.PartialFunctionClass) toPartialFunction(tree)
+          else tree
+        case tpe =>
+          cpy.Block(tree)(stats,
+              AnonClass(tpe :: Nil, fn.symbol.asTerm :: Nil, nme.apply :: Nil))
+      }
+    case _ =>
+      tree
+  }
+
+  private def toPartialFunction(tree: Block)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    val Block(
+          (applyDef @ DefDef(nme.ANON_FUN, Nil, List(List(param)), _, _)) :: Nil,
+          Closure(_, _, tpt)) = tree
+    val applyRhs: Tree = applyDef.rhs
+    val applyFn = applyDef.symbol.asTerm
+
+    val MethodType(paramNames, paramTypes) = applyFn.info
+    val isDefinedAtFn = applyFn.copy(
+        name  = nme.isDefinedAtImpl,
+        flags = Synthetic | Method,
+        info = MethodType(paramNames, paramTypes, defn.BooleanType)).asTerm
+    val tru = Literal(Constant(true))
+    def isDefinedAtRhs(paramRefss: List[List[Tree]]) = applyRhs match {
+      case Match(selector, cases) =>
+        assert(selector.symbol == param.symbol)
+        val paramRef = paramRefss.head.head
+        // Again, the alternative
+        //     val List(List(paramRef)) = paramRefs
+        // fails with a similar self instantiation error
+        def translateCase(cdef: CaseDef): CaseDef =
+          cpy.CaseDef(cdef)(body = tru).changeOwner(applyFn, isDefinedAtFn)
+        val defaultSym = ctx.newSymbol(isDefinedAtFn, nme.WILDCARD, Synthetic, selector.tpe.widen)
+        val defaultCase =
+          CaseDef(
+            Bind(defaultSym, untpd.Ident(nme.WILDCARD).withType(selector.tpe.widen)),
+            EmptyTree,
+            Literal(Constant(false)))
+        cpy.Match(applyRhs)(paramRef, cases.map(translateCase) :+ defaultCase)
+      case _ =>
+        tru
+    }
+    val isDefinedAtDef = transformFollowingDeep(DefDef(isDefinedAtFn, isDefinedAtRhs(_)))
+    val anonCls = AnonClass(tpt.tpe :: Nil, List(applyFn, isDefinedAtFn), List(nme.apply, nme.isDefinedAt))
+    cpy.Block(tree)(List(applyDef, isDefinedAtDef), anonCls)
+  }
+}

src/dotty/tools/dotc/transform/SymUtils.scala

@@ -24,30 +24,20 @@ object SymUtils {
 class SymUtils(val self: Symbol) extends AnyVal {
   import SymUtils._
 
-  def superClass(implicit ctx: Context) = {
-    val parents = self.asClass.classInfo.parents
-    if (parents.isEmpty) NoSymbol
-    else parents.head.symbol
-  }
-
-
-  /**
-   * For a class: All interfaces implemented by a class except for those inherited through the superclass.
-   * For a trait: all parent traits
-   */
-
-  def superInterfaces(implicit ctx: Context) = {
-    val superCls = self.superClass
+  /** All traits implemented by a class or trait except for those inherited through the superclass. */
+  def directlyInheritedTraits(implicit ctx: Context) = {
+    val superCls = self.asClass.superClass
     val baseClasses = self.asClass.baseClasses
     if (baseClasses.isEmpty) Nil
     else baseClasses.tail.takeWhile(_ ne superCls).reverse
-
   }
 
-  /** All interfaces implemented by a class, except for those inherited through the superclass. */
+  /** All traits implemented by a class, except for those inherited through the superclass.
+   *  The empty list if `self` is a trait.
+   */
   def mixins(implicit ctx: Context) = {
     if (self is Trait) Nil
-    else superInterfaces
+    else directlyInheritedTraits
   }
 
   def isTypeTestOrCast(implicit ctx: Context): Boolean =