Optimizing TypeRef, starting with Symbols.

There are too many potential optimizations unavailable to us due to the
lack of bright lines among different kinds of symbols. For instance the
difference between a TypeSymbol which represents a type alias and one
which represents an abstract type is only whether the DEFERRED flag
is set. This creates issues.

1) There are many (many) places where tests are performed on every symbol
which could be done more efficiently and (especially) more verifiably
correctly with polymorphism.

2) TypeRefs based on those symbols are also checking that flag
constantly, in perpetuity. A symbol created as an alias is never (to the
best of my knowledge) going to intentionally morph into one representing
an abstract type, nor vice versa.

3) One has no guarantees, because anyone can set or reset the DEFERRED
flag at any time.

So tackling more than one problem at once herein:

1) I created canonical symbol creation points which take the flags as
an argument, so that there can be a difference between initializing a
symbol's flags and setting/resetting them at arbitrary times.

2) I structured all the symbol creators to take arguments in the
same order, which is:

  def newXXX(name: Name, ..., pos: Position = NoPosition, flags: Long = 0L)

(Where "..." is for those symbols which require something
beyond the name to create, such as a TypeSkolem's origin.)
The name is first because it's the only always required argument.
I left but deprecated the variations which take (pos, name).

3) I created subclasses of TypeRef based on the information which
should be stable from creation time onward:

  - args or no args?
  - abstract type, type alias, or class?

2x3 == 6 and that's how many subclasses of TypeRef there are now. So
now, for example, every TypeRef doesn't have to carry null symInfoCache
and thisInfoCache fields for the benefit of the minority which use them.
I still intend to realize the gain possible once we can evade the fields
for pre and args without losing pattern matcher efficiency.

39 files changed, 612 insertions, 586 deletions

diff --git a/src/compiler/scala/reflect/internal/Definitions.scala b/src/compiler/scala/reflect/internal/Definitions.scala
index cc6ba32f9c..f4abb8cad3 100644
--- a/src/compiler/scala/reflect/internal/Definitions.scala
+++ b/src/compiler/scala/reflect/internal/Definitions.scala
@@ -14,6 +14,18 @@ import PartialFunction._
 trait Definitions extends reflect.api.StandardDefinitions {
   self: SymbolTable =>
 
+  private def newClass(owner: Symbol, name: TypeName, parents: List[Type], flags: Long = 0L): Symbol = {
+    val clazz = owner.newClassSymbol(name, NoPosition, flags)
+    clazz setInfo ClassInfoType(parents, new Scope, clazz)
+    owner.info.decls enter clazz
+  }
+  private def newMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type, flags: Long = 0L): Symbol = {
+    val msym   = owner.newMethod(name.encode, NoPosition, flags)
+    val params = msym.newSyntheticValueParams(formals)
+    msym setInfo MethodType(params, restpe)
+    owner.info.decls enter msym
+  }
+
   // the scala value classes
   trait ValueClassDefinitions {
     self: definitions.type =>
@@ -66,13 +78,6 @@ trait Definitions extends reflect.api.StandardDefinitions {
     lazy val boxMethod        = classesMap(x => valueModuleMethod(x, nme.box))
     lazy val unboxMethod      = classesMap(x => valueModuleMethod(x, nme.unbox))
 
-    private def newClass(owner: Symbol, name: TypeName, parents: List[Type]): Symbol = {
-      val clazz = owner.newClass(NoPosition, name)
-      clazz.setInfo(ClassInfoType(parents, new Scope, clazz))
-      owner.info.decls.enter(clazz)
-      clazz
-    }
-
     def isNumericSubClass(sub: Symbol, sup: Symbol) = (
          (numericWeight contains sub)
       && (numericWeight contains sup)
@@ -124,21 +129,21 @@ trait Definitions extends reflect.api.StandardDefinitions {
     // This is the package _root_.  The actual root cannot be referenced at
     // the source level, but _root_ is essentially a function () => <root>.
     lazy val RootPackage: Symbol = {
-      val rp = NoSymbol.newValue(NoPosition, nme.ROOTPKG)
-        .setFlag(FINAL | MODULE | PACKAGE | JAVA)
-        .setInfo(NullaryMethodType(RootClass.tpe))
+      val rp = (
+        NoSymbol.newValue(nme.ROOTPKG, flags = FINAL | MODULE | PACKAGE | JAVA)
+          setInfo NullaryMethodType(RootClass.tpe)
+      )
       RootClass.sourceModule = rp
       rp
     }
 
     // This is the actual root of everything, including the package _root_.
     lazy val RootClass: ModuleClassSymbol = (
-      NoSymbol.newModuleClass(NoPosition, tpnme.ROOT)
-        setFlag (FINAL | MODULE | PACKAGE | JAVA)
+      NoSymbol.newModuleClassSymbol(tpnme.ROOT, flags = FINAL | MODULE | PACKAGE | JAVA)
         setInfo rootLoader
     )
     // The empty package, which holds all top level types without given packages.
-    lazy val EmptyPackage       = RootClass.newPackage(NoPosition, nme.EMPTY_PACKAGE_NAME).setFlag(FINAL)
+    lazy val EmptyPackage       = RootClass.newPackage(nme.EMPTY_PACKAGE_NAME, flags = FINAL)
     lazy val EmptyPackageClass  = EmptyPackage.moduleClass
 
     lazy val JavaLangPackage      = getModule(sn.JavaLang)
@@ -190,11 +195,11 @@ trait Definitions extends reflect.api.StandardDefinitions {
     }
 
     // top types
-    lazy val AnyClass             = newClass(ScalaPackageClass, tpnme.Any, Nil) setFlag (ABSTRACT)
+    lazy val AnyClass             = newClass(ScalaPackageClass, tpnme.Any, Nil, ABSTRACT)
     lazy val AnyRefClass          = newAlias(ScalaPackageClass, tpnme.AnyRef, ObjectClass.typeConstructor)
     lazy val ObjectClass          = getClass(sn.Object)
-    lazy val AnyCompanionClass    = getRequiredClass("scala.AnyCompanion") setFlag (SEALED | ABSTRACT | TRAIT)
-    lazy val AnyValCompanionClass = getRequiredClass("scala.AnyValCompanion") setFlag (SEALED | ABSTRACT | TRAIT)
+    lazy val AnyCompanionClass    = getRequiredClass("scala.AnyCompanion") initFlags (SEALED | ABSTRACT | TRAIT)
+    lazy val AnyValCompanionClass = getRequiredClass("scala.AnyValCompanion") initFlags (SEALED | ABSTRACT | TRAIT)
 
     // bottom types
     lazy val RuntimeNothingClass  = getClass(fulltpnme.RuntimeNothing)
@@ -202,7 +207,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
 
     sealed abstract class BottomClassSymbol(name: TypeName, parent: Symbol) extends ClassSymbol(ScalaPackageClass, NoPosition, name) {
       locally {
-        this setFlag ABSTRACT | TRAIT | FINAL
+        this initFlags ABSTRACT | TRAIT | FINAL
         this setInfo ClassInfoType(List(parent.tpe), new Scope, this)
         owner.info.decls enter this
       }
@@ -296,7 +301,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
       //   .setInfo(UnitClass.tpe)
 
     lazy val TypeConstraintClass   = getRequiredClass("scala.annotation.TypeConstraint")
-    lazy val SingletonClass        = newClass(ScalaPackageClass, tpnme.Singleton, anyparam) setFlag (ABSTRACT | TRAIT | FINAL)
+    lazy val SingletonClass        = newClass(ScalaPackageClass, tpnme.Singleton, anyparam, ABSTRACT | TRAIT | FINAL)
     lazy val SerializableClass     = getRequiredClass("scala.Serializable")
     lazy val JavaSerializableClass = getClass(sn.JavaSerializable)
     lazy val ComparableClass       = getRequiredClass("java.lang.Comparable")
@@ -808,13 +813,6 @@ trait Definitions extends reflect.api.StandardDefinitions {
      */
     private def getModuleOrClass(path: Name): Symbol = getModuleOrClass(path, path.length)
 
-    private def newClass(owner: Symbol, name: TypeName, parents: List[Type]): Symbol = {
-      val clazz = owner.newClass(NoPosition, name)
-      clazz.setInfo(ClassInfoType(parents, new Scope, clazz))
-      owner.info.decls.enter(clazz)
-      clazz
-    }
-
     private def newCovariantPolyClass(owner: Symbol, name: TypeName, parent: Symbol => Type): Symbol = {
       val clazz  = newClass(owner, name, List())
       val tparam = newTypeParam(clazz, 0) setFlag COVARIANT
@@ -832,40 +830,26 @@ trait Definitions extends reflect.api.StandardDefinitions {
     }
 
     private def newAlias(owner: Symbol, name: TypeName, alias: Type): Symbol = {
-      val tpsym = owner.newAliasType(NoPosition, name)
+      val tpsym = owner.newAliasType(name)
       tpsym.setInfo(alias)
       owner.info.decls.enter(tpsym)
       tpsym
     }
 
-    private def newMethod(owner: Symbol, name: TermName): Symbol = {
-      val msym = owner.newMethod(NoPosition, name.encode)
-      owner.info.decls.enter(msym)
-      msym
-    }
-
-    private[Definitions] def newMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type): Symbol = {
-      val msym = newMethod(owner, name)
-      val params = msym.newSyntheticValueParams(formals)
-      msym.setInfo(MethodType(params, restpe))
-    }
-
     /** tcon receives the type parameter symbol as argument */
     private def newPolyMethod(owner: Symbol, name: TermName, tcon: Symbol => Type): Symbol =
       newPolyMethodCon(owner, name, tparam => msym => tcon(tparam))
 
     /** tcon receives the type parameter symbol and the method symbol as arguments */
     private def newPolyMethodCon(owner: Symbol, name: TermName, tcon: Symbol => Symbol => Type): Symbol = {
-      val msym = newMethod(owner, name)
+      val msym   = owner.info.decls enter owner.newMethod(name.encode)
       val tparam = newTypeParam(msym, 0)
-      msym.setInfo(polyType(List(tparam), tcon(tparam)(msym)))
-    }
 
-    private def newParameterlessMethod(owner: Symbol, name: TermName, restpe: Type) =
-      newMethod(owner, name).setInfo(NullaryMethodType(restpe))
+      msym setInfo polyType(List(tparam), tcon(tparam)(msym))
+    }
 
     private def newTypeParam(owner: Symbol, index: Int): Symbol =
-      owner.newTypeParameter(NoPosition, newTypeName("T" + index)) setInfo TypeBounds.empty
+      owner.newTypeParameter(newTypeName("T" + index)) setInfo TypeBounds.empty
 
     lazy val boxedClassValues = boxedClass.values.toSet
     lazy val isUnbox = unboxMethod.values.toSet
@@ -965,12 +949,12 @@ trait Definitions extends reflect.api.StandardDefinitions {
       RootClass.info.decls enter RootPackage
 
       // members of class scala.Any
-      Any_== = newMethod(AnyClass, nme.EQ, anyparam, booltype) setFlag FINAL
-      Any_!= = newMethod(AnyClass, nme.NE, anyparam, booltype) setFlag FINAL
+      Any_== = newMethod(AnyClass, nme.EQ, anyparam, booltype, FINAL)
+      Any_!= = newMethod(AnyClass, nme.NE, anyparam, booltype, FINAL)
       Any_equals   = newMethod(AnyClass, nme.equals_, anyparam, booltype)
       Any_hashCode = newMethod(AnyClass, nme.hashCode_, Nil, inttype)
       Any_toString = newMethod(AnyClass, nme.toString_, Nil, stringtype)
-      Any_##       = newMethod(AnyClass, nme.HASHHASH, Nil, inttype) setFlag FINAL
+      Any_##       = newMethod(AnyClass, nme.HASHHASH, Nil, inttype, FINAL)
 
       // Any_getClass requires special handling.  The return type is determined on
       // a per-call-site basis as if the function being called were actually:
@@ -981,26 +965,24 @@ trait Definitions extends reflect.api.StandardDefinitions {
       // Since getClass is not actually a polymorphic method, this requires compiler
       // participation.  At the "Any" level, the return type is Class[_] as it is in
       // java.lang.Object.  Java also special cases the return type.
-      Any_getClass = (
-        newMethod(AnyClass, nme.getClass_, Nil, getMember(ObjectClass, nme.getClass_).tpe.resultType)
-          setFlag DEFERRED
-      )
+      Any_getClass =
+        newMethod(AnyClass, nme.getClass_, Nil, getMember(ObjectClass, nme.getClass_).tpe.resultType, DEFERRED)
       Any_isInstanceOf = newPolyMethod(
         AnyClass, nme.isInstanceOf_, tparam => NullaryMethodType(booltype)) setFlag FINAL
       Any_asInstanceOf = newPolyMethod(
         AnyClass, nme.asInstanceOf_, tparam => NullaryMethodType(tparam.typeConstructor)) setFlag FINAL
 
       // members of class java.lang.{ Object, String }
-      Object_## = newMethod(ObjectClass, nme.HASHHASH, Nil, inttype) setFlag FINAL
-      Object_== = newMethod(ObjectClass, nme.EQ, anyrefparam, booltype) setFlag FINAL
-      Object_!= = newMethod(ObjectClass, nme.NE, anyrefparam, booltype) setFlag FINAL
-      Object_eq = newMethod(ObjectClass, nme.eq, anyrefparam, booltype) setFlag FINAL
-      Object_ne = newMethod(ObjectClass, nme.ne, anyrefparam, booltype) setFlag FINAL
+      Object_## = newMethod(ObjectClass, nme.HASHHASH, Nil, inttype, FINAL)
+      Object_== = newMethod(ObjectClass, nme.EQ, anyrefparam, booltype, FINAL)
+      Object_!= = newMethod(ObjectClass, nme.NE, anyrefparam, booltype, FINAL)
+      Object_eq = newMethod(ObjectClass, nme.eq, anyrefparam, booltype, FINAL)
+      Object_ne = newMethod(ObjectClass, nme.ne, anyrefparam, booltype, FINAL)
       Object_synchronized = newPolyMethodCon(
         ObjectClass, nme.synchronized_,
         tparam => msym => MethodType(msym.newSyntheticValueParams(List(tparam.typeConstructor)), tparam.typeConstructor)) setFlag FINAL
 
-      String_+ = newMethod(StringClass, nme.raw.PLUS, anyparam, stringtype) setFlag FINAL
+      String_+ = newMethod(StringClass, nme.raw.PLUS, anyparam, stringtype, FINAL)
 
       val forced = List( // force initialization of every symbol that is entered as a side effect
         AnnotationDefaultAttr, // #2264
@@ -1037,7 +1019,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
       // tparam => resultType, which is the resultType of PolyType, i.e. the result type after applying the
       // type parameter =-> a MethodType in this case
       // TODO: set type bounds manually (-> MulticastDelegate), see newTypeParam
-      val newCaller = newMethod(DelegateClass, name, paramTypes, delegateType) setFlag (FINAL | STATIC)
+      val newCaller = newMethod(DelegateClass, name, paramTypes, delegateType, FINAL | STATIC)
       // val newCaller = newPolyMethod(DelegateClass, name,
       // tparam => MethodType(paramTypes, tparam.typeConstructor)) setFlag (FINAL | STATIC)
       Delegate_scalaCallers = Delegate_scalaCallers ::: List(newCaller)
diff --git a/src/compiler/scala/reflect/internal/Importers.scala b/src/compiler/scala/reflect/internal/Importers.scala
index 38f808cef9..53380952c0 100644
--- a/src/compiler/scala/reflect/internal/Importers.scala
+++ b/src/compiler/scala/reflect/internal/Importers.scala
@@ -22,6 +22,7 @@ trait Importers { self: SymbolTable =>
         val myowner = importSymbol(sym.owner)
         val mypos   = importPosition(sym.pos)
         val myname  = importName(sym.name).toTermName
+        val myflags = sym.flags
         def linkReferenced(mysym: TermSymbol, x: from.TermSymbol, op: from.Symbol => Symbol): Symbol = {
           symMap(x) = mysym
           mysym.referenced = op(x.referenced)
@@ -29,19 +30,20 @@ trait Importers { self: SymbolTable =>
         }
         val mysym = sym match {
           case x: from.MethodSymbol =>
-            linkReferenced(new MethodSymbol(myowner, mypos, myname), x, importSymbol)
+            linkReferenced(myowner.newMethod(myname, mypos, myflags), x, importSymbol)
           case x: from.ModuleSymbol =>
-            linkReferenced(new ModuleSymbol(myowner, mypos, myname), x, doImport)
+            linkReferenced(myowner.newModuleSymbol(myname, mypos, myflags), x, doImport)
           case x: from.FreeVar =>
-            new FreeVar(importName(x.name).toTermName, importType(x.tpe), x.value)
+            newFreeVar(importName(x.name).toTermName, importType(x.tpe), x.value, myflags)
           case x: from.TermSymbol =>
-            linkReferenced(new TermSymbol(myowner, mypos, myname), x, importSymbol)
+            linkReferenced(myowner.newValue(myname, mypos, myflags), x, importSymbol)
           case x: from.TypeSkolem =>
-            new TypeSkolem(myowner, mypos, myname.toTypeName, x.unpackLocation match {
-              case null => null
-              case y: from.Tree => importTree(y)
+            val origin = x.unpackLocation match {
+              case null           => null
+              case y: from.Tree   => importTree(y)
               case y: from.Symbol => importSymbol(y)
-            })
+            }
+            myowner.newTypeSkolemSymbol(myname.toTypeName, origin, mypos, myflags)
           /*
               case x: from.ModuleClassSymbol =>
                 val mysym = new ModuleClassSymbol(myowner, mypos, myname.toTypeName)
@@ -49,17 +51,17 @@ trait Importers { self: SymbolTable =>
                 mysym
 */
           case x: from.ClassSymbol =>
-            val mysym = new ClassSymbol(myowner, mypos, myname.toTypeName)
+            val mysym = myowner.newClassSymbol(myname.toTypeName, mypos, myflags)
             if (sym.thisSym != sym) {
               mysym.typeOfThis = importType(sym.typeOfThis)
               mysym.thisSym.name = importName(sym.thisSym.name)
             }
             mysym
           case x: from.TypeSymbol =>
-            new TypeSymbol(myowner, mypos, myname.toTypeName)
+            myowner.newTypeSymbol(myname.toTypeName, mypos, myflags)
         }
         symMap(sym) = mysym
-        mysym setFlag sym.flags | Flags.LOCKED
+        mysym setFlag Flags.LOCKED
         mysym setInfo {
           val mytypeParams = sym.typeParams map doImport
           new LazyPolyType(mytypeParams) {
diff --git a/src/compiler/scala/reflect/internal/StdNames.scala b/src/compiler/scala/reflect/internal/StdNames.scala
index ea5565c581..2871ba59f6 100644
--- a/src/compiler/scala/reflect/internal/StdNames.scala
+++ b/src/compiler/scala/reflect/internal/StdNames.scala
@@ -230,6 +230,31 @@ trait StdNames extends NameManglers { self: SymbolTable =>
     val _20 : NameType = "_20"
     val _21 : NameType = "_21"
     val _22 : NameType = "_22"
+
+    val x_0 : NameType  = "x$0"
+    val x_1 : NameType  = "x$1"
+    val x_2 : NameType  = "x$2"
+    val x_3 : NameType  = "x$3"
+    val x_4 : NameType  = "x$4"
+    val x_5 : NameType  = "x$5"
+    val x_6 : NameType  = "x$6"
+    val x_7 : NameType  = "x$7"
+    val x_8 : NameType  = "x$8"
+    val x_9 : NameType  = "x$9"
+    
+    @switch def syntheticParamName(i: Int): TermName = i match {
+      case 0  => nme.x_0
+      case 1  => nme.x_1
+      case 2  => nme.x_2
+      case 3  => nme.x_3
+      case 4  => nme.x_4
+      case 5  => nme.x_5
+      case 6  => nme.x_6
+      case 7  => nme.x_7
+      case 8  => nme.x_8
+      case 9  => nme.x_9
+      case _  => newTermName("x$" + i)
+    }
     
     val wrapRefArray: NameType     = "wrapRefArray"
     val wrapByteArray: NameType    = "wrapByteArray"
diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala
index 6ee061392c..d969cb43bb 100644
--- a/src/compiler/scala/reflect/internal/Symbols.scala
+++ b/src/compiler/scala/reflect/internal/Symbols.scala
@@ -35,6 +35,13 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     nextexid += 1
     newTypeName("_" + nextexid + suffix)
   }
+  
+  // Set the fields which point companions at one another.  Returns the module.
+  def connectModuleToClass(m: ModuleSymbol, moduleClass: ClassSymbol): ModuleSymbol = {
+    moduleClass.sourceModule = m
+    m setModuleClass moduleClass
+    m
+  }
 
   /** The original owner of a class. Used by the backend to generate
    *  EnclosingMethod attributes.
@@ -43,8 +50,8 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
   abstract class AbsSymbolImpl extends AbsSymbol { this: Symbol =>
     def newNestedSymbol(pos: Position, name: Name) = name match {
-      case n: TermName => newValue(pos, n)
-      case n: TypeName => newAliasType(pos, n)
+      case n: TermName => newTermSymbol(n, pos)
+      case n: TypeName => newTypeSymbol(n, pos)
     }
     def typeSig: Type = info
     def typeSigIn(site: Type): Type = site.memberInfo(this)
@@ -89,64 +96,80 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
 // ------ creators -------------------------------------------------------------------
 
-    final def newValue(pos: Position, name: TermName) =
-      new TermSymbol(this, pos, name)
-    final def newValue(name: TermName, pos: Position = NoPosition) =
-      new TermSymbol(this, pos, name)
-    final def newVariable(pos: Position, name: TermName) =
-      newValue(pos, name).setFlag(MUTABLE)
-    final def newValueParameter(pos: Position, name: TermName) =
-      newValue(pos, name).setFlag(PARAM)
+    final def newValue(name: TermName, pos: Position = NoPosition, flags: Long = 0L): TermSymbol =
+      newTermSymbol(name, pos, flags)
+    final def newVariable(name: TermName, pos: Position = NoPosition, flags: Long = 0L): TermSymbol =
+      newTermSymbol(name, pos, MUTABLE | flags)
+    final def newValueParameter(name: TermName, pos: Position = NoPosition, flags: Long = 0L): TermSymbol =
+      newTermSymbol(name, pos, PARAM | flags)
+
     /** Create local dummy for template (owner of local blocks) */
     final def newLocalDummy(pos: Position) =
-      newValue(pos, nme.localDummyName(this)).setInfo(NoType)
-    final def newMethod(pos: Position, name: TermName) =
-      new MethodSymbol(this, pos, name).setFlag(METHOD)
-    final def newMethod(name: TermName, pos: Position = NoPosition) =
-      new MethodSymbol(this, pos, name).setFlag(METHOD)
-    final def newLabel(pos: Position, name: TermName) =
-      newMethod(pos, name).setFlag(LABEL)
+      newTermSymbol(nme.localDummyName(this), pos) setInfo NoType
+    final def newMethod(name: TermName, pos: Position = NoPosition, flags: Long = 0L): MethodSymbol =
+      newMethodSymbol(name, pos, METHOD | flags)
+    final def newLabel(name: TermName, pos: Position = NoPosition): MethodSymbol =
+      newMethod(name, pos, LABEL)
 
     /** Propagates ConstrFlags (JAVA, specifically) from owner to constructor. */
-    final def newConstructor(pos: Position) =
-      newMethod(pos, nme.CONSTRUCTOR) setFlag getFlag(ConstrFlags)
+    final def newConstructor(pos: Position, flags: Long = 0L) =
+      newMethod(nme.CONSTRUCTOR, pos, getFlag(ConstrFlags) | flags)
+
     /** Static constructor with info set. */
     def newStaticConstructor(pos: Position) =
-      newConstructor(pos) setFlag STATIC setInfo UnitClass.tpe
+      newConstructor(pos, STATIC) setInfo UnitClass.tpe
     /** Instance constructor with info set. */
     def newClassConstructor(pos: Position) =
       newConstructor(pos) setInfo MethodType(Nil, this.tpe)
 
-    private def finishModule(m: ModuleSymbol, clazz: ClassSymbol): ModuleSymbol = {
-      // Top-level objects can be automatically marked final, but others
-      // must be explicitly marked final if overridable objects are enabled.
-      val flags = if (isPackage || !settings.overrideObjects.value) MODULE | FINAL else MODULE
-      m setFlag flags
-      m setModuleClass clazz
-      m
+    // Top-level objects can be automatically marked final, but others
+    // must be explicitly marked final if overridable objects are enabled.
+    private def ModuleFlags = (
+      if (isPackage || !settings.overrideObjects.value) MODULE | FINAL
+      else MODULE
+    )
+    def newLinkedModule(clazz: Symbol, flags: Long = 0L): ModuleSymbol = {
+      val m = newModuleSymbol(clazz.name.toTermName, clazz.pos, ModuleFlags | flags)
+      connectModuleToClass(m, clazz.asInstanceOf[ClassSymbol])
+    }
+    final def newModule(name: TermName, pos: Position = NoPosition, flags: Long = 0L): ModuleSymbol = {
+      val m     = newModuleSymbol(name, pos, flags | ModuleFlags)
+      val clazz = newModuleClassSymbol(name.toTypeName, pos, (m getFlag ModuleToClassFlags) | MODULE)
+      connectModuleToClass(m, clazz)
     }
-    private def finishModule(m: ModuleSymbol): ModuleSymbol =
-      finishModule(m, new ModuleClassSymbol(m))
-
-    final def newModule(pos: Position, name: TermName, clazz: ClassSymbol): ModuleSymbol =
-      finishModule(new ModuleSymbol(this, pos, name), clazz)
-
-    final def newModule(name: TermName, clazz: Symbol, pos: Position = NoPosition): ModuleSymbol =
-      newModule(pos, name, clazz.asInstanceOf[ClassSymbol])
-
-    final def newModule(pos: Position, name: TermName): ModuleSymbol =
-      finishModule(new ModuleSymbol(this, pos, name))
 
-    final def newPackage(pos: Position, name: TermName): ModuleSymbol = {
-      assert(name == nme.ROOT || isPackageClass)
-      val m = newModule(pos, name).setFlag(JAVA | PACKAGE)
-      m.moduleClass setFlag (JAVA | PACKAGE)
-      m
+    final def newPackage(name: TermName, pos: Position = NoPosition, flags: Long = 0L): ModuleSymbol = {
+      assert(name == nme.ROOT || isPackageClass, this)
+      newModule(name, pos, JAVA | PACKAGE | flags)
     }
     final def newThisSym(pos: Position) =
-      newValue(pos, nme.this_).setFlag(SYNTHETIC)
+      newTermSymbol(nme.this_, pos, SYNTHETIC)
     final def newImport(pos: Position) =
-      newValue(pos, nme.IMPORT)
+      newTermSymbol(nme.IMPORT, pos)
+      
+    /** Direct symbol factories.
+     *  For internal use; these are unlikely to be what you want.
+     */
+    def newTermSymbol(name: TermName, pos: Position = NoPosition, flags: Long = 0L): TermSymbol =
+      new TermSymbol(this, pos, name) initFlags flags
+  
+    def newTypeSymbol(name: TypeName, pos: Position = NoPosition, flags: Long = 0L): TypeSymbol =
+      new TypeSymbol(this, pos, name) initFlags flags
+
+    def newModuleSymbol(name: TermName, pos: Position = NoPosition, flags: Long = 0L): ModuleSymbol =
+      new ModuleSymbol(this, pos, name) initFlags flags
+
+    def newMethodSymbol(name: TermName, pos: Position = NoPosition, flags: Long = 0L): MethodSymbol =
+      new MethodSymbol(this, pos, name) initFlags flags
+
+    def newClassSymbol(name: TypeName, pos: Position = NoPosition, flags: Long = 0L): ClassSymbol =
+      new ClassSymbol(this, pos, name) initFlags flags
+      
+    def newModuleClassSymbol(name: TypeName, pos: Position = NoPosition, flags: Long = 0L): ModuleClassSymbol =
+      new ModuleClassSymbol(this, pos, name) initFlags flags
+    
+    def newTypeSkolemSymbol(name: TypeName, origin: AnyRef, pos: Position = NoPosition, flags: Long = 0L): TypeSkolem =
+      new TypeSkolem(this, pos, name, origin) initFlags flags
 
     /** @param pre   type relative to which alternatives are seen.
      *  for instance:
@@ -166,55 +189,50 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
      *
      *    pre.memberType(m)
      */
-    final def newOverloaded(pre: Type, alternatives: List[Symbol]): Symbol =
-      newValue(alternatives.head.pos, alternatives.head.name.toTermName)
-      .setFlag(OVERLOADED)
-      .setInfo(OverloadedType(pre, alternatives))
+    final def newOverloaded(pre: Type, alternatives: List[Symbol]): Symbol = (
+      newTermSymbol(alternatives.head.name.toTermName, alternatives.head.pos, OVERLOADED)
+        setInfo OverloadedType(pre, alternatives)
+    )
 
     /** for explicit outer phase */
     final def newOuterAccessor(pos: Position) = {
-      val sym = newMethod(pos, nme.OUTER)
-      sym setFlag (STABLE | SYNTHETIC)
-      if (isTrait) sym setFlag DEFERRED
+      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) =
-      newValue(pos, name).setFlag(SYNTHETIC | IS_ERROR).setInfo(ErrorType)
+      newTermSymbol(name, pos, SYNTHETIC | IS_ERROR) setInfo ErrorType
 
     /** Symbol of a type definition  type T = ...
      */
-    final def newAliasType(pos: Position, name: TypeName) =
-      new TypeSymbol(this, pos, name)
-    final def newAliasType(name: TypeName, pos: Position = NoPosition) =
-      new TypeSymbol(this, pos, name)
-
+    final def newAliasType(name: TypeName, pos: Position = NoPosition, flags: Long = 0L): Symbol =
+      newTypeSymbol(name, pos, flags)
+      
     /** Symbol of an abstract type  type T >: ... <: ...
      */
-    final def newAbstractType(pos: Position, name: TypeName) =
-      new TypeSymbol(this, pos, name).setFlag(DEFERRED)
-    final def newAbstractType(name: TypeName, pos: Position = NoPosition) =
-      new TypeSymbol(this, pos, name).setFlag(DEFERRED)
+    final def newAbstractType(name: TypeName, pos: Position = NoPosition, flags: Long = 0L): Symbol =
+      newTypeSymbol(name, pos, DEFERRED | flags)
 
     /** Symbol of a type parameter
      */
-    final def newTypeParameter(pos: Position, name: TypeName) =
-      newAbstractType(pos, name).setFlag(PARAM)
+    final def newTypeParameter(name: TypeName, pos: Position = NoPosition, flags: Long = 0L) =
+      newAbstractType(name, pos, PARAM | flags)
 
     /** Synthetic value parameters when parameter symbols are not available
      */
     final def newSyntheticValueParamss(argtypess: List[List[Type]]): List[List[Symbol]] = {
       var cnt = 0
-      def freshName() = { cnt += 1; newTermName("x$" + cnt) }
-      def param(tp: Type) =
-        newValueParameter(focusPos(owner.pos), freshName()).setFlag(SYNTHETIC).setInfo(tp)
-      argtypess map (_.map(param))
+      def freshName() = { cnt += 1; nme.syntheticParamName(cnt) }
+      mmap(argtypess)(tp => newValueParameter(freshName(), focusPos(owner.pos), SYNTHETIC) setInfo tp)
     }
 
-    final def newExistential(pos: Position, name: TypeName): Symbol =
-      newAbstractType(pos, name).setFlag(EXISTENTIAL)
+    final def newExistential(name: TypeName, pos: Position = NoPosition, flags: Long = 0L): Symbol =
+      newAbstractType(name, pos, EXISTENTIAL | flags)
 
     final def freshExistential(suffix: String): Symbol =
       newExistential(pos, freshExistentialName(suffix))
@@ -237,45 +255,40 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
      *  body of the method, there's a local copy of `T` which is a TypeSkolem.
      */
     final def newTypeSkolem: Symbol =
-      new TypeSkolem(owner, pos, name.toTypeName, this)
-        .setFlag(flags)
+      owner.newTypeSkolemSymbol(name.toTypeName, this, pos, flags)
 
-    final def newClass(pos: Position, name: TypeName) =
-      new ClassSymbol(this, pos, name)
     final def newClass(name: TypeName, pos: Position = NoPosition) =
-      new ClassSymbol(this, pos, name)
+      newClassSymbol(name, pos)
 
-    final def newModuleClass(pos: Position, name: TypeName) =
-      new ModuleClassSymbol(this, pos, name)
     final def newModuleClass(name: TypeName, pos: Position = NoPosition) =
-      new ModuleClassSymbol(this, pos, name)
+      newModuleClassSymbol(name, pos)
 
     final def newAnonymousClass(pos: Position) =
-      newClass(pos, tpnme.ANON_CLASS_NAME)
-    final def newAnonymousFunctionClass(pos: Position) =
-      newClass(pos, tpnme.ANON_FUN_NAME)
+      newClassSymbol(tpnme.ANON_CLASS_NAME, pos)
+
+    final def newAnonymousFunctionClass(pos: Position, flags: Long = 0L) =
+      newClassSymbol(tpnme.ANON_FUN_NAME, pos, FINAL | SYNTHETIC | flags)
+
+    final def newAnonymousFunctionValue(pos: Position, flags: Long = 0L) =
+      newTermSymbol(nme.ANON_FUN_NAME, pos, SYNTHETIC | flags) setInfo NoType
 
     /** Refinement types P { val x: String; type T <: Number }
      *  also have symbols, they are refinementClasses
      */
     final def newRefinementClass(pos: Position) =
-      newClass(pos, tpnme.REFINE_CLASS_NAME)
+      newClass(tpnme.REFINE_CLASS_NAME, pos)
 
     /** Create a new getter for current symbol (which must be a field)
      */
     final def newGetter: Symbol = (
-      owner.newMethod(focusPos(pos), nme.getterName(name.toTermName))
-        setFlag getterFlags(flags)
+      owner.newMethod(nme.getterName(name.toTermName), flags = getterFlags(flags))
         setPrivateWithin privateWithin
         setInfo MethodType(Nil, tpe)
     )
 
     final def newErrorClass(name: TypeName) = {
-      val clazz = newClass(pos, name)
-      ( clazz
-          setFlag (SYNTHETIC | IS_ERROR)
-          setInfo ClassInfoType(Nil, new ErrorScope(this), clazz)
-      )
+      val clazz = newClassSymbol(name, pos, SYNTHETIC | IS_ERROR)
+      clazz setInfo ClassInfoType(Nil, new ErrorScope(this), clazz)
     }
 
     final def newErrorSymbol(name: Name): Symbol = name match {
@@ -283,6 +296,23 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       case x: TermName  => newErrorValue(x)
     }
 
+    @deprecated("Use the other signature", "2.10.0")
+    def newClass(pos: Position, name: TypeName): Symbol        = newClass(name, pos)
+    @deprecated("Use the other signature", "2.10.0")
+    def newModuleClass(pos: Position, name: TypeName): Symbol  = newModuleClass(name, pos)
+    @deprecated("Use the other signature", "2.10.0")
+    def newLabel(pos: Position, name: TermName): MethodSymbol  = newLabel(name, pos)
+    @deprecated("Use the other signature", "2.10.0")
+    def newValue(pos: Position, name: TermName): TermSymbol    = newTermSymbol(name, pos)
+    @deprecated("Use the other signature", "2.10.0")
+    def newAliasType(pos: Position, name: TypeName): Symbol    = newAliasType(name, pos)
+    @deprecated("Use the other signature", "2.10.0")
+    def newAbstractType(pos: Position, name: TypeName): Symbol = newAbstractType(name, pos)
+    @deprecated("Use the other signature", "2.10.0")  
+    def newExistential(pos: Position, name: TypeName): Symbol  = newExistential(name, pos)
+    @deprecated("Use the other signature", "2.10.0")  
+    def newMethod(pos: Position, name: TermName): MethodSymbol = newMethod(name, pos)
+
 // ----- locking and unlocking ------------------------------------------------------
 
     // True if the symbol is unlocked.
@@ -808,8 +838,17 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       (fs | ((fs & LateFlags) >>> LateShift)) & ~(fs >>> AntiShift)
     }
     final def flags_=(fs: Long) = rawflags = fs
-    final def setFlag(mask: Long): this.type = { rawflags = rawflags | mask; this }
-    final def resetFlag(mask: Long): this.type = { rawflags = rawflags & ~mask; this }
+
+    /** Set the symbol's flags to the given value, asserting
+     *  that the previous value was 0.
+     */
+    def initFlags(mask: Long): this.type = {
+      assert(rawflags == 0L, this)
+      rawflags = mask
+      this
+    }
+    def setFlag(mask: Long): this.type = { rawflags = rawflags | mask ; this }
+    def resetFlag(mask: Long): this.type = { rawflags = rawflags & ~mask ; this }
     final def getFlag(mask: Long): Long = flags & mask
     final def resetFlags() { rawflags = rawflags & TopLevelCreationFlags }
 
@@ -1149,7 +1188,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       else if (this.isTerm)
         singletonBounds(this.tpe)
       else
-        abort("unexpected alias type: "+this)
+        abort("unexpected alias type: "+this.ownerChain+ " " + hasFlagsToString(-1L))
 
     /** Reset symbol to initial state
      */
@@ -1285,9 +1324,9 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     final def cloneSymbol(owner: Symbol): Symbol = {
       val newSym = cloneSymbolImpl(owner)
       ( newSym
+          initFlags this.rawflags
           setPrivateWithin privateWithin
           setInfo (info cloneInfo newSym)
-          setFlag this.rawflags
           setAnnotations this.annotations
       )
     }
@@ -1999,7 +2038,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     var referenced: Symbol = NoSymbol
 
     def cloneSymbolImpl(owner: Symbol): Symbol =
-      new TermSymbol(owner, pos, name).copyAttrsFrom(this)
+      owner.newTermSymbol(name, pos).copyAttrsFrom(this)
 
     def copyAttrsFrom(original: TermSymbol): this.type = {
       referenced = original.referenced
@@ -2029,13 +2068,13 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       if (hasFlag(MODULE)) referenced else NoSymbol
 
     def setModuleClass(clazz: Symbol): TermSymbol = {
-      assert(hasFlag(MODULE))
+      assert(hasFlag(MODULE), this)
       referenced = clazz
       this
     }
 
     def setLazyAccessor(sym: Symbol): TermSymbol = {
-      assert(isLazy && (referenced == NoSymbol || referenced == sym), this)
+      assert(isLazy && (referenced == NoSymbol || referenced == sym), (this, hasFlagsToString(-1L), referenced, sym))
       referenced = sym
       this
     }
@@ -2096,7 +2135,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     )
 
     override def cloneSymbolImpl(owner: Symbol): Symbol =
-      new ModuleSymbol(owner, pos, name).copyAttrsFrom(this)
+      owner.newModuleSymbol(name, pos).copyAttrsFrom(this)
   }
 
   /** A class for method symbols */
@@ -2108,7 +2147,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     private var mtpeInfo: Type = _
 
     override def cloneSymbolImpl(owner: Symbol): Symbol =
-      new MethodSymbol(owner, pos, name).copyAttrsFrom(this)
+      owner.newMethodSymbol(name, pos).copyAttrsFrom(this)
 
     def typeAsMemberOf(pre: Type): Type = {
       if (mtpePeriod == currentPeriod) {
@@ -2198,9 +2237,6 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
      */
     override def tpeHK = typeConstructor // @M! used in memberType
 
-    // needed for experimental code for early types as type parameters
-    // def refreshType() { tpePeriod = NoPeriod }
-
     override def typeConstructor: Type = {
       if ((tyconCache eq null) || tyconRunId != currentRunId) {
         tyconCache = newTypeRef(Nil)
@@ -2242,8 +2278,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       }
     }
 
-    def cloneSymbolImpl(owner: Symbol): Symbol =
-      new TypeSymbol(owner, pos, name)
+    def cloneSymbolImpl(owner: Symbol): Symbol = owner.newTypeSymbol(name, pos)
 
     incCounter(typeSymbolCount)
   }
@@ -2282,7 +2317,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     override def typeParams = info.typeParams
 
     override def cloneSymbolImpl(owner: Symbol): Symbol =
-      new TypeSkolem(owner, pos, name, origin)
+      owner.newTypeSkolemSymbol(name, origin, pos)
 
     override def nameString: String =
       if (settings.debug.value) (super.nameString + "&" + level)
@@ -2363,7 +2398,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     }
 
     override def cloneSymbolImpl(owner: Symbol): Symbol = {
-      val clone = new ClassSymbol(owner, pos, name)
+      val clone = owner.newClassSymbol(name, pos)
       if (thisSym != this) {
         clone.typeOfThis = typeOfThis
         clone.thisSym.name = thisSym.name
@@ -2388,15 +2423,10 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
   class ModuleClassSymbol(owner: Symbol, pos: Position, name: TypeName)
   extends ClassSymbol(owner, pos, name) {
     private var module: Symbol = null
-    def this(module: TermSymbol) = {
-      this(module.owner, module.pos, module.name.toTypeName)
-      setFlag(module.getFlag(ModuleToClassFlags) | MODULE)
-      sourceModule = module
-    }
-    override def sourceModule = module
     private var implicitMembersCacheValue: List[Symbol] = List()
     private var implicitMembersCacheKey1: Type = NoType
     private var implicitMembersCacheKey2: ScopeEntry = null
+
     def implicitMembers: List[Symbol] = {
       val tp = info
       if ((implicitMembersCacheKey1 ne tp) || (implicitMembersCacheKey2 ne tp.decls.elems)) {
@@ -2406,8 +2436,12 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       }
       implicitMembersCacheValue
     }
+    override def sourceModule = module
     override def sourceModule_=(module: Symbol) { this.module = module }
   }
+  
+  def newFreeVar(name0: TermName, tpe: Type, value: Any, flags: Long = 0L) =
+    new FreeVar(name0, tpe, value) initFlags flags
 
   class FreeVar(name0: TermName, tpe: Type, val value: Any) extends TermSymbol(definitions.RootClass, NoPosition, name0) {
     setInfo(tpe)
@@ -2521,12 +2555,8 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
   /** Create a new existential type skolem with the given owner and origin.
    */
   def newExistentialSkolem(sym: Symbol, owner: Symbol, origin: AnyRef): TypeSkolem = {
-    val skolem = new TypeSkolem(owner, sym.pos, sym.name.toTypeName, origin)
-    ( skolem
-        setInfo (sym.info cloneInfo skolem)
-        setFlag (sym.flags | EXISTENTIAL)
-        resetFlag PARAM
-    )
+    val skolem = owner.newTypeSkolemSymbol(sym.name.toTypeName, origin, sym.pos, (sym.flags | EXISTENTIAL) & ~PARAM)
+    skolem setInfo (sym.info cloneInfo skolem)
   }
 
   /** An exception for cyclic references of symbol definitions */
diff --git a/src/compiler/scala/reflect/internal/Trees.scala b/src/compiler/scala/reflect/internal/Trees.scala
index 96f2c5cc45..1cefc07c3d 100644
--- a/src/compiler/scala/reflect/internal/Trees.scala
+++ b/src/compiler/scala/reflect/internal/Trees.scala
@@ -198,9 +198,8 @@ trait Trees extends api.Trees { self: SymbolTable =>
   def DefDef(sym: Symbol, rhs: Tree): DefDef =
     DefDef(sym, Modifiers(sym.flags), rhs)
 
-  def DefDef(sym: Symbol, rhs: List[List[Symbol]] => Tree): DefDef = {
+  def DefDef(sym: Symbol, rhs: List[List[Symbol]] => Tree): DefDef =
     DefDef(sym, rhs(sym.info.paramss))
-  }
 
   /** A TypeDef node which defines given `sym` with given tight hand side `rhs`. */
   def TypeDef(sym: Symbol, rhs: Tree): TypeDef =
diff --git a/src/compiler/scala/reflect/internal/Types.scala b/src/compiler/scala/reflect/internal/Types.scala
index 4630733db4..43905ee344 100644
--- a/src/compiler/scala/reflect/internal/Types.scala
+++ b/src/compiler/scala/reflect/internal/Types.scala
@@ -322,13 +322,20 @@ trait Types extends api.Types { self: SymbolTable =>
 
     /** The type symbol associated with the type
       * Note that the symbol of the normalized type is returned (@see normalize)
+      * A type's typeSymbol should if possible not be inspected directly, due to
+      * the likelihood that what is true for tp.typeSymbol is not true for
+      * tp.sym, due to normalization.
       */
     def typeSymbol: Symbol = NoSymbol
 
-    /** The term symbol ''directly'' associated with the type. */
+    /** The term symbol ''directly'' associated with the type.
+     */
     def termSymbolDirect: Symbol = termSymbol
 
-    /** The type symbol ''directly'' associated with the type. */
+    /** The type symbol ''directly'' associated with the type.
+     *  In other words, no normalization is performed: if this is an alias type,
+     *  the symbol returned is that of the alias, not the underlying type.
+     */
     def typeSymbolDirect: Symbol = typeSymbol
 
     /** The base type underlying a type proxy, identity on all other types */
@@ -412,6 +419,11 @@ trait Types extends api.Types { self: SymbolTable =>
 
     /** For a typeref, its arguments. The empty list for all other types */
     def typeArgs: List[Type] = List()
+    
+    /** A list of placeholder types derived from the type parameters.
+     *  Used by RefinedType and TypeRef.
+     */
+    protected def dummyArgs: List[Type] = typeParams map (_.typeConstructor)
 
     /** For a (nullary) method or poly type, its direct result type,
      *  the type itself for all other types. */
@@ -1504,8 +1516,6 @@ trait Types extends api.Types { self: SymbolTable =>
     override def typeConstructor =
       copyRefinedType(this, parents map (_.typeConstructor), decls)
 
-    private def dummyArgs = typeParams map (_.typeConstructor)
-
     /* MO to AM: This is probably not correct
      * If they are several higher-kinded parents with different bounds we need
      * to take the intersection of their bounds
@@ -1650,11 +1660,12 @@ trait Types extends api.Types { self: SymbolTable =>
 
       def apply(tp: Type): Type = {
         tp match {
-          case TypeRef(_, sym, args) if args.nonEmpty =>
-            if (settings.debug.value && !sameLength(sym.info.typeParams, args))
+          case tr @ TypeRef(_, sym, args) if args.nonEmpty =>
+            val tparams = tr.initializedTypeParams
+            if (settings.debug.value && !sameLength(tparams, args))
               debugwarn("Mismatched zip in computeRefs(): " + sym.info.typeParams + ", " + args)
 
-            foreach2(sym.info.typeParams, args) { (tparam1, arg) =>
+            foreach2(tparams, args) { (tparam1, arg) =>
               if (arg contains tparam) {
                 addRef(NonExpansive, tparam, tparam1)
                 if (arg.typeSymbol != tparam)
@@ -1759,253 +1770,289 @@ trait Types extends api.Types { self: SymbolTable =>
 
   private var volatileRecursions: Int = 0
   private val pendingVolatiles = new mutable.HashSet[Symbol]
+  
+  class ArgsTypeRef(pre0: Type, sym0: Symbol, args0: List[Type]) extends TypeRef(pre0, sym0, args0) with UniqueType {
+    require(args0.nonEmpty, this)
 
-  /** A class for named types of the form
-   *  `<prefix>.<sym.name>[args]`
-   *  Cannot be created directly; one should always use `typeRef`
-   *  for creation. (@M: Otherwise hashing breaks)
-   *
-   * @M: a higher-kinded type is represented as a TypeRef with sym.info.typeParams.nonEmpty, but args.isEmpty
-   *  @param pre  ...
-   *  @param sym  ...
-   *  @param args ...
-   */
-  abstract case class TypeRef(pre: Type, sym: Symbol, args: List[Type]) extends Type {
-//    assert(!sym.isAbstractType || pre.isStable || pre.isError)
-//    assert(!pre.isInstanceOf[ClassInfoType], this)
-//    assert(!(sym hasFlag (PARAM | EXISTENTIAL)) || pre == NoPrefix, this)
-//    assert(args.isEmpty || !sym.info.typeParams.isEmpty, this)
-//    assert(args.isEmpty || ((sym ne AnyClass) && (sym ne NothingClass))
-
-    private var parentsCache: List[Type] = _
-    private var parentsPeriod = NoPeriod
-
-    private var baseTypeSeqCache: BaseTypeSeq = _
-    private var baseTypeSeqPeriod = NoPeriod
-
-    private var symInfoCache: Type = _
-    private var memberInfoCache: Type = _
-    private var thisInfoCache: Type = _
-    private var relativeInfoCache: Type = _
-
-    private var normalized: Type = null
-
-    override def isStable: Boolean = {
-      sym == NothingClass ||
-      sym == SingletonClass ||
-      sym.isAliasType && normalize.isStable ||
-      sym.isAbstractType && (bounds.hi.typeSymbol isSubClass SingletonClass)
-    }
-
-    override def isVolatile: Boolean = {
-      sym.isAliasType && normalize.isVolatile ||
-      sym.isAbstractType && {
-        // need to be careful not to fall into an infinite recursion here
-        // because volatile checking is done before all cycles are detected.
-        // the case to avoid is an abstract type directly or
-        // indirectly upper-bounded by itself. See #2918
-        try {
-          volatileRecursions += 1
-          if (volatileRecursions < LogVolatileThreshold)
-            bounds.hi.isVolatile
-          else if (pendingVolatiles(sym))
-            true // we can return true here, because a cycle will be detected
-                 // here afterwards and an error will result anyway.
-          else
-            try {
-              pendingVolatiles += sym
-              bounds.hi.isVolatile
-            } finally {
-              pendingVolatiles -= sym
-            }
-        } finally {
-          volatileRecursions -= 1
-        }
-      }
-    }
-
-    override lazy val isTrivial: Boolean =
-      !sym.isTypeParameter && pre.isTrivial && args.forall(_.isTrivial)
+    /** No unapplied type params size it has (should have) equally as many args. */
+    override def isHigherKinded = false
+    override def typeParams = Nil
 
-    override def isNotNull =
-      sym.isModuleClass || sym == NothingClass || isValueClass(sym) || super.isNotNull
+    override def transform(tp: Type): Type = {
+      // This situation arises when a typevar is encountered for which
+      // too little information is known to determine its kind, and
+      // it later turns out not to have kind *. See SI-4070.  Only
+      // logging it for now.
+      if (sym.typeParams.size != args.size)
+        log("!!! %s.transform(%s), but tparams.isEmpty and args=".format(this, tp, args))
 
-    // @M: propagate actual type params (args) to `tp`, by replacing formal type parameters with actual ones
-    // if tp is higher kinded, the "actual" type arguments are types that simply reference the corresponding type parameters  (unbound type variables)
-    def transform(tp: Type): Type = {
-      val res = tp.asSeenFrom(pre, sym.owner)
-      if (sym.typeParams.isEmpty || (args exists (_.isError)) || isRaw(sym, args)/*#2266/2305*/) res
-      else res.instantiateTypeParams(sym.typeParams, typeArgsOrDummies)
+      asSeenFromOwner(tp).instantiateTypeParams(sym.typeParams, args)
     }
-
-    //@M! use appliedType on the polytype that represents the bounds (or if aliastype, the rhs)
-    def transformInfo(tp: Type): Type = appliedType(tp.asSeenFrom(pre, sym.owner), typeArgsOrDummies)
-
-    def thisInfo: Type =
-      if (sym.isAliasType) normalize
-      else if (!sym.isNonClassType) sym.info
-      else {
-        val symInfo = sym.info
-        if (thisInfoCache == null || (symInfo ne symInfoCache)) {
-          symInfoCache = symInfo
-          thisInfoCache = transformInfo(symInfo) match {
-            // If a subtyping cycle is not detected here, we'll likely enter an infinite
-            // loop before a sensible error can be issued.  SI-5093 is one example.
-            case x: SubType if x.supertype eq this =>
-              throw new TypeError("illegal cyclic reference involving " + sym)
-            case tp => tp
-          }
-        }
-        thisInfoCache
-      }
-
-    def relativeInfo: Type =
-      if (!sym.isNonClassType) pre.memberInfo(sym)
-      else {
-        val memberInfo = pre.memberInfo(sym)
-        if (relativeInfoCache == null || (memberInfo ne memberInfoCache)) {
-          memberInfoCache = memberInfo
-          relativeInfoCache = transformInfo(memberInfo)
-        }
-        relativeInfoCache
+    
+    // note: does not go through typeRef. There's no need to because
+    // neither `pre` nor `sym` changes.  And there's a performance
+    // advantage to call TypeRef directly.
+    override def typeConstructor = TypeRef(pre, sym, Nil)
+  }
+  class NoArgsTypeRef(pre0: Type, sym0: Symbol) extends TypeRef(pre0, sym0, Nil) with UniqueType {
+    // A reference (in a Scala program) to a type that has type parameters, but where the reference
+    // does not include type arguments. Note that it doesn't matter whether the symbol refers
+    // to a java or scala symbol, but it does matter whether it occurs in java or scala code.
+    // TypeRefs w/o type params that occur in java signatures/code are considered raw types, and are
+    // represented as existential types.
+    override def isHigherKinded = typeParams.nonEmpty
+    override def typeParams     = if (isDefinitionsInitialized) sym.typeParams else sym.unsafeTypeParams
+    private def isRaw           = !phase.erasedTypes && isRawIfWithoutArgs(sym)
+    
+    override def instantiateTypeParams(formals: List[Symbol], actuals: List[Type]): Type =
+      if (isHigherKinded) {
+        if (sameLength(formals intersect typeParams, typeParams))
+          copyTypeRef(this, pre, sym, actuals)
+        // partial application (needed in infer when bunching type arguments from classes and methods together)
+        else
+          copyTypeRef(this, pre, sym, dummyArgs).instantiateTypeParams(formals, actuals)
       }
+      else
+        super.instantiateTypeParams(formals, actuals)
 
-    override def typeSymbol = if (sym.isAliasType && (this ne normalize)) normalize.typeSymbol else sym
-    override def termSymbol = if (sym.isAliasType && (this ne normalize)) normalize.termSymbol else super.termSymbol
-    override def typeSymbolDirect = sym
-    override def termSymbolDirect = super.termSymbol
-
-/* @MAT
-whenever you see `tp.typeSymbol.isXXXX` and then act on tp based on that predicate, you're on thin ice,
-as `typeSymbol` (and `prefix`) automatically normalize, but the other inspectors don't.
-In other words, even if `tp.normalize.sym.isXXX` is true, `tp.sym.isXXX` may be false (if sym were a public method to access the non-normalized typeSymbol)...
-
-In retrospect, I think `tp.typeSymbol.isXXX` or (worse) `tp.typeSymbol==XXX` should be replaced by `val tp = tp0.asXXX`.
-A type's typeSymbol should never be inspected directly.
-*/
-
-    override def bounds: TypeBounds =
-      if (sym.isAbstractType) thisInfo.bounds // transform(thisInfo.bounds).asInstanceOf[TypeBounds] // ??? seems to be doing asSeenFrom twice
-      else super.bounds
-
-    override def parents: List[Type] = {
-      val period = parentsPeriod
-      if (period != currentPeriod) {
-        parentsPeriod = currentPeriod
-        if (!isValidForBaseClasses(period)) {
-          parentsCache = thisInfo.parents map transform
-        } else if (parentsCache == null) { // seems this can happen if things are currupted enough, see #2641
-          parentsCache = List(AnyClass.tpe)
-        }
-      }
-      parentsCache
+    override def transform(tp: Type): Type = {
+      val res = asSeenFromOwner(tp)
+      if (isHigherKinded && !isRaw)
+        res.instantiateTypeParams(typeParams, dummyArgs)
+      else
+        res
     }
-    override def typeOfThis = transform(sym.typeOfThis)
 
-/*
-    override def narrow =
-      if (sym.isModuleClass) transform(sym.thisType)
-      else if (sym.isAliasType) normalize.narrow
-      else super.narrow
-*/
+    override def transformInfo(tp: Type): Type = 
+      appliedType(asSeenFromOwner(tp), dummyArgs)
+      
     override def narrow =
       if (sym.isModuleClass) singleType(pre, sym.sourceModule)
-      else if (sym.isAliasType) normalize.narrow
       else super.narrow
 
-    override def prefix: Type =
-      if (sym.isAliasType) normalize.prefix
-      else pre
-
-    override def typeArgs: List[Type] = args
-    private def typeArgsOrDummies = if (!isHigherKinded) args else dummyArgs
-    // def hasFishyArgs = args == dummyArgs
-    private def argsMatchTypeParams = sameLength(sym.info.typeParams, args)
+    override def typeConstructor = this
+    // eta-expand, subtyping relies on eta-expansion of higher-kinded types
+    // override protected def normalizeImpl: Type = 
+    //   if (isHigherKinded) etaExpand else super.normalizeImpl
+  }
+  
+  trait ClassTypeRef extends TypeRef {
+    // !!! There are scaladoc-created symbols arriving which violate this require.
+    // require(sym.isClass, sym)
 
-    // @MAT was typeSymbol.unsafeTypeParams, but typeSymbol normalizes now
-    private def typeParamsDirect =
-      if (isDefinitionsInitialized) sym.typeParams
-      else sym.unsafeTypeParams
+    override def baseType(clazz: Symbol): Type =
+      if (sym == clazz) this
+      else transform(sym.info.baseType(clazz))
+  }
+  trait NonClassTypeRef extends TypeRef {
+    require(sym.isNonClassType, sym)
 
-    // placeholders derived from type params
-    private def dummyArgs = {
-      // @PP to @AM: this appears to me a place where
-      // higher-order tparams are going off the beam.
-      // if (sym.isAbstractType) { something goes wrong }
+    private var relativeInfoCache: Type = _
+    private var memberInfoCache: Type = _
 
-      //@M must be .typeConstructor
-      typeParamsDirect map (_.typeConstructor)
+    private def relativeInfo = {
+      val memberInfo = pre.memberInfo(sym)
+      if (relativeInfoCache == null || (memberInfo ne memberInfoCache)) {
+        memberInfoCache = memberInfo
+        relativeInfoCache = transformInfo(memberInfo)
+      }
+      relativeInfoCache
     }
+    
+    override def baseType(clazz: Symbol): Type = (
+      if (sym == clazz) this else try {
+        basetypeRecursions += 1
+        if (basetypeRecursions < LogPendingBaseTypesThreshold)
+          relativeInfo.baseType(clazz)
+        else if (pendingBaseTypes contains this)
+          if (clazz == AnyClass) clazz.tpe else NoType
+        else
+          try {
+            pendingBaseTypes += this
+            relativeInfo.baseType(clazz)
+          } finally {
+            pendingBaseTypes -= this
+          }
+      } finally {
+        basetypeRecursions -= 1
+      }
+    )
+  }
+  trait AliasTypeRef extends NonClassTypeRef {
+    require(sym.isAliasType, sym)
 
-    // (!result.isEmpty) IFF isHigherKinded
-    override def typeParams: List[Symbol] = if (isHigherKinded) typeParamsDirect else List()
-
-    // note: does not go through typeRef. There's no need to because
-    // neither `pre` nor `sym` changes.  And there's a performance
-    // advantage to call TypeRef directly.
-    override def typeConstructor = if (args.isEmpty) this else TypeRef(pre, sym, Nil)
+    override def dealias    = if (typeParamsMatchArgs) betaReduce.dealias else super.dealias
+    override def isStable   = normalize.isStable
+    override def isVolatile = normalize.isVolatile
+    override def narrow     = normalize.narrow
+    override def thisInfo   = normalize
+    // override def prefix     = normalize.prefix
+    // override def termSymbol = if (this ne normalize) normalize.termSymbol else super.termSymbol
+    // override def typeSymbol = if (this ne normalize) normalize.typeSymbol else sym
+    // beta-reduce, but don't do partial application -- cycles have been checked in typeRef
+    // override protected zzImpl = 
+    //   if (typeParamsMatchArgs) betaReduce.normalize else ErrorType
+  }
 
-    // A reference (in a Scala program) to a type that has type
-    // parameters, but where the reference does not include type
-    // arguments. Note that it doesn't matter whether the symbol refers
-    // to a java or scala symbol, but it does matter whether it occurs in
-    // java or scala code. TypeRefs w/o type params that occur in java
-    // signatures/code are considered raw types, and are represented as
-    // existential types.
-    override def isHigherKinded = args.isEmpty && typeParamsDirect.nonEmpty
+  trait AbstractTypeRef extends NonClassTypeRef {
+    require(sym.isAbstractType, sym)
+    
+    private var symInfoCache: Type = _
+    private var thisInfoCache: Type = _
 
-    override def instantiateTypeParams(formals: List[Symbol], actuals: List[Type]): Type =
-      if (isHigherKinded) {
-        if (sameLength(formals intersect typeParams, typeParams))
-          copyTypeRef(this, pre, sym, actuals)
-        // partial application (needed in infer when bunching type arguments from classes and methods together)
+    override def isVolatile = {
+      // need to be careful not to fall into an infinite recursion here
+      // because volatile checking is done before all cycles are detected.
+      // the case to avoid is an abstract type directly or
+      // indirectly upper-bounded by itself. See #2918
+      try {
+        volatileRecursions += 1
+        if (volatileRecursions < LogVolatileThreshold)
+          bounds.hi.isVolatile
+        else if (pendingVolatiles(sym))
+          true // we can return true here, because a cycle will be detected
+               // here afterwards and an error will result anyway.
         else
-          copyTypeRef(this, pre, sym, dummyArgs).instantiateTypeParams(formals, actuals)
+          try {
+            pendingVolatiles += sym
+            bounds.hi.isVolatile
+          } finally {
+            pendingVolatiles -= sym
+          }
+      } finally {
+        volatileRecursions -= 1
       }
-      else
-        super.instantiateTypeParams(formals, actuals)
-
-    /** @pre: argsMatchTypeParams */
-    @inline private def betaReduce: Type = {
-      // isHKSubType0 introduces synthetic type params so that
-      // betaReduce can first apply sym.info to typeArgs before calling
-      // asSeenFrom.  asSeenFrom then skips synthetic type params, which
-      // are used to reduce HO subtyping to first-order subtyping, but
-      // which can't be instantiated from the given prefix and class.
-      transform(sym.info.resultType)
-      // this crashes pos/depmet_implicit_tpbetareduce.scala
-      // appliedType(sym.info, typeArgs).asSeenFrom(pre, sym.owner)
-    }
-    private def isBetaReducible = sym.isAliasType && argsMatchTypeParams
-
-    // @M: initialize (by sym.info call) needed (see test/files/pos/ticket0137.scala)
-    @inline private def etaExpand: Type = {
-      val tpars = sym.info.typeParams // must go through sym.info for typeParams to initialise symbol
-      if (tpars.isEmpty) this
-      else typeFunAnon(tpars, copyTypeRef(this, pre, sym, tpars map (_.tpeHK))) // todo: also beta-reduce?
     }
+    override def thisInfo   = {
+      val symInfo = sym.info
+      if (thisInfoCache == null || (symInfo ne symInfoCache)) {
+        symInfoCache = symInfo
+        thisInfoCache = transformInfo(symInfo) match {
+          // If a subtyping cycle is not detected here, we'll likely enter an infinite
+          // loop before a sensible error can be issued.  SI-5093 is one example.
+          case x: SubType if x.supertype eq this =>
+            throw new TypeError("illegal cyclic reference involving " + sym)
+          case tp => tp
+        }
+      }
+      thisInfoCache
+    }
+    override def isStable = bounds.hi.typeSymbol isSubClass SingletonClass
+    override def bounds   = if (sym.isAbstractType) thisInfo.bounds else super.bounds
+    // def transformInfo(tp: Type): Type = appliedType(tp.asSeenFrom(pre, sym.owner), typeArgsOrDummies)
+    override protected def baseTypeSeqImpl: BaseTypeSeq = transform(bounds.hi).baseTypeSeq prepend this
+  }
+
+  /** A class for named types of the form
+   *    `<prefix>.<sym.name>[args]`
+   *  Cannot be created directly; one should always use `typeRef`
+   *  for creation. (@M: Otherwise hashing breaks)
+   *
+   * @M: a higher-kinded type is represented as a TypeRef with sym.typeParams.nonEmpty, but args.isEmpty
+   */
+  abstract case class TypeRef(pre: Type, sym: Symbol, args: List[Type]) extends Type {
+    private var parentsCache: List[Type]      = _
+    private var parentsPeriod                 = NoPeriod
+    private var baseTypeSeqCache: BaseTypeSeq = _
+    private var baseTypeSeqPeriod             = NoPeriod
+    private var normalized: Type              = _
 
-    override def dealias = if (isBetaReducible) betaReduce.dealias else this
+    // @M: propagate actual type params (args) to `tp`, by replacing
+    // formal type parameters with actual ones. If tp is higher kinded,
+    // the "actual" type arguments are types that simply reference the
+    // corresponding type parameters (unbound type variables)
+    def transform(tp: Type): Type
 
     private def normalize0: Type = (
       if (pre eq WildcardType) WildcardType // arises when argument-dependent types are approximated (see def depoly in implicits)
       else if (isHigherKinded) etaExpand   // eta-expand, subtyping relies on eta-expansion of higher-kinded types
-      else if (isBetaReducible) betaReduce.normalize // beta-reduce, but don't do partial application -- cycles have been checked in typeRef
+      else if (sym.isAliasType && typeParamsMatchArgs) betaReduce.normalize // beta-reduce, but don't do partial application -- cycles have been checked in typeRef
       else if (sym.isRefinementClass) sym.info.normalize // I think this is okay, but see #1241 (r12414), #2208, and typedTypeConstructor in Typers
       else if (sym.isAliasType) ErrorType //println("!!error: "+(pre, sym, sym.info, sym.info.typeParams, args))
       else super.normalize
     )
 
-   // TODO: test case that is compiled  in a specific order and in different runs
+    // TODO: test case that is compiled  in a specific order and in different runs
     override def normalize: Type = {
       if (phase.erasedTypes) normalize0
       else {
-        if (normalized == null)
+        if (normalized eq null)
           normalized = normalize0
-
         normalized
       }
     }
+    // isHKSubType0 introduces synthetic type params so that
+    // betaReduce can first apply sym.info to typeArgs before calling
+    // asSeenFrom.  asSeenFrom then skips synthetic type params, which
+    // are used to reduce HO subtyping to first-order subtyping, but
+    // which can't be instantiated from the given prefix and class.
+    //
+    // this crashes pos/depmet_implicit_tpbetareduce.scala
+    // appliedType(sym.info, typeArgs).asSeenFrom(pre, sym.owner)
+    def betaReduce = transform(sym.info.resultType)
+    
+    def etaExpand: Type = {
+      // must initialise symbol, see test/files/pos/ticket0137.scala
+      val tpars = initializedTypeParams
+      if (tpars.isEmpty) this
+      else typeFunAnon(tpars, copyTypeRef(this, pre, sym, tpars map (_.tpeHK))) // todo: also beta-reduce?
+    }
+
+    // #3731: return sym1 for which holds: pre bound sym.name to sym and
+    // pre1 now binds sym.name to sym1, conceptually exactly the same
+    // symbol as sym.  The selection of sym on pre must be updated to the
+    // selection of sym1 on pre1, since sym's info was probably updated
+    // by the TypeMap to yield a new symbol, sym1 with transformed info.
+    // @returns sym1
+    //
+    // only need to rebind type aliases, as typeRef already handles abstract types
+    // (they are allowed to be rebound more liberally)
+    def coevolveSym(pre1: Type): Symbol =
+      if (!sym.isAliasType || (pre eq pre1)) sym 
+      else (pre, pre1) match {
+        // don't look at parents -- it would be an error to override alias types anyway
+        case (RefinedType(_, _), RefinedType(_, decls1)) => decls1 lookup sym.name
+        // TODO: is there another way a typeref's symbol can refer to a symbol defined in its pre?
+        case _                                           => sym
+      }
+
+    //@M! use appliedType on the polytype that represents the bounds (or if aliastype, the rhs)
+    def transformInfo(tp: Type): Type = appliedType(asSeenFromOwner(tp), args)
+
+    def thisInfo                  = sym.info
+    def initializedTypeParams     = sym.info.typeParams
+    def typeParamsMatchArgs       = sameLength(initializedTypeParams, args)
+    def asSeenFromOwner(tp: Type) = tp.asSeenFrom(pre, sym.owner)
+
+    override def baseClasses      = thisInfo.baseClasses
+    override def baseTypeSeqDepth = baseTypeSeq.maxDepth
+    override def isStable         = (sym eq NothingClass) || (sym eq SingletonClass)
+    override def prefix           = if (sym.isAliasType && (this ne normalize)) normalize.prefix else pre
+    override def typeArgs         = args
+    override def typeOfThis       = transform(sym.typeOfThis)
+    override def termSymbol       = if (sym.isAliasType && (this ne normalize)) normalize.termSymbol else super.termSymbol
+    override def typeSymbol       = if (sym.isAliasType && (this ne normalize)) normalize.typeSymbol else sym
+    override def typeSymbolDirect = sym
+    override def termSymbolDirect = super.termSymbol
+
+    override lazy val isTrivial: Boolean =
+      !sym.isTypeParameter && pre.isTrivial && args.forall(_.isTrivial)
+
+    override def isNotNull =
+      sym.isModuleClass || sym == NothingClass || isValueClass(sym) || super.isNotNull
+
+    override def parents: List[Type] = {
+      val period = parentsPeriod
+      if (period != currentPeriod) {
+        parentsPeriod = currentPeriod
+        if (!isValidForBaseClasses(period)) {
+          parentsCache = thisInfo.parents map transform
+        } else if (parentsCache == null) { // seems this can happen if things are corrupted enough, see #2641
+          parentsCache = List(AnyClass.tpe)
+        }
+      }
+      parentsCache
+    }
 
     override def decls: Scope = {
       sym.info match {
@@ -2015,27 +2062,8 @@ A type's typeSymbol should never be inspected directly.
       }
       thisInfo.decls
     }
-
-    override def baseType(clazz: Symbol): Type =
-      if (sym == clazz) this
-      else if (sym.isClass) transform(sym.info.baseType(clazz))
-      else
-        try {
-          basetypeRecursions += 1
-          if (basetypeRecursions < LogPendingBaseTypesThreshold)
-            relativeInfo.baseType(clazz)
-          else if (pendingBaseTypes contains this)
-            if (clazz == AnyClass) clazz.tpe else NoType
-          else
-            try {
-              pendingBaseTypes += this
-              relativeInfo.baseType(clazz)
-            } finally {
-              pendingBaseTypes -= this
-            }
-        } finally {
-          basetypeRecursions -= 1
-        }
+  
+    protected def baseTypeSeqImpl: BaseTypeSeq = sym.info.baseTypeSeq map transform
 
     override def baseTypeSeq: BaseTypeSeq = {
       val period = baseTypeSeqPeriod
@@ -2044,9 +2072,7 @@ A type's typeSymbol should never be inspected directly.
         if (!isValidForBaseClasses(period)) {
           incCounter(typerefBaseTypeSeqCount)
           baseTypeSeqCache = undetBaseTypeSeq
-          baseTypeSeqCache =
-            if (sym.isAbstractType) transform(bounds.hi).baseTypeSeq prepend this
-            else sym.info.baseTypeSeq map transform
+          baseTypeSeqCache = baseTypeSeqImpl
         }
       }
       if (baseTypeSeqCache == undetBaseTypeSeq)
@@ -2054,11 +2080,6 @@ A type's typeSymbol should never be inspected directly.
       baseTypeSeqCache
     }
 
-    override def baseTypeSeqDepth: Int = baseTypeSeq.maxDepth
-
-    override def baseClasses: List[Symbol] = thisInfo.baseClasses
-
-    // override def isNullable: Boolean = sym.info.isNullable
     private def preString = (
       // ensure that symbol is not a local copy with a name coincidence
       if (!settings.debug.value && shorthands(sym.fullName) && sym.ownerChain.forall(_.isClass)) ""
@@ -2073,7 +2094,6 @@ A type's typeSymbol should never be inspected directly.
       )
       else ""
     )
-
     private def finishPrefix(rest: String) = (
       if (sym.isPackageClass) packagePrefix + rest
       else if (sym.isModuleClass) objectPrefix + rest
@@ -2126,12 +2146,19 @@ A type's typeSymbol should never be inspected directly.
     override def kind = "TypeRef"
   }
 
-  final class UniqueTypeRef(pre: Type, sym: Symbol, args: List[Type]) extends TypeRef(pre, sym, args) with UniqueType { }
-
   object TypeRef extends TypeRefExtractor {
-    def apply(pre: Type, sym: Symbol, args: List[Type]): Type = {
-      unique(new UniqueTypeRef(pre, sym, args))
-    }
+    def apply(pre: Type, sym: Symbol, args: List[Type]): Type = unique({
+      if (args.nonEmpty) {
+        if (sym.isAliasType)              new ArgsTypeRef(pre, sym, args) with AliasTypeRef
+        else if (sym.isAbstractType)      new ArgsTypeRef(pre, sym, args) with AbstractTypeRef
+        else                              new ArgsTypeRef(pre, sym, args) with ClassTypeRef
+      }
+      else {
+        if (sym.isAliasType)              new NoArgsTypeRef(pre, sym) with AliasTypeRef
+        else if (sym.isAbstractType)      new NoArgsTypeRef(pre, sym) with AbstractTypeRef
+        else                              new NoArgsTypeRef(pre, sym) with ClassTypeRef
+      }
+    })
   }
 
   /** A class representing a method type with parameters.
@@ -2410,7 +2437,7 @@ A type's typeSymbol should never be inspected directly.
   object HasTypeMember {
     def apply(name: TypeName, tp: Type): Type = {
       val bound = refinedType(List(WildcardType), NoSymbol)
-      val bsym = bound.typeSymbol.newAliasType(NoPosition, name)
+      val bsym = bound.typeSymbol.newAliasType(name)
       bsym setInfo tp
       bound.decls enter bsym
       bound
@@ -3298,8 +3325,8 @@ A type's typeSymbol should never be inspected directly.
       case DeBruijnBinder(pnames, ptypes, restpe) =>
         val isType = pnames.head.isTypeName
         val newParams = for (name <- pnames) yield
-          if (isType) owner.newTypeParameter(NoPosition, name.toTypeName)
-          else owner.newValueParameter(NoPosition, name.toTermName)
+          if (isType) owner.newTypeParameter(name.toTypeName)
+          else owner.newValueParameter(name.toTermName)
         paramStack = newParams :: paramStack
         try {
           (newParams, ptypes).zipped foreach ((p, t) => p setInfo this(t))
@@ -3482,7 +3509,7 @@ A type's typeSymbol should never be inspected directly.
         val hi1 = this(hi)
         if ((lo1 eq lo) && (hi1 eq hi)) tp
         else TypeBounds(lo1, hi1)
-      case TypeRef(pre, sym, args) =>
+      case tr @ TypeRef(pre, sym, args) =>
         val pre1 = this(pre)
         val args1 =
           if (args.isEmpty)
@@ -3495,7 +3522,7 @@ A type's typeSymbol should never be inspected directly.
             else mapOverArgs(args, tparams)
           }
         if ((pre1 eq pre) && (args1 eq args)) tp
-        else copyTypeRef(tp, pre1, coevolveSym(pre, pre1, sym), args1)
+        else copyTypeRef(tp, pre1, tr.coevolveSym(pre1), args1)
       case _ =>
         super.mapOver(tp)
     }
@@ -3510,37 +3537,13 @@ A type's typeSymbol should never be inspected directly.
      */
     def variance = 0
 
-    // #3731: return sym1 for which holds: pre bound sym.name to sym and
-    // pre1 now binds sym.name to sym1, conceptually exactly the same
-    // symbol as sym.  The selection of sym on pre must be updated to the
-    // selection of sym1 on pre1, since sym's info was probably updated
-    // by the TypeMap to yield a new symbol, sym1 with transformed info.
-    // @returns sym1
-    protected def coevolveSym(pre: Type, pre1: Type, sym: Symbol): Symbol =
-      if((pre ne pre1) && sym.isAliasType) // only need to rebind type aliases here, as typeRef already handles abstract types (they are allowed to be rebound more liberally)
-        (pre, pre1) match {
-          case (RefinedType(_, decls), RefinedType(_, decls1)) => // don't look at parents -- it would be an error to override alias types anyway
-            //val sym1 =
-            decls1.lookup(sym.name)
-//            assert(decls.lookupAll(sym.name).toList.length == 1)
-//            assert(decls1.lookupAll(sym.name).toList.length == 1)
-//            assert(sym1.isAliasType)
-//            println("coevolved "+ sym +" : "+ sym.info +" to "+ sym1 +" : "+ sym1.info +" with "+ pre +" -> "+ pre1)
-//            sym1
-          case _ => // TODO: is there another way a typeref's symbol can refer to a symbol defined in its pre?
-//            val sym1 = pre1.nonPrivateMember(sym.name).suchThat(sym => sym.isAliasType)
-//            println("??coevolve "+ sym +" : "+ sym.info +" to "+ sym1 +" : "+ sym1.info +" with "+ pre +" -> "+ pre1)
-            sym
-        }
-      else sym
-
     /** Map this function over given type */
     def mapOver(tp: Type): Type = tp match {
-      case TypeRef(pre, sym, args) =>
+      case tr @ TypeRef(pre, sym, args) =>
         val pre1 = this(pre)
         val args1 = args mapConserve this
         if ((pre1 eq pre) && (args1 eq args)) tp
-        else copyTypeRef(tp, pre1, coevolveSym(pre, pre1, sym), args1)
+        else copyTypeRef(tp, pre1, tr.coevolveSym(pre1), args1)
       case ThisType(_) => tp
       case SingleType(pre, sym) =>
         if (sym.isPackageClass) tp // short path
@@ -4599,7 +4602,7 @@ A type's typeSymbol should never be inspected directly.
    */
   def needsOuterTest(patType: Type, selType: Type, currentOwner: Symbol) = {
     def createDummyClone(pre: Type): Type = {
-      val dummy = currentOwner.enclClass.newValue(NoPosition, nme.ANYNAME).setInfo(pre.widen)
+      val dummy = currentOwner.enclClass.newValue(nme.ANYNAME).setInfo(pre.widen)
       singleType(ThisType(currentOwner.enclClass), dummy)
     }
     def maybeCreateDummyClone(pre: Type, sym: Symbol): Type = pre match {
@@ -5539,10 +5542,6 @@ A type's typeSymbol should never be inspected directly.
   }
 
   /** Do type arguments `targs` conform to formal parameters `tparams`?
-   *
-   *  @param tparams ...
-   *  @param targs   ...
-   *  @return        ...
    */
   def isWithinBounds(pre: Type, owner: Symbol, tparams: List[Symbol], targs: List[Type]): Boolean = {
     var bounds = instantiatedBounds(pre, owner, tparams, targs)
diff --git a/src/compiler/scala/reflect/internal/pickling/UnPickler.scala b/src/compiler/scala/reflect/internal/pickling/UnPickler.scala
index 0789f9c774..3fddc990e4 100644
--- a/src/compiler/scala/reflect/internal/pickling/UnPickler.scala
+++ b/src/compiler/scala/reflect/internal/pickling/UnPickler.scala
@@ -282,7 +282,7 @@ abstract class UnPickler /*extends reflect.generic.UnPickler*/ {
 
       finishSym(tag match {
         case TYPEsym  => owner.newAbstractType(name.toTypeName)
-        case ALIASsym => owner.newAliasType(name.toTypeName)
+        case ALIASsym => owner.newTypeSymbol(name.toTypeName)
         case CLASSsym =>
           val sym = (isClassRoot, isModuleFlag) match {
             case (true, true)   => moduleRoot.moduleClass
@@ -297,11 +297,7 @@ abstract class UnPickler /*extends reflect.generic.UnPickler*/ {
         case MODULEsym =>
           val clazz = at(inforef, () => readType()).typeSymbol // after the NMT_TRANSITION period, we can leave off the () => ... ()
           if (isModuleRoot) moduleRoot
-          else {
-            val m = owner.newModule(name.toTermName, clazz)
-            clazz.sourceModule = m
-            m
-          }
+          else owner.newLinkedModule(clazz)
         case VALsym =>
           if (isModuleRoot) { assert(false); NoSymbol }
           else if (isMethodFlag) owner.newMethod(name.toTermName)
diff --git a/src/compiler/scala/reflect/runtime/JavaToScala.scala b/src/compiler/scala/reflect/runtime/JavaToScala.scala
index 9da75bf2b0..fd3b9b9aa0 100644
--- a/src/compiler/scala/reflect/runtime/JavaToScala.scala
+++ b/src/compiler/scala/reflect/runtime/JavaToScala.scala
@@ -115,7 +115,7 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
    *  @param   jtvar   The Java type variable
    */
   private def createTypeParameter(jtvar: jTypeVariable[_ <: GenericDeclaration]): Symbol = {
-    val tparam = sOwner(jtvar).newTypeParameter(NoPosition, newTypeName(jtvar.getName))
+    val tparam = sOwner(jtvar).newTypeParameter(newTypeName(jtvar.getName))
       .setInfo(new TypeParamCompleter(jtvar))
     tparamCache enter (jtvar, tparam)
     tparam
@@ -335,7 +335,7 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
     val name = newTermName(fullname drop (split + 1))
     var pkg = owner.info decl name
     if (pkg == NoSymbol) {
-      pkg = owner.newPackage(NoPosition, name)
+      pkg = owner.newPackage(name)
       pkg.moduleClass setInfo new LazyPackageType
       pkg setInfo pkg.moduleClass.tpe
       owner.info.decls enter pkg
diff --git a/src/compiler/scala/reflect/runtime/Loaders.scala b/src/compiler/scala/reflect/runtime/Loaders.scala
index 35b3a16dc2..7aca052fa9 100644
--- a/src/compiler/scala/reflect/runtime/Loaders.scala
+++ b/src/compiler/scala/reflect/runtime/Loaders.scala
@@ -63,8 +63,8 @@ trait Loaders { self: SymbolTable =>
    */
   protected def createClassModule(owner: Symbol, name: TypeName, completer: (Symbol, Symbol) => LazyType) = {
     assert(!(name.toString endsWith "[]"), name)
-    val clazz = owner.newClass(NoPosition, name)
-    val module = owner.newModule(NoPosition, name.toTermName)
+    val clazz = owner.newClass(name)
+    val module = owner.newModule(name.toTermName)
     owner.info.decls enter clazz
     owner.info.decls enter module
     initClassModule(clazz, module, completer(clazz, module))
diff --git a/src/compiler/scala/reflect/runtime/ToolBoxes.scala b/src/compiler/scala/reflect/runtime/ToolBoxes.scala
index 231bcdbc0e..11563fa4cc 100644
--- a/src/compiler/scala/reflect/runtime/ToolBoxes.scala
+++ b/src/compiler/scala/reflect/runtime/ToolBoxes.scala
@@ -53,12 +53,12 @@ trait ToolBoxes extends { self: Universe =>
       }
     
       def wrapInObject(expr: Tree, fvs: List[Symbol]): ModuleDef = {
-        val obj = EmptyPackageClass.newModule(NoPosition, nextWrapperModuleName())
+        val obj = EmptyPackageClass.newModule(nextWrapperModuleName())
         val minfo = ClassInfoType(List(ObjectClass.tpe, ScalaObjectClass.tpe), new Scope, obj.moduleClass)
         obj.moduleClass setInfo minfo
         obj setInfo obj.moduleClass.tpe
-        val meth = obj.moduleClass.newMethod(NoPosition, newTermName(wrapperMethodName))
-        def makeParam(fv: Symbol) = meth.newValueParameter(NoPosition, fv.name.toTermName) setInfo fv.tpe
+        val meth = obj.moduleClass.newMethod(newTermName(wrapperMethodName))
+        def makeParam(fv: Symbol) = meth.newValueParameter(fv.name.toTermName) setInfo fv.tpe
         meth setInfo MethodType(fvs map makeParam, expr.tpe)
         minfo.decls enter meth
         trace("wrapping ")(defOwner(expr) -> meth)
diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
index 144322e4f5..55d5efda1f 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
@@ -96,17 +96,17 @@ abstract class TreeGen extends reflect.internal.TreeGen {
   }
 
   def mkModuleVarDef(accessor: Symbol) = {
+    val inClass    = accessor.owner.isClass
+    val extraFlags = if (inClass) PrivateLocal | SYNTHETIC else 0
+    
     val mval = (
-      accessor.owner.newVariable(accessor.pos.focus, nme.moduleVarName(accessor.name))
-      setInfo accessor.tpe.finalResultType
-      setFlag (MODULEVAR)
+      accessor.owner.newVariable(nme.moduleVarName(accessor.name), accessor.pos.focus, MODULEVAR | extraFlags)
+        setInfo accessor.tpe.finalResultType
+        addAnnotation VolatileAttr
     )
+    if (inClass)
+      mval.owner.info.decls enter mval
 
-    mval addAnnotation VolatileAttr
-    if (mval.owner.isClass) {
-      mval setFlag (PrivateLocal | SYNTHETIC)
-      mval.owner.info.decls.enter(mval)
-    }
     ValDef(mval)
   }
 
diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
index 803bd05031..15b4c8c708 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
@@ -1755,7 +1755,7 @@ abstract class GenICode extends SubComponent  {
         val sym = t.symbol
         def getLabel(pos: Position, name: Name) =
           labels.getOrElseUpdate(sym,
-            method.newLabel(sym.pos, unit.freshTermName(name.toString)) setInfo sym.tpe
+            method.newLabel(unit.freshTermName(name.toString), sym.pos) setInfo sym.tpe
           )
 
         t match {
@@ -2005,9 +2005,7 @@ abstract class GenICode extends SubComponent  {
 
       /** Make a fresh local variable. It ensures the 'name' is unique. */
       def makeLocal(pos: Position, tpe: Type, name: String): Local = {
-        val sym = method.symbol.newVariable(pos, unit.freshTermName(name))
-          .setInfo(tpe)
-          .setFlag(Flags.SYNTHETIC)
+        val sym = method.symbol.newVariable(unit.freshTermName(name), pos, Flags.SYNTHETIC) setInfo tpe
         this.method.addLocal(new Local(sym, toTypeKind(tpe), false))
       }
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
index 4ec3ef5ae6..309d8f26fb 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
@@ -876,7 +876,7 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
           if (outerField != NoSymbol) {
             log("Adding fake local to represent outer 'this' for closure " + clasz)
             val _this = new Local(
-              method.symbol.newVariable(NoPosition, nme.FAKE_LOCAL_THIS), toTypeKind(outerField.tpe), false)
+              method.symbol.newVariable(nme.FAKE_LOCAL_THIS), toTypeKind(outerField.tpe), false)
             m.locals = m.locals ::: List(_this)
             computeLocalVarsIndex(m) // since we added a new local, we need to recompute indexes
 
diff --git a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
index e3d21011d1..88bbb16e34 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
@@ -348,7 +348,7 @@ abstract class Inliners extends SubComponent {
 
         def blockEmit(i: Instruction) = block.emit(i, targetPos)
         def newLocal(baseName: String, kind: TypeKind) =
-          new Local(caller.sym.newVariable(targetPos, freshName(baseName)), kind, false)
+          new Local(caller.sym.newVariable(freshName(baseName), targetPos), kind, false)
 
         val a = new analysis.MethodTFA(inc.m)
 
@@ -400,7 +400,7 @@ abstract class Inliners extends SubComponent {
 
         /** alfa-rename `l` in caller's context. */
         def dupLocal(l: Local): Local = {
-          val sym = caller.sym.newVariable(l.sym.pos, freshName(l.sym.name.toString))
+          val sym = caller.sym.newVariable(freshName(l.sym.name.toString), l.sym.pos)
           // sym.setInfo(l.sym.tpe)
           val dupped = new Local(sym, l.kind, false)
           inlinedLocals(l) = dupped
diff --git a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
index 0d7afdc4ec..0c94e40d68 100644
--- a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
+++ b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
@@ -126,11 +126,15 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
         if (treeInfo.firstConstructor(stats) == EmptyTree) makeConstructor(List()) :: stats
         else stats)
 
-    def makeParam(name: String, tpt: Tree) =
-      ValDef(Modifiers(Flags.JAVA | Flags.PARAM), newTermName(name), tpt, EmptyTree)
+    def makeSyntheticParam(count: Int, tpt: Tree): ValDef =
+      makeParam(nme.syntheticParamName(count), tpt)
+    def makeParam(name: String, tpt: Tree): ValDef =
+      makeParam(newTypeName(name), tpt)
+    def makeParam(name: TermName, tpt: Tree): ValDef =
+      ValDef(Modifiers(Flags.JAVA | Flags.PARAM), name, tpt, EmptyTree)
 
     def makeConstructor(formals: List[Tree]) = {
-      val vparams = formals.zipWithIndex map { case (p, i) => makeParam("x$" + (i + 1), p) }
+      val vparams = mapWithIndex(formals)((p, i) => makeSyntheticParam(i + 1, p))
       DefDef(Modifiers(Flags.JAVA), nme.CONSTRUCTOR, List(), List(vparams), TypeTree(), blankExpr)
     }
 
diff --git a/src/compiler/scala/tools/nsc/matching/Matrix.scala b/src/compiler/scala/tools/nsc/matching/Matrix.scala
index 61864f0c8a..d81f05cd51 100644
--- a/src/compiler/scala/tools/nsc/matching/Matrix.scala
+++ b/src/compiler/scala/tools/nsc/matching/Matrix.scala
@@ -252,7 +252,8 @@ trait Matrix extends MatrixAdditions {
     {
       val n = if (name == null) cunit.freshTermName("temp") else name
       // careful: pos has special meaning
-      recordSyntheticSym(owner.newVariable(pos, n) setInfo tpe setFlag (SYNTHETIC.toLong /: flags)(_|_))
+      val flagsLong = (SYNTHETIC.toLong /: flags)(_|_)
+      recordSyntheticSym(owner.newVariable(n, pos, flagsLong) setInfo tpe)
     }
   }
 }
\ No newline at end of file
diff --git a/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala b/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala
index 11d829eadb..9d4c9b4411 100644
--- a/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala
+++ b/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala
@@ -54,7 +54,7 @@ trait ParallelMatching extends ast.TreeDSL
     }
     def createLabelDef(namePrefix: String, body: Tree, params: List[Symbol] = Nil, restpe: Type = matchResultType) = {
       val labelName = cunit.freshTermName(namePrefix)
-      val labelSym  = owner.newLabel(owner.pos, labelName)
+      val labelSym  = owner.newLabel(labelName, owner.pos)
       val labelInfo = MethodType(params, restpe)
 
       LabelDef(labelSym setInfo labelInfo, params, body setType restpe)
diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala
index 340e1d1d08..5d419320ac 100644
--- a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala
+++ b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala
@@ -49,7 +49,7 @@ abstract class SymbolLoaders {
    */
   def enterModule(root: Symbol, name: String, completer: SymbolLoader): Symbol = {
     val owner = realOwner(root)
-    val module = owner.newModule(NoPosition, newTermName(name))
+    val module = owner.newModule(newTermName(name))
     module setInfo completer
     module.moduleClass setInfo moduleClassLoader
     enterIfNew(owner, module, completer)
@@ -199,7 +199,7 @@ abstract class SymbolLoaders {
           return
         }
       }
-      val pkg = root.newPackage(NoPosition, newTermName(name))
+      val pkg = root.newPackage(newTermName(name))
       pkg.moduleClass.setInfo(completer)
       pkg.setInfo(pkg.moduleClass.tpe)
       root.info.decls.enter(pkg)
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
index a158012f9f..61521ea250 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
@@ -455,7 +455,7 @@ abstract class ClassfileParser {
         ss = name.subName(start, end)
         sym = owner.info.decls lookup ss
         if (sym == NoSymbol) {
-          sym = owner.newPackage(NoPosition, ss) setInfo completer
+          sym = owner.newPackage(ss) setInfo completer
           sym.moduleClass setInfo completer
           owner.info.decls enter sym
         }
@@ -813,7 +813,7 @@ abstract class ClassfileParser {
       val start = index
       while (sig(index) != '>') {
         val tpname = subName(':'.==).toTypeName
-        val s = sym.newTypeParameter(NoPosition, tpname)
+        val s = sym.newTypeParameter(tpname)
         tparams = tparams + (tpname -> s)
         sig2typeBounds(tparams, true)
         newTParams += s
@@ -1076,8 +1076,8 @@ abstract class ClassfileParser {
       val name = entry.originalName
       var sflags = toScalaFlags(jflags, isClass = true)
 
-      val innerClass = getOwner(jflags).newClass(NoPosition, name.toTypeName).setInfo(completer).setFlag(sflags)
-      val innerModule = getOwner(jflags).newModule(NoPosition, name.toTermName).setInfo(completer).setFlag(sflags)
+      val innerClass = getOwner(jflags).newClass(name.toTypeName).setInfo(completer).setFlag(sflags)
+      val innerModule = getOwner(jflags).newModule(name.toTermName).setInfo(completer).setFlag(sflags)
       innerModule.moduleClass setInfo global.loaders.moduleClassLoader
 
       getScope(jflags) enter innerClass
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
index 0b64a49a2c..288e19af06 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
@@ -988,7 +988,7 @@ abstract class ICodeReader extends ClassfileParser {
     /** Return a fresh Local variable for the given index.
      */
     private def freshLocal(idx: Int, kind: TypeKind, isArg: Boolean) = {
-      val sym = method.symbol.newVariable(NoPosition, newTermName("loc" + idx)).setInfo(kind.toType);
+      val sym = method.symbol.newVariable(newTermName("loc" + idx)).setInfo(kind.toType);
       val l = new Local(sym, kind, isArg)
       method.addLocal(l)
       l
@@ -1005,7 +1005,7 @@ abstract class ICodeReader extends ClassfileParser {
 
     /** add a method param with the given index. */
     def enterParam(idx: Int, kind: TypeKind) = {
-      val sym = method.symbol.newVariable(NoPosition, newTermName("par" + idx)).setInfo(kind.toType)
+      val sym = method.symbol.newVariable(newTermName("par" + idx)).setInfo(kind.toType)
       val l = new Local(sym, kind, true)
       assert(!locals.isDefinedAt(idx))
       locals += (idx -> List((l, kind)))
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/MetaParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/MetaParser.scala
index 676c8f09da..ead431c8d7 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/MetaParser.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/MetaParser.scala
@@ -68,7 +68,7 @@ abstract class MetaParser{
       else if (token == "-") { nextToken(); Flags.CONTRAVARIANT }
       else 0;
     assert(token startsWith "?", token)
-    val sym = owner.newTypeParameter(NoPosition, newTypeName(token)).setFlag(vflag)
+    val sym = owner.newTypeParameter(newTypeName(token)).setFlag(vflag)
     nextToken()
     val lo =
       if (token == ">") { nextToken(); parseType() }
diff --git a/src/compiler/scala/tools/nsc/symtab/clr/TypeParser.scala b/src/compiler/scala/tools/nsc/symtab/clr/TypeParser.scala
index e0cb0848be..6c238f52cc 100644
--- a/src/compiler/scala/tools/nsc/symtab/clr/TypeParser.scala
+++ b/src/compiler/scala/tools/nsc/symtab/clr/TypeParser.scala
@@ -175,7 +175,7 @@ abstract class TypeParser {
     // first pass
     for (tvarCILDef <- typ.getSortedTVars() ) {
       val tpname = newTypeName(tvarCILDef.Name.replaceAll("!", "")) // TODO are really all type-params named in all assemblies out there? (NO)
-      val tpsym = clazz.newTypeParameter(NoPosition, tpname)
+      val tpsym = clazz.newTypeParameter(tpname)
       classTParams.put(tvarCILDef.Number, tpsym)
       newTParams += tpsym
       // TODO wouldn't the following also be needed later, i.e. during getCLRType
@@ -259,8 +259,8 @@ abstract class TypeParser {
 				                                 || ntype.IsInterface /* TODO why shouldn't nested ifaces be type-parsed too? */ )
       {
         val loader = new loaders.MsilFileLoader(new MsilFile(ntype))
-	val nclazz = statics.newClass(NoPosition, ntype.Name.toTypeName)
-	val nmodule = statics.newModule(NoPosition, ntype.Name)
+	val nclazz = statics.newClass(ntype.Name.toTypeName)
+	val nmodule = statics.newModule(ntype.Name)
 	nclazz.setInfo(loader)
 	nmodule.setInfo(loader)
 	staticDefs.enter(nclazz)
@@ -449,7 +449,7 @@ abstract class TypeParser {
       // first pass
       for (mvarCILDef <- method.getSortedMVars() ) {
         val mtpname = newTypeName(mvarCILDef.Name.replaceAll("!", "")) // TODO are really all method-level-type-params named in all assemblies out there? (NO)
-        val mtpsym = methodSym.newTypeParameter(NoPosition, mtpname)
+        val mtpsym = methodSym.newTypeParameter(mtpname)
         methodTParams.put(mvarCILDef.Number, mtpsym)
         newMethodTParams += mtpsym
         // TODO wouldn't the following also be needed later, i.e. during getCLRType
diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
index 034628e95f..0bc137f3e8 100644
--- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala
+++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
@@ -143,13 +143,13 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
         /* ### CREATING THE METHOD CACHE ### */
 
         def addStaticVariableToClass(forName: TermName, forType: Type, forInit: Tree, isFinal: Boolean): Symbol = {
-          val varSym = (
-            currentClass.newVariable(ad.pos, mkTerm("" + forName))
-              setFlag PRIVATE | STATIC | SYNTHETIC
-              setInfo forType
+          val flags = PRIVATE | STATIC | SYNTHETIC | (
+            if (isFinal) FINAL else 0
           )
-          if (isFinal) varSym setFlag FINAL
-          else varSym.addAnnotation(VolatileAttr)
+          
+          val varSym = currentClass.newVariable(mkTerm("" + forName), ad.pos, flags) setInfo forType
+          if (!isFinal)
+            varSym.addAnnotation(VolatileAttr)
 
           currentClass.info.decls enter varSym
           val varDef = typedPos( VAL(varSym) === forInit )
@@ -280,7 +280,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
 
               addStaticMethodToClass(nme.reflMethodName, List(ClassClass.tpe), MethodClass.tpe)
                 { case Pair(reflMethodSym, List(forReceiverSym)) =>
-                  val methodSym = reflMethodSym.newVariable(ad.pos, mkTerm("method")) setInfo MethodClass.tpe
+                  val methodSym = reflMethodSym.newVariable(mkTerm("method"), ad.pos) setInfo MethodClass.tpe
 
                   BLOCK(
                     IF (getPolyCache OBJ_EQ NULL) THEN (safeREF(reflPolyCacheSym) === mkNewPolyCache) ENDIF,
@@ -565,7 +565,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
       case theTry @ Try(block, catches, finalizer)
         if theTry.tpe.typeSymbol != definitions.UnitClass && theTry.tpe.typeSymbol != definitions.NothingClass =>
         val tpe = theTry.tpe.widen
-        val tempVar = currentOwner.newVariable(theTry.pos, mkTerm(nme.EXCEPTION_RESULT_PREFIX)).setInfo(tpe)
+        val tempVar = currentOwner.newVariable(mkTerm(nme.EXCEPTION_RESULT_PREFIX), theTry.pos).setInfo(tpe)
         def assignBlock(rhs: Tree) = super.transform(BLOCK(Ident(tempVar) === transform(rhs)))
 
         val newBlock    = assignBlock(block)
@@ -637,8 +637,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
 
         // create a symbol for the static field
         val stfieldSym = (
-          currentClass.newVariable(pos, mkTerm("symbol$"))
-            setFlag PRIVATE | STATIC | SYNTHETIC | FINAL
+          currentClass.newVariable(mkTerm("symbol$"), pos, PRIVATE | STATIC | SYNTHETIC | FINAL)
             setInfo SymbolClass.tpe
         )
         currentClass.info.decls enter stfieldSym
diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
index cf7d6c94fe..701fda1035 100644
--- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
@@ -136,7 +136,7 @@ abstract class ExplicitOuter extends InfoTransform
       }
       if (sym.owner.isTrait) sym setNotFlag PROTECTED // 6
       if (sym.isClassConstructor && isInner(sym.owner)) { // 1
-        val p = sym.newValueParameter(sym.pos, innerClassConstructorParamName)
+        val p = sym.newValueParameter(innerClassConstructorParamName, sym.pos)
                    .setInfo(sym.owner.outerClass.thisType)
         MethodType(p :: params, restpe)
       } else if (restpe ne restpe1)
@@ -475,7 +475,7 @@ abstract class ExplicitOuter extends InfoTransform
                 val vparamss1 =
                   if (isInner(clazz)) { // (4)
                     val outerParam =
-                      sym.newValueParameter(sym.pos, nme.OUTER) setInfo outerField(clazz).info
+                      sym.newValueParameter(nme.OUTER, sym.pos) setInfo outerField(clazz).info
                     ((ValDef(outerParam) setType NoType) :: vparamss.head) :: vparamss.tail
                   } else vparamss
                 super.transform(treeCopy.DefDef(tree, mods, name, tparams, vparamss1, tpt, rhs))
diff --git a/src/compiler/scala/tools/nsc/transform/LazyVals.scala b/src/compiler/scala/tools/nsc/transform/LazyVals.scala
index 5452087aa3..f8c5f5bfc6 100644
--- a/src/compiler/scala/tools/nsc/transform/LazyVals.scala
+++ b/src/compiler/scala/tools/nsc/transform/LazyVals.scala
@@ -246,7 +246,7 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD
       if (bmps.length > n)
         bmps(n)
       else {
-        val sym = meth.newVariable(meth.pos, nme.newBitmapName(nme.BITMAP_NORMAL, n)).setInfo(IntClass.tpe)
+        val sym = meth.newVariable(nme.newBitmapName(nme.BITMAP_NORMAL, n), meth.pos).setInfo(IntClass.tpe)
         atPhase(currentRun.typerPhase) {
           sym addAnnotation VolatileAttr
         }
diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala
index c7d3b331a6..d011c15494 100644
--- a/src/compiler/scala/tools/nsc/transform/Mixin.scala
+++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala
@@ -396,9 +396,12 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
           if (sourceModule != NoSymbol) {
             sourceModule setPos sym.pos
             sourceModule.flags = MODULE | FINAL
-          } else {
-            sourceModule = clazz.owner.newModule(
-              sym.pos, sym.name.toTermName, sym.asInstanceOf[ClassSymbol])
+          }
+          else {
+            sourceModule = (
+              clazz.owner.newModuleSymbol(sym.name.toTermName, sym.pos, MODULE | FINAL)
+                setModuleClass sym.asInstanceOf[ClassSymbol]
+            )
             clazz.owner.info.decls enter sourceModule
           }
           sourceModule setInfo sym.tpe
@@ -742,7 +745,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
         assert(!sym.isOverloaded, sym)
 
         def createBitmap: Symbol = {
-          val sym = clazz0.newVariable(clazz0.pos, bitmapName) setInfo IntClass.tpe
+          val sym = clazz0.newVariable(bitmapName, clazz0.pos) setInfo IntClass.tpe
           atPhase(currentRun.typerPhase)(sym addAnnotation VolatileAttr)
 
           category match {
diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
index 99b0a82690..5d13f80897 100644
--- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
+++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
@@ -407,7 +407,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
    */
   private def typeParamSubAnyRef(sym: Symbol, cls: Symbol) = (
     anyrefSpecCache.getOrElseUpdate(sym,
-      cls.newTypeParameter(sym.pos, sym.name append nme.SPECIALIZED_SUFFIX_NAME toTypeName)
+      cls.newTypeParameter(sym.name append nme.SPECIALIZED_SUFFIX_NAME toTypeName, sym.pos)
         setInfo TypeBounds(sym.info.bounds.lo, AnyRefClass.tpe)
     ).tpe
   )
diff --git a/src/compiler/scala/tools/nsc/transform/TailCalls.scala b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
index e2cd0a8402..da767b6bce 100644
--- a/src/compiler/scala/tools/nsc/transform/TailCalls.scala
+++ b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
@@ -128,7 +128,7 @@ abstract class TailCalls extends Transform {
           * the label field.
           */
         this.label    = {
-          val label     = method.newLabel(method.pos, newTermName("_" + method.name))
+          val label     = method.newLabel(newTermName("_" + method.name), method.pos)
           val thisParam = method.newSyntheticValueParam(currentClass.typeOfThis)
           label setInfo MethodType(thisParam :: method.tpe.params, method.tpe.finalResultType)
         }
diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
index adb408f7e4..4ae4042cc7 100644
--- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala
+++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -133,11 +133,9 @@ abstract class UnCurry extends InfoTransform
 
     /** Return non-local return key for given method */
     private def nonLocalReturnKey(meth: Symbol) =
-      nonLocalReturnKeys.getOrElseUpdate(meth, {
-        meth.newValue(meth.pos, unit.freshTermName("nonLocalReturnKey"))
-          .setFlag (SYNTHETIC)
-          .setInfo (ObjectClass.tpe)
-      })
+      nonLocalReturnKeys.getOrElseUpdate(meth,
+        meth.newValue(unit.freshTermName("nonLocalReturnKey"), meth.pos, SYNTHETIC) setInfo ObjectClass.tpe
+      )
 
     /** Generate a non-local return throw with given return expression from given method.
      *  I.e. for the method's non-local return key, generate:
@@ -255,7 +253,7 @@ abstract class UnCurry extends InfoTransform
       if (fun1 ne fun) fun1
       else {
         val (formals, restpe) = (targs.init, targs.last)
-        val anonClass = owner newAnonymousFunctionClass fun.pos setFlag (FINAL | SYNTHETIC | inConstructorFlag)
+        val anonClass = owner.newAnonymousFunctionClass(fun.pos, inConstructorFlag)
         def parents =
           if (isFunctionType(fun.tpe)) List(abstractFunctionForFunctionType(fun.tpe), SerializableClass.tpe)
           else if (isPartial) List(appliedType(AbstractPartialFunctionClass.typeConstructor, targs), SerializableClass.tpe)
@@ -772,7 +770,7 @@ abstract class UnCurry extends InfoTransform
       }
       val forwresult = dd.symbol.tpe.finalResultType
       val forwformsyms = map2(forwformals, flatparams)((tp, oldparam) =>
-        currentClass.newValueParameter(oldparam.symbol.pos, oldparam.name).setInfo(tp)
+        currentClass.newValueParameter(oldparam.name, oldparam.symbol.pos).setInfo(tp)
       )
       def mono = MethodType(forwformsyms, forwresult)
       val forwtype = dd.symbol.tpe match {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index 295b66b17f..23dd28aac4 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -363,10 +363,7 @@ trait Infer {
     def makeFullyDefined(tp: Type): Type = {
       val tparams = new ListBuffer[Symbol]
       def addTypeParam(bounds: TypeBounds): Type = {
-        val tparam =
-          context.owner.newAbstractType(context.tree.pos.focus, newTypeName("_"+tparams.size))
-            .setFlag(EXISTENTIAL)
-            .setInfo(bounds)
+        val tparam = context.owner.newExistential(newTypeName("_"+tparams.size), context.tree.pos.focus) setInfo bounds
         tparams += tparam
         tparam.tpe
       }
diff --git a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
index 62393befd2..29dffd99d6 100644
--- a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
@@ -125,11 +125,7 @@ trait MethodSynthesis {
       def keepClean  = false  // whether annotations whose definitions are not meta-annotated should be kept.
       def validate() { }
       def createAndEnterSymbol(): Symbol = {
-        val sym = (
-          owner.newMethod(tree.pos.focus, name)
-            setFlag tree.mods.flags & flagsMask
-            setFlag flagsExtra
-        )
+        val sym = owner.newMethod(name, tree.pos.focus, (tree.mods.flags & flagsMask) | flagsExtra)
         setPrivateWithin(tree, sym)
         enterInScope(sym)
         sym setInfo completer(sym)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index 200191fa13..71c0de10ff 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -293,23 +293,22 @@ trait Namers extends MethodSynthesis {
     private def createMemberSymbol(tree: MemberDef, name: Name, mask: Long): Symbol = {
       val pos         = tree.pos
       val isParameter = tree.mods.isParameter
-      val sym         = tree match {
-        case TypeDef(_, _, _, _) if isParameter     => owner.newTypeParameter(pos, name.toTypeName)
-        case TypeDef(_, _, _, _)                    => owner.newAliasType(pos, name.toTypeName)
-        case DefDef(_, nme.CONSTRUCTOR, _, _, _, _) => owner.newConstructor(pos)
-        case DefDef(_, _, _, _, _, _)               => owner.newMethod(pos, name.toTermName)
-        case ClassDef(_, _, _, _)                   => owner.newClass(pos, name.toTypeName)
-        case ModuleDef(_, _, _)                     => owner.newModule(pos, name)
-        case ValDef(_, _, _, _) if isParameter      => owner.newValueParameter(pos, name)
+      val flags       = tree.mods.flags & mask
+      
+      tree match {
+        case TypeDef(_, _, _, _) if isParameter     => owner.newTypeParameter(name.toTypeName, pos, flags)
+        case TypeDef(_, _, _, _)                    => owner.newTypeSymbol(name.toTypeName, pos, flags)
+        case DefDef(_, nme.CONSTRUCTOR, _, _, _, _) => owner.newConstructor(pos, flags)
+        case DefDef(_, _, _, _, _, _)               => owner.newMethod(name.toTermName, pos, flags)
+        case ClassDef(_, _, _, _)                   => owner.newClassSymbol(name.toTypeName, pos, flags)
+        case ModuleDef(_, _, _)                     => owner.newModule(name, pos, flags)
+        case ValDef(_, _, _, _) if isParameter      => owner.newValueParameter(name, pos, flags)
         case PackageDef(pid, _)                     => createPackageSymbol(pos, pid)
-        case ValDef(_, _, _, _)                     => owner.newValue(pos, name)
+        case ValDef(_, _, _, _)                     => owner.newValue(name, pos, flags)
       }
-      sym setFlag (tree.mods.flags & mask)
     }
-    private def createFieldSymbol(tree: ValDef): TermSymbol = (
-      owner.newValue(tree.pos, nme.getterToLocal(tree.name))
-        setFlag tree.mods.flags & FieldFlags | PrivateLocal
-    )
+    private def createFieldSymbol(tree: ValDef): TermSymbol =
+      owner.newValue(nme.getterToLocal(tree.name), tree.pos, tree.mods.flags & FieldFlags | PrivateLocal)
 
     private def createImportSymbol(tree: Tree) =
       NoSymbol.newImport(tree.pos) setInfo completerOf(tree)
@@ -325,7 +324,7 @@ trait Namers extends MethodSynthesis {
       if (existing.isPackage && pkgOwner == existing.owner)
         existing
       else {
-        val pkg          = pkgOwner.newPackage(pos, pid.name.toTermName)
+        val pkg          = pkgOwner.newPackage(pid.name.toTermName, pos)
         val pkgClass     = pkg.moduleClass
         val pkgClassInfo = new PackageClassInfoType(newPackageScope(pkgClass), pkgClass)
 
@@ -579,7 +578,7 @@ trait Namers extends MethodSynthesis {
       // via "x$lzy" as can be seen in test #3927.
       val sym = (
         if (owner.isClass) createFieldSymbol(tree)
-        else owner.newValue(tree.pos, tree.name append nme.LAZY_LOCAL) setFlag tree.mods.flags resetFlag IMPLICIT
+        else owner.newValue(tree.name append nme.LAZY_LOCAL, tree.pos, tree.mods.flags & ~IMPLICIT)
       )
       enterValSymbol(tree, sym setFlag MUTABLE setLazyAccessor lazyAccessor)
     }
diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
index a8dfea02ec..07b08e52da 100644
--- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
@@ -269,7 +269,7 @@ trait NamesDefaults { self: Analyzer =>
             case _ =>
               (seqType(arg.tpe), true)
           } else (arg.tpe, false)
-        val s = context.owner.newValue(arg.pos, unit.freshTermName("x$"))
+        val s = context.owner.newValue(unit.freshTermName("x$"), arg.pos)
         val valType = if (byName) functionType(List(), argTpe)
                       else if (repeated) argTpe
                       else argTpe
diff --git a/src/compiler/scala/tools/nsc/typechecker/PatMatVirtualiser.scala b/src/compiler/scala/tools/nsc/typechecker/PatMatVirtualiser.scala
index b059e023e4..4104803194 100644
--- a/src/compiler/scala/tools/nsc/typechecker/PatMatVirtualiser.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/PatMatVirtualiser.scala
@@ -53,7 +53,7 @@ trait PatMatVirtualiser extends ast.TreeDSL { self: Analyzer =>
     import typeDebug.{ ptTree, ptBlock, ptLine }
 
     def solveContextBound(contextBoundTp: Type): (Tree, Type) = {
-      val solSym      = NoSymbol.newTypeParameter(NoPosition, newTypeName("SolveImplicit$"))
+      val solSym      = NoSymbol.newTypeParameter(newTypeName("SolveImplicit$"))
       val param       = solSym.setInfo(contextBoundTp.typeSymbol.typeParams(0).info.cloneInfo(solSym)) // TypeBounds(NothingClass.typeConstructor, baseTp)
       val pt          = appliedType(contextBoundTp, List(param.tpeHK))
       val savedUndets = context.undetparams
@@ -1245,7 +1245,7 @@ defined class Foo */
         }
         t match {
           case Function(_, _) if t.symbol == NoSymbol =>
-            t.symbol = currentOwner.newValue(t.pos, nme.ANON_FUN_NAME).setFlag(SYNTHETIC).setInfo(NoType)
+            t.symbol = currentOwner.newAnonymousFunctionValue(t.pos)
             // println("new symbol for "+ (t, t.symbol.ownerChain))
           case Function(_, _) if (t.symbol.owner == NoSymbol) || (t.symbol.owner == origOwner) =>
             // println("fundef: "+ (t, t.symbol.ownerChain, currentOwner.ownerChain))
diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
index 8f9cd46611..42a60666de 100644
--- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -444,6 +444,7 @@ abstract class RefChecks extends InfoTransform with reflect.internal.transform.R
             // check a type alias's RHS corresponds to its declaration
             // this overlaps somewhat with validateVariance
             if(member.isAliasType) {
+              // println("checkKindBounds" + ((List(member), List(memberTp.normalize), self, member.owner)))
               val kindErrors = typer.infer.checkKindBounds(List(member), List(memberTp.normalize), self, member.owner)
 
               if(!kindErrors.isEmpty)
diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
index 92e4e257bf..1df7cd86d3 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
@@ -282,7 +282,7 @@ trait SyntheticMethods extends ast.TreeDSL {
 
       def argsBody: Tree = {
         val otherName = context.unit.freshTermName(clazz.name + "$")
-        val otherSym  = m.newValue(m.pos, otherName) setInfo clazz.tpe setFlag SYNTHETIC
+        val otherSym  = m.newValue(otherName, m.pos, SYNTHETIC) setInfo clazz.tpe
         val pairwise  = accessors map (acc => fn(Select(This(clazz), acc), acc.tpe member nme.EQ, Select(Ident(otherSym), acc)))
         val canEq     = gen.mkMethodCall(otherSym, nme.canEqual_, Nil, List(This(clazz)))
         def block     = Block(ValDef(otherSym, thatCast), AND(pairwise :+ canEq: _*))
diff --git a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala
index 080a802272..02c6e86fde 100644
--- a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala
@@ -181,10 +181,7 @@ trait TypeDiagnostics {
       val getter = if (member.isSetter) member.getter(member.owner) else member
       val flags  = if (getter.setter(member.owner) != NoSymbol) DEFERRED | MUTABLE else DEFERRED
 
-      ( getter.owner.newValue(getter.pos, getter.name.toTermName)
-          setInfo getter.tpe.resultType
-          setFlag flags
-      )
+      getter.owner.newValue(getter.name.toTermName, getter.pos, flags) setInfo getter.tpe.resultType
     }
 
   def treeSymTypeMsg(tree: Tree): String = {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 5ccf27ded9..6476244221 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -1659,7 +1659,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
             case Some(repl) =>
               silent(_.typedTypeConstructor(stringParser(repl).typ())) match {
                 case tpt: Tree =>
-                  val alias = enclClass.newAliasType(useCase.pos, name.toTypeName)
+                  val alias = enclClass.newAliasType(name.toTypeName, useCase.pos)
                   val tparams = cloneSymbolsAtOwner(tpt.tpe.typeSymbol.typeParams, alias)
                   alias setInfo typeFun(tparams, appliedType(tpt.tpe, tparams map (_.tpe)))
                   context.scope.enter(alias)
@@ -1793,7 +1793,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
         case ldef @ LabelDef(_, _, _) =>
           if (ldef.symbol == NoSymbol)
             ldef.symbol = namer.enterInScope(
-              context.owner.newLabel(ldef.pos, ldef.name) setInfo MethodType(List(), UnitClass.tpe))
+              context.owner.newLabel(ldef.name, ldef.pos) setInfo MethodType(List(), UnitClass.tpe))
         case _ =>
       }
     }
@@ -1814,7 +1814,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
         } else {
           context.scope.unlink(ldef.symbol)
           val sym2 = namer.enterInScope(
-            context.owner.newLabel(ldef.pos, ldef.name) setInfo MethodType(List(), restpe))
+            context.owner.newLabel(ldef.name, ldef.pos) setInfo MethodType(List(), restpe))
           val rhs2 = typed(resetAllAttrs(ldef.rhs), restpe)
           ldef.params foreach (param => param.tpe = param.symbol.tpe)
           treeCopy.LabelDef(ldef, ldef.name, ldef.params, rhs2) setSymbol sym2 setType restpe
@@ -2529,7 +2529,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
 
           val unapp     = unapplyMember(otpe)
           val unappType = otpe.memberType(unapp)
-          val argDummy  = context.owner.newValue(fun.pos, nme.SELECTOR_DUMMY) setFlag SYNTHETIC setInfo pt
+          val argDummy  = context.owner.newValue(nme.SELECTOR_DUMMY, fun.pos, SYNTHETIC) setInfo pt
           val arg       = Ident(argDummy) setType pt
 
           if (!isApplicableSafe(Nil, unappType, List(pt), WildcardType)) {
@@ -4098,8 +4098,8 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
 
         case tree @ Function(_, _) =>
           if (tree.symbol == NoSymbol)
-            tree.symbol = context.owner.newValue(tree.pos, nme.ANON_FUN_NAME)
-              .setFlag(SYNTHETIC).setInfo(NoType)
+            tree.symbol = context.owner.newAnonymousFunctionValue(tree.pos)
+
           newTyper(context.makeNewScope(tree, tree.symbol)).typedFunction(tree, mode, pt)
 
         case Assign(lhs, rhs) =>
diff --git a/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala b/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala
index fd6f972ffc..a7cd89621c 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala
@@ -21,7 +21,7 @@ trait Unapplies extends ast.TreeDSL
   import CODE.{ CASE => _, _ }
   import treeInfo.{ isRepeatedParamType, isByNameParamType }
 
-  private val unapplyParamName = newTermName("x$0")
+  private val unapplyParamName = nme.x_0
   
   /** returns type list for return type of the extraction */
   def unapplyTypeList(ufn: Symbol, ufntpe: Type) = {