WIP simplify symbol AddInterfaces / Mixin

Author: retronym

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

@@ -145,15 +145,12 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     assert(classSym.isClass, classSym)
 
     def doesNotExist(method: Symbol) = {
-      // (1) SI-9124, some trait methods don't exist in the generated interface. see comment in BTypes.
-      // (2) Value classes. Member methods of value classes exist in the generated box class. However,
+      //     Value classes. Member methods of value classes exist in the generated box class. However,
       //     nested methods lifted into a value class are moved to the companion object and don't exist
       //     in the value class itself. We can identify such nested methods: the initial enclosing class
       //     is a value class, but the current owner is some other class (the module class).
-      method.owner.isTrait && method.isImplOnly || { // (1)
-        val enclCls = nextEnclosingClass(method)
-        exitingPickler(enclCls.isDerivedValueClass) && method.owner != enclCls // (2)
-      }
+      val enclCls = nextEnclosingClass(method)
+      exitingPickler(enclCls.isDerivedValueClass) && method.owner != enclCls
     }
 
     def enclosingMethod(sym: Symbol): Option[Symbol] = {

src/compiler/scala/tools/nsc/transform/AddInterfaces.scala

@@ -18,26 +18,6 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure =>
    */
   override def phaseNewFlags: Long = lateDEFERRED
 
-  /** Is given trait member symbol a member of the trait's interface
-   *  after this transform is performed?
-   */
-  def isInterfaceMember(sym: Symbol) = (
-    sym.isType || {
-      sym.info  // initialize to set lateMETHOD flag if necessary
-
-      (     sym.isMethod
-        && !sym.isLabel
-      )
-    }
-  )
-
-  /** Does symbol need an implementation method? */
-  def needsImplMethod(sym: Symbol) = (
-       sym.isMethod
-    && isInterfaceMember(sym)
-    && (!sym.hasFlag(DEFERRED | SUPERACCESSOR) || (sym hasFlag lateDEFERRED))
-  )
-
   def transformMixinInfo(tp: Type): Type = tp match {
     case ClassInfoType(parents, decls, clazz) if clazz.isPackageClass || !clazz.isJavaDefined =>
 
@@ -48,17 +28,7 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure =>
           if (clazz.isTrait) ObjectTpe :: tl
           else parents
       }
-      val decls1 = scopeTransform(clazz) {
-        decls filter { sym =>
-          if (clazz.isTrait) {
-            isInterfaceMember(sym) || (sym.isTerm)
-          } else sym.isClass || sym.isTerm
-        }
-      }
-      //      if (clazz.isTrait) {
-//        decls1.enter(clazz.newMethod(nme.MIXIN_CONSTRUCTOR, clazz.pos, Flags.PROTECTED | Flags.ARTIFACT) setInfo MethodType(Nil, UnitTpe))
-//      }
-      ClassInfoType(parents1, decls1, clazz)
+      ClassInfoType(parents1, decls, clazz)
     case _ =>
       tp
   }

src/compiler/scala/tools/nsc/transform/Mixin.scala

@@ -43,29 +43,18 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
    *     methods in the impl class (because they can have arbitrary initializers)
    */
   private def isImplementedStatically(sym: Symbol) = (
-       erasure.isInterfaceMember(sym)
-    && erasure.needsImplMethod(sym)
+       sym.isMethod
+    && (!sym.hasFlag(DEFERRED | SUPERACCESSOR) || (sym hasFlag lateDEFERRED))
     && sym.owner.isTrait
     && sym.isMethod
     && (!sym.isModule || sym.hasFlag(PRIVATE | LIFTED))
     && (!(sym hasFlag (ACCESSOR | SUPERACCESSOR)) || sym.isLazy)
+    && !sym.isPrivate
+    && !sym.hasAllFlags(LIFTED | MODULE | METHOD)
+    && !sym.isConstructor
+    && (!sym.hasFlag(notPRIVATE | LIFTED) || sym.hasFlag(ACCESSOR | SUPERACCESSOR | MODULE))
   )
 
-  /** A member of a trait is static only if it belongs only to the
-   *  implementation class, not the interface, and it is implemented
-   *  statically.
-   */
-  private def isStaticOnly(sym: Symbol) =
-    isImplementedStatically(sym) && sym.isImplOnly
-
-  /** A member of a trait is forwarded if it is implemented statically and it
-   *  is also visible in the trait's interface. In that case, a forwarder to
-   *  the member's static implementation will be added to the class that
-   *  inherits the trait.
-   */
-  private def isForwarded(sym: Symbol) =
-    isImplementedStatically(sym) && !sym.isImplOnly
-
   private def isFieldWithBitmap(field: Symbol) = {
     field.info // ensure that nested objects are transformed
     // For checkinit consider normal value getters
@@ -247,7 +236,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
 
     /* Mix in members of implementation class mixinClass into class clazz */
     def mixinTraitForwarders(mixinClass: Symbol) {
-      for (member <- mixinClass.info.decls ; if isForwarded(member)) {
+      for (member <- mixinClass.info.decls ; if isImplementedStatically(member)) {
         member overridingSymbol clazz match {
           case NoSymbol =>
             if (clazz.info.findMember(member.name, 0, 0L, stableOnly = false).alternatives contains member)
@@ -484,7 +473,8 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
      *       - A super accessor for every super accessor in a mixin class
      *       - Forwarders for all methods that are implemented statically
      *  All superaccessors are completed with right-hand sides (@see completeSuperAccessor)
-     *  @param clazz  The class to which definitions are added
+      *
+      *  @param clazz  The class to which definitions are added
      */
     private def addNewDefs(clazz: Symbol, stats: List[Tree]): List[Tree] = {
       val newDefs = mutable.ListBuffer[Tree]()