From 0da0208af4e3824e9ccc5fe8fe641ee541737fcc Mon Sep 17 00:00:00 2001 From: Paul Phillips Date: Mon, 16 Nov 2009 21:30:22 +0000 Subject: Minor pickler organization stemming from optimi... Minor pickler organization stemming from optimizer appeasement. --- .../scala/tools/nsc/symtab/classfile/Pickler.scala | 25 +-- .../tools/nsc/symtab/classfile/UnPickler.scala | 235 +++++++++------------ 2 files changed, 111 insertions(+), 149 deletions(-) diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala index d93dc343c8..78d83ff15d 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala @@ -405,11 +405,8 @@ abstract class Pickler extends SubComponent { } } - private def putTrees(trees: List[Tree]) = - trees.foreach(putTree _) - - private def putTreess(treess: List[List[Tree]]) = - treess.foreach(putTrees _) + 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 */ @@ -489,6 +486,10 @@ abstract class Pickler extends SubComponent { */ private def writeRef(ref: AnyRef) { writeNat(index(ref)) } private def writeRefs(refs: List[AnyRef]) { refs foreach writeRef } + private def writeRefsWithLength(refs: List[AnyRef]) { + writeNat(refs.length) + writeRefs(refs) + } /** Write name, owner, flags, and info of a symbol. */ @@ -628,7 +629,7 @@ abstract class Pickler extends SubComponent { case (target: Symbol, children: List[Symbol]) => writeRef(target) - for (c <- children) writeRef(c.asInstanceOf[Symbol]) + writeRefs(children) CHILDREN case EmptyTree => @@ -679,13 +680,9 @@ abstract class Pickler extends SubComponent { writeRef(tree.symbol) writeRef(mods) writeRef(name) - writeNat(tparams.length) - writeRefs(tparams) + writeRefsWithLength(tparams) writeNat(vparamss.length) - for(vparams <- vparamss) { - writeNat(vparams.length) - writeRefs(vparams) - } + vparamss foreach writeRefsWithLength writeRef(tpt) writeRef(rhs) TREE @@ -731,8 +728,7 @@ abstract class Pickler extends SubComponent { writeNat(TEMPLATEtree) writeRef(tree.tpe) writeRef(tree.symbol) - writeNat(parents.length) - writeRefs(parents) + writeRefsWithLength(parents) writeRef(self) writeRefs(body) TREE @@ -786,7 +782,6 @@ abstract class Pickler extends SubComponent { writeRefs(trees) TREE - case tree@Function(vparams, body) => writeNat(FUNCTIONtree) writeRef(tree.tpe) diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala index 909ecae77a..b6fdb28090 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala @@ -132,7 +132,8 @@ abstract class UnPickler { val savedIndex = readIndex readIndex = index(i) val tag = readByte().toInt - if (tag != CLASSsym) assert(false) + assert(tag == CLASSsym) + readNat(); // read length val result = readNameRef() == nme.REFINE_CLASS_NAME.toTypeName readIndex = savedIndex @@ -350,7 +351,7 @@ abstract class UnPickler { val len = readNat() (tag: @switch) match { case LITERALunit => Constant(()) - case LITERALboolean => Constant(if (readLong(len) == 0L) false else true) + case LITERALboolean => Constant(readLong(len) != 0L) case LITERALbyte => Constant(readLong(len).toByte) case LITERALshort => Constant(readLong(len).toShort) case LITERALchar => Constant(readLong(len).toChar) @@ -390,17 +391,15 @@ abstract class UnPickler { /** Read a ClassfileAnnotArg (argument to a classfile annotation) */ - private def readClassfileAnnotArg(): ClassfileAnnotArg = { - val b = peekByte() - if (peekByte() == ANNOTINFO) { + private def readClassfileAnnotArg(): ClassfileAnnotArg = peekByte() match { + case ANNOTINFO => NestedAnnotArg(readAnnotation()) - } else if (peekByte() == ANNOTARGARRAY) { + case ANNOTARGARRAY => readByte() val end = readNat() + readIndex ArrayAnnotArg(until(end, readClassfileAnnotArgRef).toArray) - } else { + case _ => LiteralAnnotArg(readConstant()) - } } /** Read an AnnotationInfo. Not to be called directly, use @@ -420,7 +419,6 @@ abstract class UnPickler { AnnotationInfo(atp, args.toList, assocs.toList) } - /** Read an annotation and as a side effect store it into * the symbol it requests. Called at top-level, for all * (symbol, annotInfo) entries. */ @@ -450,212 +448,184 @@ abstract class UnPickler { errorBadSignature("tree expected (" + outerTag + ")") val end = readNat() + readIndex val tag = readByte() - val tpe = - if (tag != EMPTYtree) - readTypeRef() - else - NoType + val tpe = if (tag == EMPTYtree) NoType else readTypeRef() + + // Set by the three functions to follow. If symbol is non-null + // after the the new tree 't' has been created, t has its Symbol + // set to symbol; and it always has its Type set to tpe. + var symbol: Symbol = null + var mods: Modifiers = null + var name: Name = null + + /** Read a Symbol, Modifiers, and a Name */ + def setSymModsName() { + symbol = readSymbolRef() + mods = readModifiersRef() + name = readNameRef() + } + /** Read a Symbol and a Name */ + def setSymName() { + symbol = readSymbolRef() + name = readNameRef() + } + /** Read a Symbol */ + def setSym() { + symbol = readSymbolRef() + } - tag match { + val t = tag match { case EMPTYtree => EmptyTree case PACKAGEtree => - val symbol = readSymbolRef() + setSym() + // val discardedSymbol = readSymbolRef() // XXX is symbol intentionally not set? val pid = readTreeRef().asInstanceOf[RefTree] val stats = until(end, readTreeRef) - PackageDef(pid, stats) setType tpe + PackageDef(pid, stats) case CLASStree => - val symbol = readSymbolRef() - val mods = readModifiersRef() - val name = readNameRef() + setSymModsName() val impl = readTemplateRef() val tparams = until(end, readTypeDefRef) - (ClassDef(mods, name, tparams, impl). - setSymbol(symbol). - setType(tpe)) + ClassDef(mods, name, tparams, impl) case MODULEtree => - val symbol = readSymbolRef() - val mods = readModifiersRef() - val name = readNameRef() - val impl = readTemplateRef() - (ModuleDef(mods, name, impl). - setSymbol(symbol). - setType(tpe)) + setSymModsName() + ModuleDef(mods, name, readTemplateRef()) case VALDEFtree => - val symbol = readSymbolRef() - val mods = readModifiersRef() - val name = readNameRef() + setSymModsName() val tpt = readTreeRef() val rhs = readTreeRef() - - (ValDef(mods, name, tpt, rhs). - setSymbol(symbol). - setType(tpe)) + ValDef(mods, name, tpt, rhs) case DEFDEFtree => - val symbol = readSymbolRef() - val mods = readModifiersRef() - val name = readNameRef() - val numTparams = readNat() - val tparams = times(numTparams, readTypeDefRef) - val numVparamss = readNat - val vparamss = times(numVparamss, () => { - val len = readNat() - times(len, readValDefRef)}) + setSymModsName() + val tparams = times(readNat(), readTypeDefRef) + val vparamss = times(readNat(), () => times(readNat(), readValDefRef)) val tpt = readTreeRef() val rhs = readTreeRef() - (DefDef(mods, name, tparams, vparamss, tpt, rhs). - setSymbol(symbol). - setType(tpe)) + DefDef(mods, name, tparams, vparamss, tpt, rhs) case TYPEDEFtree => - val symbol = readSymbolRef() - val mods = readModifiersRef() - val name = readNameRef() + setSymModsName() val rhs = readTreeRef() val tparams = until(end, readTypeDefRef) - - (TypeDef(mods, name, tparams, rhs). - setSymbol(symbol). - setType(tpe)) + TypeDef(mods, name, tparams, rhs) case LABELtree => - val symbol = readSymbolRef() - val name = readNameRef() + setSymName() val rhs = readTreeRef() val params = until(end, readIdentRef) - (LabelDef(name, params, rhs). - setSymbol(symbol). - setType(tpe)) + LabelDef(name, params, rhs) case IMPORTtree => - val symbol = readSymbolRef() + setSym() val expr = readTreeRef() val selectors = until(end, () => { val from = readNameRef() val to = readNameRef() ImportSelector(from, -1, to, -1) }) - (Import(expr, selectors). - setSymbol(symbol). - setType(tpe)) + + Import(expr, selectors) case DOCDEFtree => val comment = readConstantRef match { - case Constant(com: String) => com - case other => - errorBadSignature("Document comment not a string (" + other + ")") + case Constant(com: String) => com + case other => errorBadSignature("Document comment not a string (" + other + ")") } val definition = readTreeRef() - (DocDef(comment, definition).setType(tpe)) + DocDef(comment, definition) case TEMPLATEtree => - val symbol = readSymbolRef() - val numParents = readNat() - val parents = times(numParents, readTreeRef) + setSym() + val parents = times(readNat(), readTreeRef) val self = readValDefRef() val body = until(end, readTreeRef) - (Template(parents, self, body). - setSymbol(symbol). - setType(tpe)) + Template(parents, self, body) case BLOCKtree => val expr = readTreeRef() val stats = until(end, readTreeRef) - Block(stats, expr).setType(tpe) + Block(stats, expr) case CASEtree => val pat = readTreeRef() val guard = readTreeRef() val body = readTreeRef() - CaseDef(pat, guard, body).setType(tpe) + CaseDef(pat, guard, body) case ALTERNATIVEtree => - val trees = until(end, readTreeRef) - Alternative(trees).setType(tpe) + Alternative(until(end, readTreeRef)) case STARtree => - val elem = readTreeRef() - Star(elem).setType(tpe) + Star(readTreeRef()) case BINDtree => - val symbol = readSymbolRef() - val name = readNameRef() - val body = readTreeRef() - (Bind(name, body). - setSymbol(symbol). - setType(tpe)) + setSymName() + Bind(name, readTreeRef()) case UNAPPLYtree => val fun = readTreeRef() val args = until(end, readTreeRef) - (UnApply(fun: Tree, args).setType(tpe)) + UnApply(fun, args) case ARRAYVALUEtree => val elemtpt = readTreeRef() val trees = until(end, readTreeRef) - (ArrayValue(elemtpt, trees).setType(tpe)) + ArrayValue(elemtpt, trees) case FUNCTIONtree => - val symbol = readSymbolRef() + setSym() val body = readTreeRef() val vparams = until(end, readValDefRef) - (Function(vparams, body). - setSymbol(symbol). - setType(tpe)) + Function(vparams, body) case ASSIGNtree => val lhs = readTreeRef() val rhs = readTreeRef() - Assign(lhs, rhs).setType(tpe) + Assign(lhs, rhs) case IFtree => val cond = readTreeRef() val thenp = readTreeRef() val elsep = readTreeRef() - If(cond, thenp, elsep).setType(tpe) + If(cond, thenp, elsep) case MATCHtree => val selector = readTreeRef() val cases = until(end, readCaseDefRef) - Match(selector, cases).setType(tpe) + Match(selector, cases) case RETURNtree => - val symbol = readSymbolRef() - val expr = readTreeRef() - (Return(expr). - setSymbol(symbol). - setType(tpe)) + setSym() + Return(readTreeRef()) case TREtree => val block = readTreeRef() val finalizer = readTreeRef() val catches = until(end, readCaseDefRef) - Try(block, catches, finalizer).setType(tpe) + Try(block, catches, finalizer) case THROWtree => - val expr = readTreeRef() - Throw(expr).setType(tpe) + Throw(readTreeRef()) case NEWtree => - val tpt = readTreeRef() - New(tpt).setType(tpe) + New(readTreeRef()) case TYPEDtree => val expr = readTreeRef() val tpt = readTreeRef() - Typed(expr, tpt).setType(tpe) + Typed(expr, tpt) case TYPEAPPLYtree => val fun = readTreeRef() val args = until(end, readTreeRef) - TypeApply(fun, args).setType(tpe) + TypeApply(fun, args) case APPLYtree => val fun = readTreeRef() @@ -664,79 +634,77 @@ abstract class UnPickler { fun.setType(fun.symbol.info) typer.infer.inferMethodAlternative(fun, Nil, args map (_.tpe), tpe) } - Apply(fun, args).setType(tpe) + Apply(fun, args) case APPLYDYNAMICtree => - val symbol = readSymbolRef() + setSym() val qual = readTreeRef() val args = until(end, readTreeRef) - ApplyDynamic(qual, args).setSymbol(symbol).setType(tpe) + ApplyDynamic(qual, args) case SUPERtree => - val symbol = readSymbolRef() + setSym() val qual = readNameRef() val mix = readNameRef() - Super(qual, mix).setSymbol(symbol).setType(tpe) + Super(qual, mix) case THIStree => - val symbol = readSymbolRef() - val qual = readNameRef() - This(qual).setSymbol(symbol).setType(tpe) + setSym() + This(readNameRef()) case SELECTtree => - val symbol = readSymbolRef() + setSym() val qualifier = readTreeRef() val selector = readNameRef() - Select(qualifier, selector).setSymbol(symbol).setType(tpe) + Select(qualifier, selector) case IDENTtree => - val symbol = readSymbolRef() - val name = readNameRef() - Ident(name).setSymbol(symbol).setType(tpe) + setSymName() + Ident(name) case LITERALtree => - val value = readConstantRef() - Literal(value).setType(tpe) + Literal(readConstantRef()) case TYPEtree => - TypeTree().setType(tpe) + TypeTree() case ANNOTATEDtree => val annot = readTreeRef() val arg = readTreeRef() - Annotated(annot, arg).setType(tpe) + Annotated(annot, arg) case SINGLETONTYPEtree => - val ref = readTreeRef() - SingletonTypeTree(ref).setType(tpe) + SingletonTypeTree(readTreeRef()) case SELECTFROMTYPEtree => val qualifier = readTreeRef() val selector = readNameRef() - SelectFromTypeTree(qualifier, selector).setType(tpe) + SelectFromTypeTree(qualifier, selector) case COMPOUNDTYPEtree => - val templ = readTemplateRef() - CompoundTypeTree(templ: Template).setType(tpe) + CompoundTypeTree(readTemplateRef()) case APPLIEDTYPEtree => val tpt = readTreeRef() val args = until(end, readTreeRef) - AppliedTypeTree(tpt, args).setType(tpe) + AppliedTypeTree(tpt, args) case TYPEBOUNDStree => val lo = readTreeRef() val hi = readTreeRef() - TypeBoundsTree(lo, hi).setType(tpe) + TypeBoundsTree(lo, hi) case EXISTENTIALTYPEtree => val tpt = readTreeRef() val whereClauses = until(end, readTreeRef) - ExistentialTypeTree(tpt, whereClauses).setType(tpe) + ExistentialTypeTree(tpt, whereClauses) case _ => errorBadSignature("unknown tree type (" + tag + ")") } + + if (symbol == null) t setType tpe + else t setSymbol symbol setType tpe } def readModifiers(): Modifiers = { @@ -799,7 +767,6 @@ abstract class UnPickler { errorBadSignature("expected an TypeDef (" + other + ")") } - private def errorBadSignature(msg: String) = throw new RuntimeException("malformed Scala signature of " + classRoot.name + " at " + readIndex + "; " + msg) -- cgit v1.2.3