Reflection and reification: Names and Symbols.

 - Consolidating many islands of name organization. Folds NameManglers
into StdNames. Brings more of the string constants together with similar
constants.  Move name manipulation methods which produce TypeNames
into object tpnme rather than nme.

 - Starting on MethodSymbolApi, ClassSymbolApi, etc so we can put
sensible methods on sensible entities. This pushed into Definitions,
where I pulled a whole bunch out of the api side (or at least marked
my intention to do so -- too many tests use them to make them easy to
remove) and on the compiler side, returned something more specific than
Symbol a bunch of places.

 - Added a number of conveniences to Definitions to make it easier to
get properly typed symbols.

Note: one way in which you might notice having better typed Symbols is
with Sets, which have the annoying property of inferring a type based on
what they've been constructed with and then hard failing when you test
for the presence of a more general type. So this:

  val mySet = Set(a, b)
  println(mySet(c))

..goes from compiling to not compiling if a and b receive more specific
types (e.g. they are MethodSymbols) and c is a Symbol or ClassSymbol or
whatever.  This is easily remedied on a site-by-site basis - create
Set[Symbol](...) not Set(...) - but is an interesting and unfortunate
consequence of type inference married to invariance.

The changes to DummyMirror where things became ??? were driven by the
need to lower its tax; type "Nothing" is a lot more forgiving about changes
than is any specific symbol type.

28 files changed, 985 insertions, 874 deletions

diff --git a/src/compiler/scala/reflect/internal/Definitions.scala b/src/compiler/scala/reflect/internal/Definitions.scala
index 7353e69ab6..24fc7c7cc4 100644
--- a/src/compiler/scala/reflect/internal/Definitions.scala
+++ b/src/compiler/scala/reflect/internal/Definitions.scala
@@ -15,6 +15,8 @@ import scala.reflect.{ mirror => rm }
 trait Definitions extends reflect.api.StandardDefinitions {
   self: SymbolTable =>
 
+  object definitions extends DefinitionsClass
+
   // [Eugene] find a way to make these non-lazy
   lazy val ByteTpe    = definitions.ByteClass.asType
   lazy val ShortTpe   = definitions.ShortClass.asType
@@ -41,34 +43,21 @@ trait Definitions extends reflect.api.StandardDefinitions {
    */
   private type PolyMethodCreator = List[Symbol] => (Option[List[Type]], Type)
 
-  private def enterNewClass(owner: Symbol, name: TypeName, parents: List[Type], flags: Long = 0L): Symbol = {
+  private def enterNewClass(owner: Symbol, name: TypeName, parents: List[Type], flags: Long = 0L): ClassSymbol = {
     val clazz = owner.newClassSymbol(name, NoPosition, flags)
     clazz setInfoAndEnter ClassInfoType(parents, newScope, clazz)
   }
-  private def newMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type, flags: Long = 0L): Symbol = {
+  private def newMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type, flags: Long = 0L): MethodSymbol = {
     val msym   = owner.newMethod(name.encode, NoPosition, flags)
     val params = msym.newSyntheticValueParams(formals)
     msym setInfo MethodType(params, restpe)
   }
-  private def enterNewMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type, flags: Long = 0L): Symbol =
+  private def enterNewMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type, flags: Long = 0L): MethodSymbol =
     owner.info.decls enter newMethod(owner, name, formals, restpe, flags)
 
   // the scala value classes
   trait ValueClassDefinitions {
-    self: definitions.type =>
-
-    private[Definitions] def valueCache(name: Name) = {
-      val res = (
-        if (name.isTypeName) ScalaPackageClass.info member name
-        else ScalaPackageClass.info member name suchThat (_ hasFlag MODULE)
-      )
-      if (res eq NoSymbol)
-        abort("Could not find value classes! This is a catastrophic failure.  scala " + scala.util.Properties.versionString)
-      else res
-    }
-    private[Definitions] def valueModuleMethod(className: Name, methodName: Name): Symbol = {
-      valueCache(className.toTermName).moduleClass.tpe member methodName
-    }
+    self: DefinitionsClass =>
 
     import ClassfileConstants._
 
@@ -94,6 +83,25 @@ trait Definitions extends reflect.api.StandardDefinitions {
       tpnme.Unit    -> VOID_TAG
     )
 
+    private def catastrophicFailure() =
+      abort("Could not find value classes! This is a catastrophic failure.  scala " +
+        scala.util.Properties.versionString)
+
+    private def valueClassSymbol(name: TypeName): ClassSymbol = {
+      getMember(ScalaPackageClass, name) match {
+        case x: ClassSymbol => x
+        case _              => catastrophicFailure()
+      }
+    }
+    private def valueClassCompanion(name: TermName): ModuleSymbol = {
+      getMember(ScalaPackageClass, name) match {
+        case x: ModuleSymbol => x
+        case _               => catastrophicFailure()
+      }
+    }
+    private def valueCompanionMember(className: Name, methodName: TermName): MethodSymbol =
+      getMemberMethod(valueClassCompanion(className.toTermName).moduleClass, methodName)
+
     private def classesMap[T](f: Name => T) = symbolsMap(ScalaValueClassesNoUnit, f)
     private def symbolsMap[T](syms: List[Symbol], f: Name => T): Map[Symbol, T] = syms zip (syms map (x => f(x.name))) toMap
     private def symbolsMapFilt[T](syms: List[Symbol], p: Name => Boolean, f: Name => T) = symbolsMap(syms filter (x => p(x.name)), f)
@@ -106,8 +114,8 @@ trait Definitions extends reflect.api.StandardDefinitions {
     lazy val boxedClass       = classesMap(x => getClass(boxedName(x)))
     lazy val refClass         = classesMap(x => getRequiredClass("scala.runtime." + x + "Ref"))
     lazy val volatileRefClass = classesMap(x => getRequiredClass("scala.runtime.Volatile" + x + "Ref"))
-    lazy val boxMethod        = classesMap(x => valueModuleMethod(x, nme.box))
-    lazy val unboxMethod      = classesMap(x => valueModuleMethod(x, nme.unbox))
+    lazy val boxMethod        = classesMap(x => valueCompanionMember(x, nme.box))
+    lazy val unboxMethod      = classesMap(x => valueCompanionMember(x, nme.unbox))
 
     def isNumericSubClass(sub: Symbol, sup: Symbol) = (
          (numericWeight contains sub)
@@ -116,27 +124,28 @@ trait Definitions extends reflect.api.StandardDefinitions {
     )
 
     /** Is symbol a numeric value class? */
-    def isNumericValueClass(sym: Symbol): Boolean =
-      numericWeight contains sym
+    def isNumericValueClass(sym: Symbol) = ScalaNumericValueClasses contains sym
 
     def isGetClass(sym: Symbol) =
       (sym.name == nme.getClass_) && flattensToEmpty(sym.paramss)
 
-    lazy val UnitClass    = valueCache(tpnme.Unit)
-    lazy val ByteClass    = valueCache(tpnme.Byte)
-    lazy val ShortClass   = valueCache(tpnme.Short)
-    lazy val CharClass    = valueCache(tpnme.Char)
-    lazy val IntClass     = valueCache(tpnme.Int)
-    lazy val LongClass    = valueCache(tpnme.Long)
-    lazy val FloatClass   = valueCache(tpnme.Float)
-    lazy val DoubleClass  = valueCache(tpnme.Double)
-    lazy val BooleanClass = valueCache(tpnme.Boolean)
+    lazy val UnitClass    = valueClassSymbol(tpnme.Unit)
+    lazy val ByteClass    = valueClassSymbol(tpnme.Byte)
+    lazy val ShortClass   = valueClassSymbol(tpnme.Short)
+    lazy val CharClass    = valueClassSymbol(tpnme.Char)
+    lazy val IntClass     = valueClassSymbol(tpnme.Int)
+    lazy val LongClass    = valueClassSymbol(tpnme.Long)
+    lazy val FloatClass   = valueClassSymbol(tpnme.Float)
+    lazy val DoubleClass  = valueClassSymbol(tpnme.Double)
+    lazy val BooleanClass = valueClassSymbol(tpnme.Boolean)
       lazy val Boolean_and = getMember(BooleanClass, nme.ZAND)
       lazy val Boolean_or  = getMember(BooleanClass, nme.ZOR)
       lazy val Boolean_not = getMember(BooleanClass, nme.UNARY_!)
 
+    lazy val ScalaNumericValueClasses = ScalaValueClasses filterNot Set[Symbol](UnitClass, BooleanClass)
+
     def ScalaValueClassesNoUnit = ScalaValueClasses filterNot (_ eq UnitClass)
-    def ScalaValueClasses: List[Symbol] = List(
+    def ScalaValueClasses: List[ClassSymbol] = List(
       UnitClass,
       BooleanClass,
       ByteClass,
@@ -148,10 +157,10 @@ trait Definitions extends reflect.api.StandardDefinitions {
       DoubleClass
     )
     def ScalaValueClassCompanions: List[Symbol] = ScalaValueClasses map (_.companionSymbol)
-    def ScalaPrimitiveValueClasses: List[Symbol] = ScalaValueClasses
+    def ScalaPrimitiveValueClasses: List[ClassSymbol] = ScalaValueClasses
   }
 
-  object definitions extends AbsDefinitions with ValueClassDefinitions {
+  abstract class DefinitionsClass extends AbsDefinitions with ValueClassDefinitions {
     private var isInitialized = false
     def isDefinitionsInitialized = isInitialized
 
@@ -207,15 +216,14 @@ trait Definitions extends reflect.api.StandardDefinitions {
     }
     // It becomes tricky to create dedicated objects for other symbols because
     // of initialization order issues.
-    lazy val JavaLangPackage      = getModule(sn.JavaLang)
+    lazy val JavaLangPackage      = getRequiredPackage(sn.JavaLang)
     lazy val JavaLangPackageClass = JavaLangPackage.moduleClass
-    lazy val ScalaPackage         = getModule(nme.scala_)
+    lazy val ScalaPackage         = getRequiredPackage(nme.scala_)
     lazy val ScalaPackageClass    = ScalaPackage.moduleClass
-
-    lazy val RuntimePackage       = getRequiredModule("scala.runtime")
+    lazy val RuntimePackage       = getRequiredPackage("scala.runtime")
     lazy val RuntimePackageClass  = RuntimePackage.moduleClass
 
-    lazy val JavaLangEnumClass = getRequiredClass("java.lang.Enum")
+    lazy val JavaLangEnumClass = requiredClass[java.lang.Enum[_]]
 
     // convenient one-argument parameter lists
     lazy val anyparam     = List(AnyClass.tpe)
@@ -268,9 +276,9 @@ trait Definitions extends reflect.api.StandardDefinitions {
     }
 
     // top types
-    lazy val AnyClass             = enterNewClass(ScalaPackageClass, tpnme.Any, Nil, ABSTRACT)
-    lazy val AnyRefClass          = newAlias(ScalaPackageClass, tpnme.AnyRef, ObjectClass.tpe)
-    lazy val ObjectClass          = getClass(sn.Object)
+    lazy val AnyClass    = enterNewClass(ScalaPackageClass, tpnme.Any, Nil, ABSTRACT)
+    lazy val AnyRefClass = newAlias(ScalaPackageClass, tpnme.AnyRef, ObjectClass.tpe)
+    lazy val ObjectClass = getRequiredClass(sn.Object.toString)
 
     // Note: this is not the type alias AnyRef, it's a companion-like
     // object used by the @specialize annotation.
@@ -278,12 +286,13 @@ trait Definitions extends reflect.api.StandardDefinitions {
     @deprecated("Use AnyRefModule", "2.10.0")
     def Predef_AnyRef = AnyRefModule
 
-    lazy val AnyValClass = ScalaPackageClass.info member tpnme.AnyVal orElse {
+    lazy val AnyValClass: ClassSymbol = (ScalaPackageClass.info member tpnme.AnyVal orElse {
       val anyval    = enterNewClass(ScalaPackageClass, tpnme.AnyVal, List(AnyClass.tpe, NotNullClass.tpe), ABSTRACT)
       val av_constr = anyval.newClassConstructor(NoPosition)
       anyval.info.decls enter av_constr
       anyval
-    }
+    }).asInstanceOf[ClassSymbol]
+
       lazy val AnyVal_getClass = enterNewMethod(AnyValClass, nme.getClass_, Nil, getClassReturnType(AnyValClass.tpe))
 
     // bottom types
@@ -308,24 +317,24 @@ trait Definitions extends reflect.api.StandardDefinitions {
     }
 
     // exceptions and other throwables
-    lazy val ClassCastExceptionClass        = getRequiredClass("java.lang.ClassCastException")
+    lazy val ClassCastExceptionClass        = requiredClass[ClassCastException]
     lazy val IndexOutOfBoundsExceptionClass = getClass(sn.IOOBException)
     lazy val InvocationTargetExceptionClass = getClass(sn.InvTargetException)
-    lazy val MatchErrorClass                = getRequiredClass("scala.MatchError")
-    lazy val NonLocalReturnControlClass     = getRequiredClass("scala.runtime.NonLocalReturnControl")
+    lazy val MatchErrorClass                = requiredClass[MatchError]
+    lazy val NonLocalReturnControlClass     = requiredClass[scala.runtime.NonLocalReturnControl[_]]
     lazy val NullPointerExceptionClass      = getClass(sn.NPException)
     lazy val ThrowableClass                 = getClass(sn.Throwable)
-    lazy val UninitializedErrorClass        = getRequiredClass("scala.UninitializedFieldError")
+    lazy val UninitializedErrorClass        = requiredClass[UninitializedFieldError]
 
     // fundamental reference classes
-    lazy val PartialFunctionClass       = getRequiredClass("scala.PartialFunction")
+    lazy val PartialFunctionClass       = requiredClass[PartialFunction[_,_]]
     lazy val AbstractPartialFunctionClass = getRequiredClass("scala.runtime.AbstractPartialFunction")
     lazy val SymbolClass                = getRequiredClass("scala.Symbol")
-    lazy val StringClass                = getClass(sn.String)
+    lazy val StringClass                = requiredClass[java.lang.String]
     lazy val StringModule               = StringClass.linkedClassOfClass
-    lazy val ClassClass                 = getClass(sn.Class)
+    lazy val ClassClass                 = getRequiredClass("java.lang.Class")
       def Class_getMethod               = getMember(ClassClass, nme.getMethod_)
-    lazy val DynamicClass               = getRequiredClass("scala.Dynamic")
+    lazy val DynamicClass               = requiredClass[Dynamic]
 
     // fundamental modules
     lazy val SysPackage = getPackageObject("scala.sys")
@@ -336,14 +345,14 @@ trait Definitions extends reflect.api.StandardDefinitions {
     // Those modules and their module classes
     lazy val UnqualifiedOwners  = UnqualifiedModules.toSet ++ UnqualifiedModules.map(_.moduleClass)
 
-    lazy val PredefModule: Symbol = getRequiredModule("scala.Predef")
+    lazy val PredefModule      = requiredModule[scala.Predef.type]
     lazy val PredefModuleClass = PredefModule.moduleClass
 
-      def Predef_classOf = getMember(PredefModule, nme.classOf)
-      def Predef_identity = getMember(PredefModule, nme.identity)
-      def Predef_conforms = getMember(PredefModule, nme.conforms)
+      def Predef_classOf      = getMember(PredefModule, nme.classOf)
+      def Predef_identity     = getMember(PredefModule, nme.identity)
+      def Predef_conforms     = getMember(PredefModule, nme.conforms)
       def Predef_wrapRefArray = getMember(PredefModule, nme.wrapRefArray)
-      def Predef_??? = getMember(PredefModule, nme.???)
+      def Predef_???          = getMember(PredefModule, nme.???)
 
     /** Is `sym` a member of Predef with the given name?
      *  Note: DON't replace this by sym == Predef_conforms/etc, as Predef_conforms is a `def`
@@ -356,8 +365,8 @@ trait Definitions extends reflect.api.StandardDefinitions {
 
     /** Specialization.
      */
-    lazy val SpecializableModule  = getRequiredModule("scala.Specializable")
-    lazy val GroupOfSpecializable = SpecializableModule.info.member(newTypeName("Group"))
+    lazy val SpecializableModule  = requiredModule[Specializable]
+    lazy val GroupOfSpecializable = getMember(SpecializableModule, tpnme.Group)
 
     lazy val ConsoleModule: Symbol      = getRequiredModule("scala.Console")
     lazy val ScalaRunTimeModule: Symbol = getRequiredModule("scala.runtime.ScalaRunTime")
@@ -379,7 +388,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
     lazy val NotNullClass     = getRequiredClass("scala.NotNull")
     lazy val ScalaNumberClass           = getRequiredClass("scala.math.ScalaNumber")
     lazy val TraitSetterAnnotationClass = getRequiredClass("scala.runtime.TraitSetter")
-    lazy val DelayedInitClass = getRequiredClass("scala.DelayedInit")
+    lazy val DelayedInitClass = requiredClass[scala.DelayedInit]
       def delayedInitMethod = getMember(DelayedInitClass, nme.delayedInit)
       // a dummy value that communicates that a delayedInit call is compiler-generated
       // from phase UnCurry to phase Constructors
@@ -458,8 +467,8 @@ trait Definitions extends reflect.api.StandardDefinitions {
       lazy val Array_clone  = getMember(ArrayClass, nme.clone_)
 
     // reflection / structural types
-    lazy val SoftReferenceClass     = getRequiredClass("java.lang.ref.SoftReference")
-    lazy val WeakReferenceClass     = getRequiredClass("java.lang.ref.WeakReference")
+    lazy val SoftReferenceClass     = requiredClass[java.lang.ref.SoftReference[_]]
+    lazy val WeakReferenceClass     = requiredClass[java.lang.ref.WeakReference[_]]
     lazy val MethodClass            = getClass(sn.MethodAsObject)
       def methodClass_setAccessible = getMember(MethodClass, nme.setAccessible)
     lazy val EmptyMethodCacheClass  = getRequiredClass("scala.runtime.EmptyMethodCache")
@@ -473,22 +482,23 @@ trait Definitions extends reflect.api.StandardDefinitions {
       def Reflect_mirror = getMember(ReflectPackage, nme.mirror)
 
     lazy val ExprClass     = getMember(getRequiredClass("scala.reflect.api.Exprs"), tpnme.Expr)
-         def ExprTree      = getMember(ExprClass, nme.tree)
-         def ExprTpe       = getMember(ExprClass, nme.tpe)
+         def ExprTree      = getMemberClass(ExprClass, nme.tree)
+         def ExprTpe       = getMemberClass(ExprClass, nme.tpe)
          def ExprEval      = getMember(ExprClass, nme.eval)
          def ExprValue     = getMember(ExprClass, nme.value)
     lazy val ExprModule    = getMember(getRequiredClass("scala.reflect.api.Exprs"), nme.Expr)
 
-    lazy val ClassTagClass         = getRequiredClass("scala.reflect.ClassTag")
-         def ClassTagErasure       = getMember(ClassTagClass, nme.erasure)
-         def ClassTagTpe           = getMember(ClassTagClass, nme.tpe)
-    lazy val ClassTagModule        = getRequiredModule("scala.reflect.ClassTag")
-    lazy val TypeTagsClass         = getRequiredClass("scala.reflect.api.TypeTags")
-    lazy val TypeTagClass          = getMember(TypeTagsClass, tpnme.TypeTag)
-         def TypeTagTpe            = getMember(TypeTagClass, nme.tpe)
-    lazy val TypeTagModule         = getMember(TypeTagsClass, nme.TypeTag)
-    lazy val ConcreteTypeTagClass  = getMember(TypeTagsClass, tpnme.ConcreteTypeTag)
-    lazy val ConcreteTypeTagModule = getMember(TypeTagsClass, nme.ConcreteTypeTag)
+    lazy val ClassTagModule        = requiredModule[scala.reflect.ClassTag[_]]
+    lazy val ClassTagClass         = requiredClass[scala.reflect.ClassTag[_]]
+    lazy val TypeTagsClass         = requiredClass[scala.reflect.api.TypeTags]
+    lazy val TypeTagClass          = getMemberClass(TypeTagsClass, tpnme.TypeTag)
+    lazy val TypeTagModule         = getMemberModule(TypeTagsClass, nme.TypeTag)
+    lazy val ConcreteTypeTagClass  = getMemberClass(TypeTagsClass, tpnme.ConcreteTypeTag)
+    lazy val ConcreteTypeTagModule = getMemberModule(TypeTagsClass, nme.ConcreteTypeTag)
+
+         def ClassTagErasure       = getMemberMethod(ClassTagClass, nme.erasure)
+         def ClassTagTpe           = getMemberMethod(ClassTagClass, nme.tpe)
+         def TypeTagTpe            = getMemberMethod(TypeTagClass, nme.tpe)
 
     lazy val MacroContextClass                        = getRequiredClass("scala.reflect.makro.Context")
          def MacroContextPrefix                       = getMember(MacroContextClass, nme.prefix)
@@ -497,16 +507,16 @@ trait Definitions extends reflect.api.StandardDefinitions {
          def MacroContextReify                        = getMember(MacroContextClass, nme.reify)
     lazy val MacroImplAnnotation                      = getRequiredClass("scala.reflect.makro.internal.macroImpl")
     lazy val MacroInternalPackage                     = getPackageObject("scala.reflect.makro.internal")
-         def MacroInternal_materializeClassTag        = getMember(MacroInternalPackage, nme.materializeClassTag)
-         def MacroInternal_materializeTypeTag         = getMember(MacroInternalPackage, nme.materializeTypeTag)
-         def MacroInternal_materializeConcreteTypeTag = getMember(MacroInternalPackage, nme.materializeConcreteTypeTag)
+         def MacroInternal_materializeClassTag        = getMemberMethod(MacroInternalPackage, nme.materializeClassTag)
+         def MacroInternal_materializeTypeTag         = getMemberMethod(MacroInternalPackage, nme.materializeTypeTag)
+         def MacroInternal_materializeConcreteTypeTag = getMemberMethod(MacroInternalPackage, nme.materializeConcreteTypeTag)
 
     lazy val ScalaSignatureAnnotation = getRequiredClass("scala.reflect.ScalaSignature")
     lazy val ScalaLongSignatureAnnotation = getRequiredClass("scala.reflect.ScalaLongSignature")
 
     // Option classes
-    lazy val OptionClass: Symbol = getRequiredClass("scala.Option")
-    lazy val SomeClass: Symbol   = getRequiredClass("scala.Some")
+    lazy val OptionClass: Symbol = requiredClass[Option[_]]
+    lazy val SomeClass: Symbol   = requiredClass[Some[_]]
     lazy val NoneModule: Symbol  = getRequiredModule("scala.None")
     lazy val SomeModule: Symbol  = getRequiredModule("scala.Some")
 
@@ -618,13 +628,13 @@ trait Definitions extends reflect.api.StandardDefinitions {
     }
     def isTupleType(tp: Type) = isTupleTypeDirect(tp.normalize)
 
-    lazy val ProductRootClass: Symbol = getRequiredClass("scala.Product")
-      def Product_productArity = getMember(ProductRootClass, nme.productArity)
-      def Product_productElement = getMember(ProductRootClass, nme.productElement)
-      // def Product_productElementName = getMember(ProductRootClass, nme.productElementName)
-      def Product_iterator = getMember(ProductRootClass, nme.productIterator)
-      def Product_productPrefix = getMember(ProductRootClass, nme.productPrefix)
-      def Product_canEqual = getMember(ProductRootClass, nme.canEqual_)
+    lazy val ProductRootClass: ClassSymbol = requiredClass[scala.Product]
+      def Product_productArity          = getMemberMethod(ProductRootClass, nme.productArity)
+      def Product_productElement        = getMemberMethod(ProductRootClass, nme.productElement)
+      def Product_iterator              = getMemberMethod(ProductRootClass, nme.productIterator)
+      def Product_productPrefix         = getMemberMethod(ProductRootClass, nme.productPrefix)
+      def Product_canEqual              = getMemberMethod(ProductRootClass, nme.canEqual_)
+      // def Product_productElementName = getMemberMethod(ProductRootClass, nme.productElementName)
 
       def productProj(z:Symbol, j: Int): Symbol = getMember(z, nme.productAccessorName(j))
       def productProj(n: Int,   j: Int): Symbol = productProj(ProductClass(n), j)
@@ -949,7 +959,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
       // Trying to allow for deprecated locations
       sym.isAliasType && isMetaAnnotation(sym.info.typeSymbol)
     )
-    lazy val metaAnnotations = Set(
+    lazy val metaAnnotations = Set[Symbol](
       FieldTargetClass, ParamTargetClass,
       GetterTargetClass, SetterTargetClass,
       BeanGetterTargetClass, BeanSetterTargetClass
@@ -968,31 +978,64 @@ trait Definitions extends reflect.api.StandardDefinitions {
     def getPackageObject(fullname: String): Symbol =
       getModule(newTermName(fullname)).info member nme.PACKAGE
 
-    def getModule(fullname: Name): Symbol =
-      getModuleOrClass(fullname.toTermName)
+    def getModule(fullname: Name): ModuleSymbol =
+      getModuleOrClass(fullname.toTermName) match {
+        case x: ModuleSymbol => x
+        case _               => MissingRequirementError.notFound("object " + fullname)
+      }
 
-    def getClass(fullname: Name): Symbol = {
-      var result = getModuleOrClass(fullname.toTypeName)
-      while (result.isAliasType) result = result.info.typeSymbol
-      result
+    def getPackage(fullname: Name): PackageSymbol =
+      getModuleOrClass(fullname.toTermName) match {
+        case x: PackageSymbol => x
+        case _                => MissingRequirementError.notFound("package " + fullname)
+      }
+    @inline private def wrapMissing(body: => Symbol): Symbol =
+      try body
+      catch { case _: MissingRequirementError => NoSymbol }
+
+    private def fatalMissingSymbol(owner: Symbol, name: Name, what: String = "member") = {
+      throw new FatalError(owner + " does not have a " + what + " " + name)
     }
 
-    def getRequiredModule(fullname: String): Symbol =
+    @deprecated("Use getClassByName", "2.10.0")
+    def getClass(fullname: Name): Symbol = getClassByName(fullname)
+
+    def getRequiredPackage(fullname: String): PackageSymbol =
+      getPackage(newTermNameCached(fullname))
+
+    def getRequiredModule(fullname: String): ModuleSymbol =
       getModule(newTermNameCached(fullname))
-    def getRequiredClass(fullname: String): Symbol =
-      getClass(newTypeNameCached(fullname))
+
+    def requiredClass[T: ClassTag] : ClassSymbol =
+      getRequiredClass(classTag[T].erasure.getName)
+
+    // TODO: What syntax do we think should work here? Say you have an object
+    // like scala.Predef.  You can't say requiredModule[scala.Predef] since there's
+    // no accompanying Predef class, and if you say requiredModule[scala.Predef.type]
+    // the name found via the erasure is scala.Predef$.  For now I am
+    // removing the trailing $, but I think that classTag should have
+    // a method which returns a usable name, one which doesn't expose this
+    // detail of the backend.
+    def requiredModule[T: ClassTag] : ModuleSymbol =
+      getRequiredModule(classTag[T].erasure.getName stripSuffix "$")
+
+    def getRequiredClass(fullname: String): ClassSymbol =
+      getClassByName(newTypeNameCached(fullname)) match {
+        case x: ClassSymbol => x
+        case _              => MissingRequirementError.notFound("class " + fullname)
+      }
 
     def getClassIfDefined(fullname: String): Symbol =
       getClassIfDefined(newTypeName(fullname))
+
     def getClassIfDefined(fullname: Name): Symbol =
-      try getClass(fullname.toTypeName)
-      catch { case _: MissingRequirementError => NoSymbol }
+      wrapMissing(getClass(fullname.toTypeName))
 
     def getModuleIfDefined(fullname: String): Symbol =
       getModuleIfDefined(newTermName(fullname))
+
     def getModuleIfDefined(fullname: Name): Symbol =
-      try getModule(fullname.toTermName)
-      catch { case _: MissingRequirementError => NoSymbol }
+      wrapMissing(getModule(fullname.toTermName))
 
     def getLanguageFeature(name: String, owner: Symbol = languageFeatureModule) =
       getMember(owner, newTypeName(name))
@@ -1020,11 +1063,29 @@ trait Definitions extends reflect.api.StandardDefinitions {
           val pkg = owner.owner
           val flatname = nme.flattenedName(owner.name, name)
           getMember(pkg, flatname)
-        } else {
-        throw new FatalError(owner + " does not have a member " + name)
+        }
+        else fatalMissingSymbol(owner, name)
+      }
+    }
+    def getMemberModule(owner: Symbol, name: Name): ModuleSymbol = {
+      getMember(owner, name.toTermName) match {
+        case x: ModuleSymbol => x
+        case _               => fatalMissingSymbol(owner, name, "member object")
+      }
+    }
+    def getMemberClass(owner: Symbol, name: Name): ClassSymbol = {
+      getMember(owner, name.toTypeName) match {
+        case x: ClassSymbol => x
+        case _              => fatalMissingSymbol(owner, name, "member class")
       }
     }
+    def getMemberMethod(owner: Symbol, name: Name): MethodSymbol = {
+      getMember(owner, name.toTermName) match {
+        case x: MethodSymbol => x
+        case _               => fatalMissingSymbol(owner, name, "method")
+      }
     }
+
     def getMemberIfDefined(owner: Symbol, name: Name): Symbol =
       owner.info.nonPrivateMember(name)
 
@@ -1033,9 +1094,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
      *  know the method in question is uniquely declared in the given owner.
      */
     def getDecl(owner: Symbol, name: Name): Symbol = {
-      getDeclIfDefined(owner, name) orElse {
-        throw new FatalError(owner + " does not have a decl " + name)
-      }
+      getDeclIfDefined(owner, name) orElse fatalMissingSymbol(owner, name, "decl")
     }
     def getDeclIfDefined(owner: Symbol, name: Name): Symbol =
       owner.info.nonPrivateDecl(name)
@@ -1065,10 +1124,16 @@ trait Definitions extends reflect.api.StandardDefinitions {
      */
     private def getModuleOrClass(path: Name): Symbol = getModuleOrClass(path, path.length)
 
-    private def newAlias(owner: Symbol, name: TypeName, alias: Type): Symbol =
+    private def getClassByName(fullname: Name): Symbol = {
+      var result = getModuleOrClass(fullname.toTypeName)
+      while (result.isAliasType) result = result.info.typeSymbol
+      result
+    }
+
+    private def newAlias(owner: Symbol, name: TypeName, alias: Type): AliasTypeSymbol =
       owner.newAliasType(name) setInfoAndEnter alias
 
-    private def specialPolyClass(name: TypeName, flags: Long)(parentFn: Symbol => Type): Symbol = {
+    private def specialPolyClass(name: TypeName, flags: Long)(parentFn: Symbol => Type): ClassSymbol = {
       val clazz   = enterNewClass(ScalaPackageClass, name, Nil)
       val tparam  = clazz.newSyntheticTypeParam("T0", flags)
       val parents = List(AnyRefClass.tpe, parentFn(tparam))
@@ -1076,7 +1141,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
       clazz setInfo GenPolyType(List(tparam), ClassInfoType(parents, newScope, clazz))
     }
 
-    def newPolyMethod(typeParamCount: Int, owner: Symbol, name: TermName, flags: Long)(createFn: PolyMethodCreator): Symbol = {
+    def newPolyMethod(typeParamCount: Int, owner: Symbol, name: TermName, flags: Long)(createFn: PolyMethodCreator): MethodSymbol = {
       val msym    = owner.newMethod(name.encode, NoPosition, flags)
       val tparams = msym.newSyntheticTypeParams(typeParamCount)
       val mtpe    = createFn(tparams) match {
@@ -1089,16 +1154,16 @@ trait Definitions extends reflect.api.StandardDefinitions {
 
     /** T1 means one type parameter.
      */
-    def newT1NullaryMethod(owner: Symbol, name: TermName, flags: Long)(createFn: Symbol => Type): Symbol = {
+    def newT1NullaryMethod(owner: Symbol, name: TermName, flags: Long)(createFn: Symbol => Type): MethodSymbol = {
       newPolyMethod(1, owner, name, flags)(tparams => (None, createFn(tparams.head)))
     }
-    def newT1NoParamsMethod(owner: Symbol, name: TermName, flags: Long)(createFn: Symbol => Type): Symbol = {
+    def newT1NoParamsMethod(owner: Symbol, name: TermName, flags: Long)(createFn: Symbol => Type): MethodSymbol = {
       newPolyMethod(1, owner, name, flags)(tparams => (Some(Nil), createFn(tparams.head)))
     }
 
-    lazy val boxedClassValues = boxedClass.values.toSet
-    lazy val isUnbox = unboxMethod.values.toSet
-    lazy val isBox = boxMethod.values.toSet
+    lazy val boxedClassValues = boxedClass.values.toSet[Symbol]
+    lazy val isUnbox = unboxMethod.values.toSet[Symbol]
+    lazy val isBox = boxMethod.values.toSet[Symbol]
 
     /** Is symbol a phantom class for which no runtime representation exists? */
     lazy val isPhantomClass = Set[Symbol](AnyClass, AnyValClass, NullClass, NothingClass)
@@ -1106,8 +1171,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
     /** Is the symbol that of a parent which is added during parsing? */
     lazy val isPossibleSyntheticParent = ProductClass.toSet[Symbol] + ProductRootClass + SerializableClass
 
-    lazy val scalaValueClassesSet = ScalaValueClasses.toSet
-    private lazy val boxedValueClassesSet = boxedClass.values.toSet + BoxedUnitClass
+    private lazy val boxedValueClassesSet = boxedClass.values.toSet[Symbol] + BoxedUnitClass
 
     /** Is symbol a value class? */
     def isPrimitiveValueClass(sym: Symbol) = ScalaValueClasses contains sym
diff --git a/src/compiler/scala/reflect/internal/NameManglers.scala b/src/compiler/scala/reflect/internal/NameManglers.scala
deleted file mode 100644
index ac22017569..0000000000
--- a/src/compiler/scala/reflect/internal/NameManglers.scala
+++ /dev/null
@@ -1,216 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2011 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.reflect
-package internal
-
-import java.security.MessageDigest
-import scala.io.Codec
-import Chars.isOperatorPart
-
-/** A trait to encapsulate name mangling.  It's intended for the
- *  values and methods involved in assembling names out of other names,
- *  and not for simple synthetically named locals.
- */
-trait NameManglers {
-  self: SymbolTable =>
-
-  trait NameManglingCommon {
-    self: CommonNames =>
-
-    val MODULE_SUFFIX_STRING = NameTransformer.MODULE_SUFFIX_STRING
-    val NAME_JOIN_STRING     = NameTransformer.NAME_JOIN_STRING
-
-    val MODULE_SUFFIX_NAME: TermName = newTermName(MODULE_SUFFIX_STRING)
-    val NAME_JOIN_NAME: TermName     = newTermName(NAME_JOIN_STRING)
-
-    def flattenedName(segments: Name*): NameType = compactedString(segments mkString NAME_JOIN_STRING)
-
-    /**
-     * COMPACTIFY
-     *
-     * The hashed name has the form (prefix + marker + md5 + marker + suffix), where
-     *   - prefix/suffix.length = MaxNameLength / 4
-     *   - md5.length = 32
-     *
-     * We obtain the formula:
-     *
-     *   FileNameLength = 2*(MaxNameLength / 4) + 2.marker.length + 32 + 6
-     *
-     * (+6 for ".class"). MaxNameLength can therefore be computed as follows:
-     */
-    private final val marker = "$$$$"
-    private final val MaxNameLength = math.min(
-      settings.maxClassfileName.value - 6,
-      2 * (settings.maxClassfileName.value - 6 - 2*marker.length - 32)
-    )
-    private lazy val md5 = MessageDigest.getInstance("MD5")
-    private def toMD5(s: String, edge: Int) = {
-      val prefix = s take edge
-      val suffix = s takeRight edge
-
-      val cs = s.toArray
-      val bytes = Codec toUTF8 cs
-      md5 update bytes
-      val md5chars = md5.digest() map (b => (b & 0xFF).toHexString) mkString
-
-      prefix + marker + md5chars + marker + suffix
-    }
-    private def compactedString(s: String) =
-      if (s.length <= MaxNameLength) s
-      else toMD5(s, MaxNameLength / 4)
-  }
-
-  trait TypeNameMangling extends NameManglingCommon {
-    self: tpnme.type =>
-
-  }
-
-  trait TermNameMangling extends NameManglingCommon {
-    self: nme.type =>
-
-    val IMPL_CLASS_SUFFIX             = "$class"
-    val LOCALDUMMY_PREFIX             = "<local "   // owner of local blocks
-    val PROTECTED_PREFIX              = "protected$"
-    val PROTECTED_SET_PREFIX          = PROTECTED_PREFIX + "set"
-    val SINGLETON_SUFFIX              = ".type"
-    val SUPER_PREFIX_STRING           = "super$"
-    val TRAIT_SETTER_SEPARATOR_STRING = "$_setter_$"
-    val SETTER_SUFFIX: TermName = encode("_=")
-
-    @deprecated("Use SPECIALIZED_SUFFIX", "2.10.0")
-    def SPECIALIZED_SUFFIX_STRING = SPECIALIZED_SUFFIX.toString
-    @deprecated("Use SPECIALIZED_SUFFIX", "2.10.0")
-    def SPECIALIZED_SUFFIX_NAME: TermName = SPECIALIZED_SUFFIX.toTermName
-
-    def isConstructorName(name: Name)       = name == CONSTRUCTOR || name == MIXIN_CONSTRUCTOR
-    def isExceptionResultName(name: Name)   = name startsWith EXCEPTION_RESULT_PREFIX
-    def isImplClassName(name: Name)         = name endsWith IMPL_CLASS_SUFFIX
-    def isLocalDummyName(name: Name)        = name startsWith LOCALDUMMY_PREFIX
-    def isLocalName(name: Name)             = name endsWith LOCAL_SUFFIX_STRING
-    def isLoopHeaderLabel(name: Name)       = (name startsWith WHILE_PREFIX) || (name startsWith DO_WHILE_PREFIX)
-    def isProtectedAccessorName(name: Name) = name startsWith PROTECTED_PREFIX
-    def isSuperAccessorName(name: Name)     = name startsWith SUPER_PREFIX_STRING
-    def isReplWrapperName(name: Name)       = name containsName INTERPRETER_IMPORT_WRAPPER
-    def isSetterName(name: Name)            = name endsWith SETTER_SUFFIX
-    def isTraitSetterName(name: Name)       = isSetterName(name) && (name containsName TRAIT_SETTER_SEPARATOR_STRING)
-    def isSingletonName(name: Name)         = name endsWith SINGLETON_SUFFIX
-    def isModuleName(name: Name)            = name endsWith MODULE_SUFFIX_NAME
-
-    def isOpAssignmentName(name: Name) = name match {
-      case raw.NE | raw.LE | raw.GE | EMPTY => false
-      case _                                =>
-        name.endChar == '=' && name.startChar != '=' && isOperatorPart(name.startChar)
-    }
-
-    /** The expanded setter name of `name` relative to this class `base`
-     */
-    def expandedSetterName(name: TermName, base: Symbol): TermName =
-      expandedName(name, base, separator = TRAIT_SETTER_SEPARATOR_STRING)
-
-    /** If `name` is an expandedName name, the original name.
-     *  Otherwise `name` itself.
-     */
-    def originalName(name: Name): Name = {
-      var i = name.length
-      while (i >= 2 && !(name(i - 1) == '$' && name(i - 2) == '$')) i -= 1
-      if (i >= 2) {
-        while (i >= 3 && name(i - 3) == '$') i -= 1
-        name.subName(i, name.length)
-      } else name
-    }
-
-    def unspecializedName(name: Name): Name = (
-      if (name endsWith SPECIALIZED_SUFFIX)
-        name.subName(0, name.lastIndexOf('m') - 1)
-      else name
-    )
-
-   /** Return the original name and the types on which this name
-     *  is specialized. For example,
-     *  {{{
-     *     splitSpecializedName("foo$mIcD$sp") == ('foo', "I", "D")
-     *  }}}
-     *  `foo$mIcD$sp` is the name of a method specialized on two type
-     *  parameters, the first one belonging to the method itself, on Int,
-     *  and another one belonging to the enclosing class, on Double.
-     */
-    def splitSpecializedName(name: Name): (Name, String, String) =
-      if (name endsWith SPECIALIZED_SUFFIX) {
-        val name1 = name dropRight SPECIALIZED_SUFFIX.length
-        val idxC  = name1 lastIndexOf 'c'
-        val idxM  = name1 lastIndexOf 'm'
-
-        (name1.subName(0, idxM - 1),
-         name1.subName(idxC + 1, name1.length).toString,
-         name1.subName(idxM + 1, idxC).toString)
-      } else
-        (name, "", "")
-
-    def getterName(name: TermName): TermName     = if (isLocalName(name)) localToGetter(name) else name
-    def getterToLocal(name: TermName): TermName  = name append LOCAL_SUFFIX_STRING
-    def getterToSetter(name: TermName): TermName = name append SETTER_SUFFIX
-    def localToGetter(name: TermName): TermName  = name dropRight LOCAL_SUFFIX_STRING.length
-
-    def dropLocalSuffix(name: Name): Name  = if (name endsWith ' ') name dropRight 1 else name
-
-    def setterToGetter(name: TermName): TermName = {
-      val p = name.pos(TRAIT_SETTER_SEPARATOR_STRING)
-      if (p < name.length)
-        setterToGetter(name drop (p + TRAIT_SETTER_SEPARATOR_STRING.length))
-      else
-        name.subName(0, name.length - SETTER_SUFFIX.length)
-    }
-
-    def defaultGetterName(name: Name, pos: Int): TermName = {
-      val prefix = if (isConstructorName(name)) "init" else name
-      newTermName(prefix + DEFAULT_GETTER_STRING + pos)
-    }
-    def defaultGetterToMethod(name: Name): TermName = {
-      val p = name.pos(DEFAULT_GETTER_STRING)
-      if (p < name.length) name.toTermName.subName(0, p)
-      else name.toTermName
-    }
-
-    // def anonNumberSuffix(name: Name): Name = {
-    //   ("" + name) lastIndexOf '$' match {
-    //     case -1   => nme.EMPTY
-    //     case idx  =>
-    //       val s = name drop idx
-    //       if (s.toString forall (_.isDigit)) s
-    //       else nme.EMPTY
-    //   }
-    // }
-
-    // If the name ends with $nn where nn are
-    // all digits, strip the $ and the digits.
-    // Otherwise return the argument.
-    def stripAnonNumberSuffix(name: Name): Name = {
-      var pos = name.length
-      while (pos > 0 && name(pos - 1).isDigit)
-        pos -= 1
-
-      if (pos <= 0 || pos == name.length || name(pos - 1) != '$') name
-      else name.subName(0, pos - 1)
-    }
-
-    def stripModuleSuffix(name: Name): Name = (
-      if (isModuleName(name)) name dropRight MODULE_SUFFIX_STRING.length else name
-    )
-
-    def dropSingletonName(name: Name): TypeName = name dropRight SINGLETON_SUFFIX.length toTypeName
-    def singletonName(name: Name): TypeName     = name append SINGLETON_SUFFIX toTypeName
-    def implClassName(name: Name): TypeName     = name append IMPL_CLASS_SUFFIX toTypeName
-    def interfaceName(implname: Name): TypeName = implname dropRight IMPL_CLASS_SUFFIX.length toTypeName
-    def localDummyName(clazz: Symbol): TermName = newTermName(LOCALDUMMY_PREFIX + clazz.name + ">")
-    def superName(name: Name): TermName         = newTermName(SUPER_PREFIX_STRING + name)
-
-    /** The name of an accessor for protected symbols. */
-    def protName(name: Name): TermName = newTermName(PROTECTED_PREFIX + name)
-
-    /** The name of a setter for protected symbols. Used for inherited Java fields. */
-    def protSetterName(name: Name): TermName = newTermName(PROTECTED_SET_PREFIX + name)
-  }
-}
diff --git a/src/compiler/scala/reflect/internal/Names.scala b/src/compiler/scala/reflect/internal/Names.scala
index d2b55d9d39..dc89b14869 100644
--- a/src/compiler/scala/reflect/internal/Names.scala
+++ b/src/compiler/scala/reflect/internal/Names.scala
@@ -356,8 +356,10 @@ trait Names extends api.Names {
     final def endsWith(char: Char): Boolean     = len > 0 && endChar == char
     final def endsWith(name: String): Boolean   = endsWith(newTermName(name))
 
-    def dropRight(n: Int) = subName(0, len - n)
-    def drop(n: Int) = subName(n, len)
+    def dropRight(n: Int): ThisNameType = subName(0, len - n)
+    def drop(n: Int): ThisNameType = subName(n, len)
+    def stripSuffix(suffix: Name): ThisNameType =
+      if (this endsWith suffix) dropRight(suffix.length) else thisName
 
     def indexOf(ch: Char) = {
       val idx = pos(ch)
diff --git a/src/compiler/scala/reflect/internal/Scopes.scala b/src/compiler/scala/reflect/internal/Scopes.scala
index ef48d6102f..36e8ebb212 100644
--- a/src/compiler/scala/reflect/internal/Scopes.scala
+++ b/src/compiler/scala/reflect/internal/Scopes.scala
@@ -113,7 +113,7 @@ trait Scopes extends api.Scopes { self: SymbolTable =>
      *
      *  @param sym ...
      */
-    def enter(sym: Symbol): Symbol = { enter(newScopeEntry(sym, this)); sym }
+    def enter[T <: Symbol](sym: T): T = { enter(newScopeEntry(sym, this)); sym }
 
     /** enter a symbol, asserting that no symbol with same name exists in scope
      *
diff --git a/src/compiler/scala/reflect/internal/StdNames.scala b/src/compiler/scala/reflect/internal/StdNames.scala
index c5fe1ecb45..54be83c98f 100644
--- a/src/compiler/scala/reflect/internal/StdNames.scala
+++ b/src/compiler/scala/reflect/internal/StdNames.scala
@@ -6,27 +6,141 @@
 package scala.reflect
 package internal
 
-import scala.collection.immutable
-import NameTransformer.MODULE_SUFFIX_STRING
+import java.security.MessageDigest
+import Chars.isOperatorPart
 import annotation.switch
 import language.implicitConversions
+import scala.collection.immutable
+import scala.io.Codec
 
-trait StdNames extends NameManglers { self: SymbolTable =>
+trait StdNames {
+  self: SymbolTable =>
 
   def encode(str: String): TermName = newTermNameCached(NameTransformer.encode(str))
 
   implicit def lowerTermNames(n: TermName): String = n.toString
 
-  // implicit def stringToTermName(s: String): TermName = newTermName(s)
-
-  /** This should be the first trait in the linearization. */
-  trait Keywords {
+  /** Tensions: would like the keywords to be the very first names entered into the names
+   *  storage so their ids count from 0, which simplifies the parser. Switched to abstract
+   *  classes to avoid all the indirection which is generated with implementation-containing
+   *  traits. Since all these classes use eager vals, that means the constructor with the
+   *  keywords must run first. If it's the top in the superclass chain, then CommonNames
+   *  must inherit from it, which means TypeNames would inherit keywords as well.
+   *
+   *  Solution: Keywords extends CommonNames and uses early defs to beat the
+   *  CommonNames constructor out of the starting gate.  This is its builder.
+   */
+  private class KeywordSetBuilder {
     private var kws: Set[TermName] = Set()
-    private def kw(s: String): TermName = {
+    def apply(s: String): TermName = {
       val result = newTermNameCached(s)
       kws = kws + result
       result
     }
+    def result: Set[TermName] = {
+      val result = kws
+      kws = null
+      result
+    }
+  }
+
+  private final object compactify extends (String => String) {
+    val md5 = MessageDigest.getInstance("MD5")
+
+    /**
+     * COMPACTIFY
+     *
+     * The hashed name has the form (prefix + marker + md5 + marker + suffix), where
+     *   - prefix/suffix.length = MaxNameLength / 4
+     *   - md5.length = 32
+     *
+     * We obtain the formula:
+     *
+     *   FileNameLength = 2*(MaxNameLength / 4) + 2.marker.length + 32 + 6
+     *
+     * (+6 for ".class"). MaxNameLength can therefore be computed as follows:
+     */
+    val marker = "$$$$"
+    val MaxNameLength = math.min(
+      settings.maxClassfileName.value - 6,
+      2 * (settings.maxClassfileName.value - 6 - 2*marker.length - 32)
+    )
+    def toMD5(s: String, edge: Int): String = {
+      val prefix = s take edge
+      val suffix = s takeRight edge
+
+      val cs = s.toArray
+      val bytes = Codec toUTF8 cs
+      md5 update bytes
+      val md5chars = md5.digest() map (b => (b & 0xFF).toHexString) mkString
+
+      prefix + marker + md5chars + marker + suffix
+    }
+    def apply(s: String): String = (
+      if (s.length <= MaxNameLength) s
+      else toMD5(s, MaxNameLength / 4)
+    )
+  }
+
+  abstract class CommonNames {
+    type NameType <: Name
+    protected implicit def createNameType(name: String): NameType
+
+    def flattenedName(segments: Name*): NameType =
+      compactify(segments mkString NAME_JOIN_STRING)
+
+    val MODULE_SUFFIX_STRING: String = NameTransformer.MODULE_SUFFIX_STRING
+    val NAME_JOIN_STRING: String     = NameTransformer.NAME_JOIN_STRING
+    val SINGLETON_SUFFIX: String     = ".type"
+
+    val ANON_CLASS_NAME: NameType    = "$anon"
+    val ANON_FUN_NAME: NameType      = "$anonfun"
+    val EMPTY: NameType              = ""
+    val EMPTY_PACKAGE_NAME: NameType = "<empty>"
+    val IMPL_CLASS_SUFFIX            = "$class"
+    val IMPORT: NameType             = "<import>"
+    val MODULE_SUFFIX_NAME: NameType = MODULE_SUFFIX_STRING
+    val MODULE_VAR_SUFFIX: NameType  = "$module"
+    val NAME_JOIN_NAME: NameType     = NAME_JOIN_STRING
+    val PACKAGE: NameType            = "package"
+    val ROOT: NameType               = "<root>"
+    val SPECIALIZED_SUFFIX: NameType = "$sp"
+
+    // value types (and AnyRef) are all used as terms as well
+    // as (at least) arguments to the @specialize annotation.
+    final val Boolean: NameType = "Boolean"
+    final val Byte: NameType    = "Byte"
+    final val Char: NameType    = "Char"
+    final val Double: NameType  = "Double"
+    final val Float: NameType   = "Float"
+    final val Int: NameType     = "Int"
+    final val Long: NameType    = "Long"
+    final val Short: NameType   = "Short"
+    final val Unit: NameType    = "Unit"
+
+    final val ScalaValueNames: scala.List[NameType] =
+      scala.List(Byte, Char, Short, Int, Long, Float, Double, Boolean, Unit)
+
+    // some types whose companions we utilize
+    final val AnyRef: NameType = "AnyRef"
+    final val Array: NameType  = "Array"
+    final val List: NameType   = "List"
+    final val Seq: NameType    = "Seq"
+    final val Symbol: NameType = "Symbol"
+    final val ClassTag: NameType = "ClassTag"
+    final val TypeTag : NameType = "TypeTag"
+    final val ConcreteTypeTag: NameType = "ConcreteTypeTag"
+
+    // fictions we use as both types and terms
+    final val ERROR: NameType    = "<error>"
+    final val NO_NAME: NameType  = "<none>"  // formerly NOSYMBOL
+    final val WILDCARD: NameType = "_"
+  }
+
+  /** This should be the first trait in the linearization. */
+  // abstract class Keywords extends CommonNames {
+  abstract class Keywords extends {
+    private val kw = new KeywordSetBuilder
 
     final val ABSTRACTkw: TermName  = kw("abstract")
     final val CASEkw: TermName      = kw("case")
@@ -81,66 +195,20 @@ trait StdNames extends NameManglers { self: SymbolTable =>
     final val HASHkw: TermName      = kw("#")
     final val ATkw: TermName        = kw("@")
 
-    final val keywords = {
-      val result = kws.toSet
-      kws = null
-      result
-    }
-
+    final val keywords = kw.result
+  } with CommonNames {
     final val javaKeywords = new JavaKeywords()
   }
 
-  trait CommonNames /*extends LibraryCommonNames*/ {
-
-    type NameType <: Name
-    protected implicit def createNameType(name: String): NameType
-
-    val EMPTY: NameType              = ""
-    val ANON_FUN_NAME: NameType      = "$anonfun"
-    val ANON_CLASS_NAME: NameType    = "$anon"
-    val EMPTY_PACKAGE_NAME: NameType = "<empty>"
-    val IMPORT: NameType             = "<import>"
-    val MODULE_VAR_SUFFIX: NameType  = "$module"
-    val ROOT: NameType               = "<root>"
-    val PACKAGE: NameType            = "package"
-    val SPECIALIZED_SUFFIX: NameType = "$sp"
-
-    // value types (and AnyRef) are all used as terms as well
-    // as (at least) arguments to the @specialize annotation.
-    final val Boolean: NameType = "Boolean"
-    final val Byte: NameType    = "Byte"
-    final val Char: NameType    = "Char"
-    final val Double: NameType  = "Double"
-    final val Float: NameType   = "Float"
-    final val Int: NameType     = "Int"
-    final val Long: NameType    = "Long"
-    final val Short: NameType   = "Short"
-    final val Unit: NameType    = "Unit"
-
-    final val ScalaValueNames: scala.List[NameType] =
-      scala.List(Byte, Char, Short, Int, Long, Float, Double, Boolean, Unit)
-
-    // some types whose companions we utilize
-    final val AnyRef: NameType = "AnyRef"
-    final val Array: NameType  = "Array"
-    final val List: NameType   = "List"
-    final val Seq: NameType    = "Seq"
-    final val Symbol: NameType = "Symbol"
-    final val ClassTag: NameType = "ClassTag"
-    final val TypeTag : NameType = "TypeTag"
-    final val ConcreteTypeTag: NameType = "ConcreteTypeTag"
-
-    // fictions we use as both types and terms
-    final val ERROR: NameType    = "<error>"
-    final val NO_NAME: NameType  = "<none>"  // formerly NOSYMBOL
-    final val WILDCARD: NameType = "_"
-  }
+  abstract class TypeNames extends Keywords {
+    type NameType = TypeName
+    protected implicit def createNameType(name: String): TypeName = newTypeNameCached(name)
 
-  trait TypeNames extends CommonNames {
     final val BYNAME_PARAM_CLASS_NAME: NameType        = "<byname>"
     final val EQUALS_PATTERN_NAME: NameType            = "<equals>"
     final val JAVA_REPEATED_PARAM_CLASS_NAME: NameType = "<repeated...>"
     final val LOCAL_CHILD: NameType                    = "<local child>"
+    final val REFINE_CLASS_NAME: NameType              = "<refinement>"
     final val REPEATED_PARAM_CLASS_NAME: NameType      = "<repeated>"
     final val WILDCARD_STAR: NameType                  = "_*"
 
@@ -161,7 +229,7 @@ trait StdNames extends NameManglers { self: SymbolTable =>
     final val Annotation: NameType          = "Annotation"
     final val ClassfileAnnotation: NameType = "ClassfileAnnotation"
     final val Enum: NameType                = "Enum"
-
+    final val Group: NameType            = "Group"
     final val Tree: NameType             = "Tree"
     final val TypeTree: NameType         = "TypeTree"
 
@@ -189,34 +257,195 @@ trait StdNames extends NameManglers { self: SymbolTable =>
     final val SignatureATTR: NameType              = "Signature"
     final val SourceFileATTR: NameType             = "SourceFile"
     final val SyntheticATTR: NameType              = "Synthetic"
+
+    def dropSingletonName(name: Name): TypeName = name dropRight SINGLETON_SUFFIX.length toTypeName
+    def singletonName(name: Name): TypeName     = name append SINGLETON_SUFFIX toTypeName
+    def implClassName(name: Name): TypeName     = name append IMPL_CLASS_SUFFIX toTypeName
+    def interfaceName(implname: Name): TypeName = implname dropRight IMPL_CLASS_SUFFIX.length toTypeName
   }
 
-  trait TermNames extends Keywords with CommonNames {
+  abstract class TermNames extends Keywords {
+    type NameType = TermName
+    protected implicit def createNameType(name: String): TermName = newTermNameCached(name)
+
+    /** Base strings from which synthetic names are derived. */
+    val BITMAP_PREFIX                 = "bitmap$"
+    val CHECK_IF_REFUTABLE_STRING     = "check$ifrefutable$"
+    val DEFAULT_GETTER_STRING         = "$default$"
+    val DO_WHILE_PREFIX               = "doWhile$"
+    val EVIDENCE_PARAM_PREFIX         = "evidence$"
+    val EXCEPTION_RESULT_PREFIX       = "exceptionResult"
+    val EXPAND_SEPARATOR_STRING       = "$$"
+    val INTERPRETER_IMPORT_WRAPPER    = "$iw"
+    val INTERPRETER_LINE_PREFIX       = "line"
+    val INTERPRETER_VAR_PREFIX        = "res"
+    val INTERPRETER_WRAPPER_SUFFIX    = "$object"
+    val LOCALDUMMY_PREFIX             = "<local "       // owner of local blocks
+    val PROTECTED_PREFIX              = "protected$"
+    val PROTECTED_SET_PREFIX          = PROTECTED_PREFIX + "set"
+    val SUPER_PREFIX_STRING           = "super$"
+    val TRAIT_SETTER_SEPARATOR_STRING = "$_setter_$"
+    val WHILE_PREFIX                  = "while$"
+
     // Compiler internal names
-    val EXPAND_SEPARATOR_STRING             = "$$"
-
-    val ANYNAME: NameType                   = "<anyname>"
-    val CONSTRUCTOR: NameType               = "<init>"
-    val FAKE_LOCAL_THIS: NameType           = "this$"
-    val INITIALIZER: NameType               = CONSTRUCTOR // Is this buying us something?
-    val LAZY_LOCAL: NameType                = "$lzy"
-    val LOCAL_SUFFIX_STRING                 = " "
-    val MIRROR_PREFIX: NameType             = "$mr."
-    val MIRROR_SHORT: NameType              = "$mr"
-    val MIRROR_FREE_PREFIX: NameType        = "free$"
-    val MIRROR_FREE_THIS_SUFFIX: NameType   = "$this"
-    val MIRROR_FREE_VALUE_SUFFIX: NameType  = "$value"
-    val MIRROR_SYMDEF_PREFIX: NameType      = "symdef$"
-    val MIXIN_CONSTRUCTOR: NameType         = "$init$"
-    val MODULE_INSTANCE_FIELD: NameType     = NameTransformer.MODULE_INSTANCE_NAME  // "MODULE$"
-    val OUTER: NameType                     = "$outer"
-    val OUTER_LOCAL: NameType               = OUTER + LOCAL_SUFFIX_STRING // "$outer ", note the space
-    val OUTER_SYNTH: NameType               = "<outer>" // emitted by virtual pattern matcher, replaced by outer accessor in explicitouter
-    val SELECTOR_DUMMY: NameType            = "<unapply-selector>"
-    val SELF: NameType                      = "$this"
-    val SPECIALIZED_INSTANCE: NameType      = "specInstance$"
-    val STAR: NameType                      = "*"
-    val THIS: NameType                      = "_$this"
+    val ANYNAME: NameType                  = "<anyname>"
+    val CONSTRUCTOR: NameType              = "<init>"
+    val FAKE_LOCAL_THIS: NameType          = "this$"
+    val INITIALIZER: NameType              = CONSTRUCTOR // Is this buying us something?
+    val LAZY_LOCAL: NameType               = "$lzy"
+    val LOCAL_SUFFIX_STRING                = " "
+    val MIRROR_FREE_PREFIX: NameType       = "free$"
+    val MIRROR_FREE_THIS_SUFFIX: NameType  = "$this"
+    val MIRROR_FREE_VALUE_SUFFIX: NameType = "$value"
+    val MIRROR_PREFIX: NameType            = "$mr."
+    val MIRROR_SHORT: NameType             = "$mr"
+    val MIRROR_SYMDEF_PREFIX: NameType     = "symdef$"
+    val MIXIN_CONSTRUCTOR: NameType        = "$init$"
+    val MODULE_INSTANCE_FIELD: NameType    = NameTransformer.MODULE_INSTANCE_NAME  // "MODULE$"
+    val OUTER: NameType                    = "$outer"
+    val OUTER_LOCAL: NameType              = OUTER + LOCAL_SUFFIX_STRING // "$outer ", note the space
+    val OUTER_SYNTH: NameType              = "<outer>" // emitted by virtual pattern matcher, replaced by outer accessor in explicitouter
+    val SELECTOR_DUMMY: NameType           = "<unapply-selector>"
+    val SELF: NameType                     = "$this"
+    val SETTER_SUFFIX: NameType            = encode("_=")
+    val SPECIALIZED_INSTANCE: NameType     = "specInstance$"
+    val STAR: NameType                     = "*"
+    val THIS: NameType                     = "_$this"
+
+    @deprecated("Use SPECIALIZED_SUFFIX", "2.10.0")
+    def SPECIALIZED_SUFFIX_STRING = SPECIALIZED_SUFFIX.toString
+    @deprecated("Use SPECIALIZED_SUFFIX", "2.10.0")
+    def SPECIALIZED_SUFFIX_NAME: TermName = SPECIALIZED_SUFFIX.toTermName
+
+    def isConstructorName(name: Name)       = name == CONSTRUCTOR || name == MIXIN_CONSTRUCTOR
+    def isExceptionResultName(name: Name)   = name startsWith EXCEPTION_RESULT_PREFIX
+    def isImplClassName(name: Name)         = name endsWith IMPL_CLASS_SUFFIX
+    def isLocalDummyName(name: Name)        = name startsWith LOCALDUMMY_PREFIX
+    def isLocalName(name: Name)             = name endsWith LOCAL_SUFFIX_STRING
+    def isLoopHeaderLabel(name: Name)       = (name startsWith WHILE_PREFIX) || (name startsWith DO_WHILE_PREFIX)
+    def isProtectedAccessorName(name: Name) = name startsWith PROTECTED_PREFIX
+    def isSuperAccessorName(name: Name)     = name startsWith SUPER_PREFIX_STRING
+    def isReplWrapperName(name: Name)       = name containsName INTERPRETER_IMPORT_WRAPPER
+    def isSetterName(name: Name)            = name endsWith SETTER_SUFFIX
+    def isTraitSetterName(name: Name)       = isSetterName(name) && (name containsName TRAIT_SETTER_SEPARATOR_STRING)
+    def isSingletonName(name: Name)         = name endsWith SINGLETON_SUFFIX
+    def isModuleName(name: Name)            = name endsWith MODULE_SUFFIX_NAME
+
+    def isOpAssignmentName(name: Name) = name match {
+      case raw.NE | raw.LE | raw.GE | EMPTY => false
+      case _                                =>
+      name.endChar == '=' && name.startChar != '=' && isOperatorPart(name.startChar)
+    }
+
+    /** The expanded name of `name` relative to this class `base` with given `separator`
+     */
+    def expandedName(name: TermName, base: Symbol, separator: String = EXPAND_SEPARATOR_STRING): TermName =
+      newTermNameCached(base.fullName('$') + separator + name)
+
+    /** The expanded setter name of `name` relative to this class `base`
+    */
+    def expandedSetterName(name: TermName, base: Symbol): TermName =
+      expandedName(name, base, separator = TRAIT_SETTER_SEPARATOR_STRING)
+
+    /** If `name` is an expandedName name, the original name.
+    *  Otherwise `name` itself.
+    */
+    def originalName(name: Name): Name = {
+      var i = name.length
+      while (i >= 2 && !(name(i - 1) == '$' && name(i - 2) == '$')) i -= 1
+      if (i >= 2) {
+        while (i >= 3 && name(i - 3) == '$') i -= 1
+        name.subName(i, name.length)
+      } else name
+    }
+
+    def unspecializedName(name: Name): Name = (
+      if (name endsWith SPECIALIZED_SUFFIX)
+      name.subName(0, name.lastIndexOf('m') - 1)
+      else name
+    )
+
+    /*
+    def anonNumberSuffix(name: Name): Name = {
+      ("" + name) lastIndexOf '$' match {
+        case -1   => nme.EMPTY
+        case idx  =>
+          val s = name drop idx
+          if (s.toString forall (_.isDigit)) s
+          else nme.EMPTY
+      }
+    }
+    */
+
+    /** Return the original name and the types on which this name
+    *  is specialized. For example,
+    *  {{{
+    *     splitSpecializedName("foo$mIcD$sp") == ('foo', "I", "D")
+    *  }}}
+    *  `foo$mIcD$sp` is the name of a method specialized on two type
+    *  parameters, the first one belonging to the method itself, on Int,
+    *  and another one belonging to the enclosing class, on Double.
+    */
+    def splitSpecializedName(name: Name): (Name, String, String) =
+    if (name endsWith SPECIALIZED_SUFFIX) {
+      val name1 = name dropRight SPECIALIZED_SUFFIX.length
+      val idxC  = name1 lastIndexOf 'c'
+      val idxM  = name1 lastIndexOf 'm'
+
+      (name1.subName(0, idxM - 1),
+      name1.subName(idxC + 1, name1.length).toString,
+      name1.subName(idxM + 1, idxC).toString)
+    } else
+    (name, "", "")
+
+    def getterName(name: TermName): TermName     = if (isLocalName(name)) localToGetter(name) else name
+    def getterToLocal(name: TermName): TermName  = name append LOCAL_SUFFIX_STRING
+    def getterToSetter(name: TermName): TermName = name append SETTER_SUFFIX
+    def localToGetter(name: TermName): TermName  = name dropRight LOCAL_SUFFIX_STRING.length
+
+    def dropLocalSuffix(name: Name): Name  = if (name endsWith ' ') name dropRight 1 else name
+
+    def setterToGetter(name: TermName): TermName = {
+      val p = name.pos(TRAIT_SETTER_SEPARATOR_STRING)
+      if (p < name.length)
+      setterToGetter(name drop (p + TRAIT_SETTER_SEPARATOR_STRING.length))
+      else
+      name.subName(0, name.length - SETTER_SUFFIX.length)
+    }
+
+    def defaultGetterName(name: Name, pos: Int): TermName = {
+      val prefix = if (isConstructorName(name)) "init" else name
+      newTermName(prefix + DEFAULT_GETTER_STRING + pos)
+    }
+    def defaultGetterToMethod(name: Name): TermName = {
+      val p = name.pos(DEFAULT_GETTER_STRING)
+      if (p < name.length) name.toTermName.subName(0, p)
+      else name.toTermName
+    }
+
+    // If the name ends with $nn where nn are
+    // all digits, strip the $ and the digits.
+    // Otherwise return the argument.
+    def stripAnonNumberSuffix(name: Name): Name = {
+      var pos = name.length
+      while (pos > 0 && name(pos - 1).isDigit)
+      pos -= 1
+
+      if (pos <= 0 || pos == name.length || name(pos - 1) != '$') name
+      else name.subName(0, pos - 1)
+    }
+
+    def stripModuleSuffix(name: Name): Name = (
+      if (isModuleName(name)) name dropRight MODULE_SUFFIX_STRING.length else name
+    )
+    def localDummyName(clazz: Symbol): TermName = newTermName(LOCALDUMMY_PREFIX + clazz.name + ">")
+    def superName(name: Name): TermName         = newTermName(SUPER_PREFIX_STRING + name)
+
+    /** The name of an accessor for protected symbols. */
+    def protName(name: Name): TermName = newTermName(PROTECTED_PREFIX + name)
+
+    /** The name of a setter for protected symbols. Used for inherited Java fields. */
+    def protSetterName(name: Name): TermName = newTermName(PROTECTED_SET_PREFIX + name)
 
     final val Nil: NameType                 = "Nil"
     final val Predef: NameType              = "Predef"
@@ -508,19 +737,11 @@ trait StdNames extends NameManglers { self: SymbolTable =>
     val toInteger: NameType   = "toInteger"
   }
 
-  object tpnme extends AbsTypeNames with TypeNames /*with LibraryTypeNames*/ with TypeNameMangling {
-    type NameType = TypeName
-    protected implicit def createNameType(name: String): TypeName = newTypeNameCached(name)
-
-    val REFINE_CLASS_NAME: NameType  = "<refinement>"
-  }
+  object tpnme extends TypeNames with AbsTypeNames { }
 
   /** For fully qualified type names.
    */
   object fulltpnme extends TypeNames {
-    type NameType = TypeName
-    protected implicit def createNameType(name: String): TypeName = newTypeNameCached(name)
-
     val RuntimeNothing: NameType = "scala.runtime.Nothing$"
     val RuntimeNull: NameType    = "scala.runtime.Null$"
     val JavaLangEnum: NameType   = "java.lang.Enum"
@@ -535,18 +756,9 @@ trait StdNames extends NameManglers { self: SymbolTable =>
     val RuntimeNull    = toBinary(fulltpnme.RuntimeNull).toTypeName
   }
 
-  object fullnme extends TermNames {
-    type NameType = TermName
-    protected implicit def createNameType(name: String): TermName = newTermNameCached(name)
-
-    val MirrorPackage: NameType = "scala.reflect.mirror"
-  }
-
   val javanme = nme.javaKeywords
 
-  object nme extends AbsTermNames with TermNames /*with LibraryTermNames*/ with TermNameMangling {
-    type NameType = TermName
-    protected implicit def createNameType(name: String): TermName = newTermNameCached(name)
+  object nme extends TermNames with AbsTermNames {
 
     /** Translate a String into a list of simple TypeNames and TermNames.
      *  In all segments before the last, type/term is determined by whether
@@ -586,40 +798,20 @@ trait StdNames extends NameManglers { self: SymbolTable =>
 
     def newBitmapName(bitmapPrefix: Name, n: Int) = bitmapPrefix append ("" + n)
 
-    val BITMAP_PREFIX: String                = "bitmap$"
     val BITMAP_NORMAL: NameType              = BITMAP_PREFIX + ""           // initialization bitmap for public/protected lazy vals
     val BITMAP_TRANSIENT: NameType           = BITMAP_PREFIX + "trans$"     // initialization bitmap for transient lazy vals
     val BITMAP_PRIVATE: NameType             = BITMAP_PREFIX + "priv$"      // initialization bitmap for private lazy vals
     val BITMAP_CHECKINIT: NameType           = BITMAP_PREFIX + "init$"      // initialization bitmap for checkinit values
     val BITMAP_CHECKINIT_TRANSIENT: NameType = BITMAP_PREFIX + "inittrans$" // initialization bitmap for transient checkinit values
 
-    /** The expanded name of `name` relative to this class `base` with given `separator`
-     */
-    def expandedName(name: TermName, base: Symbol, separator: String = EXPAND_SEPARATOR_STRING): TermName =
-      newTermNameCached(base.fullName('$') + separator + name)
-
     def isModuleVarName(name: Name): Boolean =
       stripAnonNumberSuffix(name) endsWith MODULE_VAR_SUFFIX
 
     def moduleVarName(name: TermName): TermName =
       newTermNameCached("" + name + MODULE_VAR_SUFFIX)
 
-    val ROOTPKG: TermName       = "_root_"
-
-    /** Base strings from which synthetic names are derived. */
-    val CHECK_IF_REFUTABLE_STRING  = "check$ifrefutable$"
-    val DEFAULT_GETTER_STRING      = "$default$"
-    val DO_WHILE_PREFIX            = "doWhile$"
-    val EQEQ_LOCAL_VAR_STRING      = "eqEqTemp$"
-    val EVIDENCE_PARAM_PREFIX      = "evidence$"
-    val EXCEPTION_RESULT_PREFIX    = "exceptionResult"
-    val INTERPRETER_IMPORT_WRAPPER = "$iw"
-    val INTERPRETER_LINE_PREFIX    = "line"
-    val INTERPRETER_VAR_PREFIX     = "res"
-    val INTERPRETER_WRAPPER_SUFFIX = "$object"
-    val WHILE_PREFIX               = "while$"
-
-    val EQEQ_LOCAL_VAR: TermName = newTermName(EQEQ_LOCAL_VAR_STRING)
+    val ROOTPKG: TermName        = "_root_"
+    val EQEQ_LOCAL_VAR: TermName = "eqEqTemp$"
 
     def getCause   = sn.GetCause
     def getClass_  = sn.GetClass
@@ -783,6 +975,11 @@ trait StdNames extends NameManglers { self: SymbolTable =>
       case 22 => nme._22
       case _  => newTermName("_" + j)
     }
+
+    @deprecated("Use a method in tpnme", "2.10.0") def dropSingletonName(name: Name): TypeName = tpnme.dropSingletonName(name)
+    @deprecated("Use a method in tpnme", "2.10.0") def singletonName(name: Name): TypeName     = tpnme.singletonName(name)
+    @deprecated("Use a method in tpnme", "2.10.0") def implClassName(name: Name): TypeName     = tpnme.implClassName(name)
+    @deprecated("Use a method in tpnme", "2.10.0") def interfaceName(implname: Name): TypeName = tpnme.interfaceName(implname)
   }
 
   abstract class SymbolNames {
@@ -816,12 +1013,7 @@ trait StdNames extends NameManglers { self: SymbolTable =>
   }
 
   class JavaKeywords {
-    private var kws: Set[TermName] = Set()
-    private def kw(s: String): TermName = {
-      val result = newTermNameCached(s)
-      kws = kws + result
-      result
-    }
+    private val kw = new KeywordSetBuilder
 
     final val ABSTRACTkw: TermName     = kw("abstract")
     final val ASSERTkw: TermName       = kw("assert")
@@ -874,11 +1066,7 @@ trait StdNames extends NameManglers { self: SymbolTable =>
     final val VOLATILEkw: TermName     = kw("volatile")
     final val WHILEkw: TermName        = kw("while")
 
-    final val keywords = {
-      val result = kws.toSet
-      kws = null
-      result
-    }
+    final val keywords = kw.result
   }
 
   private abstract class JavaNames extends SymbolNames {
diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala
index c9ac929edf..380ceb4bc7 100644
--- a/src/compiler/scala/reflect/internal/Symbols.scala
+++ b/src/compiler/scala/reflect/internal/Symbols.scala
@@ -232,7 +232,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       newTermSymbol(name, pos, PARAM | newFlags)
 
     /** Create local dummy for template (owner of local blocks) */
-    final def newLocalDummy(pos: Position) =
+    final def newLocalDummy(pos: Position): TermSymbol =
       newTermSymbol(nme.localDummyName(this), pos) setInfo NoType
     final def newMethod(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): MethodSymbol =
       createMethodSymbol(name, pos, METHOD | newFlags)
@@ -240,15 +240,15 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       newMethod(name, pos, LABEL)
 
     /** Propagates ConstrFlags (JAVA, specifically) from owner to constructor. */
-    final def newConstructor(pos: Position, newFlags: Long = 0L) =
+    final def newConstructor(pos: Position, newFlags: Long = 0L): MethodSymbol =
       newMethod(nme.CONSTRUCTOR, pos, getFlag(ConstrFlags) | newFlags)
 
     /** Static constructor with info set. */
-    def newStaticConstructor(pos: Position) =
+    def newStaticConstructor(pos: Position): MethodSymbol =
       newConstructor(pos, STATIC) setInfo UnitClass.tpe
 
     /** Instance constructor with info set. */
-    def newClassConstructor(pos: Position) =
+    def newClassConstructor(pos: Position): MethodSymbol =
       newConstructor(pos) setInfo MethodType(Nil, this.tpe)
 
     def newLinkedModule(clazz: Symbol, newFlags: Long = 0L): ModuleSymbol = {
@@ -266,10 +266,10 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       newModule(name, pos, PackageFlags | newFlags)
     }
 
-    final def newThisSym(name: TermName = nme.this_, pos: Position = NoPosition) =
+    final def newThisSym(name: TermName = nme.this_, pos: Position = NoPosition): TermSymbol =
       newTermSymbol(name, pos, SYNTHETIC)
 
-    final def newImport(pos: Position) =
+    final def newImport(pos: Position): TermSymbol =
       newTermSymbol(nme.IMPORT, pos)
 
     final def newModuleSymbol(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): ModuleSymbol =
@@ -299,45 +299,45 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
      *
      *    pre.memberType(m)
      */
-    final def newOverloaded(pre: Type, alternatives: List[Symbol]): Symbol = (
+    final def newOverloaded(pre: Type, alternatives: List[Symbol]): TermSymbol = (
       newTermSymbol(alternatives.head.name.toTermName, alternatives.head.pos, OVERLOADED)
         setInfo OverloadedType(pre, alternatives)
     )
 
-    final def newErrorValue(name: TermName) =
+    final def newErrorValue(name: TermName): TermSymbol =
       newTermSymbol(name, pos, SYNTHETIC | IS_ERROR) setInfo ErrorType
 
     /** Symbol of a type definition  type T = ...
      */
-    final def newAliasType(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): Symbol =
+    final def newAliasType(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): AliasTypeSymbol =
       createAliasTypeSymbol(name, pos, newFlags)
 
     /** Symbol of an abstract type  type T >: ... <: ...
      */
-    final def newAbstractType(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): Symbol =
+    final def newAbstractType(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): AbstractTypeSymbol =
       createAbstractTypeSymbol(name, pos, DEFERRED | newFlags)
 
     /** Symbol of a type parameter
      */
-    final def newTypeParameter(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L) =
+    final def newTypeParameter(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): TypeSymbol =
       newAbstractType(name, pos, PARAM | newFlags)
 
     /** Symbol of an existential type T forSome { ... }
      */
-    final def newExistential(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): Symbol =
+    final def newExistential(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): TypeSymbol =
       newAbstractType(name, pos, EXISTENTIAL | newFlags)
 
     /** Synthetic value parameters when parameter symbols are not available
      */
-    final def newSyntheticValueParamss(argtypess: List[List[Type]]): List[List[Symbol]] = {
+    final def newSyntheticValueParamss(argtypess: List[List[Type]]): List[List[TermSymbol]] = {
       var cnt = 0
       def freshName() = { cnt += 1; nme.syntheticParamName(cnt) }
       mmap(argtypess)(tp => newValueParameter(freshName(), owner.pos.focus, SYNTHETIC) setInfo tp)
     }
 
-    def newSyntheticTypeParam(): Symbol                             = newSyntheticTypeParam("T0", 0L)
-    def newSyntheticTypeParam(name: String, newFlags: Long): Symbol = newTypeParameter(newTypeName(name), NoPosition, newFlags) setInfo TypeBounds.empty
-    def newSyntheticTypeParams(num: Int): List[Symbol]              = (0 until num).toList map (n => newSyntheticTypeParam("T" + n, 0L))
+    def newSyntheticTypeParam(): TypeSymbol                             = newSyntheticTypeParam("T0", 0L)
+    def newSyntheticTypeParam(name: String, newFlags: Long): TypeSymbol = newTypeParameter(newTypeName(name), NoPosition, newFlags) setInfo TypeBounds.empty
+    def newSyntheticTypeParams(num: Int): List[TypeSymbol]              = (0 until num).toList map (n => newSyntheticTypeParam("T" + n, 0L))
 
     /** Create a new existential type skolem with this symbol its owner,
      *  based on the given symbol and origin.
@@ -352,13 +352,13 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     def newGADTSkolem(name: TypeName, origin: Symbol, info: Type): TypeSkolem =
       newTypeSkolemSymbol(name, origin, origin.pos, origin.flags & ~(EXISTENTIAL | PARAM) | CASEACCESSOR | SYNTHETIC) setInfo info
 
-    final def freshExistential(suffix: String): Symbol =
+    final def freshExistential(suffix: String): TypeSymbol =
       newExistential(freshExistentialName(suffix), pos)
 
     /** Synthetic value parameters when parameter symbols are not available.
      *  Calling this method multiple times will re-use the same parameter names.
      */
-    final def newSyntheticValueParams(argtypes: List[Type]): List[Symbol] =
+    final def newSyntheticValueParams(argtypes: List[Type]): List[TermSymbol] =
       newSyntheticValueParamss(List(argtypes)).head
 
     /** Synthetic value parameter when parameter symbol is not available.
@@ -372,27 +372,27 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
      *  with name `T` in its typeParams list. While type checking the parameters, result type and
      *  body of the method, there's a local copy of `T` which is a TypeSkolem.
      */
-    final def newTypeSkolem: Symbol =
+    final def newTypeSkolem: TypeSkolem =
       owner.newTypeSkolemSymbol(name.toTypeName, this, pos, flags)
 
-    final def newClass(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L) =
+    final def newClass(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): ClassSymbol =
       newClassSymbol(name, pos, newFlags)
 
     /** A new class with its info set to a ClassInfoType with given scope and parents. */
-    def newClassWithInfo(name: TypeName, parents: List[Type], scope: Scope, pos: Position = NoPosition, newFlags: Long = 0L) = {
+    def newClassWithInfo(name: TypeName, parents: List[Type], scope: Scope, pos: Position = NoPosition, newFlags: Long = 0L): ClassSymbol = {
       val clazz = newClass(name, pos, newFlags)
       clazz setInfo ClassInfoType(parents, scope, clazz)
     }
-    final def newErrorClass(name: TypeName) =
+    final def newErrorClass(name: TypeName): ClassSymbol =
       newClassWithInfo(name, Nil, new ErrorScope(this), pos, SYNTHETIC | IS_ERROR)
 
-    final def newModuleClass(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L) =
+    final def newModuleClass(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): ModuleClassSymbol =
       newModuleClassSymbol(name, pos, newFlags | MODULE)
 
-    final def newAnonymousFunctionClass(pos: Position = NoPosition, newFlags: Long = 0L) =
+    final def newAnonymousFunctionClass(pos: Position = NoPosition, newFlags: Long = 0L): ClassSymbol =
       newClassSymbol(tpnme.ANON_FUN_NAME, pos, FINAL | SYNTHETIC | newFlags)
 
-    final def newAnonymousFunctionValue(pos: Position, newFlags: Long = 0L) =
+    final def newAnonymousFunctionValue(pos: Position, newFlags: Long = 0L): TermSymbol =
       newTermSymbol(nme.ANON_FUN_NAME, pos, SYNTHETIC | newFlags) setInfo NoType
 
     def newImplClass(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): ClassSymbol = {
@@ -402,11 +402,12 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     /** Refinement types P { val x: String; type T <: Number }
      *  also have symbols, they are refinementClasses
      */
-    final def newRefinementClass(pos: Position) = createRefinementClassSymbol(pos, 0L)
+    final def newRefinementClass(pos: Position): RefinementClassSymbol =
+      createRefinementClassSymbol(pos, 0L)
 
     /** Create a new getter for current symbol (which must be a field)
      */
-    final def newGetter: Symbol = (
+    final def newGetter: MethodSymbol = (
       owner.newMethod(nme.getterName(name.toTermName), NoPosition, getterFlags(flags))
         setPrivateWithin privateWithin
         setInfo MethodType(Nil, tpe)
@@ -1654,7 +1655,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
      *  symbol with the same owner, and the name of this symbol with $class
      *  appended to it.
      */
-    final def implClass: Symbol = owner.info.decl(nme.implClassName(name))
+    final def implClass: Symbol = owner.info.decl(tpnme.implClassName(name))
 
     /** The class that is logically an outer class of given `clazz`.
      *  This is the enclosing class, except for classes defined locally to constructors,
@@ -2242,13 +2243,13 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     /** String representation of existentially bound variable */
     def existentialToString =
       if (isSingletonExistential && !settings.debug.value)
-        "val " + nme.dropSingletonName(name) + ": " + dropSingletonType(info.bounds.hi)
+        "val " + tpnme.dropSingletonName(name) + ": " + dropSingletonType(info.bounds.hi)
       else defString
   }
 
   /** A class for term symbols */
   class TermSymbol protected[Symbols] (initOwner: Symbol, initPos: Position, initName: TermName)
-  extends Symbol(initOwner, initPos, initName) {
+  extends Symbol(initOwner, initPos, initName) with TermSymbolApi {
     private[this] var _referenced: Symbol = NoSymbol
     privateWithin = NoSymbol
 
@@ -2417,7 +2418,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
   /** A class for module symbols */
   class ModuleSymbol protected[Symbols] (initOwner: Symbol, initPos: Position, initName: TermName)
-  extends TermSymbol(initOwner, initPos, initName) with DistinguishingFlag {
+  extends TermSymbol(initOwner, initPos, initName) with DistinguishingFlag with ModuleSymbolApi {
     def distinguishingFlag = MODULE
     private var flatname: TermName = null
 
@@ -2442,14 +2443,14 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
   }
 
   class PackageSymbol protected[Symbols] (owner0: Symbol, pos0: Position, name0: TermName)
-  extends ModuleSymbol(owner0, pos0, name0) with DistinguishingFlag {
+  extends ModuleSymbol(owner0, pos0, name0) with DistinguishingFlag with PackageSymbolApi {
     override def distinguishingFlag = super.distinguishingFlag | PACKAGE
     override def isPackage = true
   }
 
   /** A class for method symbols */
   class MethodSymbol protected[Symbols] (initOwner: Symbol, initPos: Position, initName: TermName)
-  extends TermSymbol(initOwner, initPos, initName) with DistinguishingFlag {
+  extends TermSymbol(initOwner, initPos, initName) with DistinguishingFlag with MethodSymbolApi {
     def distinguishingFlag = METHOD
     // MethodSymbols pick up MODULE when trait-owned object accessors are cloned
     // during mixin composition.
@@ -2511,7 +2512,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
    *  of this class. Classes are instances of a subclass.
    */
   abstract class TypeSymbol protected[Symbols] (initOwner: Symbol, initPos: Position, initName: TypeName)
-  extends Symbol(initOwner, initPos, initName) {
+  extends Symbol(initOwner, initPos, initName) with TypeSymbolApi {
     privateWithin = NoSymbol
     private[this] var _rawname: TypeName = initName
 
@@ -2712,7 +2713,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
   /** A class for class symbols */
   class ClassSymbol protected[Symbols] (initOwner: Symbol, initPos: Position, initName: TypeName)
-  extends TypeSymbol(initOwner, initPos, initName) {
+  extends TypeSymbol(initOwner, initPos, initName) with ClassSymbolApi {
     type TypeOfClonedSymbol = ClassSymbol
 
     private[this] var flatname: TypeName       = _
@@ -2759,7 +2760,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     override def toInterface: Symbol = (
       if (isImplClass) {
         if (phase.next.erasedTypes) lastParent
-        else owner.info.decl(nme.interfaceName(name))
+        else owner.info.decl(tpnme.interfaceName(name))
       }
       else super.toInterface
     )
diff --git a/src/compiler/scala/reflect/internal/TreeGen.scala b/src/compiler/scala/reflect/internal/TreeGen.scala
index 1a374b6e59..f30ec67c7e 100644
--- a/src/compiler/scala/reflect/internal/TreeGen.scala
+++ b/src/compiler/scala/reflect/internal/TreeGen.scala
@@ -48,6 +48,9 @@ abstract class TreeGen extends api.AbsTreeGen {
   def mkMethodCall(target: Tree, targs: List[Type], args: List[Tree]): Tree =
     Apply(mkTypeApply(target, targs map TypeTree), args)
 
+  def mkNullaryCall(method: Symbol, targs: List[Type]): Tree =
+    mkTypeApply(mkAttributedRef(method), targs map TypeTree)
+
   /** Builds a reference to value whose type is given stable prefix.
    *  The type must be suitable for this.  For example, it
    *  must not be a TypeRef pointing to an abstract type variable.
diff --git a/src/compiler/scala/reflect/internal/Types.scala b/src/compiler/scala/reflect/internal/Types.scala
index 7115cafc33..32b09eddeb 100644
--- a/src/compiler/scala/reflect/internal/Types.scala
+++ b/src/compiler/scala/reflect/internal/Types.scala
@@ -2310,7 +2310,7 @@ trait Types extends api.Types { self: SymbolTable =>
       else if (sym.isPackageClass || sym.isPackageObjectOrClass)
         sym.skipPackageObject.fullName + "."
       else if (isStable && nme.isSingletonName(sym.name))
-        nme.dropSingletonName(sym.name) + "."
+        tpnme.dropSingletonName(sym.name) + "."
       else
         super.prefixString
     )
diff --git a/src/compiler/scala/reflect/internal/pickling/UnPickler.scala b/src/compiler/scala/reflect/internal/pickling/UnPickler.scala
index f89aa9bf5c..eb4bae78d0 100644
--- a/src/compiler/scala/reflect/internal/pickling/UnPickler.scala
+++ b/src/compiler/scala/reflect/internal/pickling/UnPickler.scala
@@ -816,16 +816,10 @@ abstract class UnPickler /*extends reflect.generic.UnPickler*/ {
       throw new RuntimeException("malformed Scala signature of " + classRoot.name + " at " + readIndex + "; " + msg)
 
     protected def errorMissingRequirement(name: Name, owner: Symbol): Symbol =
-      missingHook(owner, name) orElse {
-        val what = if (name.isTypeName) "type" else "value"
-        MissingRequirementError.notFound(
-          "while unpickling %s, reference %s %s of %s/%s/%s".format(
-            filename,
-            what, name.decode, owner.tpe.widen,
-            owner.tpe.typeSymbol.ownerChain,
-            owner.info.members.mkString("\n  ", "\n  ", ""))
-        )
-      }
+      missingHook(owner, name) orElse MissingRequirementError.notFound(
+        "bad reference while unpickling %s: %s not found in %s".format(
+          filename, name.longString, owner.tpe.widen)
+      )
 
     def inferMethodAlternative(fun: Tree, argtpes: List[Type], restpe: Type) {} // can't do it; need a compiler for that.
 
diff --git a/src/compiler/scala/reflect/makro/runtime/Reifiers.scala b/src/compiler/scala/reflect/makro/runtime/Reifiers.scala
index 7c96b568bd..d9a89d0e6d 100644
--- a/src/compiler/scala/reflect/makro/runtime/Reifiers.scala
+++ b/src/compiler/scala/reflect/makro/runtime/Reifiers.scala
@@ -12,6 +12,37 @@ trait Reifiers {
   import mirror._
   import definitions._
 
+  private lazy val ClassTagModule = ClassTagClass.companionSymbol
+
+  // [Eugene] imho this logic should be moved into `erasure`
+  private def calculateTagErasure(tpe: Type) = tpe match {
+    case tpe if tpe.typeSymbol.isDerivedValueClass => tpe // [Eugene to Martin] is this correct?
+    case ConstantType(value) => tpe.widen.erasure
+    case _ =>
+      // [Eugene] magikz. needs review
+      // necessary to deal with erasures of HK types, typeConstructor won't work
+      tpe.erasure.normalize match {
+        // we don't want undets in the result
+        case PolyType(undets, underlying) => existentialAbstraction(undets, underlying)
+        case result                       => result
+      }
+  }
+  private def classTagFromArgument(tpe: Type, arg: Tree) = {
+    gen.mkMethodCall(ClassTagModule, nme.apply, List(tpe), List(arg))
+    // val factory = TypeApply(Select(Ident(ClassTagModule), nme.apply), List(TypeTree(tpe)))
+    // Apply(factory, List(typeArg))
+  }
+  private def classTagFromErasure(tpe: Type) = {
+    val erasure = calculateTagErasure(tpe)
+    classTagFromArgument(tpe, gen.mkNullaryCall(Predef_classOf, List(erasure)))
+    // val targ    = TypeApply(Select(Ident(PredefModule), nme.classOf), List(TypeTree(erasure)))
+    // classTagFromArgument(tpe, targ)
+  }
+  private def typetagIsSynthetic(tree: Tree) = tree match {
+    case Block(_, _)  => true
+    case _            => tree exists (_ hasSymbolWhich Set(TypeTagModule, ConcreteTypeTagModule))
+  }
+
   lazy val reflectMirrorPrefix: Tree = {
     // [Eugene] how do I typecheck this without undergoing this tiresome (and, in general, incorrect) procedure?
     val prefix: Tree = Select(Select(Ident(definitions.ScalaPackage), newTermName("reflect")), newTermName("mirror"))
@@ -26,40 +57,36 @@ trait Reifiers {
     reifyTopLevel(prefix, tpe, dontSpliceAtTopLevel, requireConcreteTypeTag)
 
   def reifyErasure(tpe: Type): Tree = {
-    val positionBearer = enclosingMacros.find(c => c.macroApplication.pos != NoPosition).map(_.macroApplication).getOrElse(EmptyTree).asInstanceOf[Tree]
-    val typetagInScope = callsiteTyper.context.withMacrosDisabled(callsiteTyper.resolveTypeTag(positionBearer, singleType(Reflect_mirror.owner.thisPrefix, Reflect_mirror), tpe, full = true))
-    def typetagIsSynthetic(tree: Tree) = tree.isInstanceOf[Block] || (tree exists (sub => sub.symbol == TypeTagModule || sub.symbol == ConcreteTypeTagModule))
+    val positionBearer = (enclosingMacros.find(_.macroApplication.pos != NoPosition) match {
+      case None     => EmptyTree
+      case Some(m)  => m.macroApplication
+    }).asInstanceOf[Tree]
+
+    val typetagInScope = callsiteTyper.context.withMacrosDisabled(
+      callsiteTyper.resolveTypeTag(
+        positionBearer,
+        singleType(Reflect_mirror.owner.thisPrefix, Reflect_mirror),
+        tpe,
+        full = true
+      )
+    )
     typetagInScope match {
       case success if !success.isEmpty && !typetagIsSynthetic(success) =>
-        val factory = TypeApply(Select(Ident(ClassTagModule), nme.apply), List(TypeTree(tpe)))
-        Apply(factory, List(typetagInScope))
+        classTagFromArgument(tpe, typetagInScope)
       case _ =>
         if (tpe.typeSymbol == ArrayClass) {
           val componentTpe = tpe.typeArguments(0)
           val componentTag = callsiteTyper.resolveClassTag(positionBearer, componentTpe)
           Select(componentTag, nme.wrap)
-        } else {
-          // [Eugene] what's the intended behavior? there's no spec on ClassManifests
-          // for example, should we ban Array[T] or should we tag them with Array[AnyRef]?
-          // if its the latter, what should be the result of tagging Array[T] where T <: Int?
-          if (tpe.isSpliceable) throw new ReificationError(enclosingPosition, "tpe %s is an unresolved spliceable type".format(tpe))
-          // [Eugene] imho this logic should be moved into `erasure`
-          var erasure = tpe match {
-            case tpe if tpe.typeSymbol.isDerivedValueClass => tpe // [Eugene to Martin] is this correct?
-            case ConstantType(value) => tpe.widen.erasure
-            case _ => {
-              // [Eugene] magikz. needs review
-              var result = tpe.erasure.normalize // necessary to deal with erasures of HK types, typeConstructor won't work
-              result = result match {
-                case PolyType(undets, underlying) => existentialAbstraction(undets, underlying) // we don't want undets in the result
-                case _ => result
-              }
-              result
-            }
-          }
-          val factory = TypeApply(Select(Ident(ClassTagModule), nme.apply), List(TypeTree(tpe)))
-          Apply(factory, List(TypeApply(Select(Ident(PredefModule), nme.classOf), List(TypeTree(erasure)))))
         }
+        // [Eugene] what's the intended behavior? there's no spec on ClassManifests
+        // for example, should we ban Array[T] or should we tag them with Array[AnyRef]?
+        // if its the latter, what should be the result of tagging Array[T] where T <: Int?
+        else if (tpe.isSpliceable) {
+          throw new ReificationError(enclosingPosition,
+            "tpe %s is an unresolved spliceable type".format(tpe))
+        }
+        else classTagFromErasure(tpe)
     }
  }
 
diff --git a/src/compiler/scala/reflect/runtime/SynchronizedOps.scala b/src/compiler/scala/reflect/runtime/SynchronizedOps.scala
index dd806beb2a..907c0dd369 100644
--- a/src/compiler/scala/reflect/runtime/SynchronizedOps.scala
+++ b/src/compiler/scala/reflect/runtime/SynchronizedOps.scala
@@ -39,7 +39,7 @@ trait SynchronizedOps extends internal.SymbolTable
   trait SynchronizedScope extends Scope {
     override def isEmpty: Boolean = synchronized { super.isEmpty }
     override def size: Int = synchronized { super.size }
-    override def enter(sym: Symbol) = synchronized { super.enter(sym) }
+    override def enter[T <: Symbol](sym: T): T = synchronized { super.enter(sym) }
     override def rehash(sym: Symbol, newname: Name) = synchronized { super.rehash(sym, newname) }
     override def unlink(e: ScopeEntry) = synchronized { super.unlink(e) }
     override def unlink(sym: Symbol) = synchronized { super.unlink(sym) }
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index 6c038162b3..cf024ebacf 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -1531,7 +1531,7 @@ class Global(var currentSettings: Settings, var reporter: NscReporter) extends S
   /** We resolve the class/object ambiguity by passing a type/term name.
    */
   def showDef(fullName: Name, declsOnly: Boolean, ph: Phase) = {
-    val boringOwners = Set(definitions.AnyClass, definitions.AnyRefClass, definitions.ObjectClass)
+    val boringOwners = Set[Symbol](definitions.AnyClass, definitions.AnyRefClass, definitions.ObjectClass)
     def phased[T](body: => T): T = afterPhase(ph)(body)
     def boringMember(sym: Symbol) = boringOwners(sym.owner)
     def symString(sym: Symbol) = if (sym.isTerm) sym.defString else sym.toString
diff --git a/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala
index 0f2a3e0395..b0204c5971 100755
--- a/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala
@@ -30,7 +30,7 @@ abstract class SymbolicXMLBuilder(p: Parsers#Parser, preserveWS: Boolean) {
 
   private[parser] var isPattern: Boolean = _
 
-  private trait XMLTypeNames extends TypeNames {
+  private object xmltypes extends TypeNames {
     val _Comment: NameType             = "Comment"
     val _Elem: NameType                = "Elem"
     val _EntityRef: NameType           = "EntityRef"
@@ -45,7 +45,7 @@ abstract class SymbolicXMLBuilder(p: Parsers#Parser, preserveWS: Boolean) {
     val _UnprefixedAttribute: NameType = "UnprefixedAttribute"
   }
 
-  private trait XMLTermNames extends TermNames {
+  private object xmlterms extends TermNames {
     val _Null: NameType     = "Null"
     val __Elem: NameType    = "Elem"
     val __Text: NameType    = "Text"
@@ -57,15 +57,6 @@ abstract class SymbolicXMLBuilder(p: Parsers#Parser, preserveWS: Boolean) {
     val _xml: NameType      = "xml"
   }
 
-  private object xmltypes extends XMLTypeNames {
-    type NameType = TypeName
-    implicit def createNameType(name: String): TypeName = newTypeNameCached(name)
-  }
-  private object xmlterms extends XMLTermNames {
-    type NameType = TermName
-    implicit def createNameType(name: String): TermName = newTermNameCached(name)
-  }
-
   import xmltypes.{_Comment, _Elem, _EntityRef, _Group, _MetaData, _NamespaceBinding, _NodeBuffer,
     _PrefixedAttribute, _ProcInstr, _Text, _Unparsed, _UnprefixedAttribute}
 
diff --git a/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala b/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala
index f61f78ebb2..1ec2cf017a 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala
@@ -420,7 +420,7 @@ trait TypeKinds { self: ICodes =>
     // between "object PackratParsers$class" and "trait PackratParsers"
     if (sym.isImplClass) {
       // pos/spec-List.scala is the sole failure if we don't check for NoSymbol
-      val traitSym = sym.owner.info.decl(nme.interfaceName(sym.name))
+      val traitSym = sym.owner.info.decl(tpnme.interfaceName(sym.name))
       if (traitSym != NoSymbol)
         return REFERENCE(traitSym)
     }
diff --git a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
index 124a7509e8..a6728654cd 100644
--- a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
+++ b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
@@ -42,7 +42,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
     memberSym.isOmittablePrefix || (closestPackage(memberSym) == closestPackage(templateSym))
   }
 
-  private lazy val noSubclassCache = Set(AnyClass, AnyRefClass, ObjectClass)
+  private lazy val noSubclassCache = Set[Symbol](AnyClass, AnyRefClass, ObjectClass)
 
   /**  */
   def makeModel: Option[Universe] = {
@@ -675,7 +675,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
           }
         /* Refined types */
         case RefinedType(parents, defs) =>
-          val ignoreParents = Set(AnyClass, ObjectClass)
+          val ignoreParents = Set[Symbol](AnyClass, ObjectClass)
           val filtParents = parents filterNot (x => ignoreParents(x.typeSymbol)) match {
             case Nil    => parents
             case ps     => ps
diff --git a/src/compiler/scala/tools/nsc/interpreter/IMain.scala b/src/compiler/scala/tools/nsc/interpreter/IMain.scala
index 13124e6afc..e0a98ace9d 100644
--- a/src/compiler/scala/tools/nsc/interpreter/IMain.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/IMain.scala
@@ -197,8 +197,9 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
 
   import global._
   import definitions.{
-    ScalaPackage, JavaLangPackage, PredefModule, RootClass,
-    getClassIfDefined, getModuleIfDefined, getRequiredModule, getRequiredClass
+    ScalaPackage, JavaLangPackage, RootClass,
+    getClassIfDefined, getModuleIfDefined, getRequiredModule, getRequiredClass,
+    termMember, typeMember
   }
 
   private implicit def privateTreeOps(t: Tree): List[Tree] = {
@@ -807,9 +808,9 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
       */
     def resolvePathToSymbol(accessPath: String): Symbol = {
       val readRoot  = getRequiredModule(readPath)   // the outermost wrapper
-      (accessPath split '.').foldLeft(readRoot) { (sym, name) =>
-        if (name == "") sym else
-        afterTyper(sym.info member newTermName(name))
+      (accessPath split '.').foldLeft(readRoot: Symbol) {
+        case (sym, "")    => sym
+        case (sym, name)  => afterTyper(termMember(sym, name))
       }
     }
     /** We get a bunch of repeated warnings for reasons I haven't
diff --git a/src/compiler/scala/tools/nsc/matching/MatchSupport.scala b/src/compiler/scala/tools/nsc/matching/MatchSupport.scala
index 249f754e8f..72e6f32af1 100644
--- a/src/compiler/scala/tools/nsc/matching/MatchSupport.scala
+++ b/src/compiler/scala/tools/nsc/matching/MatchSupport.scala
@@ -31,7 +31,7 @@ trait MatchSupport extends ast.TreeDSL { self: ParallelMatching =>
   object Types {
     import definitions._
 
-    val subrangeTypes = Set(ByteClass, ShortClass, CharClass, IntClass)
+    val subrangeTypes = Set[Symbol](ByteClass, ShortClass, CharClass, IntClass)
 
     implicit class RichType(undecodedTpe: Type) {
       def tpe = decodedEqualsType(undecodedTpe)
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
index 775a7a9d38..862a3ffdc7 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
@@ -165,7 +165,7 @@ abstract class ICodeReader extends ClassfileParser {
     else if (name == fulltpnme.RuntimeNull)
       definitions.NullClass
     else if (nme.isImplClassName(name)) {
-      val iface = definitions.getClass(nme.interfaceName(name))
+      val iface = definitions.getClass(tpnme.interfaceName(name))
       log("forcing " + iface.owner + " at phase: " + phase + " impl: " + iface.implClass)
       iface.owner.info // force the mixin type-transformer
       definitions.getClass(name)
diff --git a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
index 5a11926048..3581f1b923 100644
--- a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
+++ b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
@@ -66,7 +66,7 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure =>
 
   private def newImplClass(iface: Symbol): Symbol = {
     val inClass   = iface.owner.isClass
-    val implName  = nme.implClassName(iface.name)
+    val implName  = tpnme.implClassName(iface.name)
     val implFlags = (iface.flags & ~(INTERFACE | lateINTERFACE)) | IMPLCLASS
 
     val impl0 = (
diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
index 6bddfe8d57..618a1cbba4 100644
--- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
+++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
@@ -159,7 +159,7 @@ abstract class LambdaLift extends InfoTransform {
               // for that failure. There should be exactly one method for any given
               // entity which always gives the right answer.
               if (sym.isImplClass)
-                localImplClasses((sym.owner, nme.interfaceName(sym.name))) = sym
+                localImplClasses((sym.owner, tpnme.interfaceName(sym.name))) = sym
               else {
                 renamable addEntry sym
                 if (sym.isTrait)
@@ -229,7 +229,7 @@ abstract class LambdaLift extends InfoTransform {
       def renameTrait(traitSym: Symbol, implSym: Symbol) {
         val originalImplName = implSym.name
         renameSym(traitSym)
-        implSym setName nme.implClassName(traitSym.name)
+        implSym setName tpnme.implClassName(traitSym.name)
 
         debuglog("renaming impl class in step with %s: %s => %s".format(traitSym, originalImplName, implSym.name))
       }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 651120db4f..f8da6a462d 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -1121,10 +1121,10 @@ trait Implicits {
     }
 
     // these should be lazy, otherwise we wouldn't be able to compile scala-library with starr
-    private val TagSymbols = Set(ClassTagClass, TypeTagClass, ConcreteTypeTagClass)
-    private val TagMaterializers = Map(
-      ClassTagClass -> MacroInternal_materializeClassTag,
-      TypeTagClass -> MacroInternal_materializeTypeTag,
+    private val TagSymbols = Set[Symbol](ClassTagClass, TypeTagClass, ConcreteTypeTagClass)
+    private val TagMaterializers = Map[Symbol, MethodSymbol](
+      ClassTagClass        -> MacroInternal_materializeClassTag,
+      TypeTagClass         -> MacroInternal_materializeTypeTag,
       ConcreteTypeTagClass -> MacroInternal_materializeConcreteTypeTag
     )
 
@@ -1140,27 +1140,34 @@ trait Implicits {
             failure(arg, "failed to typecheck the materialized typetag: %n%s".format(ex.msg), ex.pos)
         }
 
-      val prefix = (tagClass, pre) match {
-        // ClassTags only exist for scala.reflect.mirror, so their materializer doesn't care about prefixes
-        case (ClassTagClass, _) =>
-          gen.mkAttributedRef(Reflect_mirror) setType singleType(Reflect_mirror.owner.thisPrefix, Reflect_mirror)
-        // [Eugene to Martin] this is the crux of the interaction between implicits and reifiers
-        // here we need to turn a (supposedly path-dependent) type into a tree that will be used as a prefix
-        // I'm not sure if I've done this right - please, review
-        case (_, SingleType(prePre, preSym)) =>
-          gen.mkAttributedRef(prePre, preSym) setType pre
-        // necessary only to compile typetags used inside the Universe cake
-        case (_, ThisType(thisSym)) =>
-          gen.mkAttributedThis(thisSym)
-        case _ =>
-          // if ``pre'' is not a PDT, e.g. if someone wrote
-          //   implicitly[scala.reflect.makro.Context#TypeTag[Int]]
-          // then we need to fail, because we don't know the prefix to use during type reification
-          return failure(tp, "tag error: unsupported prefix type %s (%s)".format(pre, pre.kind))
-      }
-
+      val prefix = (
+        // ClassTags only exist for scala.reflect.mirror, so their materializer
+        // doesn't care about prefixes
+        if (tagClass eq ClassTagClass) (
+          gen.mkAttributedRef(Reflect_mirror)
+            setType singleType(Reflect_mirror.owner.thisPrefix, Reflect_mirror)
+        )
+        else pre match {
+          // [Eugene to Martin] this is the crux of the interaction between
+          // implicits and reifiers here we need to turn a (supposedly
+          // path-dependent) type into a tree that will be used as a prefix I'm
+          // not sure if I've done this right - please, review
+          case SingleType(prePre, preSym) =>
+            gen.mkAttributedRef(prePre, preSym) setType pre
+          // necessary only to compile typetags used inside the Universe cake
+          case ThisType(thisSym) =>
+            gen.mkAttributedThis(thisSym)
+          case _ =>
+            // if ``pre'' is not a PDT, e.g. if someone wrote
+            //   implicitly[scala.reflect.makro.Context#TypeTag[Int]]
+            // then we need to fail, because we don't know the prefix to use during type reification
+            return failure(tp, "tag error: unsupported prefix type %s (%s)".format(pre, pre.kind))
+        }
+      )
       // todo. migrate hardcoded materialization in Implicits to corresponding implicit macros
-      var materializer = atPos(pos.focus)(Apply(TypeApply(Ident(TagMaterializers(tagClass)), List(TypeTree(tp))), List(prefix)))
+      var materializer = atPos(pos.focus)(
+        gen.mkMethodCall(TagMaterializers(tagClass), List(tp), List(prefix))
+      )
       if (settings.XlogImplicits.value) println("materializing requested %s.%s[%s] using %s".format(pre, tagClass.name, tp, materializer))
       if (context.macrosEnabled) success(materializer)
       else failure(materializer, "macros are disabled")
@@ -1169,8 +1176,8 @@ trait Implicits {
     /** The manifest corresponding to type `pt`, provided `pt` is an instance of Manifest.
      */
     private def implicitTagOrOfExpectedType(pt: Type): SearchResult = pt.dealias match {
-      case TypeRef(pre, sym, args) if TagSymbols(sym) =>
-        tagOfType(pre, args.head, sym)
+      case TypeRef(pre, sym, arg :: Nil) if TagSymbols(sym) =>
+        tagOfType(pre, arg, sym)
       case tp@TypeRef(_, sym, _) if sym.isAbstractType =>
         implicitTagOrOfExpectedType(tp.bounds.lo) // #3977: use tp (==pt.dealias), not pt (if pt is a type alias, pt.bounds.lo == pt)
       case _ =>
diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
index 43cbea83ff..d327d9c397 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
@@ -134,7 +134,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
     // otherwise lead to either a compiler crash or runtime failure.
     private lazy val isDisallowed = {
       import definitions._
-      Set(Any_isInstanceOf, Object_isInstanceOf, Any_asInstanceOf, Object_asInstanceOf, Object_==, Object_!=, Object_##)
+      Set[Symbol](Any_isInstanceOf, Object_isInstanceOf, Any_asInstanceOf, Object_asInstanceOf, Object_==, Object_!=, Object_##)
     }
 
     override def transform(tree: Tree): Tree = {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 9a59d8f28a..54be9c9a87 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -3322,7 +3322,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
       val typeParams: List[Symbol] = rawSyms map { sym =>
         val name = sym.name match {
           case x: TypeName  => x
-          case x            => nme.singletonName(x)
+          case x            => tpnme.singletonName(x)
         }
         val bound      = allBounds(sym)
         val sowner     = if (isRawParameter(sym)) context.owner else sym.owner
diff --git a/src/library/scala/reflect/DummyMirror.scala b/src/library/scala/reflect/DummyMirror.scala
index 1fbf36be9d..c88b137f19 100644
--- a/src/library/scala/reflect/DummyMirror.scala
+++ b/src/library/scala/reflect/DummyMirror.scala
@@ -192,70 +192,70 @@ class DummyMirror(cl: ClassLoader) extends api.Mirror {
   val UnitTpe: Type = DummyType
   val definitions: AbsDefinitions = DummyDefinitions
   object DummyDefinitions extends AbsDefinitions {
-    def AnyClass: Symbol = DummySymbol
-    def AnyRefClass: Symbol = DummySymbol
-    def AnyValClass: Symbol = DummySymbol
-    def ArrayClass: Symbol = DummySymbol
-    def ArrayModule: Symbol = DummySymbol
-    def ArrayModule_overloadedApply: Symbol = DummySymbol
-    def Array_apply: Symbol = DummySymbol
-    def Array_clone: Symbol = DummySymbol
-    def Array_length: Symbol = DummySymbol
-    def Array_update: Symbol = DummySymbol
-    def BooleanClass: Symbol = DummySymbol
-    def ByNameParamClass: Symbol = DummySymbol
-    def ByteClass: Symbol = DummySymbol
-    def CharClass: Symbol = DummySymbol
-    def ClassClass: Symbol = DummySymbol
-    def ClassTagClass: Symbol = DummySymbol
-    def ClassTagModule: Symbol = DummySymbol
-    def ConcreteTypeTagClass: Symbol = DummySymbol
-    def ConcreteTypeTagModule: Symbol = DummySymbol
-    def ConsClass: Symbol = DummySymbol
-    def DoubleClass: Symbol = DummySymbol
-    def EmptyPackage: Symbol = DummySymbol
-    def EmptyPackageClass: Symbol = DummySymbol
-    def FloatClass: Symbol = DummySymbol
+    def ByNameParamClass = ???
+    def JavaRepeatedParamClass = ???
+    def RepeatedParamClass = ???
+    def AnyClass = ???
+    def AnyRefClass = ???
+    def AnyValClass = ???
+    def ArrayClass = ???
+    def ArrayModule = ???
+    def ArrayModule_overloadedApply = ???
+    def Array_apply = ???
+    def Array_clone = ???
+    def Array_length = ???
+    def Array_update = ???
+    def BooleanClass = ???
+    def ByteClass = ???
+    def CharClass = ???
+    def ClassClass = ???
+    def ClassTagClass = ???
+    def ClassTagModule = ???
+    def ConcreteTypeTagClass = ???
+    def ConcreteTypeTagModule = ???
+    def ConsClass = ???
+    def DoubleClass = ???
+    def EmptyPackage = ???
+    def EmptyPackageClass = ???
+    def FloatClass = ???
     def FunctionClass: Array[Symbol] = Array()
-    def IntClass: Symbol = DummySymbol
-    def IterableClass: Symbol = DummySymbol
-    def IteratorClass: Symbol = DummySymbol
-    def IteratorModule: Symbol = DummySymbol
-    def Iterator_apply: Symbol = DummySymbol
-    def JavaLangPackage: Symbol = DummySymbol
-    def JavaLangPackageClass: Symbol = DummySymbol
-    def JavaRepeatedParamClass: Symbol = DummySymbol
-    def ListClass: Symbol = DummySymbol
-    def ListModule: Symbol = DummySymbol
-    def List_apply: Symbol = DummySymbol
-    def LongClass: Symbol = DummySymbol
-    def NilModule: Symbol = DummySymbol
-    def NoneModule: Symbol = DummySymbol
-    def NothingClass: Symbol = DummySymbol
-    def NullClass: Symbol = DummySymbol
-    def ObjectClass: Symbol = DummySymbol
-    def OptionClass: Symbol = DummySymbol
-    def PredefModule: Symbol = DummySymbol
+    def IntClass = ???
+    def IterableClass = ???
+    def IteratorClass = ???
+    def IteratorModule = ???
+    def Iterator_apply = ???
+    def JavaLangPackage = ???
+    def JavaLangPackageClass = ???
+    def ListClass = ???
+    def ListModule = ???
+    def List_apply = ???
+    def LongClass = ???
+    def NilModule = ???
+    def NoneModule = ???
+    def NothingClass = ???
+    def NullClass = ???
+    def ObjectClass = ???
+    def OptionClass = ???
+    def PredefModule = ???
     def ProductClass: Array[Symbol] = Array()
-    def RepeatedParamClass: Symbol = DummySymbol
-    def RootClass: Symbol = DummySymbol
-    def RootPackage: Symbol = DummySymbol
-    def ScalaPackage: Symbol = DummySymbol
-    def ScalaPackageClass: Symbol = DummySymbol
-    def ScalaPrimitiveValueClasses: List[Symbol] = List()
-    def SeqClass: Symbol = DummySymbol
-    def SeqModule: Symbol = DummySymbol
-    def ShortClass: Symbol = DummySymbol
-    def SomeClass: Symbol = DummySymbol
-    def SomeModule: Symbol = DummySymbol
-    def StringBuilderClass: Symbol = DummySymbol
-    def StringClass: Symbol = DummySymbol
-    def SymbolClass: Symbol = DummySymbol
-    def TraversableClass: Symbol = DummySymbol
+    def RootClass = ???
+    def RootPackage = ???
+    def ScalaPackage = ???
+    def ScalaPackageClass = ???
+    def ScalaPrimitiveValueClasses = Nil
+    def SeqClass = ???
+    def SeqModule = ???
+    def ShortClass = ???
+    def SomeClass = ???
+    def SomeModule = ???
+    def StringBuilderClass = ???
+    def StringClass = ???
+    def SymbolClass = ???
+    def TraversableClass = ???
     def TupleClass: Array[Symbol] = Array()
-    def TypeTagClass: Symbol = DummySymbol
-    def TypeTagModule: Symbol = DummySymbol
-    def UnitClass: Symbol = DummySymbol
+    def TypeTagClass = ???
+    def TypeTagModule = ???
+    def UnitClass = ???
     def isNumericValueClass(sym: Symbol): Boolean = notSupported()
     def isPrimitiveValueClass(sym: Symbol): Boolean = notSupported()
     def vmClassType(arg: Type): Type = DummyType
@@ -382,10 +382,6 @@ class DummyMirror(cl: ClassLoader) extends api.Mirror {
     def setterToGetter(name: TermName): TermName = notSupported()
     def defaultGetterName(name: Name, pos: Int): TermName = notSupported()
     def defaultGetterToMethod(name: Name): TermName = notSupported()
-    def dropSingletonName(name: Name): TypeName = notSupported()
-    def singletonName(name: Name): TypeName = notSupported()
-    def implClassName(name: Name): TypeName = notSupported()
-    def interfaceName(implname: Name): TypeName = notSupported()
     def localDummyName(clazz: Symbol): TermName = notSupported()
     def superName(name: Name): TermName = notSupported()
   }
@@ -411,11 +407,16 @@ class DummyMirror(cl: ClassLoader) extends api.Mirror {
     val LOCAL_CHILD: TypeName = DummyName
     val REPEATED_PARAM_CLASS_NAME: TypeName = DummyName
     val WILDCARD_STAR: TypeName = DummyName
+
+    def dropSingletonName(name: Name): TypeName = notSupported()
+    def singletonName(name: Name): TypeName = notSupported()
+    def implClassName(name: Name): TypeName = notSupported()
+    def interfaceName(implname: Name): TypeName = notSupported()
   }
 
   // Members declared in scala.reflect.api.Symbols
   type Symbol = DummySymbol.type
-  val NoSymbol: Symbol = DummySymbol
+  val NoSymbol = ???
   object DummySymbol extends AbsSymbol {
     this: Symbol =>
 
@@ -477,19 +478,19 @@ class DummyMirror(cl: ClassLoader) extends api.Mirror {
   // type TreeGen = DummyTreeGen.type // [Eugene] cannot compile if uncomment this
   val gen: TreeGen{val global: DummyMirror.this.type} = DummyTreeGen.asInstanceOf[TreeGen{val global: DummyMirror.this.type}]
   def modifiersFromInternalFlags(flags: Long,privateWithin: Name,annotations: List[Tree]): Modifiers = DummyModifiers
-  def newFreeExistential(name: String,info: Type,value: => Any,flags: Long,origin: String): Symbol = DummySymbol
-  def newFreeTerm(name: String,info: Type,value: => Any,flags: Long,origin: String): Symbol = DummySymbol
-  def newFreeType(name: String,info: Type,value: => Any,flags: Long,origin: String): Symbol = DummySymbol
-  def selectOverloadedMethod(owner: Symbol,name: String,index: Int): Symbol = DummySymbol
-  def selectOverloadedMethodIfDefined(owner: Symbol,name: String,index: Int): Symbol = DummySymbol
-  def selectTerm(owner: Symbol,name: String): Symbol = DummySymbol
-  def selectTermIfDefined(owner: Symbol,name: String): Symbol = DummySymbol
-  def selectType(owner: Symbol,name: String): Symbol = DummySymbol
-  def selectTypeIfDefined(owner: Symbol,name: String): Symbol = DummySymbol
-  def staticClass(fullName: String): Symbol = DummySymbol
-  def staticClassIfDefined(fullName: String): Symbol = DummySymbol
-  def staticModule(fullName: String): Symbol = DummySymbol
-  def staticModuleIfDefined(fullName: String): Symbol = DummySymbol
+  def newFreeExistential(name: String,info: Type,value: => Any,flags: Long,origin: String) = ???
+  def newFreeTerm(name: String,info: Type,value: => Any,flags: Long,origin: String) = ???
+  def newFreeType(name: String,info: Type,value: => Any,flags: Long,origin: String) = ???
+  def selectOverloadedMethod(owner: Symbol,name: String,index: Int) = ???
+  def selectOverloadedMethodIfDefined(owner: Symbol,name: String,index: Int) = ???
+  def selectTerm(owner: Symbol,name: String) = ???
+  def selectTermIfDefined(owner: Symbol,name: String) = ???
+  def selectType(owner: Symbol,name: String) = ???
+  def selectTypeIfDefined(owner: Symbol,name: String) = ???
+  def staticClass(fullName: String) = ???
+  def staticClassIfDefined(fullName: String) = ???
+  def staticModule(fullName: String) = ???
+  def staticModuleIfDefined(fullName: String) = ???
   def thisModuleType(fullName: String): Type = DummyType
   object DummyTreeGen extends AbsTreeGen {
     val global: Universe = DummyMirror.this
diff --git a/src/library/scala/reflect/TagMaterialization.scala b/src/library/scala/reflect/TagMaterialization.scala
index a7237223f1..e8d4571228 100644
--- a/src/library/scala/reflect/TagMaterialization.scala
+++ b/src/library/scala/reflect/TagMaterialization.scala
@@ -9,6 +9,10 @@ import language.implicitConversions
 // Oh how much I'd love to implement this now, but I have to postpone this until we have a solution for type inference
 
 /** This object is required by the compiler and <b>should not be used in client code</b>. */
+
+ /** !!! Some of this code is copy-pasted four places.  This situation
+  *  should be resolved ASAP.
+  */
 object TagMaterialization {
   def materializeClassTag[T: c.TypeTag](c: Context): c.Expr[ClassTag[T]] = {
     import c.mirror._
diff --git a/src/library/scala/reflect/api/StandardDefinitions.scala b/src/library/scala/reflect/api/StandardDefinitions.scala
index e457bb73e0..21f7c9283b 100755
--- a/src/library/scala/reflect/api/StandardDefinitions.scala
+++ b/src/library/scala/reflect/api/StandardDefinitions.scala
@@ -6,7 +6,8 @@
 package scala.reflect
 package api
 
-trait StandardDefinitions { self: Universe =>
+trait StandardTypes {
+  self: Universe =>
 
   val ByteTpe: Type
   val ShortTpe: Type
@@ -17,110 +18,119 @@ trait StandardDefinitions { self: Universe =>
   val DoubleTpe: Type
   val BooleanTpe: Type
   val UnitTpe: Type
+
   val AnyTpe: Type
-  val ObjectTpe: Type
   val AnyValTpe: Type
   val AnyRefTpe: Type
+  val ObjectTpe: Type
+
   val NothingTpe: Type
   val NullTpe: Type
   val StringTpe: Type
+}
+
+trait StandardDefinitions extends StandardTypes {
+  self: Universe =>
 
   val definitions: AbsDefinitions
 
-  abstract class AbsDefinitions {
-    // packages
-    def RootPackage: Symbol
-    def RootClass: Symbol
-    def EmptyPackage: Symbol
+  // I intend to pull everything in here out of the public API.
+  trait AbsDefinitionsInternal {
+    def ArrayModule: Symbol
+    def ArrayModule_overloadedApply: Symbol
+    def Array_apply: Symbol
+    def Array_clone: Symbol
+    def Array_length: Symbol
+    def Array_update: Symbol
+    def ByNameParamClass: Symbol
+    def ClassTagModule: Symbol
+    def ConcreteTypeTagModule: Symbol
+    def ConsClass: Symbol
     def EmptyPackageClass: Symbol
-    def ScalaPackage: Symbol
-    def ScalaPackageClass: Symbol
-    def JavaLangPackage: Symbol
+    def FunctionClass : Array[Symbol]
+    def IterableClass: Symbol
+    def IteratorClass: Symbol
+    def IteratorModule: Symbol
+    def Iterator_apply: Symbol
     def JavaLangPackageClass: Symbol
+    def JavaRepeatedParamClass: Symbol
+    def ListModule: Symbol
+    def List_apply: Symbol
+    def NilModule: Symbol
+    def NoneModule: Symbol
+    def OptionClass: Symbol
+    def ProductClass  : Array[Symbol]
+    def RepeatedParamClass: Symbol
+    def ScalaPackageClass: Symbol
+    def SeqClass: Symbol
+    def SeqModule: Symbol
+    def SomeClass: Symbol
+    def SomeModule: Symbol
+    def StringBuilderClass: Symbol
+    def SymbolClass : Symbol
+    def TraversableClass: Symbol
+    def TupleClass    : Array[Symbol]
+    def TypeTagModule: Symbol
+    def ScalaPrimitiveValueClasses: List[ClassSymbol]
+  }
+
+  trait AbsDefinitions extends AbsDefinitionsInternal {
+    // packages
+    def RootClass: ClassSymbol
+    def RootPackage: PackageSymbol
+    def EmptyPackage: PackageSymbol
+    def ScalaPackage: PackageSymbol
+    def JavaLangPackage: PackageSymbol
 
     // top types
-    def AnyClass   : Symbol
-    def AnyValClass: Symbol
-    def AnyRefClass: Symbol
-    def ObjectClass: Symbol
+    def AnyClass   : ClassSymbol
+    def AnyValClass: ClassSymbol
+    def ObjectClass: ClassSymbol
+    def AnyRefClass: TypeSymbol
 
     // bottom types
-    def NullClass   : Symbol
-    def NothingClass: Symbol
+    def NullClass   : ClassSymbol
+    def NothingClass: ClassSymbol
 
     // the scala value classes
-    def UnitClass   : Symbol
-    def ByteClass   : Symbol
-    def ShortClass  : Symbol
-    def CharClass   : Symbol
-    def IntClass    : Symbol
-    def LongClass   : Symbol
-    def FloatClass  : Symbol
-    def DoubleClass : Symbol
-    def BooleanClass: Symbol
-    def ScalaPrimitiveValueClasses: List[Symbol]
-
-    // fundamental reference classes
-    def SymbolClass : Symbol
-    def StringClass : Symbol
-    def ClassClass  : Symbol
-
-    // product, tuple, function
-    def TupleClass    : Array[Symbol]
-    def ProductClass  : Array[Symbol]
-    def FunctionClass : Array[Symbol]
-
-    // Option classes
-    def OptionClass: Symbol
-    def SomeClass: Symbol
-    def NoneModule: Symbol
-    def SomeModule: Symbol
+    def UnitClass   : ClassSymbol
+    def ByteClass   : ClassSymbol
+    def ShortClass  : ClassSymbol
+    def CharClass   : ClassSymbol
+    def IntClass    : ClassSymbol
+    def LongClass   : ClassSymbol
+    def FloatClass  : ClassSymbol
+    def DoubleClass : ClassSymbol
+    def BooleanClass: ClassSymbol
+
+    // some special classes
+    def StringClass : ClassSymbol
+    def ClassClass  : ClassSymbol
+    def ArrayClass: ClassSymbol
 
     // collections classes
-    def ConsClass: Symbol
-    def IterableClass: Symbol
-    def IteratorClass: Symbol
-    def ListClass: Symbol
-    def SeqClass: Symbol
-    def StringBuilderClass: Symbol
-    def TraversableClass: Symbol
+    def ListClass: ClassSymbol
+    def ListModule: ModuleSymbol
 
     // collections modules
-    def PredefModule: Symbol
-    def ListModule: Symbol
-    def List_apply: Symbol
-    def NilModule: Symbol
-    def SeqModule: Symbol
-    def IteratorModule: Symbol
-    def Iterator_apply: Symbol
-
-    // arrays and their members
-    def ArrayModule: Symbol
-    def ArrayModule_overloadedApply: Symbol
-    def ArrayClass: Symbol
-    def Array_apply: Symbol
-    def Array_update: Symbol
-    def Array_length: Symbol
-    def Array_clone: Symbol
-
-    // special parameter types
-    def ByNameParamClass: Symbol
-    def JavaRepeatedParamClass: Symbol
-    def RepeatedParamClass: Symbol
+    def PredefModule: ModuleSymbol
 
     // type tags
-    def ClassTagClass: Symbol
-    def ClassTagModule: Symbol
-    def TypeTagClass: Symbol
-    def TypeTagModule: Symbol
-    def ConcreteTypeTagClass: Symbol
-    def ConcreteTypeTagModule: Symbol
+    def ClassTagClass: ClassSymbol
+    def TypeTagClass: ClassSymbol
+    def ConcreteTypeTagClass: ClassSymbol
 
     /** Given a type T, returns the type corresponding to the VM's
      *  representation: ClassClass's type constructor applied to `arg`.
      */
     def vmClassType(arg: Type): Type    // !!! better name?
-                                        // [Eugene] we already have arg.erasure, right?
+    // [Eugene] we already have arg.erasure, right?
+    //
+    // [Paul] You misunderstand the method (it could be better named).
+    // Given List[String], it returns java.lang.Class[List[String]]
+    // (or the .Net equivalent), not the erasure of List[String].
+    // See def ClassType in definitions - that's what it was called before,
+    // and obviously that name has to go.
 
     /** The string representation used by the given type in the VM.
      */
diff --git a/src/library/scala/reflect/api/StandardNames.scala b/src/library/scala/reflect/api/StandardNames.scala
index d39d44dd86..60c64f947a 100644
--- a/src/library/scala/reflect/api/StandardNames.scala
+++ b/src/library/scala/reflect/api/StandardNames.scala
@@ -1,49 +1,64 @@
 /* NSC -- new Scala compiler
- * Copyright 2005-2011 LAMP/EPFL
- * @author  Martin Odersky
- */
+* Copyright 2005-2011 LAMP/EPFL
+* @author  Martin Odersky
+*/
 
 package scala.reflect
 package api
 
-trait StandardNames { self: Universe =>
+trait StandardNames {
+  self: Universe =>
 
-  abstract class AbsNames {
+  val nme: AbsTermNames
+  val tpnme: AbsTypeNames
+
+  trait AbsNames {
     type NameType <: Name
 
-    val EMPTY: NameType
-    val ANON_FUN_NAME: NameType
     val ANON_CLASS_NAME: NameType
+    val ANON_FUN_NAME: NameType
+    val EMPTY: NameType
     val EMPTY_PACKAGE_NAME: NameType
+    val ERROR: NameType
     val IMPORT: NameType
     val MODULE_VAR_SUFFIX: NameType
-    val ROOT: NameType
+    val NO_NAME: NameType
     val PACKAGE: NameType
+    val ROOT: NameType
     val SPECIALIZED_SUFFIX: NameType
-
-    val ERROR: NameType
-    val NO_NAME: NameType
     val WILDCARD: NameType
 
     def flattenedName(segments: Name*): NameType
   }
 
-  val nme: AbsTermNames
-
-  abstract class AbsTermNames extends AbsNames {
+  trait AbsTermNames extends AbsNames {
     val EXPAND_SEPARATOR_STRING: String
+    val IMPL_CLASS_SUFFIX: String
+    val INTERPRETER_IMPORT_WRAPPER: String
+    val INTERPRETER_LINE_PREFIX: String
+    val INTERPRETER_VAR_PREFIX: String
+    val INTERPRETER_WRAPPER_SUFFIX: String
+    val LOCALDUMMY_PREFIX: String
+    val LOCAL_SUFFIX_STRING: String
+    val MODULE_SUFFIX_NAME: TermName
+    val NAME_JOIN_NAME: TermName
+    val PROTECTED_PREFIX: String
+    val PROTECTED_SET_PREFIX: String
+    val SETTER_SUFFIX: TermName
+    val SINGLETON_SUFFIX: String
+    val SUPER_PREFIX_STRING: String
+    val TRAIT_SETTER_SEPARATOR_STRING: String
 
     val ANYNAME: TermName
     val CONSTRUCTOR: TermName
     val FAKE_LOCAL_THIS: TermName
     val INITIALIZER: TermName
     val LAZY_LOCAL: TermName
-    val LOCAL_SUFFIX_STRING: String
-    val MIRROR_PREFIX: TermName
-    val MIRROR_SHORT: TermName
     val MIRROR_FREE_PREFIX: TermName
     val MIRROR_FREE_THIS_SUFFIX: TermName
     val MIRROR_FREE_VALUE_SUFFIX: TermName
+    val MIRROR_PREFIX: TermName
+    val MIRROR_SHORT: TermName
     val MIRROR_SYMDEF_PREFIX: TermName
     val MIXIN_CONSTRUCTOR: TermName
     val MODULE_INSTANCE_FIELD: TermName
@@ -62,11 +77,6 @@ trait StandardNames { self: Universe =>
     val BITMAP_CHECKINIT: TermName
     val BITMAP_CHECKINIT_TRANSIENT: TermName
 
-    val INTERPRETER_IMPORT_WRAPPER: String
-    val INTERPRETER_LINE_PREFIX: String
-    val INTERPRETER_VAR_PREFIX: String
-    val INTERPRETER_WRAPPER_SUFFIX: String
-
     val ROOTPKG: TermName
 
     val ADD: TermName
@@ -93,77 +103,62 @@ trait StandardNames { self: Universe =>
     val ZAND: TermName
     val ZOR: TermName
 
-    // [Eugene] this doesn't compile. why?!
-   val UNARY_~ : TermName
-   val UNARY_+ : TermName
-   val UNARY_- : TermName
-   val UNARY_! : TermName
+    val UNARY_~ : TermName
+    val UNARY_+ : TermName
+    val UNARY_- : TermName
+    val UNARY_! : TermName
 
-    // [Eugene] this doesn't compile. why?!
     val ??? : TermName
 
-    val MODULE_SUFFIX_NAME: TermName
-    val NAME_JOIN_NAME: TermName
-    val IMPL_CLASS_SUFFIX: String
-    val LOCALDUMMY_PREFIX: String
-    val PROTECTED_PREFIX: String
-    val PROTECTED_SET_PREFIX: String
-    val SINGLETON_SUFFIX: String
-    val SUPER_PREFIX_STRING: String
-    val TRAIT_SETTER_SEPARATOR_STRING: String
-    val SETTER_SUFFIX: TermName
-
     def isConstructorName(name: Name): Boolean
     def isExceptionResultName(name: Name): Boolean
     def isImplClassName(name: Name): Boolean
     def isLocalDummyName(name: Name): Boolean
     def isLocalName(name: Name): Boolean
     def isLoopHeaderLabel(name: Name): Boolean
+    def isModuleName(name: Name): Boolean
+    def isOpAssignmentName(name: Name): Boolean
     def isProtectedAccessorName(name: Name): Boolean
-    def isSuperAccessorName(name: Name): Boolean
     def isReplWrapperName(name: Name): Boolean
     def isSetterName(name: Name): Boolean
-    def isTraitSetterName(name: Name): Boolean
     def isSingletonName(name: Name): Boolean
-    def isModuleName(name: Name): Boolean
-    def isOpAssignmentName(name: Name): Boolean
-
-    def segments(name: String, assumeTerm: Boolean): List[Name]
-    def originalName(name: Name): Name
-    def stripModuleSuffix(name: Name): Name
-    def unspecializedName(name: Name): Name
-    def splitSpecializedName(name: Name): (Name, String, String)
-    def dropLocalSuffix(name: Name): Name
+    def isSuperAccessorName(name: Name): Boolean
+    def isTraitSetterName(name: Name): Boolean
 
-    def expandedName(name: TermName, base: Symbol, separator: String = EXPAND_SEPARATOR_STRING): TermName
+    def defaultGetterName(name: Name, pos: Int): TermName
+    def defaultGetterToMethod(name: Name): TermName
+    def expandedName(name: TermName, base: Symbol, separator: String): TermName
     def expandedSetterName(name: TermName, base: Symbol): TermName
-    def protName(name: Name): TermName
-    def protSetterName(name: Name): TermName
     def getterName(name: TermName): TermName
     def getterToLocal(name: TermName): TermName
     def getterToSetter(name: TermName): TermName
+    def localDummyName(clazz: Symbol): TermName
     def localToGetter(name: TermName): TermName
+    def protName(name: Name): TermName
+    def protSetterName(name: Name): TermName
     def setterToGetter(name: TermName): TermName
-    def defaultGetterName(name: Name, pos: Int): TermName
-    def defaultGetterToMethod(name: Name): TermName
-
-    def dropSingletonName(name: Name): TypeName
-    def singletonName(name: Name): TypeName
-    def implClassName(name: Name): TypeName
-    def interfaceName(implname: Name): TypeName
-    def localDummyName(clazz: Symbol): TermName
     def superName(name: Name): TermName
-  }
 
-  val tpnme: AbsTypeNames
+    def dropLocalSuffix(name: Name): Name
+    def originalName(name: Name): Name
+    def stripModuleSuffix(name: Name): Name
+    def unspecializedName(name: Name): Name
+    def segments(name: String, assumeTerm: Boolean): List[Name]
+    def splitSpecializedName(name: Name): (Name, String, String)
+  }
 
-  abstract class AbsTypeNames extends AbsNames {
-    val REFINE_CLASS_NAME: TypeName
+  trait AbsTypeNames extends AbsNames {
     val BYNAME_PARAM_CLASS_NAME: TypeName
     val EQUALS_PATTERN_NAME: TypeName
     val JAVA_REPEATED_PARAM_CLASS_NAME: TypeName
     val LOCAL_CHILD: TypeName
+    val REFINE_CLASS_NAME: TypeName
     val REPEATED_PARAM_CLASS_NAME: TypeName
     val WILDCARD_STAR: TypeName
+
+    def dropSingletonName(name: Name): TypeName
+    def implClassName(name: Name): TypeName
+    def interfaceName(implname: Name): TypeName
+    def singletonName(name: Name): TypeName
   }
 }
diff --git a/src/library/scala/reflect/api/Symbols.scala b/src/library/scala/reflect/api/Symbols.scala
index d9293888d9..767246a294 100755
--- a/src/library/scala/reflect/api/Symbols.scala
+++ b/src/library/scala/reflect/api/Symbols.scala
@@ -4,8 +4,101 @@ package api
 trait Symbols { self: Universe =>
 
   type Symbol >: Null <: AbsSymbol
+  type TypeSymbol <: Symbol with TypeSymbolApi
+  type TermSymbol <: Symbol with TermSymbolApi
+  type MethodSymbol <: TermSymbol with MethodSymbolApi
+  type ModuleSymbol <: TermSymbol with ModuleSymbolApi
+  type PackageSymbol <: ModuleSymbol with PackageSymbolApi
+  type ClassSymbol <: TypeSymbol with ClassSymbolApi
 
-  abstract class AbsSymbol { this: Symbol =>
+  val NoSymbol: Symbol
+
+  trait TypeSymbolApi {
+    self: TypeSymbol =>
+
+    def name: TypeName
+  }
+  trait TermSymbolApi {
+    self: TermSymbol =>
+
+    def name: TermName
+  }
+  trait MethodSymbolApi extends TermSymbolApi {
+    self: MethodSymbol =>
+  }
+  trait ClassSymbolApi extends TypeSymbolApi {
+    self: ClassSymbol =>
+  }
+  trait ModuleSymbolApi extends TermSymbolApi {
+    self: ModuleSymbol =>
+  }
+  trait PackageSymbolApi extends ModuleSymbolApi {
+    self: PackageSymbol =>
+  }
+
+  // I intend to pull everything in here out of the public API.
+  trait AbsSymbolInternal {
+    this: Symbol =>
+
+    /** A fresh symbol with given name `name`, position `pos` and flags `flags` that has
+     *  the current symbol as its owner.
+     */
+    def newNestedSymbol(name: Name, pos: Position, flags: Long, isClass: Boolean): Symbol
+    // needed by LiftCode   !!! not enough reason to have in the api
+
+    /** Low-level operation to set the symbol's flags
+     *  @return the symbol itself
+     */
+    def setInternalFlags(flags: Long): this.type
+    // needed by LiftCode   !!! not enough reason to have in the api
+
+    /** Set symbol's type signature to given type
+     *  @return the symbol itself
+     */
+    def setTypeSignature(tpe: Type): this.type
+    // needed by LiftCode       !!! not enough reason to have in the api
+
+    /** Set symbol's annotations to given annotations `annots`.
+     */
+    def setAnnotations(annots: AnnotationInfo*): this.type
+    // needed by LiftCode       !!! not enough reason to have in the api
+
+    /** Does this symbol represent the definition of a skolem?
+     *  Skolems are used during typechecking to represent type parameters viewed from inside their scopes.
+     *  If yes, `isType` is also guaranteed to be true.
+     */
+    def isSkolem       : Boolean
+
+    /** Does this symbol represent a free type captured by reification?
+     */
+    // needed for ones who wish to inspect reified trees
+    def isFreeType     : Boolean
+
+    /** The type signature of this symbol.
+     *  Note if the symbol is a member of a class, one almost always is interested
+     *  in `typeSignatureIn` with a site type instead.
+     */
+    def typeSignature: Type   // !!! Since one should almost never use this, let's give it a different name.
+
+    /**  A type reference that refers to this type symbol
+      *  Note if symbol is a member of a class, one almost always is interested
+      *  in `asTypeIn` with a site type instead.
+      *
+      *  Example: Given a class declaration `class C[T] { ... } `, that generates a symbol
+      *  `C`. Then `C.asType` is the type `C[T]`.
+      *
+      *  By contrast, `C.typeSignature` would be a type signature of form
+      *  `PolyType(ClassInfoType(...))` that describes type parameters, value
+      *  parameters, parent types, and members of `C`.
+      */
+     def asType: Type  // !!! Same as typeSignature.
+
+    /** The kind of this symbol; used for debugging */
+    def kind: String
+  }
+
+  trait AbsSymbol extends AbsSymbolInternal {
+    this: Symbol =>
 
     /** The position of this symbol
      */
@@ -177,22 +270,11 @@ trait Symbols { self: Universe =>
      */
     def isAbstractType : Boolean
 
-    /** Does this symbol represent the definition of a skolem?
-     *  Skolems are used during typechecking to represent type parameters viewed from inside their scopes.
-     *  If yes, `isType` is also guaranteed to be true.
-     */
-    def isSkolem       : Boolean
-
     /** Does this symbol represent an existentially bound type?
      *  If yes, `isType` is also guaranteed to be true.
      */
     def isExistential  : Boolean
 
-    /** Does this symbol represent a free type captured by reification?
-     */
-    // needed for ones who wish to inspect reified trees
-    def isFreeType     : Boolean
-
     /** Is the type parameter represented by this symbol contravariant?
      */
     def isContravariant : Boolean
@@ -205,29 +287,10 @@ trait Symbols { self: Universe =>
      */
     def isErroneous : Boolean
 
-    /** The type signature of this symbol.
-     *  Note if the symbol is a member of a class, one almost always is interested
-     *  in `typeSignatureIn` with a site type instead.
-     */
-    def typeSignature: Type   // !!! Since one should almost never use this, let's give it a different name.
-
     /** The type signature of this symbol seen as a member of given type `site`.
      */
     def typeSignatureIn(site: Type): Type
 
-   /**  A type reference that refers to this type symbol
-     *  Note if symbol is a member of a class, one almost always is interested
-     *  in `asTypeIn` with a site type instead.
-     *
-     *  Example: Given a class declaration `class C[T] { ... } `, that generates a symbol
-     *  `C`. Then `C.asType` is the type `C[T]`.
-     *
-     *  By contrast, `C.typeSignature` would be a type signature of form
-     *  `PolyType(ClassInfoType(...))` that describes type parameters, value
-     *  parameters, parent types, and members of `C`.
-     */
-    def asType: Type  // !!! Same as typeSignature.
-
     /** A type reference that refers to this type symbol seen
      *  as a member of given type `site`.
      */
@@ -255,29 +318,5 @@ trait Symbols { self: Universe =>
     def alternatives: List[Symbol]
 
     def resolveOverloaded(pre: Type = NoPrefix, targs: Seq[Type] = List(), actuals: Seq[Type]): Symbol
-
-    /** A fresh symbol with given name `name`, position `pos` and flags `flags` that has
-     *  the current symbol as its owner.
-     */
-    def newNestedSymbol(name: Name, pos: Position, flags: Long, isClass: Boolean): Symbol // needed by LiftCode   !!! not enough reason to have in the api
-
-    /** Low-level operation to set the symbol's flags
-     *  @return the symbol itself
-     */
-    def setInternalFlags(flags: Long): this.type // needed by LiftCode   !!! not enough reason to have in the api
-
-    /** Set symbol's type signature to given type
-     *  @return the symbol itself
-     */
-    def setTypeSignature(tpe: Type): this.type // needed by LiftCode       !!! not enough reason to have in the api
-
-    /** Set symbol's annotations to given annotations `annots`.
-     */
-    def setAnnotations(annots: AnnotationInfo*): this.type // needed by LiftCode       !!! not enough reason to have in the api
-
-    /** The kind of this symbol; used for debugging */
-    def kind: String
   }
-
-  val NoSymbol: Symbol
 }