in scalasig/scalasig/src/main/scala/scala/meta/internal/scalasig/ScalasigCodec.scala [243:654]
def toClassfile(scalasig: Scalasig): Classfile = {
val writer = new ScalasigWriter
import writer._
writeVarint(MajorVersion)
writeVarint(MinorVersion)
writeVarint(scalasig.entries.length)
scalasig.entries.foreach { entry =>
val entryStart = offset
writeByte(entryTag(entry))
writeVarint(0)
val bodyStart = offset
def writeRef(ref: Ref): Unit = {
writeVarint(ref)
}
def writeRefs(refs: List[Ref], atEnd: Boolean = true): Unit = {
if (atEnd) {
refs.foreach(writeRef)
} else {
writeVarint(refs.length)
refs.foreach(writeRef)
}
}
def writeRefss(refss: List[List[Ref]], atEnd: Boolean = true): Unit = {
if (atEnd) {
refss.foreach(writeRefs(_, atEnd = false))
} else {
writeVarint(refss.length)
refss.foreach(writeRefs(_, atEnd = false))
}
}
def writeAnnotArgs(args: List[AnnotArg]): Unit = {
args.foreach {
case ScalaAnnotArg(value) =>
writeRef(value)
case JavaAnnotArg(name, value) =>
writeRef(name)
writeRef(value)
}
}
def writeImportSelectors(selectors: List[ImportSelector]): Unit = {
selectors.foreach {
case ImportSelector(name, rename) =>
writeRef(name)
writeRef(rename)
}
}
def writeModifierFlags(flags: Long): Unit = {
writeVarint((flags >> 32).toInt)
writeVarint((flags & 0xFFFFFFFF).toInt)
}
entry match {
case TermName(value) =>
writeString(value)
case TypeName(value) =>
writeString(value)
case NoSymbol =>
()
case TypeSymbol(name, owner, flags, within, info) =>
writeRef(name)
writeRef(owner)
writeVarlong(flags)
within.foreach(writeRef)
writeRef(info)
case AliasSymbol(name, owner, flags, within, info) =>
writeRef(name)
writeRef(owner)
writeVarlong(flags)
within.foreach(writeRef)
writeRef(info)
case ClassSymbol(name, owner, flags, within, info, thisType) =>
writeRef(name)
writeRef(owner)
writeVarlong(flags)
within.foreach(writeRef)
writeRef(info)
thisType.foreach(writeRef)
case ModuleSymbol(name, owner, flags, within, info) =>
writeRef(name)
writeRef(owner)
writeVarlong(flags)
within.foreach(writeRef)
writeRef(info)
case ValSymbol(name, owner, flags, within, info, alias) =>
writeRef(name)
writeRef(owner)
writeVarlong(flags)
within.foreach(writeRef)
writeRef(info)
alias.foreach(writeRef)
case ExtRef(name, owner) =>
writeRef(name)
owner.foreach(writeRef)
case ExtModClassRef(name, owner) =>
writeRef(name)
owner.foreach(writeRef)
case Children(sym, children) =>
writeRef(sym)
writeRefs(children)
case NoType =>
()
case NoPrefix =>
()
case ThisType(sym) =>
writeRef(sym)
case SingleType(pre, sym) =>
writeRef(pre)
writeRef(sym)
case ConstantType(lit) =>
writeRef(lit)
case TypeRef(pre, sym, targs) =>
writeRef(pre)
writeRef(sym)
writeRefs(targs)
case TypeBounds(lo, hi) =>
writeRef(lo)
writeRef(hi)
case RefinedType(sym, parents) =>
writeRef(sym)
writeRefs(parents)
case ClassInfoType(sym, parents) =>
writeRef(sym)
writeRefs(parents)
case MethodType(ret, params) =>
writeRef(ret)
writeRefs(params)
case PolyType(ret, params) =>
writeRef(ret)
writeRefs(params)
case SuperType(thisp, superp) =>
writeRef(thisp)
writeRef(superp)
case AnnotatedType(tpe, annots) =>
writeRef(tpe)
writeRefs(annots)
case ExistentialType(tpe, decls) =>
writeRef(tpe)
writeRefs(decls)
case UnitLit =>
()
case BooleanLit(value) =>
if (value) writeNumber(1L)
else writeNumber(0L)
case ByteLit(value) =>
writeNumber(value.toLong)
case ShortLit(value) =>
writeNumber(value.toLong)
case CharLit(value) =>
writeNumber(value.toLong)
case IntLit(value) =>
writeNumber(value.toLong)
case LongLit(value) =>
writeNumber(value.toLong)
case FloatLit(value) =>
writeNumber(floatToIntBits(value).toLong)
case DoubleLit(value) =>
writeNumber(doubleToLongBits(value).toLong)
case StringLit(name) =>
writeRef(name)
case NullLit =>
()
case ClassLit(tpe) =>
writeRef(tpe)
case EnumLit(sym) =>
writeRef(sym)
case SymAnnot(sym, tpe, args) =>
writeRef(sym)
writeRef(tpe)
writeAnnotArgs(args)
case AnnotInfo(tpe, args) =>
writeRef(tpe)
writeAnnotArgs(args)
case AnnotArgArray(values) =>
writeRefs(values)
case tree @ EmptyTree =>
writeByte(treeTag(tree))
case tree @ PackageDefTree(tpe, sym, pid, stats) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRef(pid)
writeRefs(stats)
case tree @ ClassDefTree(tpe, sym, mods, name, tparams, impl) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRef(mods)
writeRef(name)
writeRefs(tparams, atEnd = false)
writeRef(impl)
case tree @ ModuleDefTree(tpe, sym, mods, name, impl) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRef(mods)
writeRef(name)
writeRef(impl)
case tree @ ValDefTree(tpe, sym, mods, name, tpt, rhs) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRef(mods)
writeRef(name)
writeRef(tpt)
writeRef(rhs)
case tree @ DefDefTree(tpe, sym, mods, name, tparams, paramss, ret, rhs) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRef(mods)
writeRef(name)
writeRefs(tparams, atEnd = false)
writeRefss(paramss, atEnd = false)
writeRef(ret)
writeRef(rhs)
case tree @ TypeDefTree(tpe, sym, mods, name, tparams, tpt) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRef(mods)
writeRef(name)
writeRefs(tparams, atEnd = false)
writeRef(tpt)
case tree @ LabelDefTree(tpe, sym, name, params, rhs) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRef(name)
writeRefs(params, atEnd = false)
writeRef(rhs)
case tree @ ImportTree(tpe, sym, qual, selectors) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRef(qual)
writeImportSelectors(selectors)
case tree @ TemplateTree(tpe, sym, parents, self, stats) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRefs(parents, atEnd = false)
writeRef(self)
writeRefs(stats)
case tree @ BlockTree(tpe, stats) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRefs(stats)
case tree @ CaseTree(tpe, pat, guard, body) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(pat)
writeRef(guard)
writeRef(body)
case tree @ AlternativeTree(tpe, trees) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRefs(trees)
case tree @ StarTree(tpe, elem) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(elem)
case tree @ BindTree(tpe, sym, name, body) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRef(name)
writeRef(body)
case tree @ UnapplyTree(tpe, fun, args) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(fun)
writeRefs(args)
case tree @ ArrayValueTree(tpe, elemtpt, elems) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(elemtpt)
writeRefs(elems)
case tree @ FunctionTree(tpe, sym, params, body) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRefs(params, atEnd = false)
writeRef(body)
case tree @ AssignTree(tpe, lhs, rhs) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(lhs)
writeRef(rhs)
case tree @ IfTree(tpe, cond, thenp, elsep) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(cond)
writeRef(thenp)
writeRef(elsep)
case tree @ MatchTree(tpe, scrut, cases) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(scrut)
writeRefs(cases)
case tree @ ReturnTree(tpe, sym, expr) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRef(expr)
case tree @ TryTree(tpe, expr, cases, fin) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(expr)
writeRefs(cases, atEnd = false)
writeRef(fin)
case tree @ ThrowTree(tpe, expr) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(expr)
case tree @ NewTree(tpe, tpt) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(tpt)
case tree @ TypedTree(tpe, expr, tpt) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(expr)
writeRef(tpt)
case tree @ TypeApplyTree(tpe, fun, targs) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(fun)
writeRefs(targs)
case tree @ ApplyTree(tpe, fun, args) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(fun)
writeRefs(args)
case tree @ ApplyDynamicTree(tpe, sym, fun, args) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRef(fun)
writeRefs(args)
case tree @ SuperTree(tpe, sym, qual, mix) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRef(qual)
writeRef(mix)
case tree @ ThisTree(tpe, sym, qual) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRef(qual)
case tree @ SelectTree(tpe, sym, qual, name) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRef(qual)
writeRef(name)
case tree @ IdentTree(tpe, sym, name) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(sym)
writeRef(name)
case tree @ LiteralTree(tpe, lit) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(lit)
case tree @ TypeTree(tpe) =>
writeByte(treeTag(tree))
writeRef(tpe)
case tree @ AnnotatedTree(tpe, annot, arg) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(annot)
writeRef(arg)
case tree @ SingletonTypeTree(tpe, tree1) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(tree1)
case tree @ SelectFromTypeTree(tpe, qual, name) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(qual)
writeRef(name)
case tree @ CompoundTypeTree(tpe, impl) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(impl)
case tree @ AppliedTypeTree(tpe, fun, targs) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(fun)
writeRefs(targs)
case tree @ TypeBoundsTree(tpe, lo, hi) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(lo)
writeRef(hi)
case tree @ ExistentialTypeTree(tpe, tpt, decls) =>
writeByte(treeTag(tree))
writeRef(tpe)
writeRef(tpt)
writeRefs(decls)
case Modifiers(flags, within) =>
writeModifierFlags(flags)
writeRef(within)
}
val entryLen = offset - bodyStart
patchVarint(entryStart + 1, entryLen)
}
Classfile(scalasig.name, scalasig.source, ScalaPayload(writer.toByteArray))
}