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, 1 insertions, 1 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
index 9847c9db58..32106614e3 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
@@ -27,7 +27,7 @@ class Inliner[BT <: BTypes](val btypes: BT) {
   import backendUtils._
 
   def runInliner(): Unit = {
-    rewriteFinalTraitMethodInvocations()
+//    rewriteFinalTraitMethodInvocations()
 
     for (request <- collectAndOrderInlineRequests) {
       val Right(callee) = request.callsite.callee // collectAndOrderInlineRequests returns callsites with a known callee