diff options
Diffstat (limited to 'src/compiler/scala')
11 files changed, 145 insertions, 45 deletions
diff --git a/src/compiler/scala/tools/nsc/ast/NodePrinters.scala b/src/compiler/scala/tools/nsc/ast/NodePrinters.scala index 57e60f9fba..4292cb24a0 100644 --- a/src/compiler/scala/tools/nsc/ast/NodePrinters.scala +++ b/src/compiler/scala/tools/nsc/ast/NodePrinters.scala @@ -341,8 +341,6 @@ abstract class NodePrinters { } printcln(")") } else printcln(p.productPrefix) - case _ => - printcln("***" + tree.getClass) } } } diff --git a/src/compiler/scala/tools/nsc/ast/TreePrinters.scala b/src/compiler/scala/tools/nsc/ast/TreePrinters.scala index 4deccddde6..9e9b801d25 100644 --- a/src/compiler/scala/tools/nsc/ast/TreePrinters.scala +++ b/src/compiler/scala/tools/nsc/ast/TreePrinters.scala @@ -389,7 +389,7 @@ abstract class TreePrinters { } def print(tree: Tree) { - if (settings.Xprintpos.value) print("[" + tree.pos + "]") + if (settings.Xprintpos.value) print(tree.pos.show) printRaw( if (tree.isDef && tree.symbol != NoSymbol && tree.symbol.isInitialized) { tree match { diff --git a/src/compiler/scala/tools/nsc/ast/Trees.scala b/src/compiler/scala/tools/nsc/ast/Trees.scala index 5e930bb4fc..12c5c9c46d 100644 --- a/src/compiler/scala/tools/nsc/ast/Trees.scala +++ b/src/compiler/scala/tools/nsc/ast/Trees.scala @@ -96,7 +96,7 @@ trait Trees { // @M helper method for asserts that check consistency in kinding //def kindingIrrelevant(tp: Type) = (tp eq null) || phase.name == "erasure" || phase.erasedTypes - abstract class Tree { + abstract class Tree extends Product { { import util.Statistics if (Statistics.enabled) nodeCount += 1 @@ -159,6 +159,10 @@ trait Trees { /** Is there part of this tree which satisfies predicate `p'? */ def exists(p: Tree => Boolean): Boolean = !find(p).isEmpty + /** The direct children of this tree */ + def children(): Iterator[Tree] = + productElements filter (_.isInstanceOf[Tree]) map (_.asInstanceOf[Tree]) + override def toString(): String = { val buffer = new StringWriter() val printer = treePrinters.create(new PrintWriter(buffer)) @@ -190,10 +194,7 @@ trait Trees { i += 1 } } - this match { - case p : Product => g(p) - case _ => - } + g(this) hc } def equalsStructure(that : Tree) = equalsStructure0(that){case (t0,t1) => false} @@ -1788,6 +1789,7 @@ trait Trees { override def end: Int = original.pos.end override def underlying = original.pos.underlying override def focus = original.pos.focus + override def show = "["+underlying.show+"]" } } diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index 0aa4907fc6..4254be02d5 100755 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -114,6 +114,7 @@ self => def freshName(pos: Position, prefix: String): Name def o2p(offset: Int): Position def r2p(start: Int, mid: Int, end: Int): Position + def t2p(tree: Tree): Position = SyntheticPosition(tree) //private implicit def p2i(pos: Position) = pos.offset.get /** whether a non-continuable syntax error has been seen */ @@ -370,7 +371,7 @@ self => */ def joinComment(trees: => List[Tree]): List[Tree] = { val buf = in.flushDoc - if ((buf ne null) && buf.length > 0) trees map (t => DocDef(buf, t) setPos t.pos) + if ((buf ne null) && buf.length > 0) trees map (t => DocDef(buf, t) setPos t.pos) // !!! take true comment position else trees } @@ -403,13 +404,13 @@ self => tree match { case Ident(name) => removeAsPlaceholder(name) - ValDef(Modifiers(Flags.PARAM), name, TypeTree(), EmptyTree) + ValDef(Modifiers(Flags.PARAM), name, TypeTree() setPos o2p(tree.pos.end), EmptyTree) case Typed(tree @ Ident(name), tpe) if (tpe.isType) => // get the ident! removeAsPlaceholder(name) ValDef(Modifiers(Flags.PARAM), name, tpe, EmptyTree) case _ => syntaxError(tree.pos, "not a legal formal parameter", false) - ValDef(Modifiers(Flags.PARAM), nme.ERROR, errorTypeTree, EmptyTree) + ValDef(Modifiers(Flags.PARAM), nme.ERROR, errorTypeTree setPos o2p(tree.pos.end), EmptyTree) } } @@ -812,7 +813,7 @@ self => def wildcardType(start: Int) = { val pname = freshName(o2p(start), "_$").toTypeName val t = atPos(start) { Ident(pname) } - val param = atPos(start) { makeSyntheticTypeParam(pname, typeBounds()) } + val param = atPos(t2p(t)) { makeSyntheticTypeParam(pname, typeBounds()) } placeholderTypes = param :: placeholderTypes t } @@ -1130,12 +1131,12 @@ self => path(true, false) case USCORE => val start = in.offset - atPos(in.skipToken()) { - val pname = freshName(o2p(start), "x$") - val param = atPos(start){ makeSyntheticParam(pname) } - placeholderParams = param :: placeholderParams - Ident(pname) - } + val pname = freshName(o2p(start), "x$") + val id = atPos(start) (Ident(pname)) + in.nextToken() + val param = atPos(t2p(id)){ makeSyntheticParam(pname) } + placeholderParams = param :: placeholderParams + id case LPAREN => atPos(in.skipToken()) { val ts = if (in.token == RPAREN) List() else exprs() diff --git a/src/compiler/scala/tools/nsc/interactive/Global.scala b/src/compiler/scala/tools/nsc/interactive/Global.scala index 0ad7c1b5aa..44001b4b64 100755 --- a/src/compiler/scala/tools/nsc/interactive/Global.scala +++ b/src/compiler/scala/tools/nsc/interactive/Global.scala @@ -28,8 +28,8 @@ self => /** The currently active typer run */ private var currentTyperRun: TyperRun = _ - /** Is a background compiler currently running? */ - private var compiling = false + /** Is a background compiler run needed? */ + private var outOfDate = false /** Is a reload/ background compiler currently running? */ private var acting = false @@ -84,7 +84,7 @@ self => def pollForWork() { scheduler.pollException() match { case Some(ex: CancelActionReq) => if (acting) throw ex - case Some(ex: FreshRunReq) => if (compiling) throw ex + case Some(ex: FreshRunReq) => if (outOfDate) throw ex case Some(ex: Throwable) => throw ex case _ => } @@ -115,16 +115,13 @@ self => while (true) { scheduler.waitForMoreWork() pollForWork() - var continue = true - while (continue) { + while (outOfDate) { try { - compiling = true backgroundCompile() - continue = false } catch { case ex: FreshRunReq => } finally { - compiling = false + outOfDate = false } } } @@ -190,6 +187,7 @@ self => val unit = new RichCompilationUnit(source) unitOfFile(source.file) = unit currentTyperRun.compileLate(unit) + validatePositions(unit.body) unit.status = JustParsed } moveToFront(sources) @@ -199,7 +197,8 @@ self => result set Right(ex) throw ex } - if (compiling) throw new FreshRunReq + if (outOfDate) throw new FreshRunReq + else outOfDate = true } /** Set sync var `result` to a fully attributed tree located at position `pos` */ @@ -218,6 +217,29 @@ self => // ---------------- Helper classes --------------------------- + + def validatePositions(tree: Tree) { + def check(condition: Boolean, msg: => String) { + if (!condition) { + println("**** bad positions:") + println(msg) + println("================= in =================") + println(tree) + } + } + def validate(tree: Tree, encltree: Tree, lefttree: Tree) { + if (encltree.pos.isSynthetic) check(tree.pos.isSynthetic, "synthetic "+encltree+" contains nonsynthetic" + tree) + check(encltree.pos includes tree.pos, encltree+" does not include "+tree) + if (lefttree != EmptyTree) check(lefttree.pos precedes tree.pos, lefttree+" does not not precede "+tree) + var newleft: Tree = EmptyTree + for (ct <- tree.children) { + validate(ct, tree, newleft) + newleft = ct + } + } + validate(tree, tree, EmptyTree) + } + /** A transformer that replaces tree `from` with tree `to` in a given tree */ class TreeReplacer(from: Tree, to: Tree) extends Transformer { override def transform(t: Tree): Tree = { @@ -262,6 +284,7 @@ self => */ def typedTreeAt(pos: Position): Tree = { val tree = locateTree(pos) +// println("at pos "+pos+" was found: "+tree) if (tree.tpe ne null) tree else { val unit = unitOf(pos) diff --git a/src/compiler/scala/tools/nsc/interactive/REPL.scala b/src/compiler/scala/tools/nsc/interactive/REPL.scala index 58477dd693..e773f9f281 100644 --- a/src/compiler/scala/tools/nsc/interactive/REPL.scala +++ b/src/compiler/scala/tools/nsc/interactive/REPL.scala @@ -9,12 +9,66 @@ import scala.tools.nsc.io._ /** Interface of interactive compiler to a client such as an IDE */ -object REPL extends EvalLoop { +object REPL { - val settings = new Settings() - val comp = new Global(settings, new ConsoleReporter(settings)) + val versionMsg = "Scala compiler " + + Properties.versionString + " -- " + + Properties.copyrightString - def prompt = "> " + val prompt = "> " + + var reporter: ConsoleReporter = _ + + def error(msg: String) { + reporter.error(/*new Position */FakePos("scalac"), + msg + "\n scalac -help gives more information") + } + + def process(args: Array[String]) { + val settings = new Settings(error) + reporter = new ConsoleReporter(settings) + val command = new CompilerCommand(args.toList, settings, error, false) + if (command.settings.version.value) + reporter.info(null, versionMsg, true) + else { + try { + object compiler extends Global(command.settings, reporter) + if (reporter.hasErrors) { + reporter.flush() + return + } + if (command.shouldStopWithInfo) { + reporter.info(null, command.getInfoMessage(compiler), true) + } else { + run(compiler) + } + } catch { + case ex @ FatalError(msg) => + if (true || command.settings.debug.value) // !!! + ex.printStackTrace(); + reporter.error(null, "fatal error: " + msg) + } + } + } + + def main(args: Array[String]) { + process(args) + exit(if (reporter.hasErrors) 1 else 0) + } + + def loop(action: (String) => Unit) { + Console.print(prompt) + try { + val line = Console.readLine + if (line.length() > 0) { + action(line) + } + loop(action) + } + catch { + case _: java.io.EOFException => //nop + } + } /** Commands: * @@ -23,12 +77,10 @@ object REPL extends EvalLoop { * * */ - def run() { + def run(comp: Global) { val reloadResult = new SyncVar[Either[Unit, Throwable]] val typeatResult = new SyncVar[Either[comp.Tree, Throwable]] loop { line => - println("["+line+"]") - println((line split " ").toList) (line split " ").toList match { case "reload" :: args => comp.askReload(args map toSourceFile, reloadResult) @@ -55,8 +107,4 @@ object REPL extends EvalLoop { case Right(exc/*: Throwable ??*/) => exc.printStackTrace; println("ERROR: "+exc) } } - - def main(args: Array[String]) { - run() - } } diff --git a/src/compiler/scala/tools/nsc/symtab/Definitions.scala b/src/compiler/scala/tools/nsc/symtab/Definitions.scala index ca8ad48224..03783d054c 100644 --- a/src/compiler/scala/tools/nsc/symtab/Definitions.scala +++ b/src/compiler/scala/tools/nsc/symtab/Definitions.scala @@ -37,6 +37,9 @@ trait Definitions { lazy val ScalaPackage: Symbol = getModule("scala") lazy val ScalaPackageClass: Symbol = ScalaPackage.tpe.typeSymbol + lazy val ScalaCollectionImmutablePackage: Symbol = getModule("scala.collection.immutable") + lazy val ScalaCollectionImmutablePackageClass: Symbol = ScalaCollectionImmutablePackage.tpe.typeSymbol + var AnyClass: Symbol = _ var AnyValClass: Symbol = _ var AnyRefClass: Symbol = _ @@ -111,6 +114,7 @@ trait Definitions { def Iterable_hasNext = getMember(IterableClass, nme.hasNext) lazy val IteratorClass: Symbol = getClass2("scala.Iterator", "scala.collection.Iterator") lazy val SeqClass: Symbol = getClass2("scala.Seq", "scala.collection.Sequence") + lazy val SeqModule: Symbol = getModule2("scala.Seq", "scala.collection.Sequence") lazy val TraversableClass: Symbol = getClass("scala.collection.Traversable") lazy val RandomAccessSeqMutableClass: Symbol = getMember( getModule2("scala.RandomAccessSeq", "scala.collection.Vector"), nme.Mutable) diff --git a/src/compiler/scala/tools/nsc/symtab/StdNames.scala b/src/compiler/scala/tools/nsc/symtab/StdNames.scala index bb04630985..f19a8e5138 100644 --- a/src/compiler/scala/tools/nsc/symtab/StdNames.scala +++ b/src/compiler/scala/tools/nsc/symtab/StdNames.scala @@ -234,6 +234,7 @@ trait StdNames { val Function = newTermName("Function") val Function1 = newTermName("Function1") val Int = newTermName("Int") + val List = newTermName("List") val Long = newTermName("Long") val Nil = newTermName("Nil") val Object = newTermName("Object") diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 89e2028ded..68ae453793 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -560,10 +560,25 @@ trait Typers { self: Analyzer => /** Make symbol accessible. This means: * If symbol refers to package object, insert `.package` as second to last selector. - * Call checkAccessible, which sets symbol's attributes. + * (exception for some symbols in scala package which are dealiased immediately) + * Call checkAccessible, which sets tree's attributes. + * @return modified tree and new prefix type */ - private def makeAccessible(tree: Tree, sym: Symbol, pre: Type, site: Tree): Tree = + private def makeAccessible(tree: Tree, sym: Symbol, pre: Type, site: Tree): (Tree, Type) = if (isInPackageObject(sym, pre.typeSymbol)) { + if (pre.typeSymbol == ScalaPackageClass && sym.isTerm) { + // short cut some aliases. It seems that without that pattern matching + // fails to notice exhaustiveness and to generate good code when + // List extractors are mixed with :: patterns. See Test5 in lists.scala. + def dealias(sym: Symbol) = + (atPos(tree.pos) { gen.mkAttributedRef(sym) }, sym.owner.thisType) + sym.name match { + case nme.List => return dealias(ListModule) + case nme.Seq => return dealias(SeqModule) + case nme.Nil => return dealias(NilModule) + case _ => + } + } val qual = typedQualifier { tree match { case Ident(_) => Ident(nme.PACKAGEkw) @@ -578,10 +593,9 @@ trait Typers { self: Analyzer => case SelectFromTypeTree(_, name) => SelectFromTypeTree(qual, name) } } - val tree2 = checkAccessible(tree1, sym, qual.tpe, qual) - tree2 + (checkAccessible(tree1, sym, qual.tpe, qual), qual.tpe) } else { - checkAccessible(tree, sym, pre, site) + (checkAccessible(tree, sym, pre, site), pre) } private def isInPackageObject(sym: Symbol, pkg: Symbol) = @@ -2943,7 +2957,8 @@ trait Typers { self: Analyzer => case SelectFromTypeTree(_, _) => copy.SelectFromTypeTree(tree, qual, name) } //if (name.toString == "Elem") println("typedSelect "+qual+":"+qual.tpe+" "+sym+"/"+tree1+":"+tree1.tpe) - val result = stabilize(makeAccessible(tree1, sym, qual.tpe, qual), qual.tpe, mode, pt) + val (tree2, pre2) = makeAccessible(tree1, sym, qual.tpe, qual) + val result = stabilize(tree2, pre2, mode, pt) def isPotentialNullDeference() = { phase.id <= currentRun.typerPhase.id && !sym.isConstructor && @@ -3103,7 +3118,8 @@ trait Typers { self: Analyzer => val tree1 = if (qual == EmptyTree) tree else atPos(tree.pos)(Select(qual, name)) // atPos necessary because qualifier might come from startContext - stabilize(makeAccessible(tree1, defSym, pre, qual), pre, mode, pt) + val (tree2, pre2) = makeAccessible(tree1, defSym, pre, qual) + stabilize(tree2, pre2, mode, pt) } } diff --git a/src/compiler/scala/tools/nsc/util/Position.scala b/src/compiler/scala/tools/nsc/util/Position.scala index bd60035a5a..48343fd948 100644 --- a/src/compiler/scala/tools/nsc/util/Position.scala +++ b/src/compiler/scala/tools/nsc/util/Position.scala @@ -98,6 +98,7 @@ trait Position { }) } + def show: String = "["+toString+"]" } case object NoPosition extends Position @@ -114,6 +115,7 @@ case class OffsetPosition(source0: SourceFile, offset0: Int) extends Position { case that => false } override def hashCode = offset0 * 37 + source0.file.hashCode + override def show = "["+point+"]" } /** new for position ranges */ @@ -125,6 +127,7 @@ extends OffsetPosition(source0, point) { override def endOrElse(d: Int) = end override def focus = OffsetPosition(source0, point) override def toString = "RangePosition("+source0+", "+start+", "+point+", "+end+")" + override def show = "["+start+":"+end+"]" } diff --git a/src/compiler/scala/tools/nsc/util/trace.scala b/src/compiler/scala/tools/nsc/util/trace.scala index a24a18ec45..dc78756ec6 100644 --- a/src/compiler/scala/tools/nsc/util/trace.scala +++ b/src/compiler/scala/tools/nsc/util/trace.scala @@ -5,4 +5,8 @@ object trace { println(msg+value) value } + def withFun[T, U](msg: String)(value: T)(fun: T => U): T = { + println(msg+fun(value)) + value + } } |