Nuke trait implementation classes

  - Leave the members in the trait instead (these will be emitted as
    default methods in the interface)
  - Add the trait mixin constructor to the interface, rather than
    the impl class
  - Change the invocation of the mixin constructor to use an
    invokespecial. This is encoded with the AST:
    `Apply(Select(Super(_, _), mixinConstructor)))`

I've tried to remove all traces of the interface / implclass
distinction.

Author: retronym

src/compiler/scala/tools/nsc/ast/TreeGen.scala

@@ -145,6 +145,7 @@ abstract class TreeGen extends scala.reflect.internal.TreeGen with TreeDSL {
   override def mkCast(tree: Tree, pt: Type): Tree = {
     debuglog("casting " + tree + ":" + tree.tpe + " to " + pt + " at phase: " + phase)
     assert(!tree.tpe.isInstanceOf[MethodType], tree)
+    assert(!pt.isInstanceOf[MethodType], tree)
     assert(pt eq pt.normalize, tree +" : "+ debugString(pt) +" ~>"+ debugString(pt.normalize))
     atPos(tree.pos) {
       mkAsInstanceOf(tree, pt, any = !phase.next.erasedTypes, wrapInApply = isAtPhaseAfter(currentRun.uncurryPhase))

src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala

@@ -1033,7 +1033,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
       hostSymbol.info ; methodOwner.info
 
       def needsInterfaceCall(sym: Symbol) = (
-           sym.isInterface
+           sym.isTraitOrInterface
         || sym.isJavaDefined && sym.isNonBottomSubClass(definitions.ClassfileAnnotationClass)
       )
 
@@ -1327,7 +1327,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
       def asmType(sym: Symbol) = classBTypeFromSymbol(sym).toASMType
 
       val implMethodHandle =
-        new asm.Handle(if (lambdaTarget.hasFlag(Flags.STATIC)) asm.Opcodes.H_INVOKESTATIC else if (lambdaTarget.isTrait) asm.Opcodes.H_INVOKEINTERFACE else asm.Opcodes.H_INVOKEVIRTUAL,
+        new asm.Handle(if (lambdaTarget.hasFlag(Flags.STATIC)) asm.Opcodes.H_INVOKESTATIC else if (lambdaTarget.owner.isTrait) asm.Opcodes.H_INVOKEINTERFACE else asm.Opcodes.H_INVOKEVIRTUAL,
           classBTypeFromSymbol(lambdaTarget.owner).internalName,
           lambdaTarget.name.toString,
           methodBTypeFromSymbol(lambdaTarget).descriptor)

src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala

@@ -32,7 +32,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
    * the InnerClass / EnclosingMethod classfile attributes. See comment in BTypes.
    */
   def considerAsTopLevelImplementationArtifact(classSym: Symbol) = {
-    classSym.isImplClass || classSym.isSpecialized
+    classSym.isSpecialized
   }
 
   /**
@@ -252,7 +252,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
    * Build the [[InlineInfo]] for a class symbol.
    */
   def buildInlineInfoFromClassSymbol(classSym: Symbol, classSymToInternalName: Symbol => InternalName, methodSymToDescriptor: Symbol => String): InlineInfo = {
-    val traitSelfType = if (classSym.isTrait && !classSym.isImplClass) {
+    val traitSelfType = if (classSym.isTrait) {
       // The mixin phase uses typeOfThis for the self parameter in implementation class methods.
       val selfSym = classSym.typeOfThis.typeSymbol
       if (selfSym != classSym) Some(classSymToInternalName(selfSym)) else None
@@ -263,7 +263,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     val isEffectivelyFinal = classSym.isEffectivelyFinal
 
     val sam = {
-      if (classSym.isImplClass || classSym.isEffectivelyFinal) None
+      if (classSym.isEffectivelyFinal) None
       else {
         // Phase travel necessary. For example, nullary methods (getter of an abstract val) get an
         // empty parameter list in later phases and would therefore be picked as SAM.
@@ -297,7 +297,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
           //    flag is ignored. The members are therefore not isEffectivelyFinal (their owner
           //    is not a module). Since we know that all impl class members are static, we can
           //    just take the shortcut.
-          val effectivelyFinal = classSym.isImplClass || exitingPickler(methodSym.isEffectivelyFinalOrNotOverridden)
+          val effectivelyFinal = exitingPickler(methodSym.isEffectivelyFinalOrNotOverridden)
 
           // Identify trait interface methods that have a static implementation in the implementation
           // class. Invocations of these methods can be re-wrired directly to the static implementation
@@ -314,7 +314,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
           // properties manually.
           val traitMethodWithStaticImplementation = {
             import symtab.Flags._
-            classSym.isTrait && !classSym.isImplClass &&
+            classSym.isTrait &&
               erasure.needsImplMethod(methodSym) &&
               !methodSym.isModule &&
               !(methodSym hasFlag (ACCESSOR | SUPERACCESSOR))
@@ -862,7 +862,6 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       || sym.isArtifact
       || sym.isLiftedMethod
       || sym.isBridge
-      || (sym.ownerChain exists (_.isImplClass))
     )
 
     /* @return

src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala

@@ -176,7 +176,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
           if (lmoc != NoSymbol) {
             // it must be a top level class (name contains no $s)
             val isCandidateForForwarders = {
-              exitingPickler { !(lmoc.name.toString contains '$') && lmoc.hasModuleFlag && !lmoc.isImplClass && !lmoc.isNestedClass }
+              exitingPickler { !(lmoc.name.toString contains '$') && lmoc.hasModuleFlag && !lmoc.isNestedClass }
             }
             if (isCandidateForForwarders) {
               log(s"Adding static forwarders from '$claszSymbol' to implementations in '$lmoc'")

src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala

@@ -151,7 +151,6 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
      */
     def primitiveOrClassToBType(sym: Symbol): BType = {
       assertClassNotArray(sym)
-      assert(!sym.isImplClass, sym)
       primitiveTypeMap.getOrElse(sym, classBTypeFromSymbol(sym))
     }
 
@@ -320,7 +319,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     // Check for hasAnnotationFlag for SI-9393: the classfile / java source parsers add
     // scala.annotation.Annotation as superclass to java annotations. In reality, java
     // annotation classfiles have superclass Object (like any interface classfile).
-    val superClassSym = if (classSym.isImplClass || classSym.hasJavaAnnotationFlag) ObjectClass else {
+    val superClassSym = if (classSym.hasJavaAnnotationFlag) ObjectClass else {
       val sc = classSym.superClass
       // SI-9393: Java annotation classes don't have the ABSTRACT/INTERFACE flag, so they appear
       // (wrongly) as superclasses. Fix this for BTypes: the java annotation will appear as interface
@@ -586,11 +585,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
    */
   final def isTopLevelModuleClass(sym: Symbol): Boolean = exitingPickler {
     // phase travel to pickler required for isNestedClass (looks at owner)
-    val r = sym.isModuleClass && !sym.isNestedClass
-    // The mixin phase adds the `lateMODULE` flag to trait implementation classes. Since the flag
-    // is late, it should not be visible here inside the time travel. We check this.
-    if (r) assert(!sym.isImplClass, s"isModuleClass should be false for impl class $sym")
-    r
+    sym.isModuleClass && !sym.isNestedClass
   }
 
   /**
@@ -667,7 +662,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
 
     val finalFlag = (
       (((sym.rawflags & symtab.Flags.FINAL) != 0) || isTopLevelModuleClass(sym))
-        && !sym.enclClass.isInterface
+        && !sym.enclClass.isTrait
         && !sym.isClassConstructor
         && (!sym.isMutable || nme.isTraitSetterName(sym.name)) // lazy vals and vars and their setters cannot be final, but trait setters are
       )
@@ -680,12 +675,12 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     GenBCode.mkFlags(
       if (privateFlag) ACC_PRIVATE else ACC_PUBLIC,
       if ((sym.isDeferred && !sym.hasFlag(symtab.Flags.JAVA_DEFAULTMETHOD))|| sym.hasAbstractFlag) ACC_ABSTRACT else 0,
-      if (sym.isInterface) ACC_INTERFACE else 0,
+      if (sym.isTraitOrInterface) ACC_INTERFACE else 0,
       if (finalFlag && !sym.hasAbstractFlag) ACC_FINAL else 0,
       if (sym.isStaticMember) ACC_STATIC else 0,
       if (sym.isBridge) ACC_BRIDGE | ACC_SYNTHETIC else 0,
       if (sym.isArtifact) ACC_SYNTHETIC else 0,
-      if (sym.isClass && !sym.isInterface) ACC_SUPER else 0,
+      if (sym.isClass && !sym.isTraitOrInterface) ACC_SUPER else 0,
       if (sym.hasJavaEnumFlag) ACC_ENUM else 0,
       if (sym.isVarargsMethod) ACC_VARARGS else 0,
       if (sym.hasFlag(symtab.Flags.SYNCHRONIZED)) ACC_SYNCHRONIZED else 0,