Symbol creation followup.

Changed most symbol creations to be consistent with all the others.
Opportunistically streamlined various call sites.  Moved some phase-specific
methods out of Symbol to somewhere more appropriate (like that phase.)

29 files changed, 189 insertions, 230 deletions

diff --git a/src/compiler/scala/reflect/internal/AnnotationInfos.scala b/src/compiler/scala/reflect/internal/AnnotationInfos.scala
index 665e33e783..255e69c3c6 100644
--- a/src/compiler/scala/reflect/internal/AnnotationInfos.scala
+++ b/src/compiler/scala/reflect/internal/AnnotationInfos.scala
@@ -230,10 +230,8 @@ trait AnnotationInfos extends api.AnnotationInfos { self: SymbolTable =>
     def refsSymbol(sym: Symbol) = hasArgWhich(_.symbol == sym)
 
     /** Change all ident's with Symbol "from" to instead use symbol "to" */
-    def substIdentSyms(from: Symbol, to: Symbol) = {
-      val subs = new TreeSymSubstituter(List(from), List(to))
-      AnnotationInfo(atp, args.map(subs(_)), assocs).setPos(pos)
-    }
+    def substIdentSyms(from: Symbol, to: Symbol) =
+      AnnotationInfo(atp, args map (_ substTreeSyms (from -> to)), assocs) setPos pos
 
     def stringArg(index: Int) = constantAtIndex(index) map (_.stringValue)
     def intArg(index: Int)    = constantAtIndex(index) map (_.intValue)
diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala
index 1b9ff54141..20e4362ae4 100644
--- a/src/compiler/scala/reflect/internal/Symbols.scala
+++ b/src/compiler/scala/reflect/internal/Symbols.scala
@@ -212,17 +212,6 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
         setInfo OverloadedType(pre, alternatives)
     )
 
-    /** for explicit outer phase */
-    final def newOuterAccessor(pos: Position) = {
-      val accFlags = METHOD | STABLE | SYNTHETIC | (
-        if (isTrait) DEFERRED else 0
-      )
-      val sym = newMethodSymbol(nme.OUTER, pos, accFlags)
-      sym.expandName(this)
-      sym.referenced = this
-      sym
-    }
-
     final def newErrorValue(name: TermName) =
       newTermSymbol(name, pos, SYNTHETIC | IS_ERROR) setInfo ErrorType
 
@@ -285,6 +274,14 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
     final def newClass(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L) =
       newClassSymbol(name, pos, newFlags)
+    
+    /** A new class with its info set to a ClassInfoType with given scope and parents. */
+    def newClassWithInfo(name: TypeName, parents: List[Type], scope: Scope, pos: Position = NoPosition, newFlags: Long = 0L) = {
+      val clazz = newClass(name, pos, newFlags)
+      clazz setInfo ClassInfoType(parents, scope, clazz)
+    }
+    final def newErrorClass(name: TypeName) =
+      newClassWithInfo(name, Nil, new ErrorScope(this), pos, SYNTHETIC | IS_ERROR)
 
     final def newModuleClass(name: TypeName, pos: Position = NoPosition) =
       newModuleClassSymbol(name, pos)
@@ -312,11 +309,6 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
         setInfo MethodType(Nil, tpe)
     )
 
-    final def newErrorClass(name: TypeName) = {
-      val clazz = newClassSymbol(name, pos, SYNTHETIC | IS_ERROR)
-      clazz setInfo ClassInfoType(Nil, new ErrorScope(this), clazz)
-    }
-
     final def newErrorSymbol(name: Name): Symbol = name match {
       case x: TypeName  => newErrorClass(x)
       case x: TermName  => newErrorValue(x)
@@ -1196,7 +1188,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
           oldsymbuf += sym
           newsymbuf += (
             if (sym.isClass)
-              tp.typeSymbol.newAbstractType(sym.pos, sym.name.toTypeName).setInfo(sym.existentialBound)
+              tp.typeSymbol.newAbstractType(sym.name.toTypeName, sym.pos).setInfo(sym.existentialBound)
             else
               sym.cloneSymbol(tp.typeSymbol))
         }
@@ -1346,15 +1338,15 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       cloneSymbol(owner)
 
     /** A clone of this symbol, but with given owner. */
-    final def cloneSymbol(owner: Symbol): Symbol = {
-      val newSym = cloneSymbolImpl(owner, this.rawflags)
+    final def cloneSymbol(owner: Symbol): Symbol = cloneSymbol(owner, this.rawflags)
+    final def cloneSymbol(owner: Symbol, newFlags: Long): Symbol = {
+      val newSym = cloneSymbolImpl(owner, newFlags)
       ( newSym
           setPrivateWithin privateWithin
           setInfo (info cloneInfo newSym)
           setAnnotations this.annotations
       )
     }
-    
     /** Internal method to clone a symbol's implementation with the given flags and no info. */
     def cloneSymbolImpl(owner: Symbol, newFlags: Long): Symbol
     def cloneSymbolImpl(owner: Symbol): Symbol = cloneSymbolImpl(owner, 0L)
diff --git a/src/compiler/scala/reflect/internal/Trees.scala b/src/compiler/scala/reflect/internal/Trees.scala
index 1cefc07c3d..a2c55a89d6 100644
--- a/src/compiler/scala/reflect/internal/Trees.scala
+++ b/src/compiler/scala/reflect/internal/Trees.scala
@@ -121,7 +121,12 @@ trait Trees extends api.Trees { self: SymbolTable =>
         new ChangeOwnerTraverser(oldOwner, newOwner) apply t
       }
     }
-
+    
+    def substTreeSyms(pairs: (Symbol, Symbol)*): Tree = {
+      val list  = pairs.toList
+      val subst = new TreeSymSubstituter(list map (_._1), list map (_._2))
+      subst(tree)
+    }
     def shallowDuplicate: Tree = new ShallowDuplicator(tree) transform tree
     def shortClass: String = tree.getClass.getName split "[.$]" last
     /** When you want to know a little more than the class, but a lot
diff --git a/src/compiler/scala/reflect/internal/Types.scala b/src/compiler/scala/reflect/internal/Types.scala
index dfe098e282..73f1f3db84 100644
--- a/src/compiler/scala/reflect/internal/Types.scala
+++ b/src/compiler/scala/reflect/internal/Types.scala
@@ -3726,7 +3726,7 @@ trait Types extends api.Types { self: SymbolTable =>
 
   def typeParamsToExistentials(clazz: Symbol, tparams: List[Symbol]): List[Symbol] = {
     val eparams = mapWithIndex(tparams)((tparam, i) =>
-      clazz.newExistential(clazz.pos, newTypeName("?"+i)) setInfo tparam.info.bounds)
+      clazz.newExistential(newTypeName("?"+i), clazz.pos) setInfo tparam.info.bounds)
 
     eparams map (_ substInfo (tparams, eparams))
   }
@@ -3848,10 +3848,10 @@ trait Types extends api.Types { self: SymbolTable =>
             if (tree.symbol isNonBottomSubClass clazz) &&
                (pre.widen.typeSymbol isNonBottomSubClass tree.symbol) =>
               if (pre.isStable) { // XXX why is this in this method? pull it out and guard the call `annotationArgRewriter.transform(tree)`?
-                val termSym =
-                  pre.typeSymbol.owner.newValue(
-                    pre.typeSymbol.pos,
-                    pre.typeSymbol.name.toTermName).setInfo(pre)  // what symbol should really be used?
+                val termSym = (
+                  pre.typeSymbol.owner.newValue(pre.typeSymbol.name.toTermName, pre.typeSymbol.pos) // what symbol should really be used?
+                    setInfo pre
+                )
                 gen.mkAttributedQualifier(pre, termSym)
               } else
                 giveup()
@@ -4205,7 +4205,7 @@ trait Types extends api.Types { self: SymbolTable =>
         val symowner = oldSym.owner
         val bound = singletonBounds(actualsIndexed(actualIdx))
 
-        val sym = symowner.newExistential(oldSym.pos, newTypeName(oldSym.name + ".type"))
+        val sym = symowner.newExistential(newTypeName(oldSym.name + ".type"), oldSym.pos)
         sym.setInfo(bound)
         sym.setFlag(oldSym.flags)
 
@@ -5892,7 +5892,7 @@ trait Types extends api.Types { self: SymbolTable =>
               else {
                 def lubBounds(bnds: List[TypeBounds]): TypeBounds =
                   TypeBounds(glb(bnds map (_.lo), decr(depth)), lub(bnds map (_.hi), decr(depth)))
-                lubRefined.typeSymbol.newAbstractType(proto.pos, proto.name.toTypeName)
+                lubRefined.typeSymbol.newAbstractType(proto.name.toTypeName, proto.pos)
                   .setInfoOwnerAdjusted(lubBounds(symtypes map (_.bounds)))
               }
             }
diff --git a/src/compiler/scala/reflect/runtime/JavaToScala.scala b/src/compiler/scala/reflect/runtime/JavaToScala.scala
index cd87d6331b..61b03a9a29 100644
--- a/src/compiler/scala/reflect/runtime/JavaToScala.scala
+++ b/src/compiler/scala/reflect/runtime/JavaToScala.scala
@@ -406,7 +406,7 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
     val tparams = new ListBuffer[Symbol]
     def targToScala(arg: jType): Type = arg match {
       case jwild: WildcardType =>
-        val tparam = owner.newExistential(NoPosition, newTypeName("T$" + tparams.length))
+        val tparam = owner.newExistential(newTypeName("T$" + tparams.length))
           .setInfo(TypeBounds(
             lub(jwild.getLowerBounds.toList map typeToScala),
             glb(jwild.getUpperBounds.toList map typeToScala map objToAny)))
@@ -467,9 +467,11 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
    *  @return A Scala value symbol that wraps all reflection info of `jfield`
    */
   private def jfieldAsScala(jfield: jField): Symbol = fieldCache.toScala(jfield) {
-    val field = sOwner(jfield).newValue(NoPosition, newTermName(jfield.getName))
-      .setFlag(toScalaFieldFlags(jfield.getModifiers) | JAVA)
-      .setInfo(typeToScala(jfield.getGenericType))
+    val field = (
+      sOwner(jfield)
+        newValue(newTermName(jfield.getName), NoPosition, toScalaFieldFlags(jfield.getModifiers))
+        setInfo typeToScala(jfield.getGenericType)
+    )
     fieldCache enter (jfield, field)
     copyAnnotations(field, jfield)
     field
@@ -487,8 +489,7 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
    */
   private def jmethodAsScala(jmeth: jMethod): Symbol = methodCache.toScala(jmeth) {
     val clazz = sOwner(jmeth)
-    val meth = clazz.newMethod(NoPosition, newTermName(jmeth.getName))
-      .setFlag(toScalaMethodFlags(jmeth.getModifiers) | JAVA)
+    val meth = clazz.newMethod(newTermName(jmeth.getName), NoPosition, toScalaMethodFlags(jmeth.getModifiers))
     methodCache enter (jmeth, meth)
     val tparams = jmeth.getTypeParameters.toList map createTypeParameter
     val paramtpes = jmeth.getGenericParameterTypes.toList map typeToScala
@@ -510,8 +511,7 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
   private def jconstrAsScala(jconstr: jConstructor[_]): Symbol = {
     // [Martin] Note: I know there's a lot of duplication wrt jmethodAsScala, but don't think it's worth it to factor this out.
     val clazz = sOwner(jconstr)
-    val constr = clazz.newMethod(NoPosition, nme.CONSTRUCTOR)
-      .setFlag(toScalaMethodFlags(jconstr.getModifiers) | JAVA)
+    val constr = clazz.newConstructor(NoPosition, toScalaMethodFlags(jconstr.getModifiers))
     constructorCache enter (jconstr, constr)
     val tparams = jconstr.getTypeParameters.toList map createTypeParameter
     val paramtpes = jconstr.getGenericParameterTypes.toList map typeToScala
diff --git a/src/compiler/scala/reflect/runtime/ToolBoxes.scala b/src/compiler/scala/reflect/runtime/ToolBoxes.scala
index 11563fa4cc..8afd6d2231 100644
--- a/src/compiler/scala/reflect/runtime/ToolBoxes.scala
+++ b/src/compiler/scala/reflect/runtime/ToolBoxes.scala
@@ -41,9 +41,12 @@ trait ToolBoxes extends { self: Universe =>
       private def isFree(t: Tree) = t.isInstanceOf[Ident] && t.symbol.isInstanceOf[FreeVar]
 
       def typedTopLevelExpr(tree: Tree, pt: Type): Tree = {
-        val ownerClass = EmptyPackageClass.newClass(newTypeName("<expression-owner>"))
-        ownerClass.setInfo(new ClassInfoType(List(ObjectClass.tpe), newScope, ownerClass))
-        val owner = ownerClass.newLocalDummy(tree.pos)
+        // !!! Why is this is in the empty package? If it's only to make
+        // it inaccessible then please put it somewhere designed for that
+        // rather than polluting the empty package with synthetics.
+        val ownerClass = EmptyPackageClass.newClassWithInfo(newTypeName("<expression-owner>"), List(ObjectClass.tpe), newScope)
+        val owner      = ownerClass.newLocalDummy(tree.pos)
+
         typer.atOwner(tree, owner).typed(tree, analyzer.EXPRmode, pt)
       }
       
diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
index 55d5efda1f..265d017653 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
@@ -218,11 +218,7 @@ abstract class TreeGen extends reflect.internal.TreeGen {
    */
   private def mkPackedValDef(expr: Tree, owner: Symbol, name: Name): (ValDef, () => Ident) = {
     val packedType = typer.packedType(expr, owner)
-    val sym = (
-      owner.newValue(expr.pos.makeTransparent, name)
-      setFlag SYNTHETIC
-      setInfo packedType
-    )
+    val sym = owner.newValue(name, expr.pos.makeTransparent, SYNTHETIC) setInfo packedType
 
     (ValDef(sym, expr), () => Ident(sym) setPos sym.pos.focus setType expr.tpe)
   }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenAndroid.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenAndroid.scala
index e7cf716add..d4b9d8ff7b 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenAndroid.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenAndroid.scala
@@ -34,9 +34,10 @@ trait GenAndroid {
 
   def addCreatorCode(codegen: BytecodeGenerator, block: BasicBlock) {
     import codegen._
-    val fieldSymbol = clasz.symbol.newValue(NoPosition, newTermName(fieldName))
-                        .setFlag(Flags.STATIC | Flags.FINAL)
-                        .setInfo(AndroidCreatorClass.tpe)
+    val fieldSymbol = (
+      clasz.symbol.newValue(newTermName(fieldName), NoPosition, Flags.STATIC | Flags.FINAL)
+        setInfo AndroidCreatorClass.tpe
+    )
     val methodSymbol = definitions.getMember(clasz.symbol.companionModule, fieldName)
     clasz addField new IField(fieldSymbol)
     block emit CALL_METHOD(methodSymbol, Static(false))
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
index 309d8f26fb..b5232fff09 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
@@ -966,9 +966,7 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
           serialVUID foreach { value =>
             import Flags._, definitions._
             val fieldName = "serialVersionUID"
-            val fieldSymbol = clasz.symbol.newValue(NoPosition, newTermName(fieldName))
-                                .setFlag(STATIC | FINAL)
-                                .setInfo(longType)
+            val fieldSymbol = clasz.symbol.newValue(newTermName(fieldName), NoPosition, STATIC | FINAL) setInfo longType
             clasz addField new IField(fieldSymbol)
             lastBlock emit CONSTANT(Constant(value))
             lastBlock emit STORE_FIELD(fieldSymbol, true)
diff --git a/src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala b/src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala
index a37a3406a8..ec137203bf 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala
@@ -203,7 +203,7 @@ abstract class InlineExceptionHandlers extends SubComponent {
                   // Here we could create a single local for all exceptions of a certain type. TODO: try that.
                   val localName   = currentClass.cunit.freshTermName("exception$")
                   val localType   = exceptionType
-                  val localSymbol = bblock.method.symbol.newValue(NoPosition, localName).setInfo(localType.toType)
+                  val localSymbol = bblock.method.symbol.newValue(localName).setInfo(localType.toType)
                   val local       = new Local(localSymbol, localType, false)
 
                   bblock.method.addLocal(local)
diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala
index 5d419320ac..4205c2ff36 100644
--- a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala
+++ b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala
@@ -39,7 +39,7 @@ abstract class SymbolLoaders {
    */
   def enterClass(root: Symbol, name: String, completer: SymbolLoader): Symbol = {
     val owner = realOwner(root)
-    val clazz = owner.newClass(NoPosition, newTypeName(name))
+    val clazz = owner.newClass(newTypeName(name))
     clazz setInfo completer
     enterIfNew(owner, clazz, completer)
   }
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
index b6eef8c0bb..099145d3ae 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
@@ -255,8 +255,11 @@ abstract class ClassfileParser {
               f = ownerTpe.findMember(origName, 0, 0, false).suchThat(_.tpe =:= tpe)
             } else {
               log("Couldn't find " + name + ": " + tpe + " inside: \n" + ownerTpe)
-              f = if (tpe.isInstanceOf[MethodType]) owner.newMethod(owner.pos, name).setInfo(tpe)
-                  else owner.newValue(owner.pos, name).setInfo(tpe).setFlag(MUTABLE)
+              f = tpe match {
+                case MethodType(_, _) => owner.newMethod(name, owner.pos)
+                case _                => owner.newVariable(name, owner.pos)
+              }
+              f setInfo tpe
               log("created fake member " + f.fullName)
             }
 //            println("\townerTpe.decls: " + ownerTpe.decls)
@@ -283,7 +286,7 @@ abstract class ClassfileParser {
         if (in.buf(start).toInt != CONSTANT_NAMEANDTYPE) errorBadTag(start)
         val name = getName(in.getChar(start + 1).toInt)
         // create a dummy symbol for method types
-        val dummySym = ownerTpe.typeSymbol.newMethod(ownerTpe.typeSymbol.pos, name)
+        val dummySym = ownerTpe.typeSymbol.newMethod(name, ownerTpe.typeSymbol.pos)
         var tpe  = getType(dummySym, in.getChar(start + 3).toInt)
 
         // fix the return type, which is blindly set to the class currently parsed
@@ -465,7 +468,7 @@ abstract class ClassfileParser {
       }
       ss = name.subName(0, start)
       owner.info.decls lookup ss orElse {
-        sym = owner.newClass(NoPosition, ss.toTypeName) setInfoAndEnter completer
+        sym = owner.newClass(ss.toTypeName) setInfoAndEnter completer
         debuglog("loaded "+sym+" from file "+file)
         sym
       }
@@ -608,7 +611,7 @@ abstract class ClassfileParser {
     } else {
       val name    = pool.getName(in.nextChar)
       val info    = pool.getType(in.nextChar)
-      val sym     = getOwner(jflags).newValue(NoPosition, name).setFlag(sflags)
+      val sym     = getOwner(jflags).newValue(name, NoPosition, sflags)
       val isEnum  = (jflags & JAVA_ACC_ENUM) != 0
 
       sym setInfo {
@@ -646,7 +649,7 @@ abstract class ClassfileParser {
         in.skip(4); skipAttributes()
       } else {
         val name = pool.getName(in.nextChar)
-        val sym = getOwner(jflags).newMethod(NoPosition, name).setFlag(sflags)
+        val sym = getOwner(jflags).newMethod(name, NoPosition, sflags)
         var info = pool.getType(sym, (in.nextChar))
         if (name == nme.CONSTRUCTOR)
           info match {
@@ -724,7 +727,7 @@ abstract class ClassfileParser {
                           else TypeBounds.lower(tp)
                         case '*' => TypeBounds.empty
                       }
-                      val newtparam = sym.newExistential(sym.pos, newTypeName("?"+i)) setInfo bounds
+                      val newtparam = sym.newExistential(newTypeName("?"+i), sym.pos) setInfo bounds
                       existentials += newtparam
                       xs += newtparam.tpe //@M should probably be .tpeHK
                       i += 1
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
index e7d08ef849..2eddd36db0 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
@@ -145,11 +145,8 @@ abstract class Pickler extends SubComponent {
             val (locals, globals) = sym.children partition (_.isLocalClass)
             val children =
               if (locals.isEmpty) globals
-              else {
-                val localChildDummy = sym.newClass(sym.pos, tpnme.LOCAL_CHILD)
-                localChildDummy.setInfo(ClassInfoType(List(sym.tpe), EmptyScope, localChildDummy))
-                globals + localChildDummy
-              }
+              else globals + sym.newClassWithInfo(tpnme.LOCAL_CHILD, List(sym.tpe), EmptyScope, pos = sym.pos)
+
             putChildren(sym, children.toList sortBy (_.sealedSortName))
           }
           for (annot <- sym.annotations filter (ann => ann.isStatic && !ann.isErroneous) reverse)
diff --git a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
index 8a8131c0f4..8f5d308b8f 100644
--- a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
+++ b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
@@ -121,8 +121,11 @@ abstract class AddInterfaces extends InfoTransform {
     private def implDecls(implClass: Symbol, ifaceDecls: Scope): Scope = {
       val decls = new Scope
       if ((ifaceDecls lookup nme.MIXIN_CONSTRUCTOR) == NoSymbol)
-        decls enter (implClass.newMethod(implClass.pos, nme.MIXIN_CONSTRUCTOR)
-                     setInfo MethodType(List(), UnitClass.tpe))
+        decls enter (
+          implClass.newMethod(nme.MIXIN_CONSTRUCTOR, implClass.pos)
+            setInfo MethodType(Nil, UnitClass.tpe)
+        )
+
       for (sym <- ifaceDecls.iterator) {
         if (isInterfaceMember(sym)) {
           if (needsImplMethod(sym)) {
diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
index 0bc137f3e8..50e6139e65 100644
--- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala
+++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
@@ -147,11 +147,10 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
             if (isFinal) FINAL else 0
           )
           
-          val varSym = currentClass.newVariable(mkTerm("" + forName), ad.pos, flags) setInfo forType
+          val varSym = currentClass.newVariable(mkTerm("" + forName), ad.pos, flags) setInfoAndEnter forType
           if (!isFinal)
             varSym.addAnnotation(VolatileAttr)
 
-          currentClass.info.decls enter varSym
           val varDef = typedPos( VAL(varSym) === forInit )
           newStaticMembers append transform(varDef)
 
@@ -163,13 +162,12 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
 
         def addStaticMethodToClass(forName: String, forArgsTypes: List[Type], forResultType: Type)
                                   (forBody: Pair[Symbol, List[Symbol]] => Tree): Symbol = {
-          val methSym = currentClass.newMethod(ad.pos, mkTerm(forName))
-            .setFlag(STATIC | SYNTHETIC)
 
-          methSym.setInfo(MethodType(methSym.newSyntheticValueParams(forArgsTypes), forResultType))
-          currentClass.info.decls enter methSym
+          val methSym = currentClass.newMethod(mkTerm(forName), ad.pos, STATIC | SYNTHETIC)
+          val params  = methSym.newSyntheticValueParams(forArgsTypes)
+          methSym setInfoAndEnter MethodType(params, forResultType)
 
-          val methDef = typedPos( DefDef(methSym, { forBody(Pair(methSym, methSym.paramss(0))) }) )
+          val methDef = typedPos( DefDef(methSym, forBody(methSym -> params)) )
           newStaticMembers append transform(methDef)
 
           methSym
@@ -404,7 +402,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
               def invocation  = (lookup DOT invokeName)(qual1(), invokeArgs)                        // .invoke(qual1, ...)
 
               // exception catching machinery
-              val invokeExc   = currentOwner.newValue(ad.pos, mkTerm("")) setInfo InvocationTargetExceptionClass.tpe
+              val invokeExc   = currentOwner.newValue(mkTerm(""), ad.pos) setInfo InvocationTargetExceptionClass.tpe
               def catchVar    = Bind(invokeExc, Typed(Ident(nme.WILDCARD), TypeTree(InvocationTargetExceptionClass.tpe)))
               def catchBody   = Throw(Apply(Select(Ident(invokeExc), nme.getCause), Nil))
 
@@ -492,7 +490,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
               assert(params.length == mparams.length, mparams)
               
               typedPos {
-                val sym = currentOwner.newValue(ad.pos, mkTerm("qual")) setInfo qual0.tpe
+                val sym = currentOwner.newValue(mkTerm("qual"), ad.pos) setInfo qual0.tpe
                 qual = safeREF(sym)
 
                 BLOCK(
diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala
index 2b3e5f311f..23817545e2 100644
--- a/src/compiler/scala/tools/nsc/transform/Constructors.scala
+++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala
@@ -392,11 +392,7 @@ abstract class Constructors extends Transform with ast.TreeDSL {
       /** Create a getter or a setter and enter into `clazz` scope
        */
       def addAccessor(sym: Symbol, name: TermName, flags: Long) = {
-        val m = (
-          clazz.newMethod(sym.pos, name)
-            setFlag (flags & ~LOCAL & ~PRIVATE)
-            setPrivateWithin clazz
-        )
+        val m = clazz.newMethod(name, sym.pos, flags & ~(LOCAL | PRIVATE)) setPrivateWithin clazz
         clazz.info.decls enter m
       }
 
@@ -404,12 +400,7 @@ abstract class Constructors extends Transform with ast.TreeDSL {
         val getr = addAccessor(
           sym, nme.getterName(sym.name), getterFlags(sym.flags))
         getr setInfo MethodType(List(), sym.tpe)
-        defBuf += localTyper.typed {
-          //util.trace("adding getter def for "+getr) {
-          atPos(sym.pos) {
-            DefDef(getr, Select(This(clazz), sym))
-          }//}
-        }
+        defBuf += localTyper.typedPos(sym.pos)(DefDef(getr, Select(This(clazz), sym)))
         getr
       }
 
diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
index 701fda1035..14f3dc16fa 100644
--- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
@@ -91,6 +91,21 @@ abstract class ExplicitOuter extends InfoTransform
     if (firstTry != NoSymbol && firstTry.outerSource == clazz) firstTry
     else clazz.info.decls find (_.outerSource == clazz) getOrElse NoSymbol
    }
+  def newOuterAccessor(clazz: Symbol) = {
+    val accFlags = SYNTHETIC | METHOD | STABLE | ( if (clazz.isTrait) DEFERRED else 0 )
+    val sym      = clazz.newMethodSymbol(nme.OUTER, clazz.pos, accFlags)
+    val restpe   = if (clazz.isTrait) clazz.outerClass.tpe else clazz.outerClass.thisType
+    
+    sym expandName clazz
+    sym.referenced = clazz
+    sym setInfo MethodType(Nil, restpe)
+  }
+  def newOuterField(clazz: Symbol) = {
+    val accFlags = SYNTHETIC | PARAMACCESSOR | ( if (clazz.isEffectivelyFinal) PrivateLocal else PROTECTED )
+    val sym      = clazz.newValue(nme.OUTER_LOCAL, clazz.pos, accFlags)
+
+    sym setInfo clazz.outerClass.thisType
+  }
 
   /** <p>
    *    The type transformation method:
@@ -146,27 +161,20 @@ abstract class ExplicitOuter extends InfoTransform
       var decls1 = decls
       if (isInner(clazz) && !clazz.isInterface) {
         decls1 = decls.cloneScope
-        val outerAcc = clazz.newMethod(clazz.pos, nme.OUTER) // 3
+        val outerAcc = clazz.newMethod(nme.OUTER, clazz.pos) // 3
         outerAcc expandName clazz
-
-        val restpe = if (clazz.isTrait) clazz.outerClass.tpe else clazz.outerClass.thisType
-        decls1 enter (clazz.newOuterAccessor(clazz.pos) setInfo MethodType(Nil, restpe))
-        if (hasOuterField(clazz)) { //2
-          val access = if (clazz.isEffectivelyFinal) PrivateLocal else PROTECTED
-          decls1 enter (
-            clazz.newValue(clazz.pos, nme.OUTER_LOCAL)
-            setFlag (SYNTHETIC | PARAMACCESSOR | access)
-            setInfo clazz.outerClass.thisType
-          )
-        }
+        
+        decls1 enter newOuterAccessor(clazz)
+        if (hasOuterField(clazz)) //2
+          decls1 enter newOuterField(clazz)
       }
       if (!clazz.isTrait && !parents.isEmpty) {
         for (mc <- clazz.mixinClasses) {
           val mixinOuterAcc: Symbol = atPhase(phase.next)(outerAccessor(mc))
           if (mixinOuterAcc != NoSymbol) {
             if (decls1 eq decls) decls1 = decls.cloneScope
-            val newAcc = mixinOuterAcc.cloneSymbol(clazz)
-            newAcc resetFlag DEFERRED setInfo (clazz.thisType memberType mixinOuterAcc)
+            val newAcc = mixinOuterAcc.cloneSymbol(clazz, mixinOuterAcc.flags & ~DEFERRED)
+            newAcc setInfo (clazz.thisType memberType mixinOuterAcc)
             decls1 enter newAcc
           }
         }
@@ -372,15 +380,13 @@ abstract class ExplicitOuter extends InfoTransform
 
       def makeGuardDef(vs: List[Symbol], guard: Tree) = {
         val gdname = unit.freshTermName("gd")
-        val method = currentOwner.newMethod(tree.pos, gdname) setFlag SYNTHETIC
-        val fmls   = vs map (_.tpe)
-        val tpe    = new MethodType(method newSyntheticValueParams fmls, BooleanClass.tpe)
-        method setInfo tpe
-
-        localTyper typed (DEF(method) === {
-          new ChangeOwnerTraverser(currentOwner, method) traverse guard
-          new TreeSymSubstituter(vs, method.paramss.head) transform (guard)
-        })
+        val method = currentOwner.newMethod(gdname, tree.pos, SYNTHETIC)
+        val params = method newSyntheticValueParams vs.map(_.tpe)
+        method setInfo new MethodType(params, BooleanClass.tpe)
+
+        localTyper typed {
+          DEF(method) === guard.changeOwner(currentOwner -> method).substTreeSyms(vs zip params: _*)
+        }
       }
 
       val nguard = new ListBuffer[Tree]
diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala
index d011c15494..bf19cf10e9 100644
--- a/src/compiler/scala/tools/nsc/transform/Mixin.scala
+++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala
@@ -186,13 +186,9 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
        *  always accessors and deferred. */
       def newGetter(field: Symbol): Symbol = {
         // println("creating new getter for "+ field +" : "+ field.info +" at "+ field.locationString+(field hasFlag MUTABLE))
-        // atPhase(currentRun.erasurePhase){
-        //   println("before erasure: "+ (field.info))
-        // }
-        clazz.newMethod(field.pos, nme.getterName(field.name))
-          .setFlag(field.flags & ~PrivateLocal | ACCESSOR | lateDEFERRED |
-                     (if (field.isMutable) 0 else STABLE))
-          .setInfo(MethodType(List(), field.info)) // TODO preserve pre-erasure info?
+        val newFlags = field.flags & ~PrivateLocal | ACCESSOR | lateDEFERRED | ( if (field.isMutable) 0 else STABLE )
+        // TODO preserve pre-erasure info?
+        clazz.newMethod(nme.getterName(field.name), field.pos, newFlags) setInfo MethodType(Nil, field.info)
       }
 
       /** Create a new setter. Setters are never private or local. They are
@@ -200,13 +196,13 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
       def newSetter(field: Symbol): Symbol = {
         //println("creating new setter for "+field+field.locationString+(field hasFlag MUTABLE))
         val setterName = nme.getterToSetter(nme.getterName(field.name))
-        val setter = clazz.newMethod(field.pos, setterName)
-          .setFlag(field.flags & ~PrivateLocal | ACCESSOR | lateDEFERRED)
-        setter.setInfo(MethodType(setter.newSyntheticValueParams(List(field.info)), UnitClass.tpe))  // TODO preserve pre-erasure info?
-        if (needsExpandedSetterName(field)) {
-          //println("creating expanded setter from "+field)
+        val newFlags   = field.flags & ~PrivateLocal | ACCESSOR | lateDEFERRED
+        val setter     = clazz.newMethod(setterName, field.pos, newFlags)
+        // TODO preserve pre-erasure info?
+        setter setInfo MethodType(setter.newSyntheticValueParams(List(field.info)), UnitClass.tpe)
+        if (needsExpandedSetterName(field))
           setter.name = nme.expandedSetterName(setter.name, clazz)
-        }
+        
         setter
       }
 
@@ -343,7 +339,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
                     // so it can no longer be found in the member's owner (the trait)
                     val accessed = atPhase(currentRun.picklerPhase)(member.accessed)
                     val sym = atPhase(currentRun.erasurePhase){ // #3857, need to retain info before erasure when cloning (since cloning only carries over the current entry in the type history)
-                      clazz.newValue(member.pos, nme.getterToLocal(member.name)).setInfo(member.tpe.resultType) // so we have a type history entry before erasure
+                      clazz.newValue(nme.getterToLocal(member.name), member.pos).setInfo(member.tpe.resultType) // so we have a type history entry before erasure
                     }
                     sym.updateInfo(member.tpe.resultType) // info at current phase
                     addMember(clazz,
@@ -361,9 +357,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
 
           } else if (member.isMethod && member.isModule && member.hasNoFlags(LIFTED | BRIDGE)) {
             // mixin objects: todo what happens with abstract objects?
-            addMember(clazz, member.cloneSymbol(clazz))
-              .setPos(clazz.pos)
-              .resetFlag(DEFERRED | lateDEFERRED)
+            addMember(clazz, member.cloneSymbol(clazz, member.flags & ~(DEFERRED | lateDEFERRED)) setPos clazz.pos)
           }
         }
       }
@@ -533,9 +527,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
           if (currentOwner.isImplClass) {
             if (isImplementedStatically(sym)) {
               sym setFlag notOVERRIDE
-              self = sym.newValue(sym.pos, nme.SELF)
-                .setFlag(PARAM)
-                .setInfo(toInterface(currentOwner.typeOfThis));
+              self = sym.newValueParameter(nme.SELF, sym.pos) setInfo toInterface(currentOwner.typeOfThis)
               val selfdef = ValDef(self) setType NoType
               treeCopy.DefDef(tree, mods, name, tparams, List(selfdef :: vparams), tpt, rhs)
             } else {
diff --git a/src/compiler/scala/tools/nsc/transform/SampleTransform.scala b/src/compiler/scala/tools/nsc/transform/SampleTransform.scala
index 73d17458bf..f7d2c9de28 100644
--- a/src/compiler/scala/tools/nsc/transform/SampleTransform.scala
+++ b/src/compiler/scala/tools/nsc/transform/SampleTransform.scala
@@ -37,8 +37,8 @@ abstract class SampleTransform extends Transform {
                 Select(                         // The `Select` factory method is defined in class `Trees`
                   sup,
                   currentOwner.newValue(        // creates a new term symbol owned by `currentowner`
-                    tree1.pos,
-                    newTermName("sample"))))))  // The standard term name creator
+                    newTermName("sample"),      // The standard term name creator
+                    tree1.pos)))))
         case _ =>
           tree1
       }
diff --git a/src/compiler/scala/tools/nsc/transform/TailCalls.scala b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
index da767b6bce..1655ad09c4 100644
--- a/src/compiler/scala/tools/nsc/transform/TailCalls.scala
+++ b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
@@ -144,7 +144,7 @@ abstract class TailCalls extends Transform {
       def isTransformed    = isEligible && accessed
       def tailrecFailure() = unit.error(failPos, "could not optimize @tailrec annotated " + method + ": " + failReason)
 
-      def newThis(pos: Position) = method.newValue(pos, nme.THIS) setInfo currentClass.typeOfThis setFlag SYNTHETIC
+      def newThis(pos: Position) = method.newValue(nme.THIS, pos, SYNTHETIC) setInfo currentClass.typeOfThis
 
       override def toString(): String = (
         "" + method.name + " tparams: " + tparams + " tailPos: " + tailPos +
diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
index 2e2ff23881..56d9658377 100644
--- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala
+++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -168,7 +168,7 @@ abstract class UnCurry extends InfoTransform
     private def nonLocalReturnTry(body: Tree, key: Symbol, meth: Symbol) = {
       localTyper.typed {
         val extpe = nonLocalReturnExceptionType(meth.tpe.finalResultType)
-        val ex = meth.newValue(body.pos, nme.ex) setInfo extpe
+        val ex = meth.newValue(nme.ex, body.pos) setInfo extpe
         val pat = Bind(ex,
                        Typed(Ident(nme.WILDCARD),
                              AppliedTypeTree(Ident(NonLocalReturnControlClass),
@@ -260,13 +260,12 @@ abstract class UnCurry extends InfoTransform
           else List(ObjectClass.tpe, fun.tpe, SerializableClass.tpe)
 
         anonClass setInfo ClassInfoType(parents, new Scope, anonClass)
-        val applyMethod = anonClass.newMethod(fun.pos, nme.apply) setFlag FINAL
-        applyMethod setInfo MethodType(applyMethod newSyntheticValueParams formals, restpe)
-        anonClass.info.decls enter applyMethod
-        anonClass.addAnnotation(serialVersionUIDAnnotation)
+        val applyMethod = anonClass.newMethod(nme.apply, fun.pos, FINAL) 
+        applyMethod setInfoAndEnter MethodType(applyMethod newSyntheticValueParams formals, restpe)
+        anonClass addAnnotation serialVersionUIDAnnotation
 
         fun.vparams foreach (_.symbol.owner = applyMethod)
-        new ChangeOwnerTraverser(fun.symbol, applyMethod) traverse fun.body
+        fun.body.changeOwner(fun.symbol -> applyMethod)
 
         def missingCaseCall(scrutinee: Tree): Tree = Apply(Select(This(anonClass), nme.missingCase), List(scrutinee))
 
@@ -285,12 +284,11 @@ abstract class UnCurry extends InfoTransform
             if (anonClass.info.member(nme._isDefinedAt) != NoSymbol) nme._isDefinedAt
             else nme.isDefinedAt
           }
-          val m = anonClass.newMethod(fun.pos, isDefinedAtName) setFlag FINAL
-          m setInfo MethodType(m newSyntheticValueParams formals, BooleanClass.tpe)
-          anonClass.info.decls enter m
-          val vparam = fun.vparams.head.symbol
-          val idparam = m.paramss.head.head
-          val substParam = new TreeSymSubstituter(List(vparam), List(idparam))
+          val m      = anonClass.newMethod(isDefinedAtName, fun.pos, FINAL)
+          val params = m newSyntheticValueParams formals
+          m setInfoAndEnter MethodType(params, BooleanClass.tpe)
+
+          val substParam = new TreeSymSubstituter(fun.vparams map (_.symbol), params)
           def substTree[T <: Tree](t: T): T = substParam(resetLocalAttrs(t))
 
           // waiting here until we can mix case classes and extractors reliably (i.e., when virtpatmat becomes the default)
@@ -518,9 +516,9 @@ abstract class UnCurry extends InfoTransform
        */
       def liftTree(tree: Tree) = {
         debuglog("lifting tree at: " + (tree.pos))
-        val sym = currentOwner.newMethod(tree.pos, unit.freshTermName("liftedTree"))
+        val sym = currentOwner.newMethod(unit.freshTermName("liftedTree"), tree.pos)
         sym.setInfo(MethodType(List(), tree.tpe))
-        new ChangeOwnerTraverser(currentOwner, sym).traverse(tree)
+        tree.changeOwner(currentOwner -> sym)
         localTyper.typedPos(tree.pos)(Block(
           List(DefDef(sym, List(Nil), tree)),
           Apply(Ident(sym), Nil)
@@ -783,11 +781,7 @@ abstract class UnCurry extends InfoTransform
       }
 
       // create the symbol
-      val forwsym = (
-        currentClass.newMethod(dd.pos, dd.name)
-        . setFlag (VARARGS | SYNTHETIC | flatdd.symbol.flags)
-        . setInfo (forwtype)
-      )
+      val forwsym = currentClass.newMethod(dd.name, dd.pos, VARARGS | SYNTHETIC | flatdd.symbol.flags) setInfo forwtype
 
       // create the tree
       val forwtree = theTyper.typedPos(dd.pos) {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 918eb749c8..53e88b33c8 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -192,12 +192,10 @@ trait Implicits {
    */
   def memberWildcardType(name: Name, tp: Type) = {
     val result = refinedType(List(WildcardType), NoSymbol)
-    var psym = name match {
-      case x: TypeName  => result.typeSymbol.newAbstractType(NoPosition, x)
-      case x: TermName  => result.typeSymbol.newValue(NoPosition, x)
+    name match {
+      case x: TermName => result.typeSymbol.newValue(x) setInfoAndEnter tp
+      case x: TypeName => result.typeSymbol.newAbstractType(x) setInfoAndEnter tp
     }
-    psym setInfo tp
-    result.decls enter psym
     result
   }
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
index 07b08e52da..79cb211215 100644
--- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
@@ -154,10 +154,9 @@ trait NamesDefaults { self: Analyzer =>
 
       // never used for constructor calls, they always have a stable qualifier
       def blockWithQualifier(qual: Tree, selected: Name) = {
-        val sym = blockTyper.context.owner.newValue(qual.pos, unit.freshTermName("qual$"))
-                            .setInfo(qual.tpe)
-        blockTyper.context.scope.enter(sym)
-        val vd = atPos(sym.pos)(ValDef(sym, qual).setType(NoType))
+        val sym = blockTyper.context.owner.newValue(unit.freshTermName("qual$"), qual.pos) setInfo qual.tpe
+        blockTyper.context.scope enter sym
+        val vd = atPos(sym.pos)(ValDef(sym, qual) setType NoType)
 
         var baseFunTransformed = atPos(baseFun.pos.makeTransparent) {
           // don't use treeCopy: it would assign opaque position.
diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
index cde531adc1..4e4fbe35cb 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
@@ -97,18 +97,13 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
           var superAcc = clazz.info.decl(supername).suchThat(_.alias == sym)
           if (superAcc == NoSymbol) {
             debuglog("add super acc " + sym + sym.locationString + " to `" + clazz);//debug
-            superAcc =
-              clazz.newMethod(tree.pos, supername)
-                .setFlag(SUPERACCESSOR | PRIVATE)
-                .setAlias(sym)
+            superAcc = clazz.newMethod(supername, tree.pos, SUPERACCESSOR | PRIVATE) setAlias sym
             var superAccTpe = clazz.thisType.memberType(sym)
             if (sym.isModule && !sym.isMethod) {
               // the super accessor always needs to be a method. See #231
               superAccTpe = NullaryMethodType(superAccTpe)
             }
-            superAcc.setInfo(superAccTpe.cloneInfo(superAcc))
-            //println("creating super acc "+superAcc+":"+superAcc.tpe)//DEBUG
-            clazz.info.decls enter superAcc
+            superAcc setInfoAndEnter (superAccTpe cloneInfo superAcc)
             storeAccessorDefinition(clazz, DefDef(superAcc, EmptyTree))
           }
           atPos(sup.pos) {
@@ -312,14 +307,12 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
                      memberType.cloneInfo(protAcc).asSeenFrom(qual.tpe, sym.owner))
       }
 
-      var protAcc = clazz.info.decl(accName).suchThat(s => s == NoSymbol || s.tpe =:= accType(s))
-      if (protAcc == NoSymbol) {
-        protAcc = clazz.newMethod(tree.pos, nme.protName(sym.originalName))
-        protAcc.setInfo(accType(protAcc))
-        clazz.info.decls.enter(protAcc);
+      val protAcc = clazz.info.decl(accName).suchThat(s => s == NoSymbol || s.tpe =:= accType(s)) orElse {
+        val newAcc = clazz.newMethod(nme.protName(sym.originalName), tree.pos)
+        newAcc setInfoAndEnter accType(newAcc)
 
-        val code = DefDef(protAcc, {
-          val (receiver :: _) :: tail = protAcc.paramss
+        val code = DefDef(newAcc, {
+          val (receiver :: _) :: tail = newAcc.paramss
           val base: Tree              = Select(Ident(receiver), sym)
           val allParamTypes           = mapParamss(sym)(_.tpe)
           val args = map2(tail, allParamTypes)((params, tpes) => map2(params, tpes)(makeArg(_, receiver, _)))
@@ -328,12 +321,15 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
 
         debuglog("" + code)
         storeAccessorDefinition(clazz, code)
+        newAcc
       }
-      var res: Tree = atPos(tree.pos) {
-        if (targs.head == EmptyTree)
-          Apply(Select(This(clazz), protAcc), List(qual))
-        else
-          Apply(TypeApply(Select(This(clazz), protAcc), targs), List(qual))
+      val selection = Select(This(clazz), protAcc)
+      def mkApply(fn: Tree) = Apply(fn, qual :: Nil)
+      val res = atPos(tree.pos) { 
+        targs.head match {
+          case EmptyTree  => mkApply(selection)
+          case _          => mkApply(TypeApply(selection, targs))
+        }
       }
       debuglog("Replaced " + tree + " with " + res)
       if (hasArgs) localTyper.typedOperator(res) else localTyper.typed(res)
@@ -371,25 +367,21 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
       val clazz = hostForAccessorOf(field, currentOwner.enclClass)
       assert(clazz != NoSymbol, field)
       debuglog("Decided for host class: " + clazz)
+      
       val accName = nme.protSetterName(field.originalName)
-      var protAcc = clazz.info.decl(accName)
-      if (protAcc == NoSymbol) {
-        protAcc = clazz.newMethod(field.pos, nme.protSetterName(field.originalName))
-        protAcc.setInfo(MethodType(protAcc.newSyntheticValueParams(List(clazz.typeOfThis, field.tpe)),
-                                   UnitClass.tpe))
-        clazz.info.decls.enter(protAcc)
-        val code = DefDef(protAcc, {
-          val obj :: value :: Nil = protAcc.paramss.head
-          atPos(tree.pos) {
-            Assign(
-              Select(Ident(obj), field.name),
-              Ident(value))
-          }
-        })
-        debuglog("" + code)
-        storeAccessorDefinition(clazz, code)
+      val protectedAccessor = clazz.info decl accName orElse {
+        val protAcc      = clazz.newMethod(accName, field.pos)
+        val paramTypes   = List(clazz.typeOfThis, field.tpe)
+        val params       = protAcc newSyntheticValueParams paramTypes
+        val accessorType = MethodType(params, UnitClass.tpe)
+        
+        protAcc setInfoAndEnter accessorType
+        val obj :: value :: Nil = params
+        storeAccessorDefinition(clazz, DefDef(protAcc, Assign(Select(Ident(obj), field.name), Ident(value))))
+      
+        protAcc
       }
-      atPos(tree.pos)(Select(This(clazz), protAcc))
+      atPos(tree.pos)(Select(This(clazz), protectedAccessor))
     }
 
     /** Does `sym` need an accessor when accessed from `currentOwner`?
diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
index 1df7cd86d3..4e986dc5aa 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
@@ -110,12 +110,12 @@ trait SyntheticMethods extends ast.TreeDSL {
     }
 
     private def createInternal(name: Name, f: Symbol => Tree, info: Type): Tree = {
-      val m = clazz.newMethod(clazz.pos.focus, name.toTermName)
+      val m = clazz.newMethod(name.toTermName, clazz.pos.focus)
       m setInfo info
       finishMethod(m, f)
     }
     private def createInternal(name: Name, f: Symbol => Tree, infoFn: Symbol => Type): Tree = {
-      val m = clazz.newMethod(clazz.pos.focus, name.toTermName)
+      val m = clazz.newMethod(name.toTermName, clazz.pos.focus)
       m setInfo infoFn(m)
       finishMethod(m, f)
     }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 243d922732..884ad7af3d 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -2817,7 +2817,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
         }
         val bound      = sym.existentialBound
         val sowner     = if (isRawParameter(sym)) context.owner else sym.owner
-        val quantified = sowner.newExistential(sym.pos, name)
+        val quantified = sowner.newExistential(name, sym.pos)
 
         quantified setInfo bound.cloneInfo(quantified)
       }
@@ -3079,7 +3079,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
                    * */
                   ( context.owner
                       newLocalDummy (ann.pos)
-                      newValue (ann.pos, nme.self)
+                      newValue (nme.self, ann.pos)
                       setInfo (arg1.tpe.withoutAnnotations)
                   )
                 }
@@ -3120,9 +3120,9 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
           if (vble == NoSymbol)
             vble =
               if (isFullyDefined(pt))
-                context.owner.newAliasType(tree.pos, name) setInfo pt
+                context.owner.newAliasType(name, tree.pos) setInfo pt
               else
-                context.owner.newAbstractType(tree.pos, name) setInfo TypeBounds.empty
+                context.owner.newAbstractType(name, tree.pos) setInfo TypeBounds.empty
           val rawInfo = vble.rawInfo
           vble = if (vble.name == tpnme.WILDCARD) context.scope.enter(vble)
                  else namer.enterInScope(vble)
@@ -3130,7 +3130,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
         }
         def typedBindTerm(name: TermName) = {
           if (vble == NoSymbol)
-            vble = context.owner.newValue(tree.pos, name)
+            vble = context.owner.newValue(name, tree.pos)
           if (vble.name.toTermName != nme.WILDCARD) {
             if ((mode & ALTmode) != 0)
               error(tree.pos, "illegal variable in pattern alternative")
diff --git a/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala b/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala
index 585dc3fbe8..cea558d2d3 100644
--- a/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala
+++ b/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala
@@ -215,13 +215,9 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
 
         case ldef @ LabelDef(name, params, rhs) =>
           if (hasAnswerTypeAnn(tree.tpe)) {
-            val sym = currentOwner.newMethod(tree.pos, name)
-                        .setInfo(ldef.symbol.info)
-                        .setFlag(Flags.SYNTHETIC)
-
-            val rhs1 = new TreeSymSubstituter(List(ldef.symbol), List(sym)).transform(rhs)
-            val rhsVal = transExpr(rhs1, None, getAnswerTypeAnn(tree.tpe))
-            new ChangeOwnerTraverser(currentOwner, sym) traverse rhsVal
+            val sym    = currentOwner.newMethod(name, tree.pos, Flags.SYNTHETIC) setInfo ldef.symbol.info
+            val rhs1   = new TreeSymSubstituter(List(ldef.symbol), List(sym)).transform(rhs)
+            val rhsVal = transExpr(rhs1, None, getAnswerTypeAnn(tree.tpe)) changeOwner (currentOwner -> sym)
 
             val stm1 = localTyper.typed(DefDef(sym, rhsVal))
             val expr = localTyper.typed(Apply(Ident(sym), List()))
@@ -355,12 +351,12 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
 
           val valueTpe = removeAllCPSAnnotations(expr.tpe)
 
-          val sym = currentOwner.newValue(tree.pos, newTermName(unit.fresh.newName("tmp")))
-                      .setInfo(valueTpe)
-                      .setFlag(Flags.SYNTHETIC)
-                      .setAnnotations(List(AnnotationInfo(MarkerCPSSym.tpe, Nil, Nil)))
-
-          new ChangeOwnerTraverser(currentOwner, sym) traverse expr
+          val sym: Symbol = (
+            currentOwner.newValue(newTermName(unit.fresh.newName("tmp")), tree.pos, Flags.SYNTHETIC)
+              setInfo valueTpe
+              setAnnotations List(AnnotationInfo(MarkerCPSSym.tpe, Nil, Nil))
+          )
+          expr.changeOwner(currentOwner -> sym)
 
           (stms ::: List(ValDef(sym, expr) setType(NoType)),
              Ident(sym) setType(valueTpe) setPos(tree.pos), linearize(spc, spcVal)(unit, tree.pos))
diff --git a/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala b/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala
index 09aa1b05f7..b2a1546b4e 100644
--- a/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala
+++ b/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala
@@ -200,8 +200,7 @@ abstract class SelectiveCPSTransform extends PluginComponent with
             val expr2 = localTyper.typed(atPos(pos) { Apply(Select(expr1, expr1.tpe.member(cpsNames.flatMapCatch)), List(Ident(funSym))) })
 
             argSym.owner = fun.symbol
-            val chown = new ChangeOwnerTraverser(currentOwner, fun.symbol)
-            chown.traverse(rhs)
+            rhs.changeOwner(currentOwner -> fun.symbol)
 
             val exSym = currentOwner.newValueParameter(cpsNames.ex, pos).setInfo(ThrowableClass.tpe)
             val catch2 = { localTyper.typedCases(tree, List(
@@ -263,8 +262,7 @@ abstract class SelectiveCPSTransform extends PluginComponent with
 
               val tpe = vd.symbol.tpe
               val rhs1 = atOwner(vd.symbol) { transform(rhs) }
-
-              new ChangeOwnerTraverser(vd.symbol, currentOwner).traverse(rhs1) // TODO: don't traverse twice
+              rhs1.changeOwner(vd.symbol -> currentOwner) // TODO: don't traverse twice
 
               log("valdef symbol " + vd.symbol + " has type " + tpe)
               log("right hand side " + rhs1 + " has type " + rhs1.tpe)
@@ -306,7 +304,7 @@ abstract class SelectiveCPSTransform extends PluginComponent with
                 val body1 = (new TreeSymSubstituter(List(vd.symbol), List(arg)))(body)
                 val fun = localTyper.typed(atPos(vd.symbol.pos) { Function(List(ValDef(arg)), body1) }) // types body as well
                 arg.owner = fun.symbol
-                new ChangeOwnerTraverser(currentOwner, fun.symbol).traverse(body1)
+                body1.changeOwner(currentOwner -> fun.symbol)
 
                 // see note about multiple traversals above
 
diff --git a/src/partest/scala/tools/partest/nest/SBTRunner.scala b/src/partest/scala/tools/partest/nest/SBTRunner.scala
index ae54e51761..0c176e4b06 100644
--- a/src/partest/scala/tools/partest/nest/SBTRunner.scala
+++ b/src/partest/scala/tools/partest/nest/SBTRunner.scala
@@ -71,11 +71,10 @@ object SBTRunner extends DirectRunner {
 
   def main(args: Array[String]): Unit = {
     import collection.JavaConverters._
-    val failures = for {
-      (path, result) <- mainReflect(args).asScala
-     if result == 1 || result == 2
-     val resultName = (if(result == 1) " [FAILED]" else " [TIMEOUT]")
-    } yield path + resultName
+    val failures = (
+      for ((path, result) <- mainReflect(args).asScala ; if result == 1 || result == 2) yield
+        path + ( if (result == 1) " [FAILED]" else " [TIMEOUT]" )
+    )
     // Re-list all failures so we can go figure out what went wrong.
     failures foreach System.err.println
     if(!failures.isEmpty) sys.exit(1)