aboutsummaryrefslogtreecommitdiff
path: root/src/dotty/tools/dotc/core/pickling/TreePickler.scala
diff options
context:
space:
mode:
authorDmitry Petrashko <dmitry.petrashko@gmail.com>2015-04-09 16:57:55 +0200
committerDmitry Petrashko <dmitry.petrashko@gmail.com>2015-04-09 16:57:55 +0200
commitafa630a78b4f2cd9bd799b5a0199b99548f18aaa (patch)
tree9da8ad19573c8c913b47a232a3b57662aa660ec1 /src/dotty/tools/dotc/core/pickling/TreePickler.scala
parent33f5d62bcbc6ec649e739958fc19c4524305471c (diff)
downloaddotty-afa630a78b4f2cd9bd799b5a0199b99548f18aaa.tar.gz
dotty-afa630a78b4f2cd9bd799b5a0199b99548f18aaa.tar.bz2
dotty-afa630a78b4f2cd9bd799b5a0199b99548f18aaa.zip
Remove trailing spaces in Dotty source.
Diffstat (limited to 'src/dotty/tools/dotc/core/pickling/TreePickler.scala')
-rw-r--r--src/dotty/tools/dotc/core/pickling/TreePickler.scala92
1 files changed, 46 insertions, 46 deletions
diff --git a/src/dotty/tools/dotc/core/pickling/TreePickler.scala b/src/dotty/tools/dotc/core/pickling/TreePickler.scala
index 85addc563..53dd34094 100644
--- a/src/dotty/tools/dotc/core/pickling/TreePickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/TreePickler.scala
@@ -33,7 +33,7 @@ class TreePickler(pickler: TastyPickler) {
}
def preRegister(tree: Tree)(implicit ctx: Context): Unit = tree match {
- case tree: MemberDef =>
+ case tree: MemberDef =>
if (!symRefs.contains(tree.symbol)) symRefs(tree.symbol) = NoAddr
case _ =>
}
@@ -54,13 +54,13 @@ class TreePickler(pickler: TastyPickler) {
val Signature(params, result) = sig
pickleName(TastyName.Signed(nameIndex(name), params.map(fullNameIndex), fullNameIndex(result)))
}
-
+
private def pickleName(sym: Symbol)(implicit ctx: Context): Unit =
- if (sym is Flags.ExpandedName)
+ if (sym is Flags.ExpandedName)
pickleName(TastyName.Expanded(
nameIndex(sym.name.expandedPrefix), nameIndex(sym.name.unexpandedName)))
else pickleName(sym.name)
-
+
private def pickleSymRef(sym: Symbol)(implicit ctx: Context) = symRefs.get(sym) match {
case Some(label) =>
if (label != NoAddr) writeRef(label) else pickleForwardSymRef(sym)
@@ -68,20 +68,20 @@ class TreePickler(pickler: TastyPickler) {
ctx.log(i"pickling reference to as yet undefined $sym in ${sym.owner}", sym.pos)
pickleForwardSymRef(sym)
}
-
+
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)
+ forwardSymRefs(sym) = ref :: forwardSymRefs.getOrElse(sym, Nil)
}
-
+
private def isLocallyDefined(sym: Symbol)(implicit ctx: Context) = symRefs.get(sym) match {
case Some(label) => assert(sym.exists); label != NoAddr
case None => false
}
def pickle(trees: List[Tree])(implicit ctx: Context) = {
-
+
def qualifiedName(sym: Symbol): TastyName =
if (sym.isRoot || sym.owner.isRoot) TastyName.Simple(sym.name.toTermName)
else TastyName.Qualified(nameIndex(qualifiedName(sym.owner)), nameIndex(sym.name))
@@ -141,9 +141,9 @@ class TreePickler(pickler: TastyPickler) {
println(i"error when pickling type $tpe0")
throw ex
}
-
+
def pickleNewType(tpe: Type, richTypes: Boolean): Unit = try { tpe match {
- case ConstantType(value) =>
+ case ConstantType(value) =>
pickleConstant(value)
case tpe: TypeRef if tpe.info.isAlias && tpe.symbol.is(Flags.AliasPreferred) =>
pickleType(tpe.info.bounds.hi)
@@ -152,12 +152,12 @@ class TreePickler(pickler: TastyPickler) {
if (sym.is(Flags.Package)) {
writeByte(if (tpe.isType) TYPEREFpkg else TERMREFpkg)
pickleName(qualifiedName(sym))
- }
+ }
else {
assert(tpe.prefix == NoPrefix)
def pickleRef() = {
writeByte(if (tpe.isType) TYPEREFdirect else TERMREFdirect)
- pickleSymRef(sym)
+ pickleSymRef(sym)
}
if (sym is Flags.BindDefinedType) {
registerDef(sym)
@@ -175,14 +175,14 @@ class TreePickler(pickler: TastyPickler) {
pickleNameAndSig(tpe.name, tpe.signature); pickleType(tpe.prefix)
case tpe: NamedType =>
if (tpe.name == tpnme.Apply && tpe.prefix.argInfos.nonEmpty && tpe.prefix.isInstantiatedLambda)
- // instantiated lambdas are pickled as APPLIEDTYPE; #Apply will
+ // instantiated lambdas are pickled as APPLIEDTYPE; #Apply will
// be reconstituted when unpickling.
pickleType(tpe.prefix)
else if (isLocallyDefined(tpe.symbol)) {
writeByte(if (tpe.isType) TYPEREFsymbol else TERMREFsymbol)
pickleSymRef(tpe.symbol); pickleType(tpe.prefix)
}
- else {
+ else {
writeByte(if (tpe.isType) TYPEREF else TERMREF)
pickleName(tpe.name); pickleType(tpe.prefix)
}
@@ -199,10 +199,10 @@ class TreePickler(pickler: TastyPickler) {
val args = tpe.argInfos(interpolate = false)
if (args.isEmpty) {
writeByte(REFINEDtype)
- withLength {
+ withLength {
pickleType(tpe.parent)
pickleName(tpe.refinedName)
- pickleType(tpe.refinedInfo, richTypes = true)
+ pickleType(tpe.refinedInfo, richTypes = true)
}
}
else {
@@ -211,8 +211,8 @@ class TreePickler(pickler: TastyPickler) {
}
case tpe: TypeAlias =>
writeByte(TYPEALIAS)
- withLength {
- pickleType(tpe.alias, richTypes)
+ withLength {
+ pickleType(tpe.alias, richTypes)
tpe.variance match {
case 1 => writeByte(COVARIANT)
case -1 => writeByte(CONTRAVARIANT)
@@ -237,7 +237,7 @@ class TreePickler(pickler: TastyPickler) {
case tpe: PolyType if richTypes =>
writeByte(POLYtype)
pickleMethodic(tpe.resultType, tpe.paramNames, tpe.paramBounds)
- case tpe: PolyParam =>
+ case tpe: PolyParam =>
if (!pickleParamType(tpe))
// TODO figure out why this case arises in e.g. pickling AbstractFileReader.
ctx.typerState.constraint.entry(tpe) match {
@@ -249,19 +249,19 @@ class TreePickler(pickler: TastyPickler) {
case tpe: LazyRef =>
pickleType(tpe.ref)
}} catch {
- case ex: AssertionError =>
+ case ex: AssertionError =>
println(i"error while pickling type $tpe")
throw ex
}
-
- def pickleMethodic(result: Type, names: List[Name], types: List[Type]) =
+
+ def pickleMethodic(result: Type, names: List[Name], types: List[Type]) =
withLength {
pickleType(result, richTypes = true)
(names, types).zipped.foreach { (name, tpe) =>
- pickleName(name); pickleType(tpe)
+ pickleName(name); pickleType(tpe)
}
}
-
+
def pickleParamType(tpe: ParamType): Boolean = {
val binder = pickledTypes.get(tpe.binder)
val pickled = binder != null
@@ -271,10 +271,10 @@ class TreePickler(pickler: TastyPickler) {
}
pickled
}
-
+
def pickleTpt(tpt: Tree): Unit = pickleType(tpt.tpe) // TODO correlate with original when generating positions
-
- def pickleTreeUnlessEmpty(tree: Tree): Unit =
+
+ def pickleTreeUnlessEmpty(tree: Tree): Unit =
if (!tree.isEmpty) pickleTree(tree)
def pickleTree(tree: Tree): Unit = try {
@@ -283,14 +283,14 @@ class TreePickler(pickler: TastyPickler) {
case Ident(name) =>
tree.tpe match {
case tp: TermRef => pickleType(tp)
- case _ =>
+ case _ =>
writeByte(IDENT)
pickleName(name)
pickleType(tree.tpe)
}
- case This(_) =>
+ case This(_) =>
pickleType(tree.tpe)
- case Select(qual, name) =>
+ case Select(qual, name) =>
writeByte(SELECT)
val realName = tree.tpe match {
case tp: NamedType if tp.name.isShadowedName => tp.name
@@ -321,7 +321,7 @@ class TreePickler(pickler: TastyPickler) {
}
case Super(qual, mix) =>
writeByte(SUPER)
- withLength {
+ withLength {
pickleTree(qual);
if (!mix.isEmpty) {
val SuperType(_, mixinType) = tree.tpe
@@ -350,12 +350,12 @@ class TreePickler(pickler: TastyPickler) {
case If(cond, thenp, elsep) =>
writeByte(IF)
withLength{ pickleTree(cond); pickleTree(thenp); pickleTree(elsep) }
- case Closure(env, meth, tpt) =>
+ case Closure(env, meth, tpt) =>
writeByte(LAMBDA)
assert(env.isEmpty)
- withLength{
+ withLength{
pickleTree(meth)
- if (tpt.tpe.exists) pickleTpt(tpt)
+ if (tpt.tpe.exists) pickleTpt(tpt)
}
case Match(selector, cases) =>
writeByte(MATCH)
@@ -383,14 +383,14 @@ class TreePickler(pickler: TastyPickler) {
withLength { alts.foreach(pickleTree) }
case UnApply(fun, implicits, patterns) =>
writeByte(UNAPPLY)
- withLength {
+ withLength {
pickleTree(fun)
for (implicitArg <- implicits) {
writeByte(IMPLICITarg)
pickleTree(implicitArg)
}
pickleType(tree.tpe)
- patterns.foreach(pickleTree)
+ patterns.foreach(pickleTree)
}
case tree: ValDef =>
pickleDef(VALDEF, tree.symbol, tree.tpt, tree.rhs)
@@ -400,7 +400,7 @@ class TreePickler(pickler: TastyPickler) {
for (vparams <- tree.vparamss) {
writeByte(PARAMS)
withLength { pickleParams(vparams) }
- }
+ }
}
pickleDef(DEFDEF, tree.symbol, tree.tpt, tree.rhs, pickleAllParams)
case tree: TypeDef =>
@@ -410,7 +410,7 @@ class TreePickler(pickler: TastyPickler) {
writeByte(TEMPLATE)
val (params, rest) = tree.body partition {
case stat: TypeDef => stat.symbol is Flags.Param
- case stat: ValOrDefDef =>
+ case stat: ValOrDefDef =>
stat.symbol.is(Flags.ParamAccessor) && !stat.symbol.isSetter
case _ => false
}
@@ -435,7 +435,7 @@ class TreePickler(pickler: TastyPickler) {
withLength {
pickleTree(expr)
selectors foreach {
- case Pair(Ident(from), Ident(to)) =>
+ case Pair(Ident(from), Ident(to)) =>
writeByte(RENAMED)
withLength { pickleName(from); pickleName(to) }
case Ident(name) =>
@@ -468,13 +468,13 @@ class TreePickler(pickler: TastyPickler) {
pickleModifiers(sym)
}
}
-
+
def pickleParam(tree: Tree): Unit = 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: TypeDef => pickleDef(TYPEPARAM, tree.symbol, tree.rhs)
}
-
+
def pickleParams(trees: List[Tree]): Unit = {
trees.foreach(preRegister)
trees.foreach(pickleParam)
@@ -504,7 +504,7 @@ class TreePickler(pickler: TastyPickler) {
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 (flags is Scala2x) writeByte(SCALA2X)
if (flags is InSuperCall) writeByte(INSUPERCALL)
if (sym.isTerm) {
if (flags is Implicit) writeByte(IMPLICIT)
@@ -512,18 +512,18 @@ class TreePickler(pickler: TastyPickler) {
if (flags is AbsOverride) writeByte(ABSOVERRIDE)
if (flags is Mutable) writeByte(MUTABLE)
if (flags is Accessor) writeByte(FIELDaccessor)
- if (flags is CaseAccessor) writeByte(CASEaccessor)
+ if (flags is CaseAccessor) writeByte(CASEaccessor)
if (flags is DefaultParameterized) writeByte(DEFAULTparameterized)
} else {
if (flags is Sealed) writeByte(SEALED)
- if (flags is Abstract) writeByte(ABSTRACT)
+ 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)
}
-
+
def pickleAnnotation(ann: Annotation) = {
writeByte(ANNOTATION)
withLength { pickleType(ann.symbol.typeRef); pickleTree(ann.tree) }