diff options
Diffstat (limited to 'src/compiler')
20 files changed, 304 insertions, 253 deletions
diff --git a/src/compiler/scala/tools/nsc/CompilationUnits.scala b/src/compiler/scala/tools/nsc/CompilationUnits.scala index ea2c466be4..b38ac01c8a 100644 --- a/src/compiler/scala/tools/nsc/CompilationUnits.scala +++ b/src/compiler/scala/tools/nsc/CompilationUnits.scala @@ -69,7 +69,7 @@ trait CompilationUnits { self: Global => override def toString() = source.toString() - def clear() = { + def clear() { fresh = null body = null depends.clear diff --git a/src/compiler/scala/tools/nsc/CompileServer.scala b/src/compiler/scala/tools/nsc/CompileServer.scala index 8b4767018c..dd3133acdb 100644 --- a/src/compiler/scala/tools/nsc/CompileServer.scala +++ b/src/compiler/scala/tools/nsc/CompileServer.scala @@ -48,7 +48,6 @@ class StandardCompileServer extends SocketServer { var reporter: ConsoleReporter = _ - /** Create a new compiler instance */ def newGlobal(settings: Settings, reporter: Reporter) = new Global(settings, reporter) { diff --git a/src/compiler/scala/tools/nsc/CompileSocket.scala b/src/compiler/scala/tools/nsc/CompileSocket.scala index f5fe702e7a..c22181eabf 100644 --- a/src/compiler/scala/tools/nsc/CompileSocket.scala +++ b/src/compiler/scala/tools/nsc/CompileSocket.scala @@ -251,15 +251,15 @@ class CompileSocket { } def getPassword(port: Int): String = { - val ff=portFile(port) + val ff = portFile(port) val f = new BufferedReader(new FileReader(ff)) // allow some time for the server to start up - var retry=50 - while (ff.length()==0 && retry>0) { + var retry = 50 + while (ff.length() == 0 && retry > 0) { Thread.sleep(100) - retry-=1 + retry -= 1 } - if (ff.length()==0) { + if (ff.length() == 0) { ff.delete() fatal("Unable to establish connection to server.") } diff --git a/src/compiler/scala/tools/nsc/CompilerCommand.scala b/src/compiler/scala/tools/nsc/CompilerCommand.scala index c5c7f84434..7896f4e270 100644 --- a/src/compiler/scala/tools/nsc/CompilerCommand.scala +++ b/src/compiler/scala/tools/nsc/CompilerCommand.scala @@ -77,33 +77,33 @@ class CompilerCommand( // start; an informative message of some sort // should be printed instead. // (note: do not add "files.isEmpty" do this list) - val stopSettings=List[(()=>Boolean, - (Global)=>String)]( - (()=> settings.help.value, compiler => - usageMsg + compiler.pluginOptionsHelp + val stopSettings = List[(() => Boolean, (Global) => String)]( + (() => settings.help.value, + compiler => usageMsg + compiler.pluginOptionsHelp ), - (()=> settings.Xhelp.value, compiler => - xusageMsg + (() => settings.Xhelp.value, + compiler => xusageMsg ), - (()=> settings.Yhelp.value, compiler => - yusageMsg + (() => settings.Yhelp.value, + compiler => yusageMsg ), - (()=> settings.showPlugins.value, compiler => - compiler.pluginDescriptions + (() => settings.showPlugins.value, + compiler => compiler.pluginDescriptions ), - (()=> settings.showPhases.value, compiler => - compiler.phaseDescriptions + (() => settings.showPhases.value, + compiler => compiler.phaseDescriptions ) ) - def shouldStopWithInfo = stopSettings.exists({pair => (pair._1)()}) - def getInfoMessage(compiler:Global) = - stopSettings.find({pair => (pair._1)()}) match { - case Some((test,getMessage)) => getMessage(compiler) + def shouldStopWithInfo: Boolean = + stopSettings.exists(pair => (pair._1)()) + + def getInfoMessage(compiler: Global): String = + stopSettings.find(pair => (pair._1)()) match { + case Some((test, getMessage)) => getMessage(compiler) case None => "" } - /** Whether the command was processed okay */ var ok = true diff --git a/src/compiler/scala/tools/nsc/IdeSupport.scala b/src/compiler/scala/tools/nsc/IdeSupport.scala index 91e7ea47a1..ab1580e124 100644 --- a/src/compiler/scala/tools/nsc/IdeSupport.scala +++ b/src/compiler/scala/tools/nsc/IdeSupport.scala @@ -1,12 +1,21 @@ +/* NSC -- new Scala compiler + * Copyright 2005-2009 LAMP/EPFL + * @author Martin Odersky + */ +// $Id$ + package scala.tools.nsc + import scala.tools.nsc.io._ + trait IdeSupport extends Global with symtab.IdeSupport { /** to do no dependency tracking */ - protected def normalCompile[T](f : => T) : T = f - override def unpickleIDEHook : (( => Type) => Type) = f => normalCompile(f) + protected def normalCompile[T](f: => T): T = f + override def unpickleIDEHook: (( => Type) => Type) = f => normalCompile(f) + class IdeRun extends Run { - override def compiles(sym : Symbol) : Boolean = false // throw new Error - override def compileLate(file : AbstractFile) = { + override def compiles(sym: Symbol): Boolean = false // throw new Error + override def compileLate(file: AbstractFile) = { reloadSource(file) normalCompile(super.compileLate(file)) } @@ -14,29 +23,32 @@ trait IdeSupport extends Global with symtab.IdeSupport { name == "superaccessors" || super.stopPhase(name) } - // load a source file without us caring about adapt. - def loadSource(file : AbstractFile) : Option[CompilationUnit] = { + def loadSource(file: AbstractFile): Option[CompilationUnit] = { val run = new IdeRun reloadSource(file) val source = getSourceFile(file) try { normalCompile(run.compileSources(source :: Nil)) - run.units.find(unit => unit.source == source) + run.units.find(_.source == source) } catch { case e => logError("error in presentation normal compile ", e) None } } + object loaders1 extends { - val global : IdeSupport.this.type = IdeSupport.this + val global: IdeSupport.this.type = IdeSupport.this } with scala.tools.nsc.symtab.SymbolLoaders { import global._ - protected override def completeClassfile(root : global.Symbol, loader : ClassfileLoader)(f : => Unit) : Unit = + protected override def completeClassfile(root: global.Symbol, loader: ClassfileLoader)(f: => Unit) { global.normalCompile(f) - override def computeDepends(from : PackageLoader) : global.PackageScopeDependMap = IdeSupport.this.computeDepends(from.asInstanceOf[IdeSupport.this.loaders.PackageLoader]) + } + override def computeDepends(from: PackageLoader): global.PackageScopeDependMap = + IdeSupport.this.computeDepends(from.asInstanceOf[IdeSupport.this.loaders.PackageLoader]) } - def computeDepends(from : loaders.PackageLoader) : PackageScopeDependMap = null + + def computeDepends(from: loaders.PackageLoader): PackageScopeDependMap = null override lazy val loaders = loaders1 } diff --git a/src/compiler/scala/tools/nsc/Interpreter.scala b/src/compiler/scala/tools/nsc/Interpreter.scala index a41198a97a..df14417565 100644 --- a/src/compiler/scala/tools/nsc/Interpreter.scala +++ b/src/compiler/scala/tools/nsc/Interpreter.scala @@ -94,7 +94,7 @@ class Interpreter(val settings: Settings, out: PrintWriter) { /** Be quiet. Do not print out the results of each * submitted command unless an exception is thrown. */ - def beQuiet = { printResults = false } + def beQuiet { printResults = false } /** Temporarily be quiet */ def beQuietDuring[T](operation: => T): T = { @@ -111,7 +111,9 @@ class Interpreter(val settings: Settings, out: PrintWriter) { lazy val isettings = new InterpreterSettings object reporter extends ConsoleReporter(settings, null, out) { - override def printMessage(msg: String) { out.print(clean(msg) + "\n"); out.flush() } + override def printMessage(msg: String) { + out.print(clean(msg) + "\n"); out.flush() + } } /** Instantiate a compiler. Subclasses can override this to @@ -934,4 +936,4 @@ object Interpreter { } res.toString } -}
\ No newline at end of file +} diff --git a/src/compiler/scala/tools/nsc/PhaseAssembly.scala b/src/compiler/scala/tools/nsc/PhaseAssembly.scala index 1b5306eb0e..f2abe0ca21 100644 --- a/src/compiler/scala/tools/nsc/PhaseAssembly.scala +++ b/src/compiler/scala/tools/nsc/PhaseAssembly.scala @@ -1,21 +1,14 @@ -/* __ *\ -** ________ ___ / / ___ Scala Compiler ** -** / __/ __// _ | / / / _ | (c) 2008-2009 , LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ -/** - * +/* NSC -- new Scala compiler + * Copyright 2007-2009 LAMP/EPFL * @author Anders Bach Nielsen * @version 1.0 - * $Id$ */ +// $Id$ package scala.tools.nsc -import scala.collection.mutable.{HashSet,HashMap} -import java.io.{BufferedWriter,FileWriter} +import scala.collection.mutable.{HashSet, HashMap} +import java.io.{BufferedWriter, FileWriter} /** * PhaseAssembly @@ -40,7 +33,7 @@ trait PhaseAssembly { self: Global => * Simple node with name and object ref for the phase object, * also sets of in and out going dependencies */ - class Node(name:String) { + class Node(name: String) { val phasename = name var phaseobj: Option[List[SubComponent]] = None val after = new HashSet[Edge]() @@ -50,7 +43,7 @@ trait PhaseAssembly { self: Global => def allPhaseNames(): String = phaseobj match { case None => phasename - case Some(lst) => lst.map(sc => sc.phaseName).reduceLeft( (x,y) => x + "," + y) + case Some(lst) => lst.map(_.phaseName).reduceLeft(_+","+_) } } @@ -60,8 +53,8 @@ trait PhaseAssembly { self: Global => /* Given a phase object, get the node for this phase object. If the * node object does not exist, then create it. */ - def getNodeByPhase(phs : SubComponent) : Node = { - var node : Node = getNodeByPhase(phs.phaseName) + def getNodeByPhase(phs: SubComponent): Node = { + var node: Node = getNodeByPhase(phs.phaseName) node.phaseobj match { case None => node.phaseobj = Some(List[SubComponent](phs)) @@ -73,7 +66,7 @@ trait PhaseAssembly { self: Global => /* Given the name of a phase object, get the node for that name. If the * node object does not exits, then create it. */ - def getNodeByPhase(name : String) : Node = { + def getNodeByPhase(name: String): Node = { nodes.get(name).getOrElse { val node = new Node(name) nodes += (name -> node) @@ -108,46 +101,48 @@ trait PhaseAssembly { self: Global => /* Given the entire graph, collect the phase objects at each level, where the phase * names are sorted alphabetical at each level, into the compiler phase list */ - def compilerPhaseList() : List[SubComponent] = { - var chain : List[SubComponent] = Nil + def compilerPhaseList(): List[SubComponent] = { + var chain: List[SubComponent] = Nil var lvl = 1 - var nds = nodes.values.filter(n => (n.level == lvl)).toList + var nds = nodes.values.filter(_.level == lvl).toList while(nds.size > 0) { nds = nds.sort((n1,n2) => (n1.phasename compareTo n2.phasename) < 0) - for( n <- nds ) { + for (n <- nds) { chain = chain ::: n.phaseobj.get } - lvl = lvl + 1 - nds = nodes.values.filter(n => (n.level == lvl)).toList + lvl += 1 + nds = nodes.values.filter(_.level == lvl).toList } - return chain + chain } /* Test if there are cycles in the graph, assign levels to the nodes * and collapse hard links into nodes */ - def collapseHardLinksAndLevels(node : Node, lvl: Int) : Unit = { + def collapseHardLinksAndLevels(node: Node, lvl: Int) { if (node.visited) { - throw new FatalError("Cycle in compiler phase dependencies detected, phase " + node.phasename + " reacted twice!") + throw new FatalError( + "Cycle in compiler phase dependencies detected, phase " + + node.phasename + " reacted twice!") } if (node.level < lvl) node.level = lvl - var hls = Nil ++ node.before.filter( e => e.hard ) - while( hls.size > 0 ) { - for( hl <- hls ) { + var hls = Nil ++ node.before.filter(_.hard) + while (hls.size > 0) { + for (hl <- hls) { node.phaseobj = Some(node.phaseobj.get ++ hl.frm.phaseobj.get) node.before = hl.frm.before nodes -= hl.frm.phasename edges -= hl - for( edge <- node.before ) edge.to = node + for (edge <- node.before) edge.to = node } - hls = Nil ++ node.before.filter( e => e.hard ) + hls = Nil ++ node.before.filter(_.hard) } node.visited = true - for( edge <- node.before ) { + for (edge <- node.before) { collapseHardLinksAndLevels( edge.frm, lvl + 1) } @@ -158,20 +153,20 @@ trait PhaseAssembly { self: Global => * need to check that its the only dependency. If not, then we will promote the * other dependencies down */ - def validateAndEnforceHardlinks() : Unit = { - var hardlinks = edges.filter(e => e.hard) - for(hl <- hardlinks) { + def validateAndEnforceHardlinks() { + var hardlinks = edges.filter(_.hard) + for (hl <- hardlinks) { if (hl.frm.after.size > 1) { throw new FatalError("phase " + hl.frm.phasename + " want to run right after " + hl.to.phasename + ", but some phase has declared to run before " + hl.frm.phasename + ". Re-run with -Xgenerate-phase-graph <filename> to better see the problem.") } } var rerun = true - while(rerun) { + while (rerun) { rerun = false - hardlinks = edges.filter(e => e.hard) - for(hl <- hardlinks) { - var sanity = Nil ++ hl.to.before.filter(e => e.hard) + hardlinks = edges.filter(_.hard) + for (hl <- hardlinks) { + var sanity = Nil ++ hl.to.before.filter(_.hard) if (sanity.length == 0) { throw new FatalError("There is no runs right after dependency, where there should be one! This is not supposed to happen!") } else if (sanity.length > 1) { @@ -191,7 +186,9 @@ trait PhaseAssembly { self: Global => sanity foreach (edge => hl.to.before += edge) for (edge <- promote) { rerun = true - informProgress("promote the dependency of " + edge.frm.phasename + ": " + edge.to.phasename + " => " + hl.frm.phasename) + informProgress( + "promote the dependency of " + edge.frm.phasename + + ": " + edge.to.phasename + " => " + hl.frm.phasename) edge.to = hl.frm hl.frm.before += edge } @@ -200,20 +197,22 @@ trait PhaseAssembly { self: Global => } } - /* Remove all nodes in the given graph, that have no phase object - * Make sure to clean up all edges when removing the node object - * Inform with warnings, if an external phase has a dependency on something that is dropped. + /** Remove all nodes in the given graph, that have no phase object + * Make sure to clean up all edges when removing the node object + * <code>Inform</code> with warnings, if an external phase has a + * dependency on something that is dropped. */ - def removeDanglingNodes() : Unit = { - var dnodes = nodes.values.filter(n => n.phaseobj.isEmpty ) - for(node <- dnodes) { - informProgress("dropping dependency on node with no phase object: " + node.phasename) + def removeDanglingNodes() { + var dnodes = nodes.values.filter(_.phaseobj.isEmpty) + for (node <- dnodes) { + val msg = "dropping dependency on node with no phase object: "+node.phasename + informProgress(msg) nodes -= node.phasename - for(edge <- node.before) { + for (edge <- node.before) { edges -= edge edge.frm.after -= edge edge.frm.phaseobj match { - case Some(lsc) => if (! lsc.head.internal) warning("dropping dependency on node with no phase object: " + node.phasename) + case Some(lsc) => if (! lsc.head.internal) warning(msg) case _ => } } @@ -222,71 +221,73 @@ trait PhaseAssembly { self: Global => } - /* Method called from computePhaseDescriptors in class Global */ - def buildCompilerFromPhasesSet() : List[SubComponent] = { + def buildCompilerFromPhasesSet(): List[SubComponent] = { // Add all phases in the set to the graph val graph = phasesSetToDepGraph(phasesSet) // Output the phase dependency graph at this stage - if (!(settings.genPhaseGraph.value == "")) graphToDotFile(graph, settings.genPhaseGraph.value + "1.dot") + if (settings.genPhaseGraph.value != "") + graphToDotFile(graph, settings.genPhaseGraph.value + "1.dot") // Remove nodes without phaseobj graph.removeDanglingNodes() // Output the phase dependency graph at this stage - if (!(settings.genPhaseGraph.value == "")) graphToDotFile(graph, settings.genPhaseGraph.value + "2.dot") + if (settings.genPhaseGraph.value != "") + graphToDotFile(graph, settings.genPhaseGraph.value + "2.dot") // Validate and Enforce hardlinks / runsRightAfter and promote nodes down the tree graph.validateAndEnforceHardlinks() // Output the phase dependency graph at this stage - if (!(settings.genPhaseGraph.value == "")) graphToDotFile(graph, settings.genPhaseGraph.value + "3.dot") + if (settings.genPhaseGraph.value != "") + graphToDotFile(graph, settings.genPhaseGraph.value + "3.dot") // test for cycles, assign levels and collapse hard links into nodes graph.collapseHardLinksAndLevels(graph.getNodeByPhase("parser"), 1) // Output the phase dependency graph at this stage - if (!(settings.genPhaseGraph.value == "")) graphToDotFile(graph, settings.genPhaseGraph.value + "4.dot") + if (settings.genPhaseGraph.value != "") + graphToDotFile(graph, settings.genPhaseGraph.value + "4.dot") // assemble the compiler - return graph.compilerPhaseList() + graph.compilerPhaseList() } - - /* Given the phases set, will build a dependency graph from the phases set - * Using the aux. method of the DependencyGraph to create nodes and egdes + /** Given the phases set, will build a dependency graph from the phases set + * Using the aux. method of the DependencyGraph to create nodes and egdes. */ - private def phasesSetToDepGraph(phsSet : HashSet[SubComponent]) : DependencyGraph = { + private def phasesSetToDepGraph(phsSet: HashSet[SubComponent]): DependencyGraph = { val graph = new DependencyGraph() - for(phs <- phsSet) { + for (phs <- phsSet) { var fromnode = graph.getNodeByPhase(phs) phs.runsRightAfter match { case None => - for(phsname <- phs.runsAfter) { - if (! (phsname == "terminal")) { - var tonode = graph.getNodeByPhase(phsname) + for (phsname <- phs.runsAfter) { + if (phsname != "terminal") { + val tonode = graph.getNodeByPhase(phsname) graph.softConnectNodes(fromnode, tonode) } else { error("[phase assembly, after dependency on terminal phase not allowed: " + fromnode.phasename + " => "+ phsname + "]") } } - for(phsname <- phs.runsBefore) { - if (! (phsname == "parser")) { - var tonode = graph.getNodeByPhase(phsname) + for (phsname <- phs.runsBefore) { + if (phsname != "parser") { + val tonode = graph.getNodeByPhase(phsname) graph.softConnectNodes(tonode, fromnode) } else { error("[phase assembly, before dependency on parser phase not allowed: " + phsname + " => "+ fromnode.phasename + "]") } } case Some(phsname) => - if (! (phsname == "terminal")) { - var tonode = graph.getNodeByPhase(phsname) + if (phsname != "terminal") { + val tonode = graph.getNodeByPhase(phsname) graph.hardConnectNodes(fromnode, tonode) } else { error("[phase assembly, right after dependency on terminal phase not allowed: " + fromnode.phasename + " => "+ phsname + "]") @@ -300,12 +301,12 @@ trait PhaseAssembly { self: Global => * file showing its structure. * Plug-in supplied phases are marked as green nodes and hard links are marked as blue edges. */ - private def graphToDotFile(graph : DependencyGraph, filename : String) : Unit = { - var sbuf = new StringBuffer() + private def graphToDotFile(graph: DependencyGraph, filename: String) { + var sbuf = new StringBuilder var extnodes = new HashSet[graph.Node]() var fatnodes = new HashSet[graph.Node]() sbuf.append("digraph G {\n") - for(edge <- graph.edges) { + for (edge <- graph.edges) { sbuf.append("\"" + edge.frm.allPhaseNames + "(" + edge.frm.level + ")" + "\"->\"" + edge.to.allPhaseNames + "(" + edge.to.level + ")" + "\"") if (! edge.frm.phaseobj.get.first.internal) { extnodes += edge.frm @@ -318,10 +319,10 @@ trait PhaseAssembly { self: Global => sbuf.append(" [color=\"#000000\"]\n") } } - for(node <- extnodes) { + for (node <- extnodes) { sbuf.append("\"" + node.allPhaseNames + "(" + node.level + ")" + "\" [color=\"#00ff00\"]\n") } - for(node <- fatnodes) { + for (node <- fatnodes) { sbuf.append("\"" + node.allPhaseNames + "(" + node.level + ")" + "\" [color=\"#0000ff\"]\n") } sbuf.append("}\n") diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index 35627c1c13..ed8a5d1a35 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -58,19 +58,28 @@ trait Parsers extends NewScanners with MarkupParsers { import global.posAssigner.atPos case class OpInfo(operand: Tree, operator: Name, pos: Int) + /** ... * * @author Sean McDirmid */ class UnitParser(val unit: global.CompilationUnit) extends Parser { val in = new UnitScanner(unit) - def freshName(pos : Position, prefix : String) = unit.fresh.newName(pos, prefix) - implicit def i2p(offset : Int) : Position = new OffsetPosition(unit.source,offset) - def warning(pos : Int, msg : String) : Unit = unit.warning(pos, msg) - def incompleteInputError(msg: String) : Unit = + + def freshName(pos: Position, prefix: String): Name = + unit.fresh.newName(pos, prefix) + + implicit def i2p(offset: Int): Position = new OffsetPosition(unit.source,offset) + + def warning(pos: Int, msg: String) { unit.warning(pos, msg) } + + def incompleteInputError(msg: String) { unit.incompleteInputError(unit.source.asInstanceOf[BatchSourceFile].content.length - 1, msg) - def deprecationWarning(pos : Int, msg : String) : Unit = unit.deprecationWarning(pos, msg) - def syntaxError(pos: Int, msg: String) : Unit = unit.error(pos, msg) + } + def deprecationWarning(pos: Int, msg: String) { + unit.deprecationWarning(pos, msg) + } + def syntaxError(pos: Int, msg: String) { unit.error(pos, msg) } /** the markup parser */ def xmlp = { @@ -108,11 +117,11 @@ trait Parsers extends NewScanners with MarkupParsers { val in: ParserScanner //val unit : CompilationUnit //import in.ScanPosition - protected def freshName(pos : Position, prefix: String): Name + protected def freshName(pos: Position, prefix: String): Name protected def posToReport: Int = in.currentPos - protected implicit def i2p(offset : Int) : Position - //private implicit def p2i(pos : Position) = pos.offset.get + protected implicit def i2p(offset: Int): Position + //private implicit def p2i(pos: Position) = pos.offset.get private def inToken = in.token private def inSkipToken = in.skipToken @@ -121,10 +130,10 @@ trait Parsers extends NewScanners with MarkupParsers { private def inNextTokenCode : Int = in.nextTokenCode private def inName = in.name private def charVal = in.charVal - private def intVal(isNegated : Boolean) = in.intVal(isNegated).asInstanceOf[Int] - private def longVal(isNegated : Boolean) = in.intVal(isNegated) - private def floatVal(isNegated : Boolean) = in.floatVal(isNegated).asInstanceOf[Float] - private def doubleVal(isNegated : Boolean) = in.floatVal(isNegated) + private def intVal(isNegated: Boolean) = in.intVal(isNegated).asInstanceOf[Int] + private def longVal(isNegated: Boolean) = in.intVal(isNegated) + private def floatVal(isNegated: Boolean) = in.floatVal(isNegated).asInstanceOf[Float] + private def doubleVal(isNegated: Boolean) = in.floatVal(isNegated) private def stringVal = in.stringVal /** whether a non-continuable syntax error has been seen */ @@ -133,11 +142,11 @@ trait Parsers extends NewScanners with MarkupParsers { object treeBuilder extends TreeBuilder { val global: Parsers.this.global.type = Parsers.this.global - def freshName(pos : Position, prefix: String): Name = Parser.this.freshName(pos, prefix) + def freshName(pos : Position, prefix: String): Name = + Parser.this.freshName(pos, prefix) } import treeBuilder._ - /** The implicit view parameters of the surrounding class */ var implicitClassViews: List[Tree] = Nil @@ -149,7 +158,7 @@ trait Parsers extends NewScanners with MarkupParsers { t } -/* -------- PLACEHOLDERS ------------------------------------------- */ +/* --------------- PLACEHOLDERS ------------------------------------------- */ /** The implicit parameters introduced by `_' in the current expression. * Parameters appear in reverse order @@ -199,7 +208,7 @@ trait Parsers extends NewScanners with MarkupParsers { t } -/* -------- ERROR HANDLING ------------------------------------------- */ +/* ------------- ERROR HANDLING ------------------------------------------- */ protected def skip() { var nparens = 0 @@ -228,14 +237,16 @@ trait Parsers extends NewScanners with MarkupParsers { inNextToken } } - def warning(pos : Int, msg : String) : Unit - def incompleteInputError(msg: String) : Unit - def deprecationWarning(pos : Int, msg : String) : Unit - private def syntaxError(pos : Position, msg : String, skipIt : Boolean) : Unit = pos.offset match { - case None => syntaxError(msg,skipIt) - case Some(offset) => syntaxError(offset, msg, skipIt) + def warning(pos: Int, msg: String): Unit + def incompleteInputError(msg: String): Unit + def deprecationWarning(pos: Int, msg: String): Unit + private def syntaxError(pos: Position, msg: String, skipIt: Boolean) { + pos.offset match { + case None => syntaxError(msg,skipIt) + case Some(offset) => syntaxError(offset, msg, skipIt) + } } - def syntaxError(pos: Int, msg: String) : Unit + def syntaxError(pos: Int, msg: String): Unit def syntaxError(msg: String, skipIt: Boolean) { syntaxError(inCurrentPos, msg, skipIt) } @@ -249,8 +260,8 @@ trait Parsers extends NewScanners with MarkupParsers { if (skipIt) skip() } - def warning(msg: String) : Unit = warning(inCurrentPos, msg) + def warning(msg: String) { warning(inCurrentPos, msg) } def syntaxErrorOrIncomplete(msg: String, skipIt: Boolean) { val inToken = this.inToken @@ -298,7 +309,7 @@ trait Parsers extends NewScanners with MarkupParsers { if (inToken == token) inNextToken pos } - def surround[T](open : Int, close : Int)(f : => T, orElse : T) : T = { + def surround[T](open: Int, close: Int)(f: => T, orElse: T): T = { val wasOpened = inToken == open accept(open) if (wasOpened) { @@ -308,27 +319,26 @@ trait Parsers extends NewScanners with MarkupParsers { } else orElse } - /** semi = nl {nl} | `;' * nl = `\n' // where allowed */ - def acceptStatSep() : Boolean = { + def acceptStatSep(): Boolean = if (inToken == NEWLINE || inToken == NEWLINES) { inNextToken; true } else { val ret = inToken == SEMI accept(SEMI) ret } - } def errorTypeTree = TypeTree().setType(ErrorType).setPos((inCurrentPos)) def errorTermTree = Literal(Constant(null)).setPos((inCurrentPos)) def errorPatternTree = Ident(nme.WILDCARD).setPos((inCurrentPos)) -/* -------- TOKEN CLASSES ------------------------------------------- */ +/* -------------- TOKEN CLASSES ------------------------------------------- */ def isModifier: Boolean = inToken match { - case ABSTRACT | FINAL | SEALED | PRIVATE | PROTECTED | OVERRIDE | IMPLICIT | LAZY => true + case ABSTRACT | FINAL | SEALED | PRIVATE | + PROTECTED | OVERRIDE | IMPLICIT | LAZY => true case _ => false } @@ -361,7 +371,8 @@ trait Parsers extends NewScanners with MarkupParsers { def isExprIntro: Boolean = isExprIntroToken(inToken) def isTypeIntroToken(token: Int): Boolean = token match { - case IDENTIFIER | BACKQUOTED_IDENT | THIS | SUPER | USCORE | LPAREN | AT => true + case IDENTIFIER | BACKQUOTED_IDENT | THIS | + SUPER | USCORE | LPAREN | AT => true case _ => false } @@ -373,7 +384,7 @@ trait Parsers extends NewScanners with MarkupParsers { def isStatSep: Boolean = isStatSep(inToken) -/* -------- COMMENT AND ATTRIBUTE COLLECTION ------------------------------------------- */ +/* --------- COMMENT AND ATTRIBUTE COLLECTION ----------------------------- */ /** Join the comment associated with a definition */ @@ -383,7 +394,7 @@ trait Parsers extends NewScanners with MarkupParsers { else trees } -/* -------- TREE CONSTRUCTION ------------------------------------------- */ +/* ---------- TREE CONSTRUCTION ------------------------------------------- */ /** Convert tree to formal parameter list */ @@ -447,7 +458,7 @@ trait Parsers extends NewScanners with MarkupParsers { Function(List(makeSyntheticParam(pname)), insertParam(tree)) } -/* -------- OPERAND/OPERATOR STACK ------------------------------------------- */ +/* --------- OPERAND/OPERATOR STACK --------------------------------------- */ var opstack: List[OpInfo] = Nil @@ -483,7 +494,8 @@ trait Parsers extends NewScanners with MarkupParsers { syntaxError( pos, "left- and right-associative operators with same precedence may not be mixed", false) - def reduceStack(isExpr: Boolean, base: List[OpInfo], top0: Tree, prec: Int, leftAssoc: Boolean): Tree = { + def reduceStack(isExpr: Boolean, base: List[OpInfo], top0: Tree, + prec: Int, leftAssoc: Boolean): Tree = { var top = top0 if (opstack != base && precedence(opstack.head.operator) == prec) checkAssoc(opstack.head.pos, opstack.head.operator, leftAssoc) @@ -500,7 +512,6 @@ trait Parsers extends NewScanners with MarkupParsers { /* -------- IDENTIFIERS AND LITERALS ------------------------------------------- */ - def ident(): Name = if (inToken == IDENTIFIER || inToken == BACKQUOTED_IDENT) { val name = inName.encode @@ -511,10 +522,9 @@ trait Parsers extends NewScanners with MarkupParsers { nme.ERROR } - def selector(t: Tree) = + def selector(t: Tree): Tree = atPos(inCurrentPos)(Select(t, ident())) - /** Path ::= StableId * | [Ident `.'] this * AnnotType ::= Path [`.' type] @@ -576,15 +586,15 @@ trait Parsers extends NewScanners with MarkupParsers { /** MixinQualifier ::= `[' Id `]' */ - def mixinQualifierOpt(pos : Position): (Name,Position) = + def mixinQualifierOpt(pos: Position): (Name, Position) = if (inToken == LBRACKET) { inNextToken val pos = inCurrentPos val name = ident().toTypeName accept(RBRACKET) - (name,pos) + (name, pos) } else { - (nme.EMPTY.toTypeName,pos) + (nme.EMPTY.toTypeName, pos) } /** StableId ::= Id @@ -611,15 +621,15 @@ trait Parsers extends NewScanners with MarkupParsers { def litToTree() = atPos(inCurrentPos) { Literal( inToken match { - case CHARLIT => Constant(charVal) - case INTLIT => Constant(intVal(isNegated)) - case LONGLIT => Constant(longVal(isNegated)) - case FLOATLIT =>Constant(floatVal(isNegated)) + case CHARLIT => Constant(charVal) + case INTLIT => Constant(intVal(isNegated)) + case LONGLIT => Constant(longVal(isNegated)) + case FLOATLIT => Constant(floatVal(isNegated)) case DOUBLELIT => Constant(doubleVal(isNegated)) case STRINGLIT | SYMBOLLIT => Constant(stringVal) - case TRUE => Constant(true) - case FALSE => Constant(false) - case NULL => Constant(null) + case TRUE => Constant(true) + case FALSE => Constant(false) + case NULL => Constant(null) case _ => syntaxErrorOrIncomplete("illegal literal", true) null @@ -658,7 +668,7 @@ trait Parsers extends NewScanners with MarkupParsers { if (inToken == NEWLINE && p(inNextTokenCode)) newLineOpt() } -/* -------- TYPES ------------------------------------------- */ +/* ------------- TYPES ---------------------------------------------------- */ /** TypedOpt ::= [`:' Type] */ @@ -722,7 +732,9 @@ trait Parsers extends NewScanners with MarkupParsers { } else { val ts = types(isPattern, false, true) accept(RPAREN) - if (inToken == ARROW) atPos(inSkipToken) { makeFunctionTypeTree(ts, typ(isPattern)) } + if (inToken == ARROW) atPos(inSkipToken) { + makeFunctionTypeTree(ts, typ(isPattern)) + } else { for (t <- ts) t match { case AppliedTypeTree(Select(_, n), _) @@ -745,7 +757,8 @@ trait Parsers extends NewScanners with MarkupParsers { val whereClauses = refinement() for (wc <- whereClauses) { wc match { - case TypeDef(_, _, _, TypeBoundsTree(_, _)) | ValDef(_, _, _, EmptyTree) | EmptyTree => + case TypeDef(_, _, _, TypeBoundsTree(_, _)) | + ValDef(_, _, _, EmptyTree) | EmptyTree => ; case _ => syntaxError(wc.pos, "not a legal existential clause", false) @@ -762,7 +775,7 @@ trait Parsers extends NewScanners with MarkupParsers { infixTypeRest(inCurrentPos, infixTypeFirst(isPattern), isPattern, mode) } - def infixTypeFirst(isPattern: Boolean) = + def infixTypeFirst(isPattern: Boolean): Tree = if (inToken == LBRACE) scalaAnyRefConstr else annotType(isPattern) def infixTypeRest(pos: Int, t0: Tree, isPattern: Boolean, mode: InfixMode.Value): Tree = { @@ -909,7 +922,7 @@ trait Parsers extends NewScanners with MarkupParsers { typ() } -/* -------- EXPRESSIONS ------------------------------------------- */ +/* ----------- EXPRESSIONS ------------------------------------------------ */ /** EqualsExpr ::= `=' Expr */ @@ -1232,10 +1245,13 @@ trait Parsers extends NewScanners with MarkupParsers { // again, position should be on idetifier, not ( var pos = if (t.pos == NoPosition) i2p(inCurrentPos) else t.pos simpleExprRest(atPos(pos) { - // look for anonymous function application like (f _)(x) and translate to (f _).apply(x), bug #460 + // look for anonymous function application like (f _)(x) and + // translate to (f _).apply(x), bug #460 val sel = t match { - case Parens(List(Typed(_, _: Function))) => Select(stripParens(t), nme.apply) - case _ => stripParens(t) + case Parens(List(Typed(_, _: Function))) => + Select(stripParens(t), nme.apply) + case _ => + stripParens(t) } Apply(sel, argumentExprs()) }, true) @@ -1446,7 +1462,7 @@ trait Parsers extends NewScanners with MarkupParsers { stripParens(reduceStack(false, base, top, 0, true)) } - def xmlLiteralPattern() : Tree + def xmlLiteralPattern(): Tree /** SimplePattern ::= varid * | `_' @@ -1491,14 +1507,16 @@ trait Parsers extends NewScanners with MarkupParsers { } else t case USCORE => atPos(inSkipToken) { Ident(nme.WILDCARD) } - case CHARLIT | INTLIT | LONGLIT | FLOATLIT | DOUBLELIT | STRINGLIT | SYMBOLLIT | TRUE | FALSE | NULL => + case CHARLIT | INTLIT | LONGLIT | FLOATLIT | DOUBLELIT | + STRINGLIT | SYMBOLLIT | TRUE | FALSE | NULL => literal(true, false) case LPAREN => val pos = inSkipToken val ps = if (inToken == RPAREN) List() else patterns(false) accept(RPAREN) Parens(ps) setPos (pos) - case XMLSTART => xmlLiteralPattern() + case XMLSTART => + xmlLiteralPattern() case _ => syntaxErrorOrIncomplete("illegal start of simple pattern", true) errorPatternTree @@ -1529,7 +1547,7 @@ trait Parsers extends NewScanners with MarkupParsers { /** AccessQualifier ::= "[" (Id | this) "]" */ - def accessQualifierOpt(mods: Modifiers) = { + def accessQualifierOpt(mods: Modifiers): Modifiers = { var result = mods if (inToken == LBRACKET) { inNextToken @@ -1930,7 +1948,7 @@ trait Parsers extends NewScanners with MarkupParsers { * | type [nl] TypeDcl */ def defOrDcl(mods: Modifiers): List[Tree] = { - if ((mods.hasFlag(Flags.LAZY)) && in.token != VAL) + if ((mods hasFlag Flags.LAZY) && in.token != VAL) syntaxError("lazy not allowed here. Only vals can be lazy", false) inToken match { case VAL => @@ -2098,7 +2116,8 @@ trait Parsers extends NewScanners with MarkupParsers { * | ConstrBlock */ def constrExpr(vparamss: List[List[ValDef]]): Tree = - if (inToken == LBRACE) constrBlock(vparamss) else Block(List(selfInvocation(vparamss)), Literal(())) + if (inToken == LBRACE) constrBlock(vparamss) + else Block(List(selfInvocation(vparamss)), Literal(())) /** SelfInvocation ::= this ArgumentExprs {ArgumentExprs} */ @@ -2110,8 +2129,8 @@ trait Parsers extends NewScanners with MarkupParsers { t = Apply(t, argumentExprs()) newLineOptWhenFollowedBy(LBRACE) } - if (!implicitClassViews.isEmpty) t = Apply(t, vparamss.last.map(vd => Ident(vd.name))) - t + if (implicitClassViews.isEmpty) t + else Apply(t, vparamss.last.map(vp => Ident(vp.name))) } /** ConstrBlock ::= `{' SelfInvocation {semi BlockStat} `}' @@ -2136,9 +2155,9 @@ trait Parsers extends NewScanners with MarkupParsers { // @M! a type alias as well as an abstract type may declare type parameters val tparams = inToken match { case LBRACKET => - typeParamClauseOpt(name, null) + typeParamClauseOpt(name, null) case _ => - Nil + Nil } inToken match { @@ -2206,8 +2225,16 @@ trait Parsers extends NewScanners with MarkupParsers { if (mods.hasFlag(Flags.TRAIT)) (Modifiers(Flags.TRAIT), List()) else (accessModifierOpt(), paramClauses(name, implicitClassViews, mods.hasFlag(Flags.CASE))) val thistpe = requiresTypeOpt() - var mods1 = if (mods.hasFlag( Flags.TRAIT )) if (inToken == SUBTYPE) mods | Flags.DEFERRED else mods - else if (inToken == SUBTYPE) { syntaxError("classes are not allowed to be virtual", false); mods } else mods + var mods1 = + if (mods hasFlag Flags.TRAIT) + if (inToken == SUBTYPE) mods | Flags.DEFERRED + else mods + else if (inToken == SUBTYPE) { + syntaxError("classes are not allowed to be virtual", false) + mods + } + else + mods var template = templateOpt(mods1, name, constrMods withAnnotations constrAnnots, vparamss) if (!thistpe.isEmpty) { if (template.self.isEmpty) { @@ -2288,14 +2315,15 @@ trait Parsers extends NewScanners with MarkupParsers { } } - def isInterface(mods: Modifiers, body: List[Tree]) = - (mods.hasFlag(Flags.TRAIT) && (body forall treeInfo.isInterfaceMember)) + def isInterface(mods: Modifiers, body: List[Tree]): Boolean = + (mods hasFlag Flags.TRAIT) && (body forall treeInfo.isInterfaceMember) /** ClassTemplateOpt ::= 'extends' ClassTemplate | [['extends'] TemplateBody] * TraitTemplateOpt ::= TraitExtends TraitTemplate | [['extends'] TemplateBody] | '<:' TemplateBody * TraitExtends ::= 'extends' | `<:' */ - def templateOpt(mods: Modifiers, name: Name, constrMods: Modifiers, vparamss: List[List[ValDef]]): Template = { + def templateOpt(mods: Modifiers, name: Name, constrMods: Modifiers, + vparamss: List[List[ValDef]]): Template = { val pos = inCurrentPos; val (parents0, argss, self, body) = if (inToken == EXTENDS || settings.Xexperimental.value && (mods hasFlag Flags.TRAIT) && inToken == SUBTYPE) { @@ -2328,7 +2356,7 @@ trait Parsers extends NewScanners with MarkupParsers { /** TemplateBody ::= [nl] `{' TemplateStatSeq `}' * @param isPre specifies whether in early initializer (true) or not (false) */ - def templateBody(isPre : Boolean) = { + def templateBody(isPre: Boolean) = { accept(LBRACE) val result @ (self, stats) = templateStatSeq(isPre) accept(RBRACE) @@ -2568,7 +2596,9 @@ trait Parsers extends NewScanners with MarkupParsers { ts ++= topStatSeq() } val stats = ts.toList - val usePos = if (stats.isEmpty || stats.head.pos == NoPosition) i2p(pos) else stats.head.pos + val usePos = + if (stats.isEmpty || stats.head.pos == NoPosition) i2p(pos) + else stats.head.pos atPos(usePos) { stats match { case List(stat @ PackageDef(_, _)) => stat case _ => makePackaging(Ident(nme.EMPTY_PACKAGE_NAME), stats) diff --git a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala index 4f24681a88..a2e114afca 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala @@ -71,7 +71,7 @@ trait Scanners { def floatVal(negated: Boolean): Double def intVal: Long = intVal(false) def floatVal: Double = floatVal(false) - //def token2string(token : Int) : String = configuration.token2string(token) + //def token2string(token: Int): String = configuration.token2string(token) /** return recent scala doc, if any */ def flushDoc: String } @@ -152,14 +152,11 @@ trait Scanners { enterKeyword(nme.ATkw, AT) // Build keyword array - key = new Array[Byte](maxKey + 1) - for (i <- 0 to maxKey) - key(i) = IDENTIFIER - for (j <- 0 until tokenCount) - if (tokenName(j) ne null) - key(tokenName(j).start) = j.asInstanceOf[Byte] - + key = Array.make(maxKey + 1, IDENTIFIER) + for (j <- 0 until tokenCount if tokenName(j) ne null) + key(tokenName(j).start) = j.toByte } + //Token representation ----------------------------------------------------- /** Convert name to token */ @@ -1028,9 +1025,12 @@ trait Scanners { /** ... */ class UnitScanner(unit: CompilationUnit) extends Scanner { - val in = new CharArrayReader(unit.source.asInstanceOf[BatchSourceFile].content, !settings.nouescape.value, syntaxError) + val in = new CharArrayReader( + unit.source.asInstanceOf[BatchSourceFile].content, + !settings.nouescape.value, syntaxError + ) def warning(pos: Int, msg: String) = unit.warning(pos, msg) - def error (pos: Int, msg: String) = unit. error(pos, msg) + def error (pos: Int, msg: String) = unit.error(pos, msg) def incompleteInputError(pos: Int, msg: String) = unit.incompleteInputError(pos, msg) def deprecationWarning(pos: Int, msg: String) = unit.deprecationWarning(pos, msg) implicit def p2g(pos: Position): Int = pos.offset.getOrElse(-1) diff --git a/src/compiler/scala/tools/nsc/interpreter/AbstractFileClassLoader.scala b/src/compiler/scala/tools/nsc/interpreter/AbstractFileClassLoader.scala index 40e1ce596f..bb1d049677 100644 --- a/src/compiler/scala/tools/nsc/interpreter/AbstractFileClassLoader.scala +++ b/src/compiler/scala/tools/nsc/interpreter/AbstractFileClassLoader.scala @@ -1,8 +1,10 @@ /* NSC -- new Scala compiler * Copyright 2005-2009 LAMP/EPFL */ -// $Id$ +// $Id: $ + package scala.tools.nsc.interpreter + import scala.tools.nsc.io.AbstractFile /** diff --git a/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala b/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala index 8375328017..0e66a8b06a 100644 --- a/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala +++ b/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala @@ -4,8 +4,8 @@ */ // $Id$ - package scala.tools.nsc.interpreter + import java.io.File import jline.{ History, ConsoleReader, ArgumentCompletor } diff --git a/src/compiler/scala/tools/nsc/interpreter/SimpleReader.scala b/src/compiler/scala/tools/nsc/interpreter/SimpleReader.scala index 38dfdbfb92..1bd5f217c1 100644 --- a/src/compiler/scala/tools/nsc/interpreter/SimpleReader.scala +++ b/src/compiler/scala/tools/nsc/interpreter/SimpleReader.scala @@ -5,8 +5,8 @@ // $Id$ package scala.tools.nsc.interpreter -import java.io.{BufferedReader, PrintWriter} +import java.io.{BufferedReader, PrintWriter} /** Reads using standard JDK API */ class SimpleReader( @@ -16,7 +16,7 @@ class SimpleReader( extends InteractiveReader { def this() = this(Console.in, new PrintWriter(Console.out), true) - def readOneLine(prompt: String) = { + def readOneLine(prompt: String): String = { if (interactive) { out.print(prompt) out.flush() diff --git a/src/compiler/scala/tools/nsc/plugins/Plugin.scala b/src/compiler/scala/tools/nsc/plugins/Plugin.scala index 4ebc83daa2..bce4876c41 100644 --- a/src/compiler/scala/tools/nsc/plugins/Plugin.scala +++ b/src/compiler/scala/tools/nsc/plugins/Plugin.scala @@ -81,7 +81,7 @@ object Plugin { val jar = new JarFile(jarfile) try { val ent = jar.getEntry("scalac-plugin.xml") - if(ent == null) return None + if (ent == null) return None val inBytes = jar.getInputStream(ent) val packXML = XML.load(inBytes) @@ -92,7 +92,7 @@ object Plugin { jar.close() } } catch { - case _:ZipException => None + case _: ZipException => None } } @@ -132,7 +132,7 @@ object Plugin { dir <- dirs if dir.isDirectory entries = dir.listFiles if entries ne null - entry <- entries.toList.sort((f1, f2) => f1.getName <= f2.getName) + entry <- entries.toList.sort(_.getName <= _.getName) if entry.toString.toLowerCase endsWith ".jar" pdesc <- loadDescription(entry) if !(ignoring contains pdesc.name) diff --git a/src/compiler/scala/tools/nsc/plugins/Plugins.scala b/src/compiler/scala/tools/nsc/plugins/Plugins.scala index cd457dfec1..812bfd7ce8 100644 --- a/src/compiler/scala/tools/nsc/plugins/Plugins.scala +++ b/src/compiler/scala/tools/nsc/plugins/Plugins.scala @@ -20,7 +20,8 @@ trait Plugins { self: Global => /** Load a rough list of the plugins. For speed, it * does not instantiate a compiler run. Therefore it cannot * test for same-named phases or other problems that are - * filtered from the final list of plugins. */ + * filtered from the final list of plugins. + */ protected def loadRoughPluginsList(): List[Plugin] = { val jars = settings.plugin.value.map(new File(_)) val dirs = @@ -41,7 +42,6 @@ trait Plugins { self: Global => roughPluginsListCache.get } - /** Load all available plugins. Skips plugins that * either have the same name as another one, or which * define a phase name that another one does. @@ -117,7 +117,6 @@ trait Plugins { self: Global => plugs } - private var pluginsCache: Option[List[Plugin]] = None def plugins: List[Plugin] = { @@ -126,7 +125,6 @@ trait Plugins { self: Global => pluginsCache.get } - /** A description of all the plugins that are loaded */ def pluginDescriptions: String = { val messages = @@ -140,10 +138,7 @@ trait Plugins { self: Global => * @see phasesSet */ protected def computePluginPhases() { - - var plugPhases = plugins.flatMap(_.components) - - // Add all phases supplied by plugins to the phasesSet + val plugPhases = plugins.flatMap(_.components) for (pPhase <- plugPhases) { phasesSet += pPhase } diff --git a/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala b/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala index 4c62a8435d..d6f94e8626 100644 --- a/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala +++ b/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala @@ -16,7 +16,7 @@ import scala.tools.nsc.util.Position abstract class AbstractReporter extends Reporter { private val positions = new HashMap[Position, Severity] - override def reset = { + override def reset { super.reset positions.clear } @@ -28,7 +28,7 @@ abstract class AbstractReporter extends Reporter { protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean) { severity match { - case INFO => + case INFO => if (force || settings.verbose.value) display(pos, msg, severity) case WARNING => val hidden = testAndLog(pos, severity) diff --git a/src/compiler/scala/tools/nsc/reporters/Reporter.scala b/src/compiler/scala/tools/nsc/reporters/Reporter.scala index 3dbdfc85f1..c12e32a026 100644 --- a/src/compiler/scala/tools/nsc/reporters/Reporter.scala +++ b/src/compiler/scala/tools/nsc/reporters/Reporter.scala @@ -22,7 +22,7 @@ abstract class Reporter { val WARNING = new Severity(1) val ERROR = new Severity(2) - def reset: Unit = { + def reset { INFO.count = 0 ERROR.count = 0 WARNING.count = 0 @@ -41,9 +41,9 @@ abstract class Reporter { def setSource(source: SourceFile) { this.source = source } def getSource: SourceFile = source - def info(pos: Position, msg: String, force: Boolean): Unit = info0(pos, msg, INFO, force) - def warning(pos: Position, msg: String ): Unit = info0(pos, msg, WARNING, false) - def error(pos: Position, msg: String ): Unit = info0(pos, msg, ERROR, false) + def info(pos: Position, msg: String, force: Boolean) { info0(pos, msg, INFO, force) } + def warning(pos: Position, msg: String ) { info0(pos, msg, WARNING, false) } + def error(pos: Position, msg: String ) { info0(pos, msg, ERROR, false) } /** An error that could possibly be fixed if the unit were longer. * This is used only when the interpreter tries diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/AbstractFileReader.scala b/src/compiler/scala/tools/nsc/symtab/classfile/AbstractFileReader.scala index 08f7493b75..3563c69646 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/AbstractFileReader.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/AbstractFileReader.scala @@ -38,22 +38,21 @@ class AbstractFileReader(val file: AbstractFile) { @throws(classOf[IndexOutOfBoundsException]) def nextByte: Byte = { val b = buf(bp) - bp = bp + 1 + bp += 1 b } /** read some bytes */ def nextBytes(len: Int): Array[Byte] = { - bp = bp + len + bp += len buf.subArray(bp - len, bp) } /** read a character */ - def nextChar: Char = { + def nextChar: Char = (((nextByte & 0xff) << 8) + (nextByte & 0xff)).toChar - } /** read an integer */ diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala index b40547d9d9..24ba34c572 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala @@ -66,11 +66,9 @@ abstract class ICodeReader extends ClassfileParser { /** If we're parsing a scala module, the owner of members is always * the module symbol. */ - override def getOwner(jflags: Int): Symbol = { - if (isScalaModule) { - this.staticModule - } else super.getOwner(jflags) - } + override def getOwner(jflags: Int): Symbol = + if (isScalaModule) this.staticModule + else super.getOwner(jflags) override def parseClass() { this.instanceCode = new IClass(clazz) @@ -634,6 +632,7 @@ abstract class ICodeReader extends ClassfileParser { def isBox(m: Symbol): Boolean = (m.owner == definitions.BoxesRunTimeClass.moduleClass && m.name.startsWith("boxTo")) + def isUnbox(m: Symbol): Boolean = (m.owner == definitions.BoxesRunTimeClass.moduleClass && m.name.startsWith("unboxTo")) @@ -643,7 +642,8 @@ abstract class ICodeReader extends ClassfileParser { */ def getCode(flags: Int): IClass = if (isScalaModule) staticCode - else if ((flags & JAVA_ACC_STATIC) != 0) staticCode else instanceCode + else if ((flags & JAVA_ACC_STATIC) != 0) staticCode + else instanceCode class LinearCode { var instrs: ListBuffer[(Int, Instruction)] = new ListBuffer diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala index cf2b194489..52fbc7b83c 100644 --- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala +++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala @@ -621,7 +621,8 @@ abstract class CleanUp extends Transform { case MethodType(paramTypes, resType) => assert(params.length == paramTypes.length) atPos(ad.pos)(localTyper.typed { - val sym = currentOwner.newValue(ad.pos, newTermName(unit.fresh.newName("qual"))) setInfo qual0.tpe + val t1 = newTermName(unit.fresh.newName(ad.pos, "qual")) + val sym = currentOwner.newValue(ad.pos, t1) setInfo qual0.tpe qual = gen.mkAttributedRef(sym) Block( List(ValDef(sym, qual0)), diff --git a/src/compiler/scala/tools/nsc/util/FreshNameCreator.scala b/src/compiler/scala/tools/nsc/util/FreshNameCreator.scala index e0070e5827..a25d73a08a 100644 --- a/src/compiler/scala/tools/nsc/util/FreshNameCreator.scala +++ b/src/compiler/scala/tools/nsc/util/FreshNameCreator.scala @@ -9,36 +9,46 @@ package scala.tools.nsc.util import scala.collection.mutable.HashMap trait FreshNameCreator { - /** do not call before after type checking ends. Use newName(Position,String) instead. */ - @deprecated def newName(prefix : String) : String - /** do not call before after type checking ends. Use newName(Position) instead. */ - @deprecated def newName() : String - def newName(pos : util.Position, prefix : String) : String - def newName(pos : util.Position) : String + + /** do not call before after type checking ends. + * Use <code>newName(Position, String)</code> instead. + */ + @deprecated def newName(prefix: String): String + + /** do not call before after type checking ends. + * Use newName(Position) instead. + */ + @deprecated def newName(): String + + def newName(pos: util.Position, prefix: String): String + def newName(pos: util.Position): String } + object FreshNameCreator { + class Default extends FreshNameCreator { - protected var counter = 0 - protected val counters = new HashMap[String, Int] + protected var counter = 0 + protected val counters = new HashMap[String, Int] - /** - * Create a fresh name with the given prefix. It is guaranteed - * that the returned name has never been returned by a previous - * call to this function (provided the prefix does not end in a digit). - */ - def newName(prefix: String): String = { - val safePrefix = prefix.replace('<', '$').replace('>', '$') - val count = counters.getOrElse(safePrefix, 0) + 1 - counters(safePrefix) = count - safePrefix + count - } - def newName(pos : util.Position, prefix : String) = newName(prefix) - def newName(pos : util.Position) = newName() + /** + * Create a fresh name with the given prefix. It is guaranteed + * that the returned name has never been returned by a previous + * call to this function (provided the prefix does not end in a digit). + */ + def newName(prefix: String): String = { + val safePrefix = prefix.replace('<', '$').replace('>', '$') + val count = counters.getOrElse(safePrefix, 0) + 1 + counters(safePrefix) = count + safePrefix + count + } + def newName(pos: util.Position, prefix: String) = newName(prefix) + def newName(pos: util.Position) = newName() - def newName(): String = { - counter = counter + 1 - "$" + counter + "$" + def newName(): String = { + counter += 1 + "$" + counter + "$" + } } -} + } |