Eliminate redundant pickling code.

This commit drops about 700 lines of redundant traversal logic.

There had been ad hoc adjustments to the pickling scheme here and
there, probably in pursuit of tiny performance improvements.
For instance, a Block was pickled expr/stats instead of stats/expr,
a TypeDef was pickled rhs/tparams instead of tparams/rhs.
The benefits derived are invisible compared to the cost of having
several hundred lines of tree traversal code duplicated in half a
dozen or more places.

After making Traverser consistent/complete, it was a straightforward
matter to use it for pickling. It is ALSO now possible to write a
vastly cleaner tree printer than the ones presently in trunk, but I
leave this as an exercise for Dear Reviewer.

4 files changed, 189 insertions, 684 deletions

diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
index a46da92233..ce3e7b1bb5 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
@@ -11,6 +11,7 @@ import java.lang.Float.floatToIntBits
 import java.lang.Double.doubleToLongBits
 import scala.io.Codec
 import scala.reflect.internal.pickling.{ PickleBuffer, PickleFormat }
+import scala.reflect.internal.util.shortClassOfInstance
 import scala.collection.mutable.LinkedHashMap
 import PickleFormat._
 import Flags._
@@ -106,13 +107,14 @@ abstract class Pickler extends SubComponent {
      *  anyway? This is the case if symbol is a refinement class,
      *  an existentially bound variable, or a higher-order type parameter.
      */
-    private def isLocal(sym: Symbol): Boolean =
-      !sym.isPackageClass && sym != NoSymbol &&
-      (isRootSym(sym) ||
-       sym.isRefinementClass ||
-       sym.isAbstractType && sym.hasFlag(EXISTENTIAL) || // existential param
-       sym.isParameter ||
-       isLocal(sym.owner))
+    private def isLocal(sym: Symbol): Boolean = (sym != NoSymbol) && !sym.isPackageClass && (
+         isRootSym(sym)
+      || sym.isRefinementClass
+      || sym.isAbstractType && sym.hasFlag(EXISTENTIAL) // existential param
+      || sym.isParameter
+      || isLocal(sym.owner)
+    )
+    private def isExternalSymbol(sym: Symbol): Boolean = (sym != NoSymbol) && !isLocal(sym)
 
     // Phase 1 methods: Populate entries/index ------------------------------------
 
@@ -135,13 +137,18 @@ abstract class Pickler extends SubComponent {
         true
     }
 
+    private def deskolemizeTypeSymbols(ref: AnyRef): AnyRef = ref match {
+      case sym: Symbol => deskolemize(sym)
+      case _           => ref
+    }
+
     /** If the symbol is a type skolem, deskolemize and log it.
      *  If we fail to deskolemize, in a method like
      *    trait Trait[+A] { def f[CC[X]] : CC[A] }
      *  the applied type CC[A] will hold a different CC symbol
      *  than the type-constructor type-parameter CC.
      */
-    private def deskolemize(sym: Symbol) = {
+    private def deskolemize(sym: Symbol): Symbol = {
       if (sym.isTypeSkolem) {
         val sym1 = sym.deSkolemize
         log({
@@ -169,7 +176,7 @@ abstract class Pickler extends SubComponent {
           putSymbol(sym.owner)
           putSymbol(sym.privateWithin)
           putType(sym.info)
-          if (sym.thisSym.tpeHK != sym.tpeHK)
+          if (sym.hasSelfType)
             putType(sym.typeOfThis)
           putSymbol(sym.alias)
           if (!sym.children.isEmpty) {
@@ -202,252 +209,65 @@ abstract class Pickler extends SubComponent {
         case ThisType(sym) =>
           putSymbol(sym)
         case SingleType(pre, sym) =>
-          putType(pre); putSymbol(sym)
+          putType(pre)
+          putSymbol(sym)
         case SuperType(thistpe, supertpe) =>
           putType(thistpe)
           putType(supertpe)
         case ConstantType(value) =>
           putConstant(value)
         case TypeRef(pre, sym, args) =>
-//          if (sym.isAbstractType && (sym hasFlag EXISTENTIAL))
-//            if (!(boundSyms contains sym))
-//              println("unbound existential: "+sym+sym.locationString)
-          putType(pre); putSymbol(sym); putTypes(args)
+          putType(pre)
+          putSymbol(sym)
+          putTypes(args)
         case TypeBounds(lo, hi) =>
-          putType(lo); putType(hi)
-        case RefinedType(parents, decls) =>
-          val rclazz = tp.typeSymbol
-          for (m <- decls.iterator)
-            if (m.owner != rclazz) abort("bad refinement member "+m+" of "+tp+", owner = "+m.owner)
-          putSymbol(rclazz); putTypes(parents); putSymbols(decls.toList)
-        case ClassInfoType(parents, decls, clazz) =>
-          putSymbol(clazz); putTypes(parents); putSymbols(decls.toList)
+          putType(lo)
+          putType(hi)
+        case tp: CompoundType =>
+          putSymbol(tp.typeSymbol)
+          putTypes(tp.parents)
+          putSymbols(tp.decls.toList)
         case MethodType(params, restpe) =>
-          putType(restpe); putSymbols(params)
+          putType(restpe)
+          putSymbols(params)
         case NullaryMethodType(restpe) =>
           putType(restpe)
         case PolyType(tparams, restpe) =>
-          /* no longer needed since all params are now local
-          tparams foreach { tparam =>
-            if (!isLocal(tparam)) locals += tparam // similar to existential types, these tparams are local
-          }
-          */
-          putType(restpe); putSymbols(tparams)
+          putType(restpe)
+          putSymbols(tparams)
         case ExistentialType(tparams, restpe) =>
-//          val savedBoundSyms = boundSyms // boundSyms are known to be local based on the EXISTENTIAL flag  (see isLocal)
-//          boundSyms = tparams ::: boundSyms
-//          try {
-            putType(restpe)
-            //          } finally {
-//            boundSyms = savedBoundSyms
-//          }
+          putType(restpe)
           putSymbols(tparams)
-        case AnnotatedType(annotations, underlying, selfsym) =>
+        case AnnotatedType(_, underlying, selfsym) =>
           putType(underlying)
           if (settings.selfInAnnots) putSymbol(selfsym)
-          putAnnotations(annotations filter (_.isStatic))
+          tp.staticAnnotations foreach putAnnotation
         case _ =>
           throw new FatalError("bad type: " + tp + "(" + tp.getClass + ")")
       }
     }
     private def putTypes(tps: List[Type]) { tps foreach putType }
 
-    private def putTree(tree: Tree): Unit = if (putEntry(tree)) {
-      if (tree != EmptyTree)
-        putType(tree.tpe)
-      if (tree.hasSymbolField)
-        putSymbol(tree.symbol)
-
-      tree match {
-        case EmptyTree =>
-
-        case tree@PackageDef(pid, stats) =>
-          putTree(pid)
-          putTrees(stats)
-
-        case ClassDef(mods, name, tparams, impl) =>
-          putMods(mods)
-          putEntry(name)
-          putTree(impl)
-          putTrees(tparams)
-
-        case ModuleDef(mods, name, impl) =>
-          putMods(mods)
-          putEntry(name)
-          putTree(impl)
-
-        case ValDef(mods, name, tpt, rhs) =>
-          putMods(mods)
-          putEntry(name)
-          putTree(tpt)
-          putTree(rhs)
-
-        case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
-          putMods(mods)
-          putEntry(name)
-          putTrees(tparams)
-          putTreess(vparamss)
-          putTree(tpt)
-          putTree(rhs)
-
-        case TypeDef(mods, name, tparams, rhs) =>
-          putMods(mods)
-          putEntry(name)
-          putTree(rhs)
-          putTrees(tparams)
-
-        case LabelDef(name, params, rhs) =>
-          putEntry(name)
-          putTree(rhs)
-          putTrees(params)
-
-        case Import(expr, selectors) =>
-          putTree(expr)
-          for (ImportSelector(from, _, to, _) <- selectors) {
-            putEntry(from)
-            putEntry(to)
-          }
-/*
-        case DocDef(comment, definition) =>  should not be needed
-          putConstant(Constant(comment))
-          putTree(definition)
-*/
-        case Template(parents, self, body) =>
-          putTrees(parents)
-          putTree(self)
-          putTrees(body)
-
-        case Block(stats, expr) =>
-          putTree(expr)
-          putTrees(stats)
-
-        case CaseDef(pat, guard, body) =>
-          putTree(pat)
-          putTree(guard)
-          putTree(body)
-
-        case Alternative(trees) =>
-          putTrees(trees)
-
-        case Star(elem) =>
-          putTree(elem)
-
-        case Bind(name, body) =>
-          putEntry(name)
-          putTree(body)
-
-        case UnApply(fun: Tree, args) =>
-          putTree(fun)
-          putTrees(args)
-
-        case ArrayValue(elemtpt, trees) =>
-          putTree(elemtpt)
-          putTrees(trees)
-
-
-        case Function(vparams, body) =>
-          putTree(body)
-          putTrees(vparams)
-
-        case Assign(lhs, rhs) =>
-          putTree(lhs)
-          putTree(rhs)
-
-        case If(cond, thenp, elsep) =>
-          putTree(cond)
-          putTree(thenp)
-          putTree(elsep)
-
-        case Match(selector, cases) =>
-          putTree(selector)
-          putTrees(cases)
-
-        case Return(expr) =>
-          putTree(expr)
-
-        case Try(block, catches, finalizer) =>
-          putTree(block)
-          putTree(finalizer)
-          putTrees(catches)
-
-        case Throw(expr) =>
-          putTree(expr)
-
-        case New(tpt) =>
-          putTree(tpt)
-
-        case Typed(expr, tpt) =>
-          putTree(expr)
-          putTree(tpt)
-
-        case TypeApply(fun, args) =>
-          putTree(fun)
-          putTrees(args)
-
-        case Apply(fun, args) =>
-          putTree(fun)
-          putTrees(args)
-
-        case ApplyDynamic(qual, args) =>
-          putTree(qual)
-          putTrees(args)
-
-        case Super(qual, mix) =>
-          putTree(qual)
-          putEntry(mix:Name)
-
-        case This(qual) =>
-          putEntry(qual)
-
-        case Select(qualifier, selector) =>
-          putTree(qualifier)
-          putEntry(selector)
-
-        case Ident(name) =>
-          putEntry(name)
-
-        case Literal(value) =>
-          putEntry(value)
-
-        case TypeTree() =>
-
-        case Annotated(annot, arg) =>
-          putTree(annot)
-          putTree(arg)
-
-        case SingletonTypeTree(ref) =>
-          putTree(ref)
-
-        case SelectFromTypeTree(qualifier, selector) =>
-          putTree(qualifier)
-          putEntry(selector)
-
-        case CompoundTypeTree(templ: Template) =>
-          putTree(templ)
-
-        case AppliedTypeTree(tpt, args) =>
-          putTree(tpt)
-          putTrees(args)
-
-        case TypeBoundsTree(lo, hi) =>
-          putTree(lo)
-          putTree(hi)
-
-        case ExistentialTypeTree(tpt, whereClauses) =>
-          putTree(tpt)
-          putTrees(whereClauses)
+    private object putTreeTraverser extends Traverser {
+      // Only used when pickling trees, i.e. in an argument of some Annotation
+      // annotations in Modifiers are removed by the typechecker
+      override def traverseModifiers(mods: Modifiers): Unit = if (putEntry(mods)) putEntry(mods.privateWithin)
+      override def traverseName(name: Name): Unit           = putEntry(name)
+      override def traverseConstant(const: Constant): Unit  = putEntry(const)
+      override def traverse(tree: Tree): Unit               = putTree(tree)
+
+      def put(tree: Tree): Unit = {
+        if (tree.canHaveAttrs)
+          putType(tree.tpe)
+        if (tree.hasSymbolField)
+          putSymbol(tree.symbol)
+
+        super.traverse(tree)
       }
     }
-
-    private def putTrees(trees: List[Tree]) = trees foreach putTree
-    private def putTreess(treess: List[List[Tree]]) = treess foreach putTrees
-
-    /** only used when pickling trees, i.e. in an
-     *  argument of some Annotation */
-    private def putMods(mods: Modifiers) = if (putEntry(mods)) {
-      // annotations in Modifiers are removed by the typechecker
-      val Modifiers(_, privateWithin, Nil) = mods
-      putEntry(privateWithin)
+    private def putTree(tree: Tree) {
+      if (putEntry(tree))
+        putTreeTraverser put tree
     }
 
     /** Store a constant in map index, along with anything it references.
@@ -461,7 +281,7 @@ abstract class Pickler extends SubComponent {
     }
 
     private def putChildren(sym: Symbol, children: List[Symbol]) {
-      assert(putEntry((sym, children)))
+      putEntry(sym -> children)
       children foreach putSymbol
     }
 
@@ -469,14 +289,10 @@ abstract class Pickler extends SubComponent {
     private def putAnnotation(sym: Symbol, annot: AnnotationInfo) {
       // if an annotation with the same arguments is applied to the
       // same symbol multiple times, it's only pickled once.
-      if (putEntry((sym, annot)))
+      if (putEntry(sym -> annot))
         putAnnotationBody(annot)
     }
 
-    /** used in AnnotatedType only, i.e. annotations on types */
-    private def putAnnotations(annots: List[AnnotationInfo]) {
-      annots foreach putAnnotation
-    }
     private def putAnnotation(annot: AnnotationInfo) {
       if (putEntry(annot))
         putAnnotationBody(annot)
@@ -510,14 +326,11 @@ abstract class Pickler extends SubComponent {
 
     /** Write a reference to object, i.e., the object's number in the map index.
      */
-    private def writeRef(ref0: AnyRef) {
-      val ref = ref0 match {
-        case sym: Symbol => deskolemize(sym)
-        case _           => ref0
-      }
-      writeNat(index(ref))
+    private def writeRef(ref: AnyRef) {
+      writeNat(index(deskolemizeTypeSymbols(ref)))
     }
-    private def writeRefs(refs: List[AnyRef]) { refs foreach writeRef }
+    private def writeRefs(refs: List[AnyRef]): Unit = refs foreach writeRef
+
     private def writeRefsWithLength(refs: List[AnyRef]) {
       writeNat(refs.length)
       writeRefs(refs)
@@ -567,446 +380,137 @@ abstract class Pickler extends SubComponent {
       }
     }
 
-    /** Write an entry */
-    private def writeEntry(entry: AnyRef) {
-      def writeBody(entry: AnyRef): Int = entry match {
-        case name: Name =>
-          writeName(name)
-          if (name.isTermName) TERMname else TYPEname
-        case NoSymbol =>
-          NONEsym
-        case sym: Symbol if !isLocal(sym) =>
-          val tag =
-            if (sym.isModuleClass) {
-              writeRef(sym.name.toTermName); EXTMODCLASSref
-            } else {
-              writeRef(sym.name); EXTref
-            }
-          if (!sym.owner.isRoot) writeRef(sym.owner)
-          tag
-        case sym: ClassSymbol =>
-          writeSymInfo(sym)
-          if (sym.thisSym.tpe_* != sym.tpe_*) writeRef(sym.typeOfThis)
-          CLASSsym
-        case sym: TypeSymbol =>
-          writeSymInfo(sym)
-          if (sym.isAbstractType) TYPEsym else ALIASsym
-        case sym: TermSymbol =>
-          writeSymInfo(sym)
-          if (sym.alias != NoSymbol) writeRef(sym.alias)
-          if (sym.isModule) MODULEsym else VALsym
-        case NoType =>
-          NOtpe
-        case NoPrefix =>
-          NOPREFIXtpe
-        case ThisType(sym) =>
-          writeRef(sym); THIStpe
-        case SingleType(pre, sym) =>
-          writeRef(pre); writeRef(sym); SINGLEtpe
-        case SuperType(thistpe, supertpe) =>
-          writeRef(thistpe); writeRef(supertpe); SUPERtpe
-        case ConstantType(value) =>
-          writeRef(value); CONSTANTtpe
-        case TypeRef(pre, sym, args) =>
-          writeRef(pre); writeRef(sym); writeRefs(args); TYPEREFtpe
-        case TypeBounds(lo, hi) =>
-          writeRef(lo); writeRef(hi); TYPEBOUNDStpe
-        case tp @ RefinedType(parents, decls) =>
-          writeRef(tp.typeSymbol); writeRefs(parents); REFINEDtpe
-        case ClassInfoType(parents, decls, clazz) =>
-          writeRef(clazz); writeRefs(parents); CLASSINFOtpe
-        case mt @ MethodType(formals, restpe) =>
-          writeRef(restpe); writeRefs(formals) ; METHODtpe
-        case mt @ NullaryMethodType(restpe) =>
-          // reuse POLYtpe since those can never have an empty list of tparams.
-          // TODO: is there any way this can come back and bite us in the bottom?
-          // ugliness and thrift aside, this should make this somewhat more backward compatible
-          // (I'm not sure how old scalac's would deal with nested PolyTypes, as these used to be folded into one)
-          writeRef(restpe); writeRefs(Nil); POLYtpe
-        case PolyType(tparams, restpe) => // invar: tparams nonEmpty
-          writeRef(restpe); writeRefs(tparams); POLYtpe
-        case ExistentialType(tparams, restpe) =>
-          writeRef(restpe); writeRefs(tparams); EXISTENTIALtpe
-        case c @ Constant(_) =>
-          if (c.tag == BooleanTag) writeLong(if (c.booleanValue) 1 else 0)
-          else if (ByteTag <= c.tag && c.tag <= LongTag) writeLong(c.longValue)
-          else if (c.tag == FloatTag) writeLong(floatToIntBits(c.floatValue).toLong)
-          else if (c.tag == DoubleTag) writeLong(doubleToLongBits(c.doubleValue))
-          else if (c.tag == StringTag) writeRef(newTermName(c.stringValue))
-          else if (c.tag == ClazzTag) writeRef(c.typeValue)
-          else if (c.tag == EnumTag) writeRef(c.symbolValue)
-          LITERAL + c.tag // also treats UnitTag, NullTag; no value required
-        case AnnotatedType(annotations, tp, selfsym) =>
-          annotations filter (_.isStatic) match {
-            case Nil          => writeBody(tp) // write the underlying type if there are no annotations
-            case staticAnnots =>
-              if (settings.selfInAnnots && selfsym != NoSymbol)
-                writeRef(selfsym)
-              writeRef(tp)
-              writeRefs(staticAnnots)
-              ANNOTATEDtpe
-          }
-        // annotations attached to a symbol (i.e. annots on terms)
-        case (target: Symbol, annot@AnnotationInfo(_, _, _)) =>
-          writeRef(target)
-          writeAnnotation(annot)
-          SYMANNOT
-
-        case ArrayAnnotArg(args) =>
-          args foreach writeClassfileAnnotArg
-          ANNOTARGARRAY
-
-        case (target: Symbol, children: List[_]) =>
-          writeRef(target)
-          writeRefs(children.asInstanceOf[List[Symbol]])
-          CHILDREN
-
-        case EmptyTree =>
-          writeNat(EMPTYtree)
-          TREE
-
-        case tree@PackageDef(pid, stats) =>
-          writeNat(PACKAGEtree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(tree.mods)
-          writeRef(pid)
-          writeRefs(stats)
-          TREE
-
-        case tree@ClassDef(mods, name, tparams, impl) =>
-          writeNat(CLASStree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(mods)
-          writeRef(name)
-          writeRef(impl)
-          writeRefs(tparams)
-          TREE
-
-        case tree@ModuleDef(mods, name, impl) =>
-          writeNat(MODULEtree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(mods)
-          writeRef(name)
-          writeRef(impl)
-          TREE
-
-        case tree@ValDef(mods, name, tpt, rhs) =>
-          writeNat(VALDEFtree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(mods)
-          writeRef(name)
-          writeRef(tpt)
-          writeRef(rhs)
-          TREE
-
-        case tree@DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
-          writeNat(DEFDEFtree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(mods)
-          writeRef(name)
-          writeRefsWithLength(tparams)
-          writeNat(vparamss.length)
-          vparamss foreach writeRefsWithLength
-          writeRef(tpt)
-          writeRef(rhs)
-          TREE
-
-        case tree@TypeDef(mods, name, tparams, rhs) =>
-          writeNat(TYPEDEFtree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(mods)
-          writeRef(name)
-          writeRef(rhs)
-          writeRefs(tparams)
-          TREE
-
-        case tree@LabelDef(name, params, rhs) =>
-          writeNat(LABELtree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(name)
-          writeRef(rhs)
-          writeRefs(params)
-          TREE
-
-        case tree@Import(expr, selectors) =>
-          writeNat(IMPORTtree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(expr)
-          for (ImportSelector(from, _, to, _) <- selectors) {
-            writeRef(from)
-            writeRef(to)
-          }
-          TREE
-
-        case tree@DocDef(comment, definition) =>
-          writeNat(DOCDEFtree)
-          writeRef(tree.tpe)
-          writeRef(Constant(comment))
-          writeRef(definition)
-          TREE
-
-        case tree@Template(parents, self, body) =>
-          writeNat(TEMPLATEtree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRefsWithLength(parents)
-          writeRef(self)
-          writeRefs(body)
-          TREE
-
-        case tree@Block(stats, expr) =>
-          writeNat(BLOCKtree)
-          writeRef(tree.tpe)
-          writeRef(expr)
-          writeRefs(stats)
-          TREE
-
-        case tree@CaseDef(pat, guard, body) =>
-          writeNat(CASEtree)
-          writeRef(tree.tpe)
-          writeRef(pat)
-          writeRef(guard)
-          writeRef(body)
-          TREE
-
-        case tree@Alternative(trees) =>
-          writeNat(ALTERNATIVEtree)
-          writeRef(tree.tpe)
-          writeRefs(trees)
-          TREE
-
-        case tree@Star(elem) =>
-          writeNat(STARtree)
-          writeRef(tree.tpe)
-          writeRef(elem)
-          TREE
-
-        case tree@Bind(name, body) =>
-          writeNat(BINDtree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(name)
-          writeRef(body)
-          TREE
-
-        case tree@UnApply(fun: Tree, args) =>
-          writeNat(UNAPPLYtree)
-          writeRef(tree.tpe)
-          writeRef(fun)
-          writeRefs(args)
-          TREE
-
-        case tree@ArrayValue(elemtpt, trees) =>
-          writeNat(ARRAYVALUEtree)
-          writeRef(tree.tpe)
-          writeRef(elemtpt)
-          writeRefs(trees)
-          TREE
-
-        case tree@Function(vparams, body) =>
-          writeNat(FUNCTIONtree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(body)
-          writeRefs(vparams)
-          TREE
-
-        case tree@Assign(lhs, rhs) =>
-          writeNat(ASSIGNtree)
-          writeRef(tree.tpe)
-          writeRef(lhs)
-          writeRef(rhs)
-          TREE
-
-        case tree@If(cond, thenp, elsep) =>
-          writeNat(IFtree)
-          writeRef(tree.tpe)
-          writeRef(cond)
-          writeRef(thenp)
-          writeRef(elsep)
-          TREE
-
-        case tree@Match(selector, cases) =>
-          writeNat(MATCHtree)
-          writeRef(tree.tpe)
-          writeRef(selector)
-          writeRefs(cases)
-          TREE
-
-        case tree@Return(expr) =>
-          writeNat(RETURNtree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(expr)
-          TREE
-
-        case tree@Try(block, catches, finalizer) =>
-          writeNat(TREtree)
-          writeRef(tree.tpe)
-          writeRef(block)
-          writeRef(finalizer)
-          writeRefs(catches)
-          TREE
-
-        case tree@Throw(expr) =>
-          writeNat(THROWtree)
-          writeRef(tree.tpe)
-          writeRef(expr)
-          TREE
-
-        case tree@New(tpt) =>
-          writeNat(NEWtree)
-          writeRef(tree.tpe)
-          writeRef(tpt)
-          TREE
-
-        case tree@Typed(expr, tpt) =>
-          writeNat(TYPEDtree)
-          writeRef(tree.tpe)
-          writeRef(expr)
-          writeRef(tpt)
-          TREE
-
-        case tree@TypeApply(fun, args) =>
-          writeNat(TYPEAPPLYtree)
-          writeRef(tree.tpe)
-          writeRef(fun)
-          writeRefs(args)
-          TREE
-
-        case tree@Apply(fun, args) =>
-          writeNat(APPLYtree)
-          writeRef(tree.tpe)
-          writeRef(fun)
-          writeRefs(args)
-          TREE
-
-        case tree@ApplyDynamic(qual, args) =>
-          writeNat(APPLYDYNAMICtree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(qual)
-          writeRefs(args)
-          TREE
-
-        case tree@Super(qual, mix) =>
-          writeNat(SUPERtree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(qual)
-          writeRef(mix)
-          TREE
-
-        case tree@This(qual) =>
-          writeNat(THIStree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(qual)
-          TREE
-
-        case tree@Select(qualifier, selector) =>
-          writeNat(SELECTtree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(qualifier)
-          writeRef(selector)
-          TREE
-
-        case tree@Ident(name) =>
-          writeNat(IDENTtree)
-          writeRef(tree.tpe)
-          writeRef(tree.symbol)
-          writeRef(name)
-          TREE
-
-        case tree@Literal(value) =>
-          writeNat(LITERALtree)
-          writeRef(tree.tpe)
-          writeRef(value)
-          TREE
-
-        case tree@TypeTree() =>
-          writeNat(TYPEtree)
-          writeRef(tree.tpe)
-          TREE
-
-        case tree@Annotated(annot, arg) =>
-          writeNat(ANNOTATEDtree)
-          writeRef(tree.tpe)
-          writeRef(annot)
-          writeRef(arg)
-          TREE
-
-        case tree@SingletonTypeTree(ref) =>
-          writeNat(SINGLETONTYPEtree)
+    private object writeTreeBodyTraverser extends Traverser {
+      private var refs = false
+      @inline private def asRefs[T](body: => T): T = {
+        val saved = refs
+        refs = true
+        try body finally refs = saved
+      }
+      override def traverseModifiers(mods: Modifiers): Unit          = if (refs) writeRef(mods) else super.traverseModifiers(mods)
+      override def traverseName(name: Name): Unit                    = writeRef(name)
+      override def traverseConstant(const: Constant): Unit           = writeRef(const)
+      override def traverseParams(params: List[Tree]): Unit          = writeRefsWithLength(params)
+      override def traverseParamss(vparamss: List[List[Tree]]): Unit = {
+        writeNat(vparamss.length)
+        super.traverseParamss(vparamss)
+      }
+      override def traverse(tree: Tree): Unit = {
+        if (refs)
+          writeRef(tree)
+        else {
           writeRef(tree.tpe)
-          writeRef(ref)
-          TREE
+          if (tree.hasSymbolField)
+            writeRef(tree.symbol)
 
-        case tree@SelectFromTypeTree(qualifier, selector) =>
-          writeNat(SELECTFROMTYPEtree)
-          writeRef(tree.tpe)
-          writeRef(qualifier)
-          writeRef(selector)
-          TREE
+          asRefs(super.traverse(tree))
+        }
+      }
+    }
 
-        case tree@CompoundTypeTree(templ: Template) =>
-          writeNat(COMPOUNDTYPEtree)
-          writeRef(tree.tpe)
-          writeRef(templ)
-          TREE
+    /** Write an entry */
+    private def writeEntry(entry: AnyRef) {
+      def writeLocalSymbolBody(sym: Symbol) {
+        writeSymInfo(sym)
+        sym match {
+          case _: ClassSymbol if sym.hasSelfType => writeRef(sym.typeOfThis)
+          case _: TermSymbol if sym.alias.exists => writeRef(sym.alias)
+          case _                                 =>
+        }
+      }
+      def writeExtSymbolBody(sym: Symbol) {
+        val name = if (sym.isModuleClass) sym.name.toTermName else sym.name
+        writeRef(name)
+        if (!sym.owner.isRoot)
+          writeRef(sym.owner)
+      }
+      def writeSymbolBody(sym: Symbol) {
+        if (sym ne NoSymbol) {
+          if (isLocal(sym))
+            writeLocalSymbolBody(sym)
+          else
+            writeExtSymbolBody(sym)
+        }
+      }
 
-        case tree@AppliedTypeTree(tpt, args) =>
-          writeNat(APPLIEDTYPEtree)
-          writeRef(tree.tpe)
-          writeRef(tpt)
-          writeRefs(args)
-          TREE
+      // NullaryMethodType reuses POLYtpe since those can never have an empty list of tparams.
+      // TODO: is there any way this can come back and bite us in the bottom?
+      // ugliness and thrift aside, this should make this somewhat more backward compatible
+      // (I'm not sure how old scalac's would deal with nested PolyTypes, as these used to be folded into one)
+      def writeTypeBody(tpe: Type): Unit = tpe match {
+        case NoType | NoPrefix                   =>
+        case ThisType(sym)                       => writeRef(sym)
+        case SingleType(pre, sym)                => writeRef(pre) ; writeRef(sym)
+        case SuperType(thistpe, supertpe)        => writeRef(thistpe) ; writeRef(supertpe)
+        case ConstantType(value)                 => writeRef(value)
+        case TypeBounds(lo, hi)                  => writeRef(lo) ; writeRef(hi)
+        case TypeRef(pre, sym, args)             => writeRef(pre) ; writeRef(sym); writeRefs(args)
+        case MethodType(formals, restpe)         => writeRef(restpe) ; writeRefs(formals)
+        case NullaryMethodType(restpe)           => writeRef(restpe); writeRefs(Nil)
+        case PolyType(tparams, restpe)           => writeRef(restpe); writeRefs(tparams)
+        case ExistentialType(tparams, restpe)    => writeRef(restpe); writeRefs(tparams)
+        case StaticallyAnnotatedType(annots, tp) => writeRef(tp) ; writeRefs(annots)
+        case AnnotatedType(_, tp, _)             => writeTypeBody(tp) // write the underlying type if there are no static annotations
+        case CompoundType(parents, _, clazz)     => writeRef(clazz); writeRefs(parents)
+      }
 
-        case tree@TypeBoundsTree(lo, hi) =>
-          writeNat(TYPEBOUNDStree)
-          writeRef(tree.tpe)
-          writeRef(lo)
-          writeRef(hi)
-          TREE
+      def writeTreeBody(tree: Tree) {
+        writeNat(picklerSubTag(tree))
+        if (!tree.isEmpty)
+          writeTreeBodyTraverser traverse tree
+      }
 
-        case tree@ExistentialTypeTree(tpt, whereClauses) =>
-          writeNat(EXISTENTIALTYPEtree)
-          writeRef(tree.tpe)
-          writeRef(tpt)
-          writeRefs(whereClauses)
-          TREE
+      def writeConstant(c: Constant): Unit = c.tag match {
+        case BooleanTag => writeLong(if (c.booleanValue) 1 else 0)
+        case FloatTag   => writeLong(floatToIntBits(c.floatValue).toLong)
+        case DoubleTag  => writeLong(doubleToLongBits(c.doubleValue))
+        case StringTag  => writeRef(newTermName(c.stringValue))
+        case ClazzTag   => writeRef(c.typeValue)
+        case EnumTag    => writeRef(c.symbolValue)
+        case tag        => if (ByteTag <= tag && tag <= LongTag) writeLong(c.longValue)
+      }
 
-        case Modifiers(flags, privateWithin, _) =>
-          val pflags = rawToPickledFlags(flags)
-          writeNat((pflags >> 32).toInt)
-          writeNat((pflags & 0xFFFFFFFF).toInt)
-          writeRef(privateWithin)
-          MODIFIERS
+      def writeModifiers(mods: Modifiers) {
+        val pflags = rawToPickledFlags(mods.flags)
+        writeNat((pflags >> 32).toInt)
+        writeNat((pflags & 0xFFFFFFFF).toInt)
+        writeRef(mods.privateWithin)
+      }
 
-        // annotations on types (not linked to a symbol)
-        case annot@AnnotationInfo(_, _, _) =>
-          writeAnnotation(annot)
-          ANNOTINFO
+      def writeSymbolTuple(target: Symbol, other: Any) {
+        writeRef(target)
+        other match {
+          case annot: AnnotationInfo             => writeAnnotation(annot)
+          case children: List[Symbol @unchecked] => writeRefs(children)
+          case _                                 =>
+        }
+      }
 
-        case _ =>
-          throw new FatalError("bad entry: " + entry + " " + entry.getClass)
+      def writeBody(entry: AnyRef): Unit = entry match {
+        case tree: Tree              => writeTreeBody(tree)
+        case sym: Symbol             => writeSymbolBody(sym)
+        case tpe: Type               => writeTypeBody(tpe)
+        case name: Name              => writeName(name)
+        case const: Constant         => writeConstant(const)
+        case mods: Modifiers         => writeModifiers(mods)
+        case annot: AnnotationInfo   => writeAnnotation(annot)
+        case (target: Symbol, other) => writeSymbolTuple(target, other)
+        case ArrayAnnotArg(args)     => args foreach writeClassfileAnnotArg
+        case _                       => devWarning(s"Unexpected entry to pickler ${shortClassOfInstance(entry)} $entry")
       }
 
       // begin writeEntry
-      val startpos = writeIndex
-      // reserve some space so that the patchNat's most likely won't need to shift
-      writeByte(0); writeByte(0)
-      patchNat(startpos, writeBody(entry))
-      patchNat(startpos + 1, writeIndex - (startpos + 2))
+      // The picklerTag method can't determine if it's an external symbol reference
+      val tag = entry match {
+        case sym: Symbol if isExternalSymbol(sym) => if (sym.isModuleClass) EXTMODCLASSref else EXTref
+        case _                                    => picklerTag(entry)
+      }
+      writeNat(tag)
+      writeByte(0) // reserve a place to record the number of bytes written
+      val start = writeIndex
+      writeBody(entry)
+      val length = writeIndex - start
+      patchNat(start - 1, length) // patch bytes written over the placeholder
     }
 
     /** Write byte array */
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index 599969598e..e3d7bfd4f8 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -425,11 +425,10 @@ trait Namers extends MethodSynthesis {
       sym
     }
 
-    /** Enter a module symbol. The tree parameter can be either
-     *  a module definition or a class definition.
+    /** Enter a module symbol.
      */
     def enterModuleSymbol(tree : ModuleDef): Symbol = {
-      var m: Symbol = context.scope lookupAll tree.name find (_.isModule) getOrElse NoSymbol
+      var m: Symbol = context.scope lookupModule tree.name
       val moduleFlags = tree.mods.flags | MODULE
       if (m.isModule && !m.isPackage && inCurrentScope(m) && (currentRun.canRedefine(m) || m.isSynthetic)) {
         updatePosFlags(m, tree.pos, moduleFlags)
diff --git a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
index 1b726c37b9..fd8f9bebba 100644
--- a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
@@ -283,6 +283,9 @@ abstract class TreeCheckers extends Analyzer {
       }
 
       private def traverseInternal(tree: Tree) {
+        if (!tree.canHaveAttrs)
+          return
+
         checkSymbolRefsRespectScope(enclosingMemberDefs takeWhile (md => !md.symbol.hasPackageFlag), tree)
         checkReturnReferencesDirectlyEnclosingDef(tree)
 
@@ -329,10 +332,9 @@ abstract class TreeCheckers extends Analyzer {
             return
           case _ =>
         }
-
-        if (tree.canHaveAttrs && tree.pos == NoPosition)
+        if (tree.pos == NoPosition)
           noPos(tree)
-        else if (tree.tpe == null && phase.id > currentRun.typerPhase.id)
+        else if (tree.tpe == null && isPastTyper)
           noType(tree)
         else if (tree.isDef) {
           checkSym(tree)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 6dadb3100f..3826c819f9 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -13,7 +13,7 @@ package scala
 package tools.nsc
 package typechecker
 
-import scala.collection.mutable
+import scala.collection.{ mutable, immutable }
 import scala.reflect.internal.util.{ BatchSourceFile, Statistics, shortClassOfInstance }
 import mutable.ListBuffer
 import symtab.Flags._
@@ -3405,7 +3405,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           else {
             val annScope = annType.decls
                 .filter(sym => sym.isMethod && !sym.isConstructor && sym.isJavaDefined)
-            val names = new scala.collection.mutable.HashSet[Symbol]
+            val names = mutable.Set[Symbol]()
             names ++= (if (isJava) annScope.iterator
                        else typedFun.tpe.params.iterator)
 
@@ -3545,8 +3545,8 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           while (o != owner && o != NoSymbol && !o.hasPackageFlag) o = o.owner
           o == owner && !isVisibleParameter(sym)
         }
-      var localSyms = scala.collection.immutable.Set[Symbol]()
-      var boundSyms = scala.collection.immutable.Set[Symbol]()
+      var localSyms = immutable.Set[Symbol]()
+      var boundSyms = immutable.Set[Symbol]()
       def isLocal(sym: Symbol): Boolean =
         if (sym == NoSymbol || sym.isRefinementClass || sym.isLocalDummy) false
         else if (owner == NoSymbol) tree exists (defines(_, sym))
@@ -4126,7 +4126,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           NotAMemberError(tpt, TypeTree(tp), nme.CONSTRUCTOR)
           setError(tpt)
         }
-        else if (!(  tp == sym.thisSym.tpe_* // when there's no explicit self type -- with (#3612) or without self variable
+        else if (!(  tp == sym.typeOfThis // when there's no explicit self type -- with (#3612) or without self variable
                      // sym.thisSym.tpe == tp.typeOfThis (except for objects)
                   || narrowRhs(tp) <:< tp.typeOfThis
                   || phase.erasedTypes