New miniphase: ExpandSAMs

The phase replaces SAM closures with anonymous classes when necessary.

Author: odersky

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/core/StdNames.scala

@@ -416,6 +416,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/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,
@@ -3047,6 +3052,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,91 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Contexts._, Symbols._, Types._, Flags._, Decorators._, StdNames._, Constants._
+import SymDenotations.SymDenotation
+import TreeTransforms._
+import ast.untpd
+import ast.Trees._
+
+/** Expand SAM closures that cannot be represented by the JVM to anonymous classes.
+ *  These fall into three categories
+ *
+ *   1. Partial function closures, we need to generate a isDefinedAt method for these.
+ *   2. Closures implementaing non-trait classes.
+ *   3. 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) || ExplicitOuter.needsOuterIfReferenced(cls) || cls.typeRef.fields.nonEmpty
+
+  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, 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(params), _, _)) :: Nil,
+          Closure(_, _, tpt)) = tree
+    val List(param) = params
+    // Dotty problem: If we match instead List(List(param)) directly,
+    // we get:
+    // Exception in thread "main" java.lang.AssertionError: assertion failed: self instantiation of (A?
+    // ...
+    //  at scala.Predef$.assert(Predef.scala:165)
+    //  at dotty.tools.dotc.core.Types$TypeVar.instantiateWith(Types.scala:2308)
+    //  at dotty.tools.dotc.core.Types$TypeVar.instantiate(Types.scala:2363)
+    //  at dotty.tools.dotc.typer.Inferencing$$anonfun$interpolate$1$1$$anonfun$apply$mcV$sp$4.apply(Inferencing.scala:198)
+    // at dotty.tools.dotc.typer.Inferencing$$anonfun$interpolate$1$1$$anonfun$apply$mcV$sp$4.apply(Inferencing.scala:195)
+    //
+    // I think it has to do with the double :: (or List) pattern to extract `param`.
+
+    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, List(applyFn, isDefinedAtFn), List(nme.apply, nme.isDefinedAt))
+    cpy.Block(tree)(List(applyDef, isDefinedAtDef), anonCls)
+  }
+}

test/dotc/tests.scala

@@ -35,7 +35,7 @@ class tests extends CompilerTest {
   val allowDoubleBindings = defaultOptions diff List("-Yno-double-bindings")
 
   val testsDir      = "./tests/"
-  val posDir        = testsDir + "pos/"  
+  val posDir        = testsDir + "pos/"
   val posSpecialDir = testsDir + "pos-special/"
   val negDir        = testsDir + "neg/"
   val newDir        = testsDir + "new/"
@@ -50,7 +50,7 @@ class tests extends CompilerTest {
   @Test def pickle_ast = compileDir(dotcDir, "ast", testPickling)
 
   //@Test def pickle_core = compileDir(dotcDir, "core", testPickling, xerrors = 2) // two spurious comparison errors in Types and TypeOps
-  
+
   @Test def pos_t2168_pat = compileFile(posDir, "t2168", twice)
   @Test def pos_erasure = compileFile(posDir, "erasure", twice)
   @Test def pos_Coder() = compileFile(posDir, "Coder", twice)
@@ -108,9 +108,6 @@ class tests extends CompilerTest {
   @Test def neg_i50_volatile = compileFile(negDir, "i50-volatile", xerrors = 6)
   @Test def neg_t0273_doubledefs = compileFile(negDir, "t0273", xerrors = 1)
   @Test def neg_zoo = compileFile(negDir, "zoo", xerrors = 12)
-  @Test def neg_sam = compileFile(negDir, "sammy_poly", xerrors = 1)
-  // TODO: this test file doesn't exist (anymore?), remove?
-  // @Test def neg_t1192_legalPrefix = compileFile(negDir, "t1192", xerrors = 1)
 
   val negTailcallDir = negDir + "tailcall/"
   @Test def neg_tailcall_t1672b = compileFile(negTailcallDir, "t1672b", xerrors = 6)
@@ -119,7 +116,7 @@ class tests extends CompilerTest {
   @Test def neg_tailcall = compileFile(negTailcallDir, "tailrec", xerrors = 7)
   @Test def neg_tailcall2 = compileFile(negTailcallDir, "tailrec-2", xerrors = 2)
   @Test def neg_tailcall3 = compileFile(negTailcallDir, "tailrec-3", xerrors = 2)
-  
+
   @Test def neg_t1279a = compileFile(negDir, "t1279a", xerrors = 1)
   @Test def neg_t1843_variances = compileFile(negDir, "t1843-variances", xerrors = 1)
   @Test def neg_t2660_ambi = compileFile(negDir, "t2660", xerrors = 2)

tests/neg/sammy_poly.scala

@@ -0,0 +1,63 @@
+object test {
+
+  trait X { def foo(x: Int): Int; def bar = foo(2) }
+
+  val x: X = (x: Int) => 2  // should be a closure
+
+  trait T {
+    var f = 2
+    def foo(x: Int): Int
+  }
+
+  val t: T = (x: Int) => 2   // needs to be an anonymous class because of defined field
+
+  trait U extends T
+
+  val u: U = (x: Int) => 2   // needs to be an anonymous class because of inherited field
+
+  trait Y extends X {
+    def baz = super.bar
+  }
+
+  val y: Y = (x: Int) => 2   // needs to be an anonymous class because of super accessor
+
+  abstract class C {
+    def foo(x: Int): Int
+
+    trait I { def foo(x: Int): Int }
+
+  }
+
+  val c: C = (x: Int) => 2   // needs to be an anonymous class because C is not a trait
+
+  val ci: c.I = (x: Int) => 2 // needs to be an anonymous class because it needs an outer pointer
+
+
+  val pf: PartialFunction[Int, Int] = {
+    case 1 => 1
+    case 2 => 2
+  }
+
+  val qf: PartialFunction[(Int, String), Int] = {
+    case (1, "abc") => 1
+    case _ => 2
+  }
+
+  val rf: PartialFunction[(Int, AnyRef), Int] = {
+    case (_: Int, _: String) => 1
+    case _ => 2
+  }
+
+  val sf: PartialFunction[Any, Int] = {
+    case x: String if x == "abc" => 1
+  }
+}
+
+// From: neg/sammy_poly
+// synthesizeSAMFunction where the sam type is not fully defined
+class T {
+  trait F[T, U] { def apply(x: T): U }
+  // this is an inner trait, that will recieve an abstract $outer pointer. Not a SAM.
+  def app[T, U](x: T)(f: F[T, U]): U = f(x)
+  app(1)(x => List(x))
+}