A lot of minor code adjustments to ease the bur...

A lot of minor code adjustments to ease the burden on the optimizer, and
various cleanups encountered along the way.

1 files changed, 93 insertions, 98 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
index 5001f8b9bf..b80a782e36 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
@@ -128,112 +128,107 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
         tree
     }
 
-    override def transform(tree: Tree): Tree = try { tree match {
-      case ClassDef(_, _, _, _) =>
-        checkCompanionNameClashes(tree.symbol)
-        val decls = tree.symbol.info.decls
-        for (sym <- decls.toList) {
-          if (sym.privateWithin.isClass && !sym.privateWithin.isModuleClass &&
-              !sym.hasFlag(EXPANDEDNAME) && !sym.isConstructor) {
-            decls.unlink(sym)
-            sym.expandName(sym.privateWithin)
-            decls.enter(sym)
-          }
-        }
-        super.transform(tree)
-      case ModuleDef(_, _, _) =>
-        checkCompanionNameClashes(tree.symbol)
-        super.transform(tree)
-      case Template(parents, self, body) =>
-	val ownAccDefs = new ListBuffer[Tree];
-	accDefs = (currentOwner, ownAccDefs) :: accDefs;
-
-        // ugly hack... normally, the following line should not be
-        // necessary, the 'super' method taking care of that. but because
-        // that one is iterating through parents (and we dont want that here)
-        // we need to inline it.
-        curTree = tree
-        val body1 = atOwner(currentOwner) { transformTrees(body) }
-	accDefs = accDefs.tail;
-	treeCopy.Template(tree, parents, self, ownAccDefs.toList ::: body1);
-
-      case TypeApply(sel @ Select(This(_), name), args) =>
-        val sym = tree.symbol
-        if (needsProtectedAccessor(sym, tree.pos)) {
-          if (settings.debug.value) log("Adding protected accessor for " + tree);
-          transform(makeAccessor(sel.asInstanceOf[Select], args))
-        } else
-          tree
+    override def transform(tree: Tree): Tree = {
+      val sym = tree.symbol
 
-      case Select(qual @ This(_), name) =>
-        val sym = tree.symbol
-         if ((sym hasFlag PARAMACCESSOR) && (sym.alias != NoSymbol)) {
-          val result = typed {
-            Select(
-              Super(qual.symbol, nme.EMPTY.toTypeName/*qual.symbol.info.parents.head.symbol.name*/) setPos qual.pos,
-              sym.alias) setPos tree.pos
-          }
+      def mayNeedProtectedAccessor(sel: Select, args: List[Tree], goToSuper: Boolean) =
+        if (needsProtectedAccessor(sym, tree.pos)) {
           if (settings.debug.value)
-            Console.println("alias replacement: " + tree + " ==> " + result);//debug
-          transformSuperSelect(result)
-        } else {
-          if (needsProtectedAccessor(sym, tree.pos)) {
-            if (settings.debug.value) log("Adding protected accessor for " + tree);
-            transform(makeAccessor(tree.asInstanceOf[Select], List(EmptyTree)))
-          } else
-            tree
-        }
-      case Select(sup @ Super(_, mix), name) =>
-        val sym = tree.symbol
-        if (sym.isValue && !sym.isMethod || sym.hasFlag(ACCESSOR)) {
-          unit.error(tree.pos, "super may be not be used on "+
-                     (if (sym.hasFlag(ACCESSOR)) sym.accessed else sym))
-        }
-        transformSuperSelect(tree)
+            log("Adding protected accessor for " + tree)
 
-      case TypeApply(sel @ Select(qual, name), args) =>
-        val sym = tree.symbol
-        if (needsProtectedAccessor(sym, tree.pos)) {
-          if (settings.debug.value) log("Adding protected accessor for tree: " + tree);
-          transform(makeAccessor(sel.asInstanceOf[Select], args))
-        } else
+          transform(makeAccessor(sel, args))
+        }
+        else if (goToSuper) super.transform(tree)
+        else tree
+
+      try tree match {
+        case ClassDef(_, _, _, _) =>
+          checkCompanionNameClashes(sym)
+          val decls = sym.info.decls
+          for (s <- decls.toList) {
+            if (s.privateWithin.isClass && !s.privateWithin.isModuleClass &&
+                !s.hasFlag(EXPANDEDNAME) && !s.isConstructor) {
+              decls.unlink(s)
+              s.expandName(s.privateWithin)
+              decls.enter(s)
+            }
+          }
           super.transform(tree)
-
-      case Select(qual, name) =>
-        val sym = tree.symbol
-        if (needsProtectedAccessor(sym, tree.pos)) {
-          if (settings.debug.value) log("Adding protected accessor for tree: " + tree);
-          transform(makeAccessor(tree.asInstanceOf[Select], List(EmptyTree)))
-        } else
+        case ModuleDef(_, _, _) =>
+          checkCompanionNameClashes(sym)
           super.transform(tree)
+        case Template(parents, self, body) =>
+          val ownAccDefs = new ListBuffer[Tree];
+          accDefs = (currentOwner, ownAccDefs) :: accDefs;
+
+          // ugly hack... normally, the following line should not be
+          // necessary, the 'super' method taking care of that. but because
+          // that one is iterating through parents (and we dont want that here)
+          // we need to inline it.
+          curTree = tree
+          val body1 = atOwner(currentOwner) { transformTrees(body) }
+          accDefs = accDefs.tail;
+          treeCopy.Template(tree, parents, self, ownAccDefs.toList ::: body1);
+
+        case TypeApply(sel @ Select(This(_), name), args) =>
+          mayNeedProtectedAccessor(sel, args, false)
+
+        case sel @ Select(qual @ This(_), name) =>
+           if ((sym hasFlag PARAMACCESSOR) && (sym.alias != NoSymbol)) {
+            val result = typed {
+              Select(
+                Super(qual.symbol, nme.EMPTY.toTypeName/*qual.symbol.info.parents.head.symbol.name*/) setPos qual.pos,
+                sym.alias) setPos tree.pos
+            }
+            if (settings.debug.value)
+              Console.println("alias replacement: " + tree + " ==> " + result);//debug
+            transformSuperSelect(result)
+          }
+          else mayNeedProtectedAccessor(sel, List(EmptyTree), false)
 
-      case Assign(lhs @ Select(qual, name), rhs) =>
-        if (lhs.symbol.isVariable &&
-            lhs.symbol.hasFlag(JAVA) &&
-            needsProtectedAccessor(lhs.symbol, tree.pos)) {
-          if (settings.debug.value) log("Adding protected setter for " + tree)
-          val setter = makeSetter(lhs);
-          if (settings.debug.value)
-            log("Replaced " + tree + " with " + setter);
-          transform(typed(Apply(setter, List(qual, rhs))))
-        } else
+        case Select(sup @ Super(_, mix), name) =>
+          if (sym.isValue && !sym.isMethod || sym.hasFlag(ACCESSOR)) {
+            unit.error(tree.pos, "super may be not be used on "+
+                       (if (sym.hasFlag(ACCESSOR)) sym.accessed else sym))
+          }
+          transformSuperSelect(tree)
+
+        case TypeApply(sel @ Select(qual, name), args) =>
+          mayNeedProtectedAccessor(sel, args, true)
+
+        case sel @ Select(qual, name) =>
+          mayNeedProtectedAccessor(sel, List(EmptyTree), true)
+
+        case Assign(lhs @ Select(qual, name), rhs) =>
+          if (lhs.symbol.isVariable &&
+              lhs.symbol.hasFlag(JAVA) &&
+              needsProtectedAccessor(lhs.symbol, tree.pos)) {
+            if (settings.debug.value) log("Adding protected setter for " + tree)
+            val setter = makeSetter(lhs);
+            if (settings.debug.value)
+              log("Replaced " + tree + " with " + setter);
+            transform(typed(Apply(setter, List(qual, rhs))))
+          } else
+            super.transform(tree)
+
+        case Apply(fn, args) =>
+          assert(fn.tpe != null, tree)
+          treeCopy.Apply(tree, transform(fn), transformArgs(args, fn.tpe.paramTypes))
+        case Function(vparams, body) =>
+          withInvalidOwner {
+            treeCopy.Function(tree, vparams, transform(body))
+          }
+        case _ =>
           super.transform(tree)
+      }
+      catch {
+        case ex : AssertionError =>
+          if (sym != null && sym != NoSymbol)
+            Console.println("TRANSFORM: " + tree.symbol.sourceFile)
 
-      case Apply(fn, args) =>
-        assert(fn.tpe != null, tree)
-        treeCopy.Apply(tree, transform(fn), transformArgs(args, fn.tpe.paramTypes))
-      case Function(vparams, body) =>
-        withInvalidOwner {
-          treeCopy.Function(tree, vparams, transform(body))
-        }
-      case _ =>
-        super.transform(tree)
-    }} catch {
-      case ex : AssertionError =>
-        if (tree.symbol != null && tree.symbol != NoSymbol)
-          Console.println("TRANSFORM: " + tree.symbol.sourceFile)
-        Console.println("TREE: " + tree)
-        throw ex
+          Console.println("TREE: " + tree)
+          throw ex
+      }
     }
 
     override def atOwner[A](owner: Symbol)(trans: => A): A = {