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.

To allow us to call arbitrary super methods with invokespecial,
the backend will add a transitively inherited interface as a direct
when needed to circumvent the JVM restriction that invokespecial
can only use a direct parent as the receiver.

Mark trait methods as final to allow inlining

Fix uncurry of dep methods in traits

Fix elision of abstract trait methods

Fix constructors phase for specialized trait fiels: pos/t4957.scala

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

@@ -588,12 +588,13 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
         // to call super constructors explicitly and/or use their 'returned' value.
         // therefore, we can ignore this fact, and generate code that leaves nothing
         // on the stack (contrary to what the type in the AST says).
-        case Apply(fun @ Select(Super(_, _), _), args) =>
+        case Apply(fun @ Select(Super(qual, mix), _), args) =>
           val invokeStyle = InvokeStyle.Super
           // if (fun.symbol.isConstructor) Static(true) else SuperCall(mix);
           mnode.visitVarInsn(asm.Opcodes.ALOAD, 0)
+          val hostClass = qual.symbol.parentSymbols.find(_.name == mix).orNull
           genLoadArguments(args, paramTKs(app))
-          genCallMethod(fun.symbol, invokeStyle, app.pos)
+          genCallMethod(fun.symbol, invokeStyle, app.pos, hostClass)
           generatedType = methodBTypeFromSymbol(fun.symbol).returnType
 
         // 'new' constructor call: Note: since constructors are
@@ -1050,19 +1051,26 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
       hostSymbol.info ; methodOwner.info
 
       def needsInterfaceCall(sym: Symbol) = (
-           sym.isInterface
+           sym.isTraitOrInterface
         || sym.isJavaDefined && sym.isNonBottomSubClass(definitions.ClassfileAnnotationClass)
       )
 
+      val isTraitSuperCallToObjectMethod =
+        style.isSuper && hostSymbol != methodOwner && methodOwner.isTraitOrInterface && ObjectTpe.decl(method.name) != NoSymbol && method.overrideChain.last.owner == ObjectClass
+
       // whether to reference the type of the receiver or
       // the type of the method owner
-      val useMethodOwner = (
+      val useMethodOwner = ((
            !style.isVirtual
         || hostSymbol.isBottomClass
         || methodOwner == definitions.ObjectClass
-      )
+      ) && !(style.isSuper && hostSymbol != null)) || isTraitSuperCallToObjectMethod
       val receiver = if (useMethodOwner) methodOwner else hostSymbol
       val jowner   = internalName(receiver)
+
+      if (style.isSuper && (isTraitSuperCallToObjectMethod || receiver.isTraitOrInterface) && !cnode.interfaces.contains(jowner))
+        cnode.interfaces.add(jowner)
+
       val jname    = method.javaSimpleName.toString
       val bmType   = methodBTypeFromSymbol(method)
       val mdescr   = bmType.descriptor
@@ -1342,7 +1350,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 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
 
   /**
    * Cache the value of delambdafy == "inline" for each run. We need to query this value many
@@ -251,7 +251,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
@@ -262,7 +262,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.
@@ -287,41 +287,15 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
           val name      = methodSym.javaSimpleName.toString // same as in genDefDef
           val signature = name + methodSymToDescriptor(methodSym)
 
-          // Some detours are required here because of changing flags (lateDEFERRED, lateMODULE):
+          // Some detours are required here because of changing flags (lateDEFERRED):
           // 1. Why the phase travel? Concrete trait methods obtain the lateDEFERRED flag in Mixin.
           //    This makes isEffectivelyFinalOrNotOverridden false, which would prevent non-final
           //    but non-overridden methods of sealed traits from being inlined.
-          // 2. Why the special case for `classSym.isImplClass`? Impl class symbols obtain the
-          //    lateMODULE flag during Mixin. During the phase travel to exitingPickler, the late
-          //    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)
-
-          // 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
-          // if they are final or the receiver is known.
-          //
-          // Using `erasure.needsImplMethod` is not enough: it keeps field accessors, module getters
-          // and super accessors. When AddInterfaces creates the impl class, these methods are
-          // initially added to it.
-          //
-          // The mixin phase later on filters out most of these members from the impl class (see
-          // Mixin.isImplementedStatically). However, accessors for concrete lazy vals remain in the
-          // impl class after mixin. So the filter in mixin is not exactly what we need here (we
-          // want to identify concrete trait methods, not any accessors). So we check some symbol
-          // properties manually.
-          val traitMethodWithStaticImplementation = {
-            import symtab.Flags._
-            classSym.isTrait && !classSym.isImplClass &&
-              erasure.needsImplMethod(methodSym) &&
-              !methodSym.isModule &&
-              !(methodSym hasFlag (ACCESSOR | SUPERACCESSOR))
-          }
+          val effectivelyFinal = exitingPickler(methodSym.isEffectivelyFinalOrNotOverridden) && !(methodSym.owner.isTrait && methodSym.isModule)
 
           val info = MethodInlineInfo(
             effectivelyFinal                    = effectivelyFinal,
-            traitMethodWithStaticImplementation = traitMethodWithStaticImplementation,
+            traitMethodWithStaticImplementation = false,
             annotatedInline                     = methodSym.hasAnnotation(ScalaInlineClass),
             annotatedNoInline                   = methodSym.hasAnnotation(ScalaNoInlineClass)
           )
@@ -869,7 +843,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

@@ -174,7 +174,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

@@ -172,7 +172,6 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
      */
     def primitiveOrClassToBType(sym: Symbol): BType = {
       assertClassNotArray(sym)
-      assert(!sym.isImplClass, sym)
       primitiveTypeToBType.getOrElse(sym, classBTypeFromSymbol(sym))
     }
 
@@ -337,7 +336,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
@@ -603,11 +602,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
   }
 
   /**
@@ -684,7 +679,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
       )
@@ -697,12 +692,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,

src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala

@@ -137,7 +137,7 @@ class CallGraph[BT <: BTypes](val btypes: BT) {
                   callee = method,
                   calleeDeclarationClass = declarationClassBType,
                   safeToInline = safeToInline,
-                  safeToRewrite = safeToRewrite,
+                  safeToRewrite = false,
                   canInlineFromSource = canInlineFromSource,
                   annotatedInline = annotatedInline,
                   annotatedNoInline = annotatedNoInline,
@@ -299,7 +299,7 @@ class CallGraph[BT <: BTypes](val btypes: BT) {
               receiverType.info.orThrow.inlineInfo.isEffectivelyFinal // (1)
           }
 
-          val isRewritableTraitCall = isStaticallyResolved && methodInlineInfo.traitMethodWithStaticImplementation
+          val isRewritableTraitCall = false
 
           val warning = calleeDeclarationClassBType.info.orThrow.inlineInfo.warning.map(
             MethodInlineInfoIncomplete(calleeDeclarationClassBType.internalName, calleeMethodNode.name, calleeMethodNode.desc, _))