diff options
author | michelou <michelou@epfl.ch> | 2006-07-04 15:16:49 +0000 |
---|---|---|
committer | michelou <michelou@epfl.ch> | 2006-07-04 15:16:49 +0000 |
commit | 3d7e84e6faa04b33af34229b24fd55a000c1d6b0 (patch) | |
tree | d471ed4160ba5253b487f508b25441053e5ccbec | |
parent | b34c9f524f5d6170b0004dd20d2b08ba823e2f18 (diff) | |
download | scala-3d7e84e6faa04b33af34229b24fd55a000c1d6b0.tar.gz scala-3d7e84e6faa04b33af34229b24fd55a000c1d6b0.tar.bz2 scala-3d7e84e6faa04b33af34229b24fd55a000c1d6b0.zip |
removed leading/trailing tabs/blanks in ast/par...
removed leading/trailing tabs/blanks in ast/parser/TreeBuilder.scala
-rw-r--r-- | src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala | 192 |
1 files changed, 97 insertions, 95 deletions
diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala index f53ba1b365..53936ed9aa 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala @@ -1,31 +1,32 @@ -/* NSC -- new scala compiler - * Copyright 2005 LAMP/EPFL +/* NSC -- new Scala compiler + * Copyright 2005-2006 LAMP/EPFL * @author Martin Odersky */ // $Id$ -package scala.tools.nsc.ast.parser; -import symtab.Flags._; -import scala.collection.mutable.ListBuffer; +package scala.tools.nsc.ast.parser + +import symtab.Flags._ +import scala.collection.mutable.ListBuffer abstract class TreeBuilder { - val global: Global; - import global._; - import posAssigner.atPos; + val global: Global + import global._ + import posAssigner.atPos - def freshName(prefix: String): Name; + def freshName(prefix: String): Name - def freshName(): Name = freshName("x$"); + def freshName(): Name = freshName("x$") def scalaDot(name: Name): Tree = Select(Ident(nme.scala_) setSymbol definitions.ScalaPackage, name) def scalaAnyRefConstr: Tree = - scalaDot(nme.AnyRef.toTypeName); + scalaDot(nme.AnyRef.toTypeName) def scalaScalaObjectConstr: Tree = - scalaDot(nme.ScalaObject.toTypeName); + scalaDot(nme.ScalaObject.toTypeName) def caseClassConstr: Tree = - scalaDot(nme.CaseClass.toTypeName); + scalaDot(nme.CaseClass.toTypeName) /** Convert all occurrences of (lower-case) variables in a pattern as follows: * x becomes x @ _ @@ -34,50 +35,52 @@ abstract class TreeBuilder { private object patvarTransformer extends Transformer { override def transform(tree: Tree): Tree = tree match { case Ident(name) if (treeInfo.isVariableName(name) && name != nme.WILDCARD) => - atPos(tree.pos)(Bind(name, Ident(nme.WILDCARD))) + atPos(tree.pos)(Bind(name, Ident(nme.WILDCARD))) case Typed(id @ Ident(name), tpt) if (treeInfo.isVariableName(name) && name != nme.WILDCARD) => - Bind(name, atPos(tree.pos)(Typed(Ident(nme.WILDCARD), tpt))) setPos id.pos + Bind(name, atPos(tree.pos)(Typed(Ident(nme.WILDCARD), tpt))) setPos id.pos case Apply(fn @ Apply(_, _), args) => - copy.Apply(tree, transform(fn), transformTrees(args)) + copy.Apply(tree, transform(fn), transformTrees(args)) case Apply(fn, args) => - copy.Apply(tree, fn, transformTrees(args)) + copy.Apply(tree, fn, transformTrees(args)) case Typed(expr, tpt) => - copy.Typed(tree, transform(expr), tpt) + copy.Typed(tree, transform(expr), tpt) case Bind(name, body) => - copy.Bind(tree, name, transform(body)) + copy.Bind(tree, name, transform(body)) case Sequence(_) | Alternative(_) | Star(_) => - super.transform(tree) + super.transform(tree) case _ => - tree + tree } } /** Traverse pattern and collect all variable names with their types in buffer */ private object getvarTraverser extends Traverser { - val buf = new ListBuffer[Pair[Name, Tree]]; + val buf = new ListBuffer[Pair[Name, Tree]] def init: Traverser = { buf.clear; this } override def traverse(tree: Tree): unit = tree match { case Bind(name, Typed(tree1, tpt)) => - if ((name != nme.WILDCARD) && (buf.elements forall (name !=))) + if ((name != nme.WILDCARD) && (buf.elements forall (name !=))) buf += Pair(name, tpt) traverse(tree1) case Bind(name, tree1) => - if ((name != nme.WILDCARD) && (buf.elements forall (name !=))) + if ((name != nme.WILDCARD) && (buf.elements forall (name !=))) buf += Pair(name, TypeTree()) - traverse(tree1) + traverse(tree1) case _ => super.traverse(tree) } } - /** Returns list of all pattern variables, possibly with their types, without duplicates */ + /** Returns list of all pattern variables, possibly with their types, + * without duplicates + */ private def getVariables(tree: Tree): List[Pair[Name, Tree]] = { - getvarTraverser.init.traverse(tree); + getvarTraverser.init.traverse(tree) getvarTraverser.buf.toList } private def makeTuple(trees: List[Tree], isType: boolean): Tree = { - val tupString = "Tuple" + trees.length; + val tupString = "Tuple" + trees.length Apply(scalaDot(if (isType) newTypeName(tupString) else newTermName(tupString)), trees) } @@ -98,84 +101,82 @@ abstract class TreeBuilder { } /** Create tree representing (unencoded) binary operation expression or pattern. */ - def makeBinop(isExpr: boolean, left: Tree, op: Name, right: Tree): Tree = { + def makeBinop(isExpr: boolean, left: Tree, op: Name, right: Tree): Tree = if (isExpr) { if (treeInfo.isLeftAssoc(op)) { - Apply(Select(left, op.encode), List(right)) + Apply(Select(left, op.encode), List(right)) } else { - val x = freshName(); - Block( - List(ValDef(Modifiers(SYNTHETIC), x, TypeTree(), left)), - Apply(Select(right, op.encode), List(Ident(x)))) + val x = freshName(); + Block( + List(ValDef(Modifiers(SYNTHETIC), x, TypeTree(), left)), + Apply(Select(right, op.encode), List(Ident(x)))) } } else { Apply(Ident(op.encode.toTypeName), List(left, right)) } - } /** Create tree representing an object creation <new parents { stats }> */ def makeNew(parents: List[Tree], stats: List[Tree], argss: List[List[Tree]]): Tree = if (parents.tail.isEmpty && stats.isEmpty) New(parents.head, argss) else { - val x = nme.ANON_CLASS_NAME.toTypeName; + val x = nme.ANON_CLASS_NAME.toTypeName Block( List(ClassDef( Modifiers(FINAL | SYNTHETIC), x, List(), TypeTree(), Template(parents, List(List()), argss, stats))), - New(Ident(x), List(List()))) + New(Ident(x), List(List()))) } - /** Create a tree represeting an assignment <lhs = rhs> */ + /** Create a tree represeting an assignment <lhs = rhs> */ def makeAssign(lhs: Tree, rhs: Tree): Tree = lhs match { case Apply(fn, args) => Apply(Select(fn, nme.update), args ::: List(rhs)) case _ => Assign(lhs, rhs) } /** A type tree corresponding to (possibly unary) intersection type */ - def makeIntersectionTypeTree(tps: List[Tree]): Tree = { - if (tps.tail.isEmpty) tps.head else CompoundTypeTree(Template(tps, List())) - } + def makeIntersectionTypeTree(tps: List[Tree]): Tree = + if (tps.tail.isEmpty) tps.head + else CompoundTypeTree(Template(tps, List())) /** Create tree representing a while loop */ def makeWhile(lname: Name, cond: Tree, body: Tree): Tree = { - val continu = Apply(Ident(lname), List()); - val rhs = If(cond, Block(List(body), continu), Literal(())); + val continu = Apply(Ident(lname), List()) + val rhs = If(cond, Block(List(body), continu), Literal(())) LabelDef(lname, Nil, rhs) } /** Create tree representing a do-while loop */ def makeDoWhile(lname: Name, body: Tree, cond: Tree): Tree = { - val continu = Apply(Ident(lname), List()); - val rhs = Block(List(body), If(cond, continu, Literal(()))); + val continu = Apply(Ident(lname), List()) + val rhs = Block(List(body), If(cond, continu, Literal(()))) LabelDef(lname, Nil, rhs) } /** Create block of statements `stats' */ - def makeBlock(stats: List[Tree]): Tree = { + def makeBlock(stats: List[Tree]): Tree = if (stats.isEmpty) Literal(()) - else if (!stats.last.isTerm) Block(stats, Literal(())); + else if (!stats.last.isTerm) Block(stats, Literal(())) else if (stats.length == 1) stats(0) else Block(stats.init, stats.last) - } - /** Create tree for for-comprehension generator <val pat0 <- rhs0> */ + /** Create tree for for-comprehension generator <val pat0 <- rhs0> */ def makeGenerator(pos: int, pat: Tree, valeq: boolean, rhs: Tree): Enumerator = { val pat1 = patvarTransformer.transform(pat); val rhs1 = if (valeq) rhs else matchVarPattern(pat1) match { case Some(_) => - rhs + rhs case None => - atPos(pos) { + atPos(pos) { Apply( - Select(rhs, nme.filter), - List( + Select(rhs, nme.filter), + List( makeVisitor( List( - CaseDef(pat1.duplicate, EmptyTree, Literal(true)), - CaseDef(Ident(nme.WILDCARD), EmptyTree, Literal(false))), + CaseDef(pat1.duplicate, EmptyTree, Literal(true)), + CaseDef(Ident(nme.WILDCARD), EmptyTree, Literal(false))), nme.CHECK_IF_REFUTABLE_STRING ))) } @@ -188,8 +189,8 @@ abstract class TreeBuilder { case class ValEq(pos: int, pat: Tree, rhs: Tree) extends Enumerator case class Filter(test: Tree) extends Enumerator - /** Create tree for for-comprehension <for (enums) do body> or - * <for (enums) yield body> where mapName and flatMapName are chosen + /** Create tree for for-comprehension <for (enums) do body> or + * <for (enums) yield body> where mapName and flatMapName are chosen * corresponding to whether this is a for-do or a for-yield. * The creation performs the following rewrite rules: * @@ -238,7 +239,7 @@ abstract class TreeBuilder { case Some(Pair(name, tpt)) => Function(List(ValDef(Modifiers(PARAM), name, tpt, EmptyTree)), body) case None => - makeVisitor(List(CaseDef(pat, EmptyTree, body))) + makeVisitor(List(CaseDef(pat, EmptyTree, body))) } def makeCombination(meth: Name, qual: Tree, pat: Tree, body: Tree): Tree = @@ -268,13 +269,13 @@ abstract class TreeBuilder { makeCombination(flatMapName, rhs, pat, makeFor(mapName, flatMapName, rest, body)) } case ValFrom(pos, pat, rhs) :: Filter(test) :: rest => - makeFor(mapName, flatMapName, - ValFrom(pos, pat, makeCombination(nme.filter, rhs, pat.duplicate, test)) :: rest, - body) + makeFor(mapName, flatMapName, + ValFrom(pos, pat, makeCombination(nme.filter, rhs, pat.duplicate, test)) :: rest, + body) case ValFrom(pos, pat, rhs) :: rest => val valeqs = rest.take(definitions.MaxTupleArity - 1).takeWhile(.isInstanceOf[ValEq]); - assert(!valeqs.isEmpty); - val rest1 = rest.drop(valeqs.length); + assert(!valeqs.isEmpty) + val rest1 = rest.drop(valeqs.length) val pats = valeqs map { case ValEq(_, pat, _) => pat } val rhss = valeqs map { case ValEq(_, _, rhs) => rhs } val defpats = pats map (x => makeBind(x.duplicate)) @@ -290,13 +291,13 @@ abstract class TreeBuilder { } } - /** Create tree for for-do comprehension <for (enums) body> */ + /** Create tree for for-do comprehension <for (enums) body> */ def makeFor(enums: List[Enumerator], body: Tree): Tree = - makeFor(nme.foreach, nme.foreach, enums, body); + makeFor(nme.foreach, nme.foreach, enums, body) - /** Create tree for for-yield comprehension <for (enums) yield body> */ + /** Create tree for for-yield comprehension <for (enums) yield body> */ def makeForYield(enums: List[Enumerator], body: Tree): Tree = - makeFor(nme.map, nme.flatMap, enums, body); + makeFor(nme.map, nme.flatMap, enums, body) /** Create tree for a pattern alternative */ def makeAlternative(ts: List[Tree]): Tree = { @@ -318,30 +319,31 @@ abstract class TreeBuilder { /** Create tree for the p+ regex pattern, becomes p p* */ def makePlus(p: Tree): Tree = - makeSequence(List(p, Star(p.duplicate))); + makeSequence(List(p, Star(p.duplicate))) /** Create tree for the p? regex pattern, becomes (p| ) */ def makeOpt(p: Tree): Tree = - makeAlternative(List(p, Sequence(List()))); + makeAlternative(List(p, Sequence(List()))) /** Create visitor <x => x match cases> */ - def makeVisitor(cases: List[CaseDef]): Tree = makeVisitor(cases, "x$"); + def makeVisitor(cases: List[CaseDef]): Tree = + makeVisitor(cases, "x$") /** Create visitor <x => x match cases> */ def makeVisitor(cases: List[CaseDef], prefix: String): Tree = { - val x = freshName(prefix); + val x = freshName(prefix) Function(List(ValDef(Modifiers(PARAM | SYNTHETIC), x, TypeTree(), EmptyTree)), Match(Ident(x), cases)) } - /** Create tree for case definition <case pat if guard => rhs> */ - def makeCaseDef(pat: Tree, guard: Tree, rhs: Tree): CaseDef = { - CaseDef(patvarTransformer.transform(pat), guard, rhs); - } + /** Create tree for case definition <case pat if guard => rhs> */ + def makeCaseDef(pat: Tree, guard: Tree, rhs: Tree): CaseDef = + CaseDef(patvarTransformer.transform(pat), guard, rhs) - /** Create tree for pattern definition <val pat0 = rhs> */ - def makePatDef(pat: Tree, rhs: Tree): List[Tree] = makePatDef(Modifiers(0), pat, rhs) + /** Create tree for pattern definition <val pat0 = rhs> */ + def makePatDef(pat: Tree, rhs: Tree): List[Tree] = + makePatDef(Modifiers(0), pat, rhs) - /** Create tree for pattern definition <mods val pat0 = rhs> */ + /** Create tree for pattern definition <mods val pat0 = rhs> */ def makePatDef(mods: Modifiers, pat: Tree, rhs: Tree): List[Tree] = matchVarPattern(pat) match { case Some(Pair(name, tpt)) => List(ValDef(mods, name, tpt, rhs)) @@ -358,25 +360,25 @@ abstract class TreeBuilder { // val x_1 = t$._1 // ... // val x_N = t$._N - val pat1 = patvarTransformer.transform(pat); - val vars = getVariables(pat1); + val pat1 = patvarTransformer.transform(pat) + val vars = getVariables(pat1) val matchExpr = atPos(pat1.pos){ Match(rhs, List(CaseDef(pat1, EmptyTree, makeTupleTerm(vars map (._1) map Ident)))) } vars match { - case List() => - List(matchExpr) - case List(Pair(vname, tpt)) => - List(ValDef(mods, vname, tpt, matchExpr)) - case _ => - val tmp = freshName(); - val firstDef = ValDef(Modifiers(PRIVATE | LOCAL | SYNTHETIC), tmp, TypeTree(), matchExpr); - var cnt = 0; - val restDefs = for (val Pair(vname, tpt) <- vars) yield { - cnt = cnt + 1; - ValDef(mods, vname, tpt, Select(Ident(tmp), newTermName("_" + cnt))) - } - firstDef :: restDefs + case List() => + List(matchExpr) + case List(Pair(vname, tpt)) => + List(ValDef(mods, vname, tpt, matchExpr)) + case _ => + val tmp = freshName() + val firstDef = ValDef(Modifiers(PRIVATE | LOCAL | SYNTHETIC), tmp, TypeTree(), matchExpr) + var cnt = 0 + val restDefs = for (val Pair(vname, tpt) <- vars) yield { + cnt = cnt + 1 + ValDef(mods, vname, tpt, Select(Ident(tmp), newTermName("_" + cnt))) + } + firstDef :: restDefs } } @@ -386,8 +388,8 @@ abstract class TreeBuilder { /** Append implicit view section if for `implicitViews' if nonempty */ def addImplicitViews(owner: Name, vparamss: List[List[ValDef]], implicitViews: List[Tree]): List[List[ValDef]] = { - val mods = Modifiers(if (owner.isTypeName) PARAMACCESSOR | LOCAL | PRIVATE else PARAM); - def makeViewParam(tpt: Tree) = ValDef(mods | IMPLICIT, freshName("view$"), tpt, EmptyTree); + val mods = Modifiers(if (owner.isTypeName) PARAMACCESSOR | LOCAL | PRIVATE else PARAM) + def makeViewParam(tpt: Tree) = ValDef(mods | IMPLICIT, freshName("view$"), tpt, EmptyTree) if (implicitViews.isEmpty) vparamss else vparamss ::: List(implicitViews map makeViewParam) } |