fixed bug 421.check file

cleaned up handling of mixin classes

4 files changed, 71 insertions, 85 deletions

diff --git a/src/compiler/scala/tools/nsc/matching/TransMatcher.scala b/src/compiler/scala/tools/nsc/matching/TransMatcher.scala
index 5ffd620981..e42ba067fb 100644
--- a/src/compiler/scala/tools/nsc/matching/TransMatcher.scala
+++ b/src/compiler/scala/tools/nsc/matching/TransMatcher.scala
@@ -287,7 +287,6 @@ with PatternMatchers */ {
       // @todo: remove unused variables
 
       if (containsReg) {
-        System.out.println("" + sel + " match " + ocases)
         cunit.error(sel.pos, "regular expressions not yet implemented")
         //sel
         EmptyTree
diff --git a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
index 215069659b..604b926b0a 100644
--- a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
+++ b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
@@ -161,10 +161,9 @@ abstract class AddInterfaces extends InfoTransform {
       val parents1 =
         if (parents.isEmpty) List()
         else {
-          assert(!parents.head.symbol.isTrait || clazz == RepeatedParamClass, clazz);
-          if (clazz hasFlag INTERFACE) erasedTypeRef(ObjectClass) :: parents.tail
-          else if (clazz.isImplClass || clazz == ArrayClass) parents
-          else parents map mixinToImplClass
+          assert(!parents.head.symbol.isTrait, clazz)
+          if (clazz.isTrait) erasedTypeRef(ObjectClass) :: parents.tail
+          else parents
         }
       val decls1 = decls filter (sym =>
         if (clazz hasFlag INTERFACE) isInterfaceMember(sym)
@@ -249,25 +248,17 @@ abstract class AddInterfaces extends InfoTransform {
    *  to `tree'. `tree' which is assumed to be the body of a constructor of class `clazz'.
    */
   private def addMixinConstructorCalls(tree: Tree, clazz: Symbol): Tree = {
-    def mixinConstructorCall(mixinClass: Symbol): Tree = atPos(tree.pos) {
-      Apply(Select(This(clazz), mixinClass.primaryConstructor), List())
+    def mixinConstructorCall(impl: Symbol): Tree = atPos(tree.pos) {
+      Apply(Select(This(clazz), impl.primaryConstructor), List())
     }
-    def toImplClass(sym: Symbol) =
-      if (sym.needsImplClass) implClass(sym) else sym
     val mixinConstructorCalls: List[Tree] = {
-      for (val mc <- clazz.mixinClasses.reverse.map(toImplClass).removeDuplicates;
-           mc.isImplClass && mc.toInterface != ScalaObjectClass)
-      yield mixinConstructorCall(mc)
+      for (val mc <- clazz.mixinClasses.reverse;
+           mc.hasFlag(lateINTERFACE) && mc != ScalaObjectClass)
+      yield mixinConstructorCall(implClass(mc))
     }
-    tree match { //todo: remove checking code
+    tree match {
       case Block(supercall :: stats, expr) =>
-        assert(supercall match {
-          case Apply(Select(Super(_, _), _), _) => true
-          case _ => false
-        })
         copy.Block(tree, supercall :: mixinConstructorCalls ::: stats, expr)
-      case Block(_, _) =>
-        assert(false, tree);  tree
     }
   }
 
@@ -296,8 +287,9 @@ abstract class AddInterfaces extends InfoTransform {
             if (owner == impl) This(impl) setPos tree.pos
             else tree
           } else tree
+/* !!!
         case Super(qual, mix) =>
-          val mix1 =
+          val mix1 = mix
             if (mix == nme.EMPTY.toTypeName) mix
             else {
               val ps = atPhase(currentRun.erasurePhase) {
@@ -309,6 +301,7 @@ abstract class AddInterfaces extends InfoTransform {
             }
           if (sym.needsImplClass) Super(implClass(sym), mix1) setPos tree.pos
           else copy.Super(tree, qual, mix1)
+*/
         case _ =>
           tree
       }
diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala
index 23e3a22f4d..7cf864c850 100644
--- a/src/compiler/scala/tools/nsc/transform/Mixin.scala
+++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala
@@ -176,80 +176,75 @@ abstract class Mixin extends InfoTransform {
 
       assert(!clazz.isTrait, clazz)
       assert(!clazz.info.parents.isEmpty, clazz)
-      assert(phase == currentRun.mixinPhase)
 
       // first complete the superclass with mixed in members
       addMixedinMembers(clazz.superClass)
 
       //System.out.println("adding members of " + clazz.info.baseClasses.tail.takeWhile(superclazz !=) + " to " + clazz);//DEBUG
 
-      // Mix in all traits that are not inherited by the superclass
-      val mixins = clazz.mixinClasses
-
-      /** Mix in members of class mixinClass into class clazz */
-      def mixinMembers(mixinClass: Symbol): unit = {
-        //Console.println("mixin members of "+mixinClass+":"+mixinClass.info.decls+" into "+clazz)//DEBUG
-        if (mixinClass.isImplClass) {
-          val iface = mixinClass.toInterface
-          addLateInterfaceMembers(iface)
-          for (val member <- mixinClass.info.decls.toList) {
-            if (isForwarded(member)) {
-              val imember = member.overriddenSymbol(iface)
-              //Console.println("mixin member "+member+":"+member.tpe+member.locationString+" "+imember+" "+imember.overridingSymbol(clazz)+" to "+clazz+" with scope "+clazz.info.decls)//DEBUG
-              if (imember.overridingSymbol(clazz) == NoSymbol &&
-                  clazz.info.findMember(member.name, 0, lateDEFERRED, false).alternatives.contains(imember)) {
-                    val member1 = addMember(
-                      clazz,
-                      member.cloneSymbol(clazz) setPos clazz.pos resetFlag (DEFERRED | lateDEFERRED))
-                    member1.asInstanceOf[TermSymbol] setAlias member;
-                  }
-            }
-          }
-        } else if (mixinClass.hasFlag(lateINTERFACE)) {
-          addLateInterfaceMembers(mixinClass)
-          val impl = implClass(mixinClass)
-          //System.out.println("late impl " + mixinClass + " " + impl);//DEBUG
-          if (!(mixins contains impl)) mixinMembers(impl)
-          // For all members of a trait's interface do:
-          for (val member <- mixinClass.info.decls.toList) {
-
-            if ((member hasFlag ACCESSOR) &&
-                (!(member hasFlag DEFERRED) || (member hasFlag lateDEFERRED))) {
-              // mixin field accessors
-              val member1 = addMember(
-                clazz,
-                member.cloneSymbol(clazz)
-                  setPos clazz.pos
-                  setFlag FINAL resetFlag (DEFERRED | lateDEFERRED))
-              if (!member.isSetter)
-                member.tpe match {
-                  case MethodType(List(), ConstantType(_)) =>
-                    // member is a constant; only getter is needed
-                    ;
-                  case _ =>
-                    // otherwise mixin a field as well
-                    addMember(clazz,
-                              clazz.newValue(member.pos, nme.getterToLocal(member.name))
-                              setFlag (LOCAL | PRIVATE | member.getFlag(MUTABLE))
-                              setInfo member.tpe.resultType)
+      /** Mix in members of implementation class mixinClass into class clazz */
+      def mixinImplClassMembers(impl: Symbol, iface: Symbol): unit = {
+        assert (impl.isImplClass)
+        for (val member <- impl.info.decls.toList) {
+          if (isForwarded(member)) {
+            val imember = member.overriddenSymbol(iface)
+            //Console.println("mixin member "+member+":"+member.tpe+member.locationString+" "+imember+" "+imember.overridingSymbol(clazz)+" to "+clazz+" with scope "+clazz.info.decls)//DEBUG
+            if (imember.overridingSymbol(clazz) == NoSymbol &&
+                clazz.info.findMember(member.name, 0, lateDEFERRED, false).alternatives.contains(imember)) {
+                  val member1 = addMember(
+                    clazz,
+                    member.cloneSymbol(clazz) setPos clazz.pos resetFlag (DEFERRED | lateDEFERRED))
+                  member1.asInstanceOf[TermSymbol] setAlias member;
                 }
-            } else if (member hasFlag SUPERACCESSOR) { // mixin super accessors
-              val member1 = addMember(clazz, member.cloneSymbol(clazz)) setPos clazz.pos
-              assert(member1.alias != NoSymbol, member1)
-              val alias1 = rebindSuper(clazz, member.alias, mixinClass)
-              member1.asInstanceOf[TermSymbol] setAlias alias1
-
-            } else if (member.isMethod && member.isModule && !(member hasFlag (LIFTED | BRIDGE))) {
-              // mixin objects: todo what happens with abstract objects?
-              addMember(clazz, member.cloneSymbol(clazz))
-                .setPos(clazz.pos)
-                .resetFlag(DEFERRED | lateDEFERRED)
-            }
           }
         }
       }
-      for (val mixinClass <- mixins) mixinMembers(mixinClass)
-      if (settings.debug.value) log("new defs of " + clazz + " = " + clazz.info.decls)
+
+      /** Mix in members of trait mixinClass into class clazz */
+      def mixinTraitMembers(mixinClass: Symbol): unit = {
+        // For all members of a trait's interface do:
+        for (val member <- mixinClass.info.decls.toList) {
+          if ((member hasFlag ACCESSOR) &&
+              (!(member hasFlag DEFERRED) || (member hasFlag lateDEFERRED))) {
+            // mixin field accessors
+            val member1 = addMember(
+              clazz,
+              member.cloneSymbol(clazz)
+                setPos clazz.pos
+                setFlag FINAL resetFlag (DEFERRED | lateDEFERRED))
+            if (!member.isSetter)
+              member.tpe match {
+                case MethodType(List(), ConstantType(_)) =>
+                  // member is a constant; only getter is needed
+                  ;
+                case _ =>
+                  // otherwise mixin a field as well
+                  addMember(clazz,
+                            clazz.newValue(member.pos, nme.getterToLocal(member.name))
+                            setFlag (LOCAL | PRIVATE | member.getFlag(MUTABLE))
+                            setInfo member.tpe.resultType)
+              }
+          } else if (member hasFlag SUPERACCESSOR) { // mixin super accessors
+            val member1 = addMember(clazz, member.cloneSymbol(clazz)) setPos clazz.pos
+            assert(member1.alias != NoSymbol, member1)
+            val alias1 = rebindSuper(clazz, member.alias, mixinClass)
+            member1.asInstanceOf[TermSymbol] setAlias alias1
+
+          } else if (member.isMethod && member.isModule && !(member hasFlag (LIFTED | BRIDGE))) {
+            // mixin objects: todo what happens with abstract objects?
+            addMember(clazz, member.cloneSymbol(clazz))
+              .setPos(clazz.pos)
+              .resetFlag(DEFERRED | lateDEFERRED)
+          }
+        }
+      }
+
+      for (val mc <- clazz.mixinClasses)
+        if (mc hasFlag lateINTERFACE) {
+          addLateInterfaceMembers(mc)
+          mixinTraitMembers(mc)
+          mixinImplClassMembers(implClass(mc), mc)
+        }
     }
   }
 
diff --git a/test/files/neg/bug421.check b/test/files/neg/bug421.check
index 9f21d432fb..eafd421ad4 100644
--- a/test/files/neg/bug421.check
+++ b/test/files/neg/bug421.check
@@ -1,4 +1,3 @@
-new foo.this.Bar.this("foo", "meets", Array[java.lang.String]{"bar"}) match List(case (java.lang.String,java.lang.Object,scala.Seq[java.lang.String])foo.this.Bar("foo", (_)*, Array[java.lang.String]{}) => scala.this.Predef.error("huh?"))
 bug421.scala:4 error: regular expressions not yet implemented
   Bar("foo","meets","bar") match {
      ^