New trait encoding: use default methods, jettison impl classes

Until now, concrete methods in traits were encoded with
"trait implementation classes".

  - Such a trait would compile to two class files
    - the trait interface, a Java interface, and
    - the implementation class, containing "trait implementation methods"
  - trait implementation methods are static methods has an explicit self
    parameter.
  - some methods don't require addition of an interface method, such as
    private methods. Calls to these directly call the implementation method
  - classes that mixin a trait install "trait forwarders", which implement
    the abstract method in the interface by forwarding to the trait
    implementation method.

The new encoding:
  - no longer emits trait implementation classes or trait implementation
    methods.
  - instead, concrete methods are simply retained in the interface, as JVM 8
    default interface methods (the JVM spec changes in
    [JSR-335](http://download.oracle.com/otndocs/jcp/lambda-0_9_3-fr-eval-spec/index.html)
    pave the way)
  - use `invokespecial` to call private or particular super implementations
    of a method (rather `invokestatic`)
    - in cases when we `invokespecial` to a method in an indirect ancestor, we add
    that ancestor redundantly as a direct parent. We are investigating alternatives
    approaches here.
  - we still emit trait fowrarders, although we are
    [investigating](https://github.com/scala/scala-dev/issues/98) ways to only do
    this when the JVM would be unable to resolve the correct method using its rules
    for default method resolution.

Here's an example:

```
trait T {
  println("T")
  def m1 = m2
  private def m2 = "m2"
}
trait U extends T {
  println("T")
  override def m1 = super[T].m1
}
class C extends U {
  println("C")
  def test = m1
}
```

The old and new encodings are displayed and diffed here: https://gist.github.com/retronym/f174d23f859f0e053580

Some notes in the implementation:

  - No need to filter members from class decls at all in AddInterfaces
    (although we do have to trigger side effecting info transformers)
  - We can now emit an EnclosingMethod attribute for classes nested
    in private trait methods
  - Created a factory method for an AST shape that is used in
    a number of places to symbolically bind to a particular
    super method without needed to specify the qualifier of
    the `Super` tree (which is too limiting, as it only allows
    you to refer to direct parents.)
    - I also found a similar tree shape created in Delambdafy,
      that is better expressed with an existing tree creation
      factory method, mkSuperInit.

1 files changed, 4 insertions, 49 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
index a372136781..7a5bd747c4 100644
--- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
+++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
@@ -98,11 +98,6 @@ abstract class LambdaLift extends InfoTransform {
      */
     private val proxyNames       = mutable.HashMap[Symbol, Name]()
 
-    // (trait, name) -> owner
-    private val localTraits      = mutable.HashMap[(Symbol, Name), Symbol]()
-    // (owner, name) -> implClass
-    private val localImplClasses = mutable.HashMap[(Symbol, Name), Symbol]()
-
     /** A flag to indicate whether new free variables have been found */
     private var changedFreeVars: Boolean = _
 
@@ -176,24 +171,7 @@ abstract class LambdaLift extends InfoTransform {
           case ClassDef(_, _, _, _) =>
             liftedDefs(tree.symbol) = Nil
             if (sym.isLocalToBlock) {
-              // Don't rename implementation classes independently of their interfaces. If
-              // the interface is to be renamed, then we will rename the implementation
-              // class at that time. You'd think we could call ".implClass" on the trait
-              // rather than collecting them in another map, but that seems to fail for
-              // exactly the traits being renamed here (i.e. defined in methods.)
-              //
-              // !!! - it makes no sense to have methods like "implClass" and
-              // "companionClass" which fail for an arbitrary subset of nesting
-              // arrangements, and then have separate methods which attempt to compensate
-              // for that failure. There should be exactly one method for any given
-              // entity which always gives the right answer.
-              if (sym.isImplClass)
-                localImplClasses((sym.owner, tpnme.interfaceName(sym.name))) = sym
-              else {
-                renamable += sym
-                if (sym.isTrait)
-                  localTraits((sym, sym.name)) = sym.owner
-              }
+              renamable += sym
             }
           case DefDef(_, _, _, _, _, _) =>
             if (sym.isLocalToBlock) {
@@ -264,40 +242,18 @@ abstract class LambdaLift extends InfoTransform {
           //         Generating a unique name, mangled with the enclosing full class name (including
           //         package - subclass might have the same name), avoids a VerifyError in the case
           //         that a sub-class happens to lifts out a method with the *same* name.
-          if (originalName.isTermName && !sym.enclClass.isImplClass && calledFromInner(sym))
+          if (originalName.isTermName && calledFromInner(sym))
             newTermNameCached(nonAnon(sym.enclClass.fullName('$')) + nme.EXPAND_SEPARATOR_STRING + name)
           else
             name
         }
       }
 
-      /* Rename a trait's interface and implementation class in coordinated fashion. */
-      def renameTrait(traitSym: Symbol, implSym: Symbol) {
-        val originalImplName = implSym.name
-        renameSym(traitSym)
-        implSym setName tpnme.implClassName(traitSym.name)
-
-        debuglog("renaming impl class in step with %s: %s => %s".format(traitSym, originalImplName, implSym.name))
-      }
-
       val allFree: Set[Symbol] = free.values.flatMap(_.iterator).toSet
 
       for (sym <- renamable) {
-        // If we renamed a trait from Foo to Foo$1, we must rename the implementation
-        // class from Foo$class to Foo$1$class.  (Without special consideration it would
-        // become Foo$class$1 instead.) Since the symbols are being renamed out from
-        // under us, and there's no reliable link between trait symbol and impl symbol,
-        // we have maps from ((trait, name)) -> owner and ((owner, name)) -> impl.
-        localTraits remove ((sym, sym.name)) match {
-          case None        =>
-            if (allFree(sym)) proxyNames(sym) = newName(sym)
-            else renameSym(sym)
-          case Some(owner) =>
-            localImplClasses remove ((owner, sym.name)) match {
-              case Some(implSym)  => renameTrait(sym, implSym)
-              case _              => renameSym(sym) // pure interface, no impl class
-            }
-        }
+        if (allFree(sym)) proxyNames(sym) = newName(sym)
+        else renameSym(sym)
       }
 
       afterOwnPhase {
@@ -456,7 +412,6 @@ abstract class LambdaLift extends InfoTransform {
       }
 
       sym.owner = sym.owner.enclClass
-      if (sym.isClass) sym.owner = sym.owner.toInterface
       if (sym.isMethod) sym setFlag LIFTED
       liftedDefs(sym.owner) ::= tree
       // TODO: this modifies the ClassInfotype of the enclosing class, which is associated with another phase (explicitouter).