From 7449ae546950661a0dfec37a812ad57d2b35b826 Mon Sep 17 00:00:00 2001 From: Guillaume Martres Date: Mon, 23 Apr 2018 14:10:44 +0200 Subject: [PATCH] Remove unused code copied from Dotty's TreePickler --- tasty4scalac/src/tasty4scalac/Plugin.scala | 2 +- .../src/tasty4scalac/ScalacTreePickler.scala | 867 +++--------------- 2 files changed, 135 insertions(+), 734 deletions(-) diff --git a/tasty4scalac/src/tasty4scalac/Plugin.scala b/tasty4scalac/src/tasty4scalac/Plugin.scala index 173a42cd48a1..514376d3c5f7 100644 --- a/tasty4scalac/src/tasty4scalac/Plugin.scala +++ b/tasty4scalac/src/tasty4scalac/Plugin.scala @@ -55,7 +55,7 @@ class Plugin(val global: Global) extends NscPlugin { self => println("Hello: " + tree) val pickler = new ScalacTastyPickler(global) val treePkl = pickler.treePkl - treePkl.spickle(List(tree.asInstanceOf[treePkl.g.Tree])) + treePkl.pickle(List(tree.asInstanceOf[treePkl.g.Tree])) treePkl.compactify() val pickled = pickler.assembleParts() diff --git a/tasty4scalac/src/tasty4scalac/ScalacTreePickler.scala b/tasty4scalac/src/tasty4scalac/ScalacTreePickler.scala index 8724455fa57f..ff10b471c591 100644 --- a/tasty4scalac/src/tasty4scalac/ScalacTreePickler.scala +++ b/tasty4scalac/src/tasty4scalac/ScalacTreePickler.scala @@ -22,14 +22,6 @@ import config.Config import scala.tools.nsc.Global -object ScalacTreePickler { - - case class Hole(idx: Int, args: List[tpd.Tree]) extends tpd.TermTree { - override def fallbackToText(printer: Printer): Text = - s"[[$idx|" ~~ printer.toTextGlobal(args, ", ") ~~ "]]" - } -} - class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { val buf = new TreeBuffer pickler.newSection("ASTs", buf) @@ -38,13 +30,9 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { import pickler.nameBuffer.nameIndex import tpd._ - private val symRefs = Symbols.newMutableSymbolMap[Addr] - private val forwardSymRefs = Symbols.newMutableSymbolMap[List[Addr]] - private val pickledTypes = new java.util.IdentityHashMap[Type, Any] // Value type is really Addr, but that's not compatible with null - - private val ssymRefs = new mutable.HashMap[g.Symbol, Addr] - private val sforwardSymRefs = new mutable.HashMap[g.Symbol, List[Addr]] - private val spickledTypes = new java.util.IdentityHashMap[g.Type, Any] // Value type is really Addr, but that's not compatible with null + private val symRefs = new mutable.HashMap[g.Symbol, Addr] + private val forwardSymRefs = new mutable.HashMap[g.Symbol, List[Addr]] + private val pickledTypes = new java.util.IdentityHashMap[g.Type, Any] // Value type is really Addr, but that's not compatible with null private def withLength(op: => Unit) = { val lengthAddr = reserveRef(relative = true) @@ -52,16 +40,6 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { fillRef(lengthAddr, currentAddr, relative = true) } - def addrOfSym(sym: Symbol): Option[Addr] = { - symRefs.get(sym) - } - - def preRegister(tree: Tree)(implicit ctx: Context): Unit = tree match { - case tree: MemberDef => - if (!symRefs.contains(tree.symbol)) symRefs(tree.symbol) = NoAddr - case _ => - } - def pickledSym(sym: g.Symbol): g.Symbol = if (sym.isParamAccessor && !sym.isSetter) { val getter = sym.getterIn(sym.owner) @@ -72,14 +50,14 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { } else sym - def spreRegister(tree: g.Tree): Unit = tree match { + def preRegister(tree: g.Tree): Unit = tree match { case _: g.MemberDef | _: g.LabelDef | _: g.Function => val sym = pickledSym(tree.symbol) - if (!ssymRefs.contains(sym)) ssymRefs(sym) = NoAddr + if (!symRefs.contains(sym)) symRefs(sym) = NoAddr case _ => } - def registerDef(sym: Symbol): Unit = { + def registerDef(sym: g.Symbol): Unit = { symRefs(sym) = currentAddr forwardSymRefs.get(sym) match { case Some(refs) => @@ -89,17 +67,7 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { } } - def sregisterDef(sym: g.Symbol): Unit = { - ssymRefs(sym) = currentAddr - sforwardSymRefs.get(sym) match { - case Some(refs) => - refs.foreach(fillRef(_, currentAddr, relative = false)) - sforwardSymRefs -= sym - case None => - } - } - - private def sconvertName(name: g.Name): Name = + private def convertName(name: g.Name): Name = if (name eq g.nme.isInstanceOf_Ob) nme.isInstanceOf_ else if (name eq g.nme.asInstanceOf_Ob) @@ -115,33 +83,27 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { qname } - private def sconvertFullName(sym: g.Symbol): Name = ??? + private def pickleDottyName(name: Name): Unit = writeNat(nameIndex(name).index) - private def spickleName(name: g.Name): Unit = - pickleName(sconvertName(name)) + private def pickleName(name: g.Name): Unit = + pickleDottyName(convertName(name)) - private def pickleName(name: Name): Unit = writeNat(nameIndex(name).index) - private def spickleNameAndSig(name: g.Name, tp: g.Type): Unit = { - val sig = ssignature(tp, isConstructor = name eq g.nme.CONSTRUCTOR) - val name1 = sconvertName(name) - pickleName( + private def pickleNameAndSig(name: g.Name, tp: g.Type): Unit = { + val sig = signature(tp, isConstructor = name eq g.nme.CONSTRUCTOR) + val name1 = convertName(name) + pickleDottyName( if (sig eq Signature.NotAMethod) name1 else SignedName(name1.toTermName, sig)) } - private def pickleNameAndSig(name: Name, sig: Signature): Unit = - pickleName( - if (sig eq Signature.NotAMethod) name - else SignedName(name.toTermName, sig)) - private def sigName(tp: g.Type): TypeName = tp match { case g.TypeRef(_, sym, _) => // TODO: special case arrays, maybe value classes too - sconvertName(sym.fullNameAsName('.')).asTypeName + convertName(sym.fullNameAsName('.')).asTypeName } - private def ssignature(tp: g.Type, isConstructor: Boolean): Signature = tp.erasure match { + private def signature(tp: g.Type, isConstructor: Boolean): Signature = tp.erasure match { case tp @ g.MethodType(_, resultType0) => val resultType = if (isConstructor && (resultType0.typeSymbol eq g.definitions.ArrayClass)) @@ -153,42 +115,24 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { Signature.NotAMethod } - private def spickleSymRef(sym: g.Symbol) = ssymRefs.get(sym) match { + private def pickleSymRef(sym: g.Symbol) = symRefs.get(sym) match { case Some(label) => - if (label != NoAddr) writeRef(label) else spickleForwardSymRef(sym) + if (label != NoAddr) writeRef(label) else pickleForwardSymRef(sym) case None => assert(false, s"pickling reference to as yet undefined $sym in ${sym.owner}") // pickleForwardSymRef(sym) } - private def pickleSymRef(sym: Symbol)(implicit ctx: Context) = symRefs.get(sym) match { - case Some(label) => - if (label != NoAddr) writeRef(label) else pickleForwardSymRef(sym) - case None => - // See pos/t1957.scala for an example where this can happen. - // I believe it's a bug in typer: the type of an implicit argument refers - // to a closure parameter outside the closure itself. TODO: track this down, so that we - // can eliminate this case. - ctx.log(i"pickling reference to as yet undefined $sym in ${sym.owner}", sym.pos) - pickleForwardSymRef(sym) - } - - private def spickleForwardSymRef(sym: g.Symbol) = { + private def pickleForwardSymRef(sym: g.Symbol) = { val ref = reserveRef(relative = false) assert(!sym.hasPackageFlag, sym) - sforwardSymRefs(sym) = ref :: sforwardSymRefs.getOrElse(sym, Nil) - } - - private def pickleForwardSymRef(sym: Symbol)(implicit ctx: Context) = { - val ref = reserveRef(relative = false) - assert(!sym.is(Flags.Package), sym) forwardSymRefs(sym) = ref :: forwardSymRefs.getOrElse(sym, Nil) } private def isLocallyDefined(sym: Symbol)(implicit ctx: Context) = ??? //sym.topLevelClass.isLinkedWith(pickler.rootCls) - def spickleConstant(c: g.Constant): Unit = c.tag match { + def pickleConstant(c: g.Constant): Unit = c.tag match { case UnitTag => writeByte(UNITconst) case BooleanTag => @@ -216,7 +160,7 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { writeLongInt(java.lang.Double.doubleToRawLongBits(c.doubleValue)) case StringTag => writeByte(STRINGconst) - pickleName(c.stringValue.toTermName) + pickleDottyName(c.stringValue.toTermName) case NullTag => writeByte(NULLconst) case ClazzTag => @@ -230,50 +174,7 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { ??? //pickleName(c.scalaSymbolValue.name.toTermName) } - def pickleConstant(c: Constant)(implicit ctx: Context): Unit = c.tag match { - case UnitTag => - writeByte(UNITconst) - case BooleanTag => - writeByte(if (c.booleanValue) TRUEconst else FALSEconst) - case ByteTag => - writeByte(BYTEconst) - writeInt(c.byteValue) - case ShortTag => - writeByte(SHORTconst) - writeInt(c.shortValue) - case CharTag => - writeByte(CHARconst) - writeNat(c.charValue) - case IntTag => - writeByte(INTconst) - writeInt(c.intValue) - case LongTag => - writeByte(LONGconst) - writeLongInt(c.longValue) - case FloatTag => - writeByte(FLOATconst) - writeInt(java.lang.Float.floatToRawIntBits(c.floatValue)) - case DoubleTag => - writeByte(DOUBLEconst) - writeLongInt(java.lang.Double.doubleToRawLongBits(c.doubleValue)) - case StringTag => - writeByte(STRINGconst) - pickleName(c.stringValue.toTermName) - case NullTag => - writeByte(NULLconst) - case ClazzTag => - writeByte(CLASSconst) - pickleType(c.typeValue) - case EnumTag => - writeByte(ENUMconst) - pickleType(c.symbolValue.termRef) - case ScalaSymbolTag => - writeByte(SYMBOLconst) - pickleName(c.scalaSymbolValue.name.toTermName) - } - - def pickleType(tpe0: Type, richTypes: Boolean = false)(implicit ctx: Context): Unit = { - val tpe = tpe0.stripTypeVar + def pickleType(tpe: g.Type, richTypes: Boolean = false): Unit = try { val prev = pickledTypes.get(tpe) if (prev == null) { @@ -284,31 +185,13 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { writeByte(SHAREDtype) writeRef(prev.asInstanceOf[Addr]) } - } catch { - case ex: AssertionError => - println(i"error when pickling type $tpe") - throw ex - } - } - - def spickleType(tpe: g.Type, richTypes: Boolean = false): Unit = - try { - val prev = spickledTypes.get(tpe) - if (prev == null) { - spickledTypes.put(tpe, currentAddr) - spickleNewType(tpe, richTypes) - } - else { - writeByte(SHAREDtype) - writeRef(prev.asInstanceOf[Addr]) - } } catch { case ex: AssertionError => println(s"error when pickling type $tpe") throw ex } - private def spickleNamedType(pre0: g.Type, sym: g.Symbol, isType: Boolean): Unit = { + private def pickleNamedType(pre0: g.Type, sym: g.Symbol, isType: Boolean): Unit = { val pre = if (pre0 == g.NoPrefix && sym.isTypeParameter) sym.owner.thisType @@ -316,19 +199,19 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { pre0 if (sym.hasPackageFlag) { writeByte(if (isType) TYPEREFpkg else TERMREFpkg) - spickleName(sym.fullNameAsName('.')) + pickleName(sym.fullNameAsName('.')) } else if (sym.isExistential) { writeByte(TYPEBOUNDS) withLength { - spickleType(g.definitions.NothingTpe) + pickleType(g.definitions.NothingTpe) // FIXME: Incorrect for higher-kinded existential variable - spickleType(g.definitions.AnyTpe) + pickleType(g.definitions.AnyTpe) } } else if (pre == g.NoPrefix) { writeByte(if (isType) TYPEREFdirect else TERMREFdirect) - spickleSymRef(sym) + pickleSymRef(sym) } else { writeByte(if (isType) TYPEREF else TERMREF) @@ -339,42 +222,42 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { sym.name.decode.toTypeName.moduleClassName else sym.name.decode.toTypeName - pickleName(name1) - spickleType(pre) + pickleDottyName(name1) + pickleType(pre) } } - private def spickleNewType(tpe: g.Type, richTypes: Boolean): Unit = tpe match { + private def pickleNewType(tpe: g.Type, richTypes: Boolean): Unit = tpe match { case g.ConstantType(value) => - spickleConstant(value) + pickleConstant(value) case g.TypeRef(pre, sym, args) => if (!args.isEmpty) { writeByte(APPLIEDtype) withLength { - spickleNamedType(pre, sym, isType = true) - args.foreach(spickleType(_)) + pickleNamedType(pre, sym, isType = true) + args.foreach(pickleType(_)) } } else - spickleNamedType(pre, sym, isType = true) + pickleNamedType(pre, sym, isType = true) case g.SingleType(pre, sym) => - spickleNamedType(pre, sym, sym.isType) + pickleNamedType(pre, sym, sym.isType) case tpe @ g.ThisType(sym) => if (sym.hasPackageFlag && !sym.isRoot) { writeByte(TERMREFpkg) - spickleName(sym.fullNameAsName('.')) + pickleName(sym.fullNameAsName('.')) } else { assert(!sym.isRoot) writeByte(THIS) - spickleType(tpe.underlying.typeConstructor.asInstanceOf[g.TypeRef]) + pickleType(tpe.underlying.typeConstructor.asInstanceOf[g.TypeRef]) } case g.TypeBounds(lo, hi) => if (lo eq hi) { writeByte(TYPEALIAS) - spickleType(lo, richTypes) + pickleType(lo, richTypes) } else { writeByte(TYPEBOUNDS) - withLength { spickleType(lo, richTypes); spickleType(hi, richTypes) } + withLength { pickleType(lo, richTypes); pickleType(hi, richTypes) } } case g.AnnotatedType(annotations, underlying) => def pickleAnnot(annots: List[g.AnnotationInfo]): Unit = annots match { @@ -382,161 +265,29 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { writeByte(ANNOTATEDtype) withLength { pickleAnnot(as) - spickleTree(a.original) + pickleTree(a.original) } case Nil => - spickleType(underlying, richTypes) + pickleType(underlying, richTypes) } pickleAnnot(annotations) case tpe @ g.ExistentialType(quantified, underlying) => if (!tpe.isRepresentableWithWildcards) { assert(false, s"Cannot pickle existential type not representable using wildcards: $tpe") } - spickleType(underlying) - } - - private def pickleNewType(tpe: Type, richTypes: Boolean)(implicit ctx: Context): Unit = tpe match { - case AppliedType(tycon, args) => - writeByte(APPLIEDtype) - withLength { pickleType(tycon); args.foreach(pickleType(_)) } - case ConstantType(value) => - pickleConstant(value) - case tpe: NamedType => - val sym = tpe.symbol - def pickleExternalRef(sym: Symbol) = { - def pickleCore() = { - pickleNameAndSig(sym.name, tpe.signature) - pickleType(tpe.prefix) - } - val isShadowedRef = - sym.isClass && tpe.prefix.member(sym.name).symbol != sym - if (sym.is(Flags.Private) || isShadowedRef) { - writeByte(if (tpe.isType) TYPEREFin else TERMREFin) - withLength { - pickleCore() - pickleType(sym.owner.typeRef) - } - } - else { - writeByte(if (tpe.isType) TYPEREF else TERMREF) - pickleCore() - } - } - if (sym.is(Flags.Package)) { - writeByte(if (tpe.isType) TYPEREFpkg else TERMREFpkg) - pickleName(sym.fullName) - } - else if (tpe.prefix == NoPrefix) { - writeByte(if (tpe.isType) TYPEREFdirect else TERMREFdirect) - pickleSymRef(sym) - } - else if (isLocallyDefined(sym)) { - writeByte(if (tpe.isType) TYPEREFsymbol else TERMREFsymbol) - pickleSymRef(sym); pickleType(tpe.prefix) - } - else tpe.designator match { - case name: Name => - writeByte(if (tpe.isType) TYPEREF else TERMREF) - pickleName(name); pickleType(tpe.prefix) - case sym: Symbol => - pickleExternalRef(sym) - } - case tpe: ThisType => - if (tpe.cls.is(Flags.Package) && !tpe.cls.isEffectiveRoot) { - writeByte(TERMREFpkg) - pickleName(tpe.cls.fullName) - } - else { - writeByte(THIS) - assert(!tpe.cls.isEffectiveRoot, s"This happened: $tpe - ${tpe.cls}") - pickleType(tpe.tref) - } - case tpe: SuperType => - writeByte(SUPERtype) - withLength { pickleType(tpe.thistpe); pickleType(tpe.supertpe) } - case tpe: RecThis => - writeByte(RECthis) - val binderAddr = pickledTypes.get(tpe.binder) - assert(binderAddr != null, tpe.binder) - writeRef(binderAddr.asInstanceOf[Addr]) - case tpe: SkolemType => - pickleType(tpe.info) - case tpe: RefinedType => - writeByte(REFINEDtype) - withLength { - pickleName(tpe.refinedName) - pickleType(tpe.parent) - pickleType(tpe.refinedInfo, richTypes = true) - } - case tpe: RecType => - writeByte(RECtype) - pickleType(tpe.parent) - case tpe: TypeAlias => - writeByte(TYPEALIAS) - pickleType(tpe.alias, richTypes) - case tpe: TypeBounds => - writeByte(TYPEBOUNDS) - withLength { pickleType(tpe.lo, richTypes); pickleType(tpe.hi, richTypes) } - case tpe: AnnotatedType => - writeByte(ANNOTATEDtype) - withLength { pickleType(tpe.tpe, richTypes); pickleTree(tpe.annot.tree) } - case tpe: AndType => - writeByte(ANDtype) - withLength { pickleType(tpe.tp1, richTypes); pickleType(tpe.tp2, richTypes) } - case tpe: OrType => - writeByte(ORtype) - withLength { pickleType(tpe.tp1, richTypes); pickleType(tpe.tp2, richTypes) } - case tpe: ExprType => - writeByte(BYNAMEtype) - pickleType(tpe.underlying) - case tpe: HKTypeLambda => - pickleMethodic(TYPELAMBDAtype, tpe) - case tpe: PolyType if richTypes => - pickleMethodic(POLYtype, tpe) - case tpe: MethodType if richTypes => - pickleMethodic(methodType(isImplicit = tpe.isImplicitMethod, isErased = tpe.isErasedMethod), tpe) - case tpe: ParamRef => - assert(pickleParamRef(tpe), s"orphan parameter reference: $tpe") - case tpe: LazyRef => - pickleType(tpe.ref) - } - - def pickleMethodic(tag: Int, tpe: LambdaType)(implicit ctx: Context) = { - writeByte(tag) - withLength { - pickleType(tpe.resultType, richTypes = true) - (tpe.paramNames, tpe.paramInfos).zipped.foreach { (name, tpe) => - pickleName(name); pickleType(tpe) - } - } + pickleType(underlying) } - def pickleParamRef(tpe: ParamRef)(implicit ctx: Context): Boolean = { - val binder = pickledTypes.get(tpe.binder) - val pickled = binder != null - if (pickled) { - writeByte(PARAMtype) - withLength { writeRef(binder.asInstanceOf[Addr]); writeNat(tpe.paramNum) } - } - pickled - } - - def spickleTpt(tpt: g.Tree): Unit = - spickleTree(tpt) - - def pickleTpt(tpt: Tree)(implicit ctx: Context): Unit = + def pickleTpt(tpt: g.Tree): Unit = pickleTree(tpt) - def spickleTreeUnlessEmpty(tree: g.Tree): Unit = - if (!tree.isEmpty) spickleTree(tree) - - def pickleTreeUnlessEmpty(tree: Tree)(implicit ctx: Context): Unit = + def pickleTreeUnlessEmpty(tree: g.Tree): Unit = if (!tree.isEmpty) pickleTree(tree) - def spickleDef(tag: Int, sym0: g.Symbol, tpt: g.Tree, rhs0: g.Tree = null, pickleParams: => Unit = ()) = { + def pickleDef(tag: Int, sym0: g.Symbol, tpt: g.Tree, rhs0: g.Tree = null, pickleParams: => Unit = ()) = { val sym = pickledSym(sym0) - assert(ssymRefs(sym) == NoAddr, s"$sym - $sym0") - sregisterDef(sym) + assert(symRefs(sym) == NoAddr, s"$sym - $sym0") + registerDef(sym) writeByte(tag) withLength { val name = @@ -544,11 +295,11 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { g.nme.CONSTRUCTOR // FIXME: this is not enough, if trait is PureInterface, no $init$ is generated at all else sym.name - spickleName(name) + pickleName(name) pickleParams tpt match { - case _: g.Template => spickleTree(tpt) - case _ if tpt.isType => spickleTree(tpt) + case _: g.Template => pickleTree(tpt) + case _ if tpt.isType => pickleTree(tpt) } val rhs = if (sym0.isSetter && sym0.isAccessor) { @@ -563,8 +314,8 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { g.Ident(g.nme.WILDCARD).setType(sym.info.resultType) else rhs0 - if (rhs != null) spickleTreeUnlessEmpty(rhs) - spickleModifiers(sym, + if (rhs != null) pickleTreeUnlessEmpty(rhs) + pickleModifiers(sym, mutable = sym0.isMutable, // Mutable flag is on field only field = sym0 != sym, methodParam = sym0.owner.isMethod && tag == PARAM @@ -572,61 +323,26 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { } } - def pickleDef(tag: Int, sym: Symbol, tpt: Tree, rhs: Tree = EmptyTree, pickleParams: => Unit = ())(implicit ctx: Context) = { - assert(symRefs(sym) == NoAddr, sym) - registerDef(sym) - writeByte(tag) - withLength { - pickleName(sym.name) - pickleParams - tpt match { - case _: Template | _: Hole => pickleTree(tpt) - case _ if tpt.isType => pickleTpt(tpt) - } - pickleTreeUnlessEmpty(rhs) - pickleModifiers(sym) - } - } - - def spickleParam(tree: g.Tree): Unit = { - registerTreeAddr(tree) - tree match { - case tree: g.ValDef => spickleDef(PARAM, tree.symbol, tree.tpt) - case tree: g.DefDef => spickleDef(PARAM, tree.symbol, tree.tpt, tree.rhs) - case tree: g.TypeDef => spickleDef(TYPEPARAM, tree.symbol, tree.rhs) - } - } - - def pickleParam(tree: Tree)(implicit ctx: Context): Unit = { + def pickleParam(tree: g.Tree): Unit = { registerTreeAddr(tree) tree match { - case tree: ValDef => pickleDef(PARAM, tree.symbol, tree.tpt) - case tree: DefDef => pickleDef(PARAM, tree.symbol, tree.tpt, tree.rhs) - case tree: TypeDef => pickleDef(TYPEPARAM, tree.symbol, tree.rhs) + case tree: g.ValDef => pickleDef(PARAM, tree.symbol, tree.tpt) + case tree: g.DefDef => pickleDef(PARAM, tree.symbol, tree.tpt, tree.rhs) + case tree: g.TypeDef => pickleDef(TYPEPARAM, tree.symbol, tree.rhs) } } - def spickleParams(trees: List[g.Tree]): Unit = { - trees.foreach(spreRegister) - trees.foreach(spickleParam) - } - - def pickleParams(trees: List[Tree])(implicit ctx: Context): Unit = { + def pickleParams(trees: List[g.Tree]): Unit = { trees.foreach(preRegister) trees.foreach(pickleParam) } - def spickleStats(stats: List[g.Tree]) = { - stats.foreach(spreRegister) - stats.foreach(stat => if (!stat.isEmpty) spickleTree(stat)) - } - - def pickleStats(stats: List[Tree])(implicit ctx: Context) = { + def pickleStats(stats: List[g.Tree]) = { stats.foreach(preRegister) stats.foreach(stat => if (!stat.isEmpty) pickleTree(stat)) } - def spickleTree(tree: g.Tree): Unit = { + def pickleTree(tree: g.Tree): Unit = { // Accessors that are not in traits should not be pickled, they will be reconstructed if (tree.isDef && tree.symbol != null && !tree.symbol.owner.isTrait && tree.symbol.isAccessor && !tree.symbol.isSetter) { return @@ -641,41 +357,41 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { try tree match { case g.PackageDef(pid, stats) => writeByte(PACKAGE) - withLength { spickleType(pid.tpe); spickleStats(stats) } + withLength { pickleType(pid.tpe); pickleStats(stats) } case tree @ g.ClassDef(mods, name, tparams, impl) => //pickleDef val sym = tree.symbol val tag = TYPEDEF - sregisterDef(sym) + registerDef(sym) writeByte(tag) withLength { - spickleName(name) - spickleTree(impl.copy(body = tparams ++ impl.body)) - spickleModifiers(sym) + pickleName(name) + pickleTree(impl.copy(body = tparams ++ impl.body)) + pickleModifiers(sym) } case tree @ g.ModuleDef(_, name, impl) => - sregisterDef(tree.symbol) + registerDef(tree.symbol) writeByte(VALDEF) withLength { - spickleName(name) - spickleType(impl.tpe) + pickleName(name) + pickleType(impl.tpe) writeByte(APPLY) withLength { writeByte(SELECT) - pickleName("".toTermName) + pickleDottyName("".toTermName) writeByte(NEW) - spickleType(impl.tpe.underlying) + pickleType(impl.tpe.underlying) } - spickleModifiers(tree.symbol) + pickleModifiers(tree.symbol) } writeByte(TYPEDEF) withLength { - pickleName(name.decode.toTypeName.moduleClassName) - spickleTree(impl) - spickleModifiers(tree.symbol, moduleClass = true) + pickleDottyName(name.decode.toTypeName.moduleClassName) + pickleTree(impl) + pickleModifiers(tree.symbol, moduleClass = true) } case tree @ g.Template(parents, self, body) => - sregisterDef(tree.symbol) + registerDef(tree.symbol) writeByte(TEMPLATE) val (params, rest0) = tree.body partition { case stat: g.TypeDef => stat.symbol.isParameter @@ -690,38 +406,38 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { // val primaryCtr = g.treeInfo.firstConstructor(body) withLength { - spickleParams(params) - parents.foreach(spickleTree) + pickleParams(params) + parents.foreach(pickleTree) if (!self.isEmpty && false) { // TODO } val owner = tree.symbol.owner if (owner.isModuleClass) { writeByte(SELFDEF) - pickleName(nme.WILDCARD) + pickleName(g.nme.WILDCARD) val pre = owner.owner.thisType - spickleNamedType(pre, owner.module, isType = false) + pickleNamedType(pre, owner.module, isType = false) } - spickleStats(constructors ++ rest1) + pickleStats(constructors ++ rest1) } case g.This(qual) => if (qual.isEmpty) { // Needs to be a ThisType, but can be a TypeRef - spickleType(g.ThisType(tree.symbol)) + pickleType(g.ThisType(tree.symbol)) } else { writeByte(QUALTHIS) writeByte(IDENTtpt) - spickleName(qual) + pickleName(qual) val tp = tree.tpe.underlying.widen.typeConstructor assert(tp.isInstanceOf[g.TypeRef], s"${tp} ${tp.getClass}") - spickleType(tp) + pickleType(tp) } case g.Select(qual, name) => def pickleSelect = { writeByte(if (name.isTypeName) SELECTtpt else SELECT) - spickleNameAndSig(name, tree.tpe) - spickleTree(qual) + pickleNameAndSig(name, tree.tpe) + pickleTree(qual) } if (tree.symbol.isConstructor && !tree.symbol.owner.typeParams.isEmpty) { val g.TypeRef(_, _, targs) = qual.tpe.widen @@ -729,7 +445,7 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { writeByte(TYPEAPPLY) withLength { pickleSelect - targs.foreach(spickleType(_)) + targs.foreach(pickleType(_)) } } else @@ -739,19 +455,19 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { case g.TypeApply(fun1, _) if fun1.symbol eq g.definitions.Object_isInstanceOf => // isInstanceOf does not have a parameter list, but scalac sometimes thinks it does assert(args.isEmpty) - spickleTree(fun) + pickleTree(fun) case _ => writeByte(APPLY) withLength { - spickleTree(fun) - args.foreach(spickleTree) + pickleTree(fun) + args.foreach(pickleTree) } } case g.TypeApply(fun, args) => writeByte(TYPEAPPLY) withLength { - spickleTree(fun) - args.foreach(spickleTpt) + pickleTree(fun) + args.foreach(pickleTpt) } case g.Ident(name) => // wildcards are pattern bound, need to be preserved as ids. @@ -765,11 +481,11 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { case tp => tp } - spickleType(tp1) + pickleType(tp1) } else { writeByte(if (tree.isType) IDENTtpt else IDENT) - spickleName(name) - spickleType(tree.tpe) + pickleName(name) + pickleType(tree.tpe) } case tree @ g.DefDef(mods, name, tparams, vparamss, tpt, rhs) => val isConstructor = tree.symbol.isConstructor @@ -779,16 +495,16 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { for (tparam <- tree.symbol.owner.typeParams) { writeByte(TYPEPARAM) withLength { - spickleName(tparam.name) - spickleType(tparam.info) + pickleName(tparam.name) + pickleType(tparam.info) } } } else { - spickleParams(tree.tparams) + pickleParams(tree.tparams) } for (vparams <- tree.vparamss) { writeByte(PARAMS) - withLength { spickleParams(vparams) } + withLength { pickleParams(vparams) } } } val tpt1 = @@ -801,11 +517,11 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { g.EmptyTree // TODO: Check if there's no information lost here else tree.rhs - spickleDef(DEFDEF, tree.symbol, tpt1, rhs1, pickleAllParams) + pickleDef(DEFDEF, tree.symbol, tpt1, rhs1, pickleAllParams) case tree: g.LabelDef => // We run before pattern matching, so the only LabelDefs we see // should be translatable to regular defs - spreRegister(tree) + preRegister(tree) def pickleLabelParam = { writeByte(PARAMS) withLength { @@ -818,46 +534,46 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { writeByte(APPLY) withLength { writeByte(TERMREFdirect) - spickleSymRef(tree.symbol) + pickleSymRef(tree.symbol) } - spickleDef(DEFDEF, tree.symbol, tpt, tree.rhs, pickleLabelParam) + pickleDef(DEFDEF, tree.symbol, tpt, tree.rhs, pickleLabelParam) } case tree: g.ValDef => - spickleDef(VALDEF, tree.symbol, tree.tpt, tree.rhs) + pickleDef(VALDEF, tree.symbol, tree.tpt, tree.rhs) case g.Import(expr, selectors) => writeByte(IMPORT) withLength { - spickleTree(expr) + pickleTree(expr) selectors.foreach { case g.ImportSelector(name, _, null, _) => writeByte(IMPORTED) - spickleName(name) + pickleName(name) case g.ImportSelector(name, _, rename, _) => writeByte(IMPORTED) - spickleName(name) + pickleName(name) writeByte(RENAMED) - spickleName(rename) + pickleName(rename) } } case tree: g.TypeTree => - spickleType(tree.tpe) + pickleType(tree.tpe) case g.Super(qual, mix) => writeByte(SUPER) withLength { - spickleTree(qual) + pickleTree(qual) if (!mix.isEmpty) { ??? // TODO } } case g.Block(stats, expr) => writeByte(BLOCK) - stats.foreach(spreRegister) - withLength { spickleTree(expr); stats.foreach(spickleTree) } + stats.foreach(preRegister) + withLength { pickleTree(expr); stats.foreach(pickleTree) } case g.If(cond, thenp, elsep) => writeByte(IF) - withLength { spickleTree(cond); spickleTree(thenp); spickleTree(elsep) } + withLength { pickleTree(cond); pickleTree(thenp); pickleTree(elsep) } case g.Literal(const1) => - spickleConstant { + pickleConstant { tree.tpe match { case g.ConstantType(const2) => const2 case _ => const1 @@ -865,54 +581,54 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { } case g.Match(selector, cases) => writeByte(MATCH) - withLength { spickleTree(selector); cases.foreach(spickleTree) } + withLength { pickleTree(selector); cases.foreach(pickleTree) } case g.CaseDef(pat, guard, rhs) => writeByte(CASEDEF) - withLength { spickleTree(pat); spickleTree(rhs); spickleTreeUnlessEmpty(guard) } + withLength { pickleTree(pat); pickleTree(rhs); pickleTreeUnlessEmpty(guard) } case g.Bind(name, body) => - sregisterDef(tree.symbol) + registerDef(tree.symbol) writeByte(BIND) withLength { - spickleName(name); spickleType(tree.symbol.info); spickleTree(body) + pickleName(name); pickleType(tree.symbol.info); pickleTree(body) } case g.New(tpt) => writeByte(NEW) - spickleTpt(tpt) + pickleTpt(tpt) case g.Throw(expr) => writeByte(APPLY) withLength { writeByte(TERMREF) - pickleName("throw".toTermName) + pickleDottyName("throw".toTermName) writeByte(TERMREFpkg) - pickleName("".toTermName) - spickleTree(expr) + pickleDottyName("".toTermName) + pickleTree(expr) } case g.Assign(lhs, rhs) => writeByte(ASSIGN) - withLength { spickleTree(lhs); spickleTree(rhs) } + withLength { pickleTree(lhs); pickleTree(rhs) } case g.Typed(expr, tpt) => writeByte(TYPED) - withLength { spickleTree(expr); spickleTpt(tpt) } + withLength { pickleTree(expr); pickleTpt(tpt) } case g.Return(expr) => writeByte(RETURN) val fromSymbol = tree.symbol - withLength { spickleSymRef(fromSymbol); spickleTreeUnlessEmpty(expr) } + withLength { pickleSymRef(fromSymbol); pickleTreeUnlessEmpty(expr) } case g.Function(vparams, body) => def pickleFunctionParams = { writeByte(PARAMS) withLength { - spickleParams(vparams) + pickleParams(vparams) } } writeByte(BLOCK) - spreRegister(tree) + preRegister(tree) withLength { writeByte(LAMBDA) withLength { - spickleNamedType(g.NoPrefix, tree.symbol, isType = false) + pickleNamedType(g.NoPrefix, tree.symbol, isType = false) // TODO: tpt for SAMs } - spickleDef(DEFDEF, tree.symbol, g.TypeTree(body.tpe), body, pickleFunctionParams) + pickleDef(DEFDEF, tree.symbol, g.TypeTree(body.tpe), body, pickleFunctionParams) } } catch { @@ -922,263 +638,12 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { } } - def pickleTree(tree: Tree)(implicit ctx: Context): Unit = { - val addr = registerTreeAddr(tree) - if (addr != currentAddr) { - writeByte(SHAREDterm) - writeRef(addr) - } - else - try tree match { - case Ident(name) => - tree.tpe match { - case tp: TermRef if name != nme.WILDCARD => - // wildcards are pattern bound, need to be preserved as ids. - pickleType(tp) - case tp => - writeByte(if (tree.isType) IDENTtpt else IDENT) - pickleName(name) - pickleType(tp) - } - case This(qual) => - if (qual.isEmpty) pickleType(tree.tpe) - else { - writeByte(QUALTHIS) - val ThisType(tref) = tree.tpe - pickleTree(qual.withType(tref)) - } - case Select(qual, name) => - name match { - case OuterSelectName(_, levels) => - writeByte(SELECTouter) - withLength { - writeNat(levels) - pickleTree(qual) - val SkolemType(tp) = tree.tpe - pickleType(tp) - } - case _ => - writeByte(if (name.isTypeName) SELECTtpt else SELECT) - val sig = tree.tpe.signature - pickleNameAndSig(name, sig) - pickleTree(qual) - } - case Apply(fun, args) => - writeByte(APPLY) - withLength { - pickleTree(fun) - args.foreach(pickleTree) - } - case TypeApply(fun, args) => - writeByte(TYPEAPPLY) - withLength { - pickleTree(fun) - args.foreach(pickleTpt) - } - case Literal(const1) => - pickleConstant { - tree.tpe match { - case ConstantType(const2) => const2 - case _ => const1 - } - } - case Super(qual, mix) => - writeByte(SUPER) - withLength { - pickleTree(qual); - if (!mix.isEmpty) { - val SuperType(_, mixinType: TypeRef) = tree.tpe - pickleTree(mix.withType(mixinType)) - } - } - case New(tpt) => - writeByte(NEW) - pickleTpt(tpt) - case Typed(expr, tpt) => - writeByte(TYPED) - withLength { pickleTree(expr); pickleTpt(tpt) } - case NamedArg(name, arg) => - writeByte(NAMEDARG) - pickleName(name) - pickleTree(arg) - case Assign(lhs, rhs) => - writeByte(ASSIGN) - withLength { pickleTree(lhs); pickleTree(rhs) } - case Block(stats, expr) => - writeByte(BLOCK) - stats.foreach(preRegister) - withLength { pickleTree(expr); stats.foreach(pickleTree) } - case If(cond, thenp, elsep) => - writeByte(IF) - withLength { pickleTree(cond); pickleTree(thenp); pickleTree(elsep) } - case Closure(env, meth, tpt) => - writeByte(LAMBDA) - assert(env.isEmpty) - withLength { - pickleTree(meth) - if (tpt.tpe.exists) pickleTpt(tpt) - } - case Match(selector, cases) => - writeByte(MATCH) - withLength { pickleTree(selector); cases.foreach(pickleTree) } - case CaseDef(pat, guard, rhs) => - writeByte(CASEDEF) - withLength { pickleTree(pat); pickleTree(rhs); pickleTreeUnlessEmpty(guard) } - case Return(expr, from) => - writeByte(RETURN) - withLength { pickleSymRef(from.symbol); pickleTreeUnlessEmpty(expr) } - case Try(block, cases, finalizer) => - writeByte(TRY) - withLength { pickleTree(block); cases.foreach(pickleTree); pickleTreeUnlessEmpty(finalizer) } - case SeqLiteral(elems, elemtpt) => - writeByte(REPEATED) - withLength { pickleTree(elemtpt); elems.foreach(pickleTree) } - case Inlined(call, bindings, expansion) => - writeByte(INLINED) - bindings.foreach(preRegister) - withLength { pickleTree(call); pickleTree(expansion); bindings.foreach(pickleTree) } - case Bind(name, body) => - registerDef(tree.symbol) - writeByte(BIND) - withLength { - pickleName(name); pickleType(tree.symbol.info); pickleTree(body) - } - case Alternative(alts) => - writeByte(ALTERNATIVE) - withLength { alts.foreach(pickleTree) } - case UnApply(fun, implicits, patterns) => - writeByte(UNAPPLY) - withLength { - pickleTree(fun) - for (implicitArg <- implicits) { - writeByte(IMPLICITarg) - pickleTree(implicitArg) - } - pickleType(tree.tpe) - patterns.foreach(pickleTree) - } - case tree: ValDef => - pickleDef(VALDEF, tree.symbol, tree.tpt, tree.rhs) - case tree: DefDef => - def pickleAllParams = { - pickleParams(tree.tparams) - for (vparams <- tree.vparamss) { - writeByte(PARAMS) - withLength { pickleParams(vparams) } - } - } - pickleDef(DEFDEF, tree.symbol, tree.tpt, tree.rhs, pickleAllParams) - case tree: TypeDef => - pickleDef(TYPEDEF, tree.symbol, tree.rhs) - case tree: Template => - registerDef(tree.symbol) - writeByte(TEMPLATE) - val (params, rest) = tree.body partition { - case stat: TypeDef => stat.symbol is Flags.Param - case stat: ValOrDefDef => - stat.symbol.is(Flags.ParamAccessor) && !stat.symbol.isSetter - case _ => false - } - withLength { - pickleParams(params) - tree.parents.foreach(pickleTree) - val cinfo @ ClassInfo(_, _, _, _, selfInfo) = tree.symbol.owner.info - if ((selfInfo ne NoType) || !tree.self.isEmpty) { - writeByte(SELFDEF) - pickleName(tree.self.name) - - if (!tree.self.tpt.isEmpty) pickleTree(tree.self.tpt) - else { - if (!tree.self.isEmpty) registerTreeAddr(tree.self) - pickleType { - selfInfo match { - case sym: Symbol => sym.info - case tp: Type => tp - } - } - } - } - pickleStats(tree.constr :: rest) - } - case Import(expr, selectors) => - writeByte(IMPORT) - withLength { - pickleTree(expr) - selectors foreach { - case Thicket((from @ Ident(_)) :: (to @ Ident(_)) :: Nil) => - pickleSelector(IMPORTED, from) - pickleSelector(RENAMED, to) - case id @ Ident(_) => - pickleSelector(IMPORTED, id) - } - } - case PackageDef(pid, stats) => - writeByte(PACKAGE) - withLength { pickleType(pid.tpe); pickleStats(stats) } - case tree: TypeTree => - pickleType(tree.tpe) - case SingletonTypeTree(ref) => - writeByte(SINGLETONtpt) - pickleTree(ref) - case RefinedTypeTree(parent, refinements) => - if (refinements.isEmpty) pickleTree(parent) - else { - val refineCls = refinements.head.symbol.owner.asClass - pickledTypes.put(refineCls.typeRef, currentAddr) - writeByte(REFINEDtpt) - refinements.foreach(preRegister) - withLength { pickleTree(parent); refinements.foreach(pickleTree) } - } - case AppliedTypeTree(tycon, args) => - writeByte(APPLIEDtpt) - withLength { pickleTree(tycon); args.foreach(pickleTree) } - case AndTypeTree(tp1, tp2) => - writeByte(ANDtpt) - withLength { pickleTree(tp1); pickleTree(tp2) } - case OrTypeTree(tp1, tp2) => - writeByte(ORtpt) - withLength { pickleTree(tp1); pickleTree(tp2) } - case ByNameTypeTree(tp) => - writeByte(BYNAMEtpt) - pickleTree(tp) - case Annotated(tree, annot) => - writeByte(ANNOTATEDtpt) - withLength { pickleTree(tree); pickleTree(annot.tree) } - case LambdaTypeTree(tparams, body) => - writeByte(LAMBDAtpt) - withLength { pickleParams(tparams); pickleTree(body) } - case TypeBoundsTree(lo, hi) => - writeByte(TYPEBOUNDStpt) - withLength { - pickleTree(lo); - if (hi ne lo) pickleTree(hi) - } - case Hole(idx, args) => - writeByte(HOLE) - withLength { - writeNat(idx) - args.foreach(pickleTree) - } - } - catch { - case ex: AssertionError => - println(i"error when pickling tree $tree") - throw ex - } - } - - def pickleSelector(tag: Int, id: untpd.Ident)(implicit ctx: Context): Unit = { - registerTreeAddr(id) - writeByte(tag) - pickleName(id.name) - } - - def spickleModifiers(sym: g.Symbol, moduleClass: Boolean = false, mutable: Boolean = false, + def pickleModifiers(sym: g.Symbol, moduleClass: Boolean = false, mutable: Boolean = false, field: Boolean = false, methodParam: Boolean = false): Unit = { val privateWithin = sym.privateWithin if (privateWithin.exists) { writeByte(if (sym.isProtected) PROTECTEDqualified else PRIVATEqualified) - spickleType(privateWithin.toType) + pickleType(privateWithin.toType) } if (sym.isPrivate || sym.isTypeParameter) writeByte(PRIVATE) if (sym.isProtected) if (!privateWithin.exists) writeByte(PROTECTED) @@ -1214,84 +679,20 @@ class ScalacTreePickler(pickler: ScalacTastyPickler, val g: Global) { if (sym.isCovariant) writeByte(COVARIANT) if (sym.isContravariant) writeByte(CONTRAVARIANT) } + // TODO: // sym.annotations.foreach(pickleAnnotation(sym, _)) } - def pickleModifiers(sym: Symbol)(implicit ctx: Context): Unit = { - import Flags._ - val flags = sym.flags - val privateWithin = sym.privateWithin - if (privateWithin.exists) { - writeByte(if (flags is Protected) PROTECTEDqualified else PRIVATEqualified) - pickleType(privateWithin.typeRef) - } - if (flags is Private) writeByte(PRIVATE) - if (flags is Protected) if (!privateWithin.exists) writeByte(PROTECTED) - if ((flags is Final) && !(sym is Module)) writeByte(FINAL) - if (flags is Case) writeByte(CASE) - if (flags is Override) writeByte(OVERRIDE) - if (flags is Inline) writeByte(INLINE) - if (flags is Macro) writeByte(MACRO) - if (flags is JavaStatic) writeByte(STATIC) - if (flags is Module) writeByte(OBJECT) - if (flags is Local) writeByte(LOCAL) - if (flags is Synthetic) writeByte(SYNTHETIC) - if (flags is Artifact) writeByte(ARTIFACT) - if (flags is Scala2x) writeByte(SCALA2X) - if (sym.isTerm) { - if (flags is Implicit) writeByte(IMPLICIT) - if (flags is Erased) writeByte(ERASED) - if ((flags is Lazy) && !(sym is Module)) writeByte(LAZY) - if (flags is AbsOverride) { writeByte(ABSTRACT); writeByte(OVERRIDE) } - if (flags is Mutable) writeByte(MUTABLE) - if (flags is Accessor) writeByte(FIELDaccessor) - if (flags is CaseAccessor) writeByte(CASEaccessor) - if (flags is DefaultParameterized) writeByte(DEFAULTparameterized) - if (flags is Stable) writeByte(STABLE) - if ((flags is ParamAccessor) && sym.isSetter) writeByte(PARAMsetter) - } else { - if (flags is Sealed) writeByte(SEALED) - if (flags is Abstract) writeByte(ABSTRACT) - if (flags is Trait) writeByte(TRAIT) - if (flags is Covariant) writeByte(COVARIANT) - if (flags is Contravariant) writeByte(CONTRAVARIANT) - } - sym.annotations.foreach(pickleAnnotation(sym, _)) - } - - private def isUnpicklable(owner: Symbol, ann: Annotation)(implicit ctx: Context) = ann match { - case Annotation.Child(sym) => sym.isInaccessibleChildOf(owner) - // If child annotation refers to a local class or enum value under - // a different toplevel class, it is impossible to pickle a reference to it. - // Such annotations will be reconstituted when unpickling the child class. - // See tests/pickling/i3149.scala - case _ => ann.symbol == defn.BodyAnnot - // inline bodies are reconstituted automatically when unpickling - } - - def pickleAnnotation(owner: Symbol, ann: Annotation)(implicit ctx: Context) = - if (!isUnpicklable(owner, ann)) { - writeByte(ANNOTATION) - withLength { pickleType(ann.symbol.typeRef); pickleTree(ann.tree) } - } - - def spickle(trees: List[g.Tree]) = { - trees.foreach(tree => if (!tree.isEmpty) spickleTree(tree)) + def pickle(trees: List[g.Tree]) = { + trees.foreach(tree => if (!tree.isEmpty) pickleTree(tree)) def missing = forwardSymRefs.keysIterator/*.map(_.showLocated)*/.toList assert(forwardSymRefs.isEmpty, s"unresolved symbols: $missing%, % when pickling ..."/*${ctx.source}*/) } - - def pickle(trees: List[Tree])(implicit ctx: Context) = { - trees.foreach(tree => if (!tree.isEmpty) pickleTree(tree)) - def missing = forwardSymRefs.keysIterator.map(_.showLocated).toList - assert(forwardSymRefs.isEmpty, i"unresolved symbols: $missing%, % when pickling ${ctx.source}") - } - def compactify() = { buf.compactify() - def updateMapWithDeltas(mp: MutableSymbolMap[Addr]) = - for (key <- mp.keysIterator.toBuffer[Symbol]) mp(key) = adjusted(mp(key)) + def updateMapWithDeltas(mp: mutable.HashMap[g.Symbol, Addr]) = + for (key <- mp.keysIterator.toBuffer[g.Symbol]) mp(key) = adjusted(mp(key)) updateMapWithDeltas(symRefs) }