From c14b30a39e6ca4c3a101a648c73793c84800d849 Mon Sep 17 00:00:00 2001 From: Paul Phillips Date: Mon, 16 Nov 2009 21:30:54 +0000 Subject: 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. --- .../tools/nsc/typechecker/SuperAccessors.scala | 191 ++++++++++----------- 1 file changed, 93 insertions(+), 98 deletions(-) (limited to 'src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala') 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 = { -- cgit v1.2.3