unpickler.scala

来自「JAVA 语言的函数式编程扩展」· SCALA 代码 · 共 790 行 · 第 1/2 页

      val tpe = 
	if (tag != EMPTYtree)
	  readTypeRef()
	else
	  NoType

      tag match {
	case EMPTYtree =>
	  EmptyTree

	case PACKAGEtree =>
	  val symbol = readSymbolRef()
	  val name = readNameRef()
	  val stats = until(end, readTreeRef)
	  
	  PackageDef(name, stats) setType tpe

	case CLASStree =>
	  val symbol = readSymbolRef() 
          val mods = readModifiersRef()
	  val name = readNameRef()
	  val impl = readTemplateRef()
	  val tparams = until(end, readTypeDefRef)
	  (ClassDef(mods, name, tparams, impl).
	   setSymbol(symbol).
	   setType(tpe))

	case MODULEtree =>
	  val symbol = readSymbolRef()
	  val mods = readModifiersRef()
	  val name = readNameRef()
	  val impl = readTemplateRef()
	  (ModuleDef(mods, name, impl).
	   setSymbol(symbol).
	   setType(tpe))

	case VALDEFtree =>
	  val symbol = readSymbolRef()
	  val mods = readModifiersRef()
	  val name = readNameRef()
	  val tpt = readTreeRef()
	  val rhs = readTreeRef()

	  (ValDef(mods, name, tpt, rhs).
	   setSymbol(symbol).
	   setType(tpe))
	
	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)})
	  val tpt = readTreeRef()
	  val rhs = readTreeRef()

	  (DefDef(mods, name, tparams, vparamss, tpt, rhs).
  	   setSymbol(symbol).
	   setType(tpe))

	case TYPEDEFtree =>
          val symbol = readSymbolRef()
	  val mods = readModifiersRef()
	  val name = readNameRef()
	  val rhs = readTreeRef()
	  val tparams = until(end, readTypeDefRef)
	
	  (TypeDef(mods, name, tparams, rhs).
  	   setSymbol(symbol).
	   setType(tpe))


	case LABELtree =>
	  val symbol = readSymbolRef()
	  val rhs = readTreeRef()
	  val params = until(end, readIdentRef)
          (LabelDef(name, params, rhs).
  	   setSymbol(symbol).
	   setType(tpe))

	case IMPORTtree =>
          val symbol = readSymbolRef()
	  val expr = readTreeRef()
 	  val selectors = until(end, () => {
	    val from = readNameRef()
	    val to = readNameRef()
	    (from, to)
	  })
	  (Import(expr, selectors).
  	   setSymbol(symbol).
	   setType(tpe))

	case ANNOTATIONtree =>
	  val constr = readTreeRef()
	  val elements = until(end, readTreeRef)
	  (Annotation(constr, elements).setType(tpe))

	case DOCDEFtree =>
	  val comment = readConstantRef match {
	    case Constant(com: String) => com
	    case other =>
	      errorBadSignature("Document comment not a string (" + other + ")")
	  }
	  val definition = readTreeRef()
	  (DocDef(comment, definition).setType(tpe))

	case TEMPLATEtree =>
	  val symbol = readSymbolRef()
          val numParents = readNat()
	  val parents = times(numParents, readTreeRef)
	  val self = readValDefRef()
	  val body = until(end, readTreeRef)

	  (Template(parents, self, body).
	   setSymbol(symbol).
	   setType(tpe))

	case BLOCKtree =>
	  val expr = readTreeRef()
	  val stats = until(end, readTreeRef)
	  Block(stats, expr).setType(tpe)

	case CASEtree =>
	  val pat = readTreeRef()
	  val guard = readTreeRef()
	  val body = readTreeRef()
	  CaseDef(pat, guard, body).setType(tpe)

	case SEQUENCEtree =>
	  val trees = until(end, readTreeRef)
	  Sequence(trees).setType(tpe)

	case ALTERNATIVEtree =>
	  val trees = until(end, readTreeRef)
	  Alternative(trees).setType(tpe)

	case STARtree =>
	  val elem = readTreeRef()
	  Star(elem).setType(tpe)

	case BINDtree =>
	  val symbol = readSymbolRef()
	  val name = readNameRef()
	  val body = readTreeRef()
	  (Bind(name, body).
	   setSymbol(symbol).
	   setType(tpe))

	case UNAPPLYtree =>
	  val fun = readTreeRef()
	  val args = until(end, readTreeRef)
          (UnApply(fun: Tree, args).setType(tpe))

	case ARRAYVALUEtree =>
	  val elemtpt = readTreeRef()
	  val trees = until(end, readTreeRef)
	  (ArrayValue(elemtpt, trees).setType(tpe))

	case FUNCTIONtree =>
	  val symbol = readSymbolRef()
	  val body = readTreeRef()
	  val vparams = until(end, readValDefRef)
	  (Function(vparams, body).
	   setSymbol(symbol).
	   setType(tpe))

	case ASSIGNtree =>
          val lhs = readTreeRef()
          val rhs = readTreeRef()
	  Assign(lhs, rhs).setType(tpe)
	
	case IFtree =>
          val cond = readTreeRef()
          val thenp = readTreeRef()
          val elsep = readTreeRef()
	  If(cond, thenp, elsep).setType(tpe)

	case MATCHtree =>
          val selector = readTreeRef()
          val cases = until(end, readCaseDefRef)
	  Match(selector, cases).setType(tpe)

	case RETURNtree =>
	  val symbol = readSymbolRef()
	  val expr = readTreeRef()
	  (Return(expr).
	   setSymbol(symbol).
	   setType(tpe))

	case TREtree =>
          val block = readTreeRef()
	  val finalizer = readTreeRef()
	  val catches = until(end, readCaseDefRef)
	  Try(block, catches, finalizer).setType(tpe)

	case THROWtree =>
	  val expr = readTreeRef()
	  Throw(expr).setType(tpe)

	case NEWtree =>
	  val tpt = readTreeRef()
	  New(tpt).setType(tpe)
	  
	case TYPEDtree =>
	  val expr = readTreeRef()
	  val tpt = readTreeRef()
          Typed(expr, tpt).setType(tpe)

	case TYPEAPPLYtree =>
	  val fun = readTreeRef()
	  val args = until(end, readTreeRef)
	  TypeApply(fun, args).setType(tpe)	  
	  
	case APPLYtree =>
	  val fun = readTreeRef()
          val args = until(end, readTreeRef)
	  Apply(fun, args).setType(tpe)
	  

	case APPLYDYNAMICtree =>
	  val symbol = readSymbolRef()
	  val qual = readTreeRef()
          val args = until(end, readTreeRef)
	  ApplyDynamic(qual, args).setSymbol(symbol).setType(tpe)

	case SUPERtree =>
	  val symbol = readSymbolRef()
	  val qual = readNameRef()
	  val mix = readNameRef()
	  Super(qual, mix).setSymbol(symbol).setType(tpe)

        case THIStree =>
	  val symbol = readSymbolRef()
	  val qual = readNameRef()
	  This(qual).setSymbol(symbol).setType(tpe)

        case SELECTtree =>
	  val symbol = readSymbolRef()
	  val qualifier = readTreeRef()
	  val selector = readNameRef()
	  Select(qualifier, selector).setSymbol(symbol).setType(tpe)

	case IDENTtree =>
	  val symbol = readSymbolRef()
	  val name = readNameRef()
	  Ident(name).setSymbol(symbol).setType(tpe)
	  
	case LITERALtree =>
	  val value = readConstantRef()
	  Literal(value).setType(tpe)

	case TYPEtree =>
	  TypeTree().setType(tpe)
	  
	case ANNOTATEDtree =>
          val annot = readAnnotationTreeRef()
          val arg = readTreeRef()
	  Annotated(annot, arg).setType(tpe)
	  
	case SINGLETONTYPEtree =>
	  val ref = readTreeRef()
	  SingletonTypeTree(ref).setType(tpe)

	case SELECTFROMTYPEtree =>
          val qualifier = readTreeRef()
          val selector = readNameRef()
	  SelectFromTypeTree(qualifier, selector).setType(tpe)

	case COMPOUNDTYPEtree =>
	  val templ = readTemplateRef()
	  CompoundTypeTree(templ: Template).setType(tpe)
	  
	case APPLIEDTYPEtree =>
	  val tpt = readTreeRef()
          val args = until(end, readTreeRef)
	  AppliedTypeTree(tpt, args).setType(tpe)
	  
	case TYPEBOUNDStree =>
	  val lo = readTreeRef()
	  val hi = readTreeRef()
	  TypeBoundsTree(lo, hi).setType(tpe)
	  
	case EXISTENTIALTYPEtree =>
	  val tpt = readTreeRef()
	  val whereClauses = until(end, readTreeRef)
	  ExistentialTypeTree(tpt, whereClauses).setType(tpe)
	  
	case _ =>
          errorBadSignature("unknown tree type (" + tag + ")")
      }
    }

    def readModifiers(): Modifiers = {
      val tag = readNat()
      if (tag != MODIFIERS)
	errorBadSignature("expected a modifiers tag (" + tag + ")")
      val end = readNat() + readIndex
      val flagsHi = readNat()
      val flagsLo = readNat()
      val flags = (flagsHi.toLong << 32) + flagsLo
      val privateWithin = readNameRef()
      val annotations = until(end, readAnnotationTreeRef)
      Modifiers(flags, privateWithin, annotations)
    }

    /* Read a reference to a pickled item */
    private def readNameRef(): Name = at(readNat(), readName)
    private def readSymbolRef(): Symbol = at(readNat(), readSymbol)
    private def readTypeRef(): Type = at(readNat(), readType)
    private def readConstantRef(): Constant = at(readNat(), readConstant)
    private def readAnnotationArgRef(): AnnotationArgument =
      at(readNat(), readAnnotationArg)
    private def readTreeAttribRef(): AnnotationInfo =
      at(readNat(), readTreeAttrib)
    private def readAnnotationTreeRef(): Annotation =
      at(readNat(), readAnnotationTree)
    private def readModifiersRef(): Modifiers =
      at(readNat(), readModifiers)
    private def readTreeRef(): Tree =
      at(readNat(), readTree)

    private def readTemplateRef(): Template =
      readTreeRef() match {
	case templ:Template => templ
	case other =>
          errorBadSignature("expected a template (" + other + ")")
      }
    private def readCaseDefRef(): CaseDef =
      readTreeRef() match {
	case tree:CaseDef => tree
	case other =>
          errorBadSignature("expected a case def (" + other + ")")
      }
    private def readValDefRef(): ValDef =
      readTreeRef() match {
	case tree:ValDef => tree
	case other =>
          errorBadSignature("expected a ValDef (" + other + ")")
      }
    private def readIdentRef(): Ident =
      readTreeRef() match {
	case tree:Ident => tree
	case other =>
          errorBadSignature("expected an Ident (" + other + ")")
      }
    private def readTypeDefRef(): TypeDef =
      readTreeRef() match {
	case tree:TypeDef => tree
	case other =>
          errorBadSignature("expected an TypeDef (" + other + ")")
      }


    private def errorBadSignature(msg: String) =
      if (inIDE) throw new TypeError(msg)
      else throw new RuntimeException("malformed Scala signature of " + classRoot.name + " at " + readIndex + "; " + msg)

    private var printedReflectAnnotationWarning = false
    private def reflectAnnotationWarning() {
      if (!printedReflectAnnotationWarning) {
	global.warning(
	  "warning: dropping a legacy format annotation in " + classRoot.name)
	printedReflectAnnotationWarning = true
      }
    }

    private class LazyTypeRef(i: Int) extends LazyType {
      private val definedAtRunId = currentRunId
      // In IDE, captures class files dependencies so they can be reloaded when their dependencies change.
      private val ideHook = unpickleIDEHook
      override def complete(sym: Symbol) : Unit = {
        if (sym.rawInfo != this && inIDE) return
        val tp = ideHook(at(i, readType))
        sym setInfo tp
        if (!inIDE && currentRunId != definedAtRunId) sym.setInfo(adaptToNewRunMap(tp))
      }
      override def load(sym: Symbol) { complete(sym) }
    }

    private class LazyTypeRefAndAlias(i: Int, j: Int) extends LazyTypeRef(i) {
      override def complete(sym: Symbol) {
        super.complete(sym)
        var alias = at(j, readSymbol)
        if (alias hasFlag OVERLOADED)
          alias = alias suchThat (alt => sym.tpe =:= sym.owner.thisType.memberType(alt))
        sym.asInstanceOf[TermSymbol].setAlias(alias)
      }
    }
  }
}