diff options
author | michelou <michelou@epfl.ch> | 2006-08-17 14:11:13 +0000 |
---|---|---|
committer | michelou <michelou@epfl.ch> | 2006-08-17 14:11:13 +0000 |
commit | 80bfcf9e75b7724453fdfd4be4cdf0efed52a5fb (patch) | |
tree | c3215dd8f7e0ee3dccc31807040e7a9f30292f1d | |
parent | 22a098bf7e2515f5585be0ddf2d0a9f09e2b9e9d (diff) | |
download | scala-80bfcf9e75b7724453fdfd4be4cdf0efed52a5fb.tar.gz scala-80bfcf9e75b7724453fdfd4be4cdf0efed52a5fb.tar.bz2 scala-80bfcf9e75b7724453fdfd4be4cdf0efed52a5fb.zip |
removed leading/trailing blanks/tabs in nsc/tra...
removed leading/trailing blanks/tabs in nsc/transform/*.scala
5 files changed, 230 insertions, 193 deletions
diff --git a/src/compiler/scala/tools/nsc/transform/LiftCode.scala b/src/compiler/scala/tools/nsc/transform/LiftCode.scala index 9f94832cb0..fde24539a7 100644 --- a/src/compiler/scala/tools/nsc/transform/LiftCode.scala +++ b/src/compiler/scala/tools/nsc/transform/LiftCode.scala @@ -1,40 +1,47 @@ -/* NSC -- new scala compiler - * Copyright 2005 LAMP/EPFL - * @author +/* NSC -- new Scala compiler + * Copyright 2005-2006 LAMP/EPFL + * @author Gilles Dubochet */ // $Id$ -package scala.tools.nsc.transform; -import symtab._; -import Flags._; -import util.TreeSet; -import symtab.Flags._; -import scala.collection.immutable.ListMap; -import scala.collection.mutable.{HashMap, ListBuffer}; -import scala.tools.nsc.util.FreshNameCreator; +package scala.tools.nsc.transform +import symtab._ +import Flags._ +import symtab.Flags._ +import scala.collection.immutable.ListMap +import scala.collection.mutable.{HashMap, ListBuffer} +import scala.tools.nsc.util.{FreshNameCreator, TreeSet} + +/** This abstract class ... + * + * @author Gilles Dubochet + * @version 1.0 + */ abstract class LiftCode extends Transform { - import global._; // the global environment - import definitions._; // standard classes and methods - import typer.{typed, atOwner}; // methods to type trees - import posAssigner.atPos; // for filling in tree positions + import global._ // the global environment + import definitions._ // standard classes and methods + import typer.{typed, atOwner} // methods to type trees + import posAssigner.atPos // for filling in tree positions /** the following two members override abstract members in Transform */ - val phaseName: String = "liftcode"; + val phaseName: String = "liftcode" - def newTransformer(unit: CompilationUnit): Transformer = new AddRefFields(unit); + def newTransformer(unit: CompilationUnit): Transformer = + new AddRefFields(unit) class AddRefFields(unit: CompilationUnit) extends Transformer { override def transform(tree: Tree): Tree = tree match { - case Apply(TypeApply(Select(x@Ident(_), nme.lift_), _), List(tree)) if x.symbol == CodeModule => + case Apply(TypeApply(Select(x@Ident(_), nme.lift_), _), List(tree)) + if x.symbol == CodeModule => typed(atPos(tree.pos)(codify(tree))) case _ => super.transform(tree) } } - case class FreeValue(tree: Tree) extends reflect.Tree; + case class FreeValue(tree: Tree) extends reflect.Tree class ReifyEnvironment extends HashMap[Symbol, reflect.Symbol] { var targets = new HashMap[String, Option[reflect.LabelSymbol]]() @@ -212,7 +219,7 @@ abstract class LiftCode extends Transform { } - type InjectEnvironment = ListMap[reflect.Symbol, Name]; + type InjectEnvironment = ListMap[reflect.Symbol, Name] class Injector(env: InjectEnvironment, fresh: FreshNameCreator) { @@ -220,7 +227,10 @@ abstract class LiftCode extends Transform { def className(value: CaseClass): String = value match { case _ :: _ => "scala.$colon$colon" case reflect.MethodType(_, _) => - if (value.isInstanceOf[reflect.ImplicitMethodType]) "scala.reflect.ImplicitMethodType" else "scala.reflect.MethodType" + if (value.isInstanceOf[reflect.ImplicitMethodType]) + "scala.reflect.ImplicitMethodType" + else + "scala.reflect.MethodType" case x => "scala.reflect."+x.caseName //case _ => // bq:unreachable code @@ -228,27 +238,27 @@ abstract class LiftCode extends Transform { } def objectName(value: Any): String = value match { - case Nil => "scala.Nil" - case reflect.NoSymbol => "scala.reflect.NoSymbol" + case Nil => "scala.Nil" + case reflect.NoSymbol => "scala.reflect.NoSymbol" case reflect.RootSymbol => "scala.reflect.RootSymbol" - case reflect.NoPrefix => "scala.reflect.NoPrefix" - case reflect.NoType => "scala.reflect.NoType" + case reflect.NoPrefix => "scala.reflect.NoPrefix" + case reflect.NoType => "scala.reflect.NoType" case _ => "" } def inject(value: Any): Tree = value match { case FreeValue(tree) => New(Ident(definitions.getClass("scala.reflect.Literal")), List(List(tree))) - case () => Literal(Constant(())) - case x: String => Literal(Constant(x)) - case x: Boolean => Literal(Constant(x)) - case x: Byte => Literal(Constant(x)) - case x: Short => Literal(Constant(x)) - case x: Char => Literal(Constant(x)) - case x: Int => Literal(Constant(x)) - case x: Long => Literal(Constant(x)) - case x: Float => Literal(Constant(x)) - case x: Double => Literal(Constant(x)) + case () => Literal(Constant(())) + case x: String => Literal(Constant(x)) + case x: Boolean => Literal(Constant(x)) + case x: Byte => Literal(Constant(x)) + case x: Short => Literal(Constant(x)) + case x: Char => Literal(Constant(x)) + case x: Int => Literal(Constant(x)) + case x: Long => Literal(Constant(x)) + case x: Float => Literal(Constant(x)) + case x: Double => Literal(Constant(x)) case c: CaseClass => val name = objectName(c); if (name.length() != 0) gen.mkAttributedRef(definitions.getModule(name)) @@ -260,20 +270,24 @@ abstract class LiftCode extends Transform { injectedArgs += inject(c.caseElement(i)); New(Ident(definitions.getClass(name)), List(injectedArgs.toList)) } - case null => gen.mkAttributedRef(definitions.getModule("scala.reflect.NoType")) - case _ => throw new Error("don't know how to inject " + value); + case null => + gen.mkAttributedRef(definitions.getModule("scala.reflect.NoType")) + case _ => + throw new Error("don't know how to inject " + value) } } def reify(tree: Tree): reflect.Tree = - new Reifier(new ReifyEnvironment(), reflect.NoSymbol).reify(tree); + new Reifier(new ReifyEnvironment(), reflect.NoSymbol).reify(tree) def inject(code: reflect.Tree): Tree = - new Injector(ListMap.Empty, new FreshNameCreator).inject(code); + new Injector(ListMap.Empty, new FreshNameCreator).inject(code) def codify (tree: Tree): Tree = - New(TypeTree(appliedType(definitions.CodeClass.typeConstructor, List(tree.tpe))),List(List(inject(reify(tree))))) + New(TypeTree(appliedType(definitions.CodeClass.typeConstructor, + List(tree.tpe))), + List(List(inject(reify(tree))))) } @@ -311,4 +325,3 @@ abstract class LiftCode extends Transform { // case Alternative(trees) => // case Star(elem) => // case Bind(name, body) => - diff --git a/src/compiler/scala/tools/nsc/transform/OverridingPairs.scala b/src/compiler/scala/tools/nsc/transform/OverridingPairs.scala index fc3aaacaef..00d0c2a469 100644 --- a/src/compiler/scala/tools/nsc/transform/OverridingPairs.scala +++ b/src/compiler/scala/tools/nsc/transform/OverridingPairs.scala @@ -1,41 +1,50 @@ -/* NSC -- new scala compiler - * Copyright 2005 LAMP/EPFL - * @author +/* NSC -- new Scala compiler + * Copyright 2005-2006 LAMP/EPFL + * @author Martin Odersky */ // $Id$ -package scala.tools.nsc.transform; -import util.HashSet; -import collection.mutable.HashMap; -import symtab.Flags._; +package scala.tools.nsc.transform +import collection.mutable.HashMap +import symtab.Flags._ +import util.HashSet + +/** This abstract class ... + * + * @author Martin Odersky + * @version 1.0 + */ abstract class OverridingPairs { - val global: Global; - import global._; + val global: Global + import global._ class Cursor(base: Symbol) { - private val self = base.thisType; + private val self = base.thisType - protected def exclude(sym: Symbol): boolean = sym.isConstructor || (sym hasFlag LOCAL); + protected def exclude(sym: Symbol): boolean = + sym.isConstructor || (sym hasFlag LOCAL) - protected def parents: List[Type] = base.info.parents; + protected def parents: List[Type] = base.info.parents protected def matches(sym1: Symbol, sym2: Symbol): boolean = - sym1.isType || (self.memberType(sym1) matches self.memberType(sym2)); + sym1.isType || (self.memberType(sym1) matches self.memberType(sym2)) - private type BitSet = Array[int]; + private type BitSet = Array[int] - private def newBitSet(size: int): BitSet = new Array((size + 31) >> 5); + private def newBitSet(size: int): BitSet = new Array((size + 31) >> 5) private def include(bs: BitSet, n: int): unit = { - val nshifted = n >> 5; - val nmask = 1 << (n & 31); + val nshifted = n >> 5 + val nmask = 1 << (n & 31) bs(nshifted) = bs(nshifted) | nmask } - private def intersectionContainsElementLeq(bs1: BitSet, bs2: BitSet, n: int): boolean = { + private def intersectionContainsElementLeq(bs1: BitSet, bs2: BitSet, + n: int): boolean = + { val nshifted = n >> 5; val nmask = 1 << (n & 31); ((List.range(0, nshifted) exists (i => (bs1(i) & bs2(i)) != 0)) || @@ -45,33 +54,34 @@ abstract class OverridingPairs { private val decls = new Scope; { def fillDecls(bcs: List[Symbol], deferredflag: int): unit = if (!bcs.isEmpty) { - fillDecls(bcs.tail, deferredflag); - var e = bcs.head.info.decls.elems; - while (e != null) { - if (e.sym.getFlag(DEFERRED) == deferredflag && !exclude(e.sym)) decls enter e.sym; - e = e.next - } - } - fillDecls(base.info.baseClasses, DEFERRED); - fillDecls(base.info.baseClasses, 0); + fillDecls(bcs.tail, deferredflag) + var e = bcs.head.info.decls.elems; + while (e != null) { + if (e.sym.getFlag(DEFERRED) == deferredflag && !exclude(e.sym)) + decls enter e.sym; + e = e.next + } + } + fillDecls(base.info.baseClasses, DEFERRED) + fillDecls(base.info.baseClasses, 0) } - private val size = base.info.baseClasses.length; + private val size = base.info.baseClasses.length - private val index = new HashMap[Symbol, int]; + private val index = new HashMap[Symbol, int] { var i = 0; for (val bc <- base.info.baseClasses) { - index(bc) = i; - i = i + 1 + index(bc) = i + i = i + 1 } } - private val subParents = new Array[BitSet](size); + private val subParents = new Array[BitSet](size) { for (val i <- List.range(0, size)) - subParents(i) = new BitSet(size); + subParents(i) = new BitSet(size); for (val p <- parents) { - val pIndex = index(p.symbol); - for (val bc <- p.baseClasses) include(subParents(index(bc)), pIndex); + val pIndex = index(p.symbol) + for (val bc <- p.baseClasses) include(subParents(index(bc)), pIndex) } } @@ -79,45 +89,45 @@ abstract class OverridingPairs { private def hasCommonParent(sym1: Symbol, sym2: Symbol) = { //assert(index.get(sym1.owner) != None, "" + base + " " + sym1 + " " + sym1.owner);//DEBUG //assert(index.get(sym2.owner) != None, "" + base + " " + sym2 + " " + sym2.owner);//DEBUG - val index1 = index(sym1.owner); - val index2 = index(sym2.owner); - val minindex = if (index1 < index2) index1 else index2; + val index1 = index(sym1.owner) + val index2 = index(sym2.owner) + val minindex = if (index1 < index2) index1 else index2 intersectionContainsElementLeq(subParents(index1), subParents(index2), minindex) } - private val visited = new HashSet[ScopeEntry](256); - private var curEntry = decls.elems; - private var nextEntry = curEntry; + private val visited = new HashSet[ScopeEntry](256) + private var curEntry = decls.elems + private var nextEntry = curEntry - var overriding: Symbol = _; - var overridden: Symbol = _; + var overriding: Symbol = _ + var overridden: Symbol = _ - def hasNext: boolean = curEntry != null; + def hasNext: boolean = curEntry != null def next: unit = if (curEntry != null) { - overriding = curEntry.sym; - if (nextEntry != null) { - do { - nextEntry = decls.lookupNextEntry(nextEntry); - } while (nextEntry != null && - ((nextEntry.sym hasFlag PRIVATE) || - (overriding.owner == nextEntry.sym.owner) || - (!matches(overriding, nextEntry.sym)) || - (hasCommonParent(overriding, nextEntry.sym)) || - (overriding hasFlag LOCAL))) - } - if (nextEntry != null) { - overridden = nextEntry.sym; - //System.out.println("yield: " + overriding + overriding.locationString + " / " + overridden + overridden.locationString);//DEBUG - visited addEntry nextEntry - } else { - do { - curEntry = curEntry.next - } while (curEntry != null && (visited contains curEntry)); - nextEntry = curEntry; - next - } + overriding = curEntry.sym + if (nextEntry != null) { + do { + nextEntry = decls.lookupNextEntry(nextEntry); + } while (nextEntry != null && + ((nextEntry.sym hasFlag PRIVATE) || + (overriding.owner == nextEntry.sym.owner) || + (!matches(overriding, nextEntry.sym)) || + (hasCommonParent(overriding, nextEntry.sym)) || + (overriding hasFlag LOCAL))) + } + if (nextEntry != null) { + overridden = nextEntry.sym; + //System.out.println("yield: " + overriding + overriding.locationString + " / " + overridden + overridden.locationString);//DEBUG + visited addEntry nextEntry + } else { + do { + curEntry = curEntry.next + } while (curEntry != null && (visited contains curEntry)); + nextEntry = curEntry + next + } } next diff --git a/src/compiler/scala/tools/nsc/transform/SampleTransform.scala b/src/compiler/scala/tools/nsc/transform/SampleTransform.scala index 404e03e572..8c1f4934df 100644 --- a/src/compiler/scala/tools/nsc/transform/SampleTransform.scala +++ b/src/compiler/scala/tools/nsc/transform/SampleTransform.scala @@ -1,23 +1,26 @@ -/* NSC -- new scala compiler - * Copyright 2005 LAMP/EPFL - * @author +/* NSC -- new Scala compiler + * Copyright 2005-2006 LAMP/EPFL + * @author Martin Odersky */ // $Id$ -package scala.tools.nsc.transform; + +package scala.tools.nsc.transform /** A sample transform. */ abstract class SampleTransform extends Transform { // inherits abstract value `global' and class `Phase' from Transform - import global._; // the global environment - import definitions._; // standard classes and methods - import typer.{typed, atOwner}; // methods to type trees - import posAssigner.atPos; // for filling in tree positions + import global._ // the global environment + import definitions._ // standard classes and methods + import typer.{typed, atOwner} // methods to type trees + import posAssigner.atPos // for filling in tree positions /** the following two members override abstract members in Transform */ - val phaseName: String = "sample-phase"; - protected def newTransformer(unit: CompilationUnit): Transformer = new SampleTransformer(unit); + val phaseName: String = "sample-phase" + + protected def newTransformer(unit: CompilationUnit): Transformer = + new SampleTransformer(unit) class SampleTransformer(unit: CompilationUnit) extends Transformer { diff --git a/src/compiler/scala/tools/nsc/transform/TailCalls.scala b/src/compiler/scala/tools/nsc/transform/TailCalls.scala index ccd1acebca..49c950363a 100644 --- a/src/compiler/scala/tools/nsc/transform/TailCalls.scala +++ b/src/compiler/scala/tools/nsc/transform/TailCalls.scala @@ -1,34 +1,41 @@ /* NSC -- new scala compiler * Copyright 2005 LAMP/EPFL - * @author + * @author Iulian Dragos */ // $Id$ + package scala.tools.nsc.transform; import scala.tools.nsc.symtab.Flags; /** Perform tail recursive call elimination. + * + * @author Iulian Dragos + * @version 1.0 */ abstract class TailCalls extends Transform /* with JavaLogging() */ { // inherits abstract value `global' and class `Phase' from Transform - import global._; // the global environment - import definitions._; // standard classes and methods - import typer.{typed, atOwner}; // methods to type trees - import posAssigner.atPos; // for filling in tree positions + import global._ // the global environment + import definitions._ // standard classes and methods + import typer.{typed, atOwner} // methods to type trees + import posAssigner.atPos // for filling in tree positions + + val phaseName: String = "tailcalls" - val phaseName: String = "tailcalls"; - def newTransformer(unit: CompilationUnit): Transformer = new TailCallElimination(unit); + def newTransformer(unit: CompilationUnit): Transformer = + new TailCallElimination(unit) /** Create a new phase which applies transformer */ - override def newPhase(prev: scala.tools.nsc.Phase): StdPhase = new Phase(prev); + override def newPhase(prev: scala.tools.nsc.Phase): StdPhase = new Phase(prev) /** The phase defined by this transform */ class Phase(prev: scala.tools.nsc.Phase) extends StdPhase(prev) { - def apply(unit: global.CompilationUnit): unit = if (!(settings.debuginfo.value == "notc")) { - newTransformer(unit).transformUnit(unit); - } + def apply(unit: global.CompilationUnit): unit = + if (!(settings.debuginfo.value == "notc")) { + newTransformer(unit).transformUnit(unit); + } } @@ -74,51 +81,51 @@ abstract class TailCalls extends Transform class Context { /** The current method */ - var currentMethod: Symbol = NoSymbol; + var currentMethod: Symbol = NoSymbol /** The current tail-call label */ - var label: Symbol = NoSymbol; + var label: Symbol = NoSymbol /** The expected type arguments of self-recursive calls */ - var tparams: List[Symbol] = Nil; + var tparams: List[Symbol] = Nil /** Tells whether we are in a (possible) tail position */ - var tailPos = false; + var tailPos = false /** Is the label accessed? */ - var accessed = false; + var accessed = false def this(that: Context) = { - this(); - this.currentMethod = that.currentMethod; - this.label = that.label; - this.tparams = that.tparams; - this.tailPos = that.tailPos; - this.accessed = that.accessed; + this() + this.currentMethod = that.currentMethod + this.label = that.label + this.tparams = that.tparams + this.tailPos = that.tailPos + this.accessed = that.accessed } /** Create a new method symbol for the current method and store it in * the label field. */ def makeLabel(): Unit = { - label = currentMethod.newLabel(currentMethod.pos, "_" + currentMethod.name); - accessed = false; + label = currentMethod.newLabel(currentMethod.pos, "_" + currentMethod.name) + accessed = false } override def toString(): String = ( "" + currentMethod.name + " tparams: " + tparams + " tailPos: " + tailPos + " accessed: " + accessed + "\nLabel: " + label + "\nLabel type: " + label.info - ); + ) } - private def mkContext(that: Context) = new Context(that); + private def mkContext(that: Context) = new Context(that) private def mkContext(that: Context, tp: Boolean): Context = { - val t = mkContext(that); - t.tailPos = tp; + val t = mkContext(that) + t.tailPos = tp t } - private var ctx: Context = new Context(); + private var ctx: Context = new Context() /** Rewrite this tree to contain no tail recursive calls */ def transform(tree: Tree, nctx: Context): Tree = { @@ -133,23 +140,23 @@ abstract class TailCalls extends Transform tree match { case DefDef(mods, name, tparams, vparams, tpt, rhs) => - log("Entering DefDef: " + name); - val newCtx = mkContext(ctx); - newCtx.currentMethod = tree.symbol; - newCtx.makeLabel(); - newCtx.label.setInfo(tree.symbol.info); - newCtx.tailPos = true; + log("Entering DefDef: " + name) + val newCtx = mkContext(ctx) + newCtx.currentMethod = tree.symbol + newCtx.makeLabel() + newCtx.label.setInfo(tree.symbol.info) + newCtx.tailPos = true val t1 = if (newCtx.currentMethod.isFinal || newCtx.currentMethod.enclClass.hasFlag(Flags.MODULE)) { - newCtx.tparams = Nil; - log(" Considering " + name + " for tailcalls"); + newCtx.tparams = Nil + log(" Considering " + name + " for tailcalls") tree.symbol.tpe match { case PolyType(tpes, restpe) => - newCtx.tparams = tparams map (.symbol); + newCtx.tparams = tparams map (.symbol) newCtx.label.setInfo( - restpe.substSym(tpes, tparams map (.symbol))); - case _ => (); + restpe.substSym(tpes, tparams map (.symbol))) + case _ => () } var newRHS = transform(rhs, newCtx); @@ -170,29 +177,29 @@ abstract class TailCalls extends Transform log("Leaving DefDef: " + name); t1; - case EmptyTree => tree; + case EmptyTree => tree - case PackageDef(name, stats) => super.transform(tree); + case PackageDef(name, stats) => super.transform(tree) case ClassDef(mods, name, tparams, tpt, impl) => - log("Entering class " + name); - val res = super.transform(tree); - log("Leaving class " + name); + log("Entering class " + name) + val res = super.transform(tree) + log("Leaving class " + name) res - case ValDef(mods, name, tpt, rhs) => tree; - case AbsTypeDef(mods, name, lo, hi) => tree; // (eliminated by erasure) - case AliasTypeDef(mods, name, tparams, rhs) => tree; // (eliminated by erasure) - case LabelDef(name, params, rhs) => super.transform(tree); + case ValDef(mods, name, tpt, rhs) => tree + case AbsTypeDef(mods, name, lo, hi) => tree // (eliminated by erasure) + case AliasTypeDef(mods, name, tparams, rhs) => tree // (eliminated by erasure) + case LabelDef(name, params, rhs) => super.transform(tree) - case Template(parents, body) => super.transform(tree); + case Template(parents, body) => super.transform(tree) case Block(stats, expr) => copy.Block(tree, transformTrees(stats, mkContext(ctx, false)), - transform(expr)); + transform(expr)) case CaseDef(pat, guard, body) => - copy.CaseDef(tree, pat, guard, transform(body)); + copy.CaseDef(tree, pat, guard, transform(body)) case Sequence(_) | Alternative(_) | Star(_) | Bind(_, _) => @@ -209,12 +216,12 @@ abstract class TailCalls extends Transform case Match(selector, cases) => //super.transform(tree); copy.Match(tree, transform(selector, mkContext(ctx, false)), transformTrees(cases).asInstanceOf[List[CaseDef]]); - case Return(expr) => super.transform(tree); - case Try(block, catches, finalizer) => super.transform(tree); + case Return(expr) => super.transform(tree) + case Try(block, catches, finalizer) => super.transform(tree) - case Throw(expr) => super.transform(tree); - case New(tpt) => super.transform(tree); - case Typed(expr, tpt) => super.transform(tree); + case Throw(expr) => super.transform(tree) + case New(tpt) => super.transform(tree) + case Typed(expr, tpt) => super.transform(tree) case Apply(tapply @ TypeApply(fun, targs), vargs) => if ( ctx.currentMethod.isFinal && @@ -226,7 +233,7 @@ abstract class TailCalls extends Transform copy.Apply(tree, tapply, transformTrees(vargs, mkContext(ctx, false))); case TypeApply(fun, args) => - super.transform(tree); + super.transform(tree) // throw new RuntimeException("Lonely TypeApply found -- we can only handle them inside Apply(TypeApply()): " + tree + " at: " + unit); case Apply(fun, args) => @@ -238,24 +245,24 @@ abstract class TailCalls extends Transform copy.Apply(tree, fun, transformTrees(args, mkContext(ctx, false))); case Super(qual, mix) => - tree; + tree case This(qual) => - tree; + tree case Select(qualifier, selector) => - tree; + tree case Ident(name) => - tree; + tree case Literal(value) => - tree; - case TypeTree() => tree; - + tree + case TypeTree() => + tree case _ => tree } } def transformTrees(trees: List[Tree], nctx: Context): List[Tree] = - trees map ((tree) => transform(tree, nctx)); + trees map ((tree) => transform(tree, nctx)) private def rewriteTailCall(fun: Tree, args: List[Tree]): Tree = { log("Rewriting tail recursive method call at: " + @@ -281,11 +288,11 @@ abstract class TailCalls extends Transform fun match { case Select(t @ This(_), _) => assert(t.symbol == ctx.currentMethod.owner, "This refers to other class: " + - t.symbol + ": " + ctx.currentMethod.owner); - true; + t.symbol + ": " + ctx.currentMethod.owner) + true - case Ident(_) => true; - case _ => false; + case Ident(_) => true + case _ => false } else false; diff --git a/src/compiler/scala/tools/nsc/transform/Transform.scala b/src/compiler/scala/tools/nsc/transform/Transform.scala index cfdf796f27..9aefaf7a8d 100644 --- a/src/compiler/scala/tools/nsc/transform/Transform.scala +++ b/src/compiler/scala/tools/nsc/transform/Transform.scala @@ -1,25 +1,29 @@ -/* NSC -- new scala compiler - * Copyright 2005 LAMP/EPFL - * @author +/* NSC -- new Scala compiler + * Copyright 2005-2006 LAMP/EPFL + * @author Martin Odersky */ // $Id$ + package scala.tools.nsc.transform; /** A base class for transforms. * A transform contains a compiler phase which applies a tree transformer. + * + * @author Martin Odersky + * @version 1.0 */ abstract class Transform extends SubComponent { /** The transformer factory */ - protected def newTransformer(unit: global.CompilationUnit): global.Transformer; + protected def newTransformer(unit: global.CompilationUnit): global.Transformer /** Create a new phase which applies transformer */ - def newPhase(prev: scala.tools.nsc.Phase): StdPhase = new Phase(prev); + def newPhase(prev: scala.tools.nsc.Phase): StdPhase = new Phase(prev) /** The phase defined by this transform */ class Phase(prev: scala.tools.nsc.Phase) extends StdPhase(prev) { def apply(unit: global.CompilationUnit): unit = { - newTransformer(unit).transformUnit(unit); + newTransformer(unit).transformUnit(unit) } } } |