diff options
16 files changed, 159 insertions, 84 deletions
@@ -184,7 +184,7 @@ PROPERTIES <!-- if ANT_OPTS is already set by the environment, it will be unaltered, but if it is unset it will take this default value. --> - <property name="env.ANT_OPTS" value="-Xms1536M -Xmx1536M -Xss1M -XX:MaxPermSize=128M -XX:+UseParallelGC" /> + <property name="env.ANT_OPTS" value="-Xms1536M -Xmx1536M -Xss1M -XX:MaxPermSize=192M -XX:+UseParallelGC" /> <!-- to find max heap usage: -Xaprof ; currently at 980M for locker.comp --> <echo message="Using ANT_OPTS: ${env.ANT_OPTS}" /> diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 6d9bc2976a..a52235fd90 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -255,7 +255,11 @@ class Global(var settings: Settings, var reporter: Reporter) extends SymbolTable abstract class GlobalPhase(prev: Phase) extends Phase(prev) { phaseWithId(id) = this - def run { currentRun.units foreach applyPhase } + + def run { + echoPhaseSummary(this) + currentRun.units foreach applyPhase + } def apply(unit: CompilationUnit): Unit @@ -276,7 +280,9 @@ class Global(var settings: Settings, var reporter: Reporter) extends SymbolTable } final def applyPhase(unit: CompilationUnit) { - if (settings.debug.value) inform("[running phase " + name + " on " + unit + "]") + if (doEchoFilenames) + inform("[running phase " + name + " on " + unit + "]") + val unit0 = currentRun.currentUnit try { currentRun.currentUnit = unit @@ -586,6 +592,14 @@ class Global(var settings: Settings, var reporter: Reporter) extends SymbolTable */ override def currentRunId = curRunId + def currentRunSize = currentRun.unitbufSize + def doEchoFilenames = settings.debug.value && (settings.verbose.value || currentRunSize < 5) + def echoPhaseSummary(ph: Phase) = { + /** Only output a summary message under debug if we aren't echoing each file. */ + if (settings.debug.value && !doEchoFilenames) + inform("[running phase " + ph.name + " on " + currentRunSize + " compilation units]") + } + /** A Run is a single execution of the compiler on a sets of units */ class Run { @@ -693,10 +707,14 @@ class Global(var settings: Settings, var reporter: Reporter) extends SymbolTable private var unitbuf = new ListBuffer[CompilationUnit] var compiledFiles = new HashSet[String] + private var _unitbufSize = 0 + def unitbufSize = _unitbufSize + /** add unit to be compiled in this run */ private def addUnit(unit: CompilationUnit) { // unit.parseSettings() unitbuf += unit + _unitbufSize += 1 // counting as they're added so size is cheap compiledFiles += unit.source.file.path } diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index 4ac6aea923..b414981665 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -200,21 +200,19 @@ self => accept(EOF) def mainModuleName = settings.script.value + /** If there is only a single object template in the file and it has a + * suitable main method, we will use it rather than building another object + * around it. Since objects are loaded lazily the whole script would have + * been a no-op, so we're not taking much liberty. + */ def searchForMain(): Option[Tree] = { - /** If there is only a single object template in the file and it has a - * suitable main method, we will use it rather than building another object - * around it. Since objects are loaded lazily the whole script would have - * been a no-op, so we're not taking much liberty. - */ - val MainName: Name = newTermName("main") - /** Have to be fairly liberal about what constitutes a main method since * nothing has been typed yet - for instance we can't assume the parameter * type will look exactly like "Array[String]" as it could have been renamed * via import, etc. */ def isMainMethod(t: Tree) = t match { - case DefDef(_, MainName, Nil, List(_), _, _) => true + case DefDef(_, nme.main, Nil, List(_), _, _) => true case _ => false } /** For now we require there only be one top level object. */ @@ -268,11 +266,11 @@ self => ) // def main - def mainParamType = AppliedTypeTree(Ident("Array".toTypeName), List(Ident("String".toTypeName))) + def mainParamType = AppliedTypeTree(Ident(nme.Array.toTypeName), List(Ident(nme.String.toTypeName))) def mainParameter = List(ValDef(Modifiers(Flags.PARAM), "argv", mainParamType, EmptyTree)) def mainSetArgv = List(ValDef(NoMods, "args", TypeTree(), Ident("argv"))) def mainNew = makeNew(Nil, emptyValDef, stmts, List(Nil), NoPosition, NoPosition) - def mainDef = DefDef(NoMods, "main", Nil, List(mainParameter), scalaDot(nme.Unit.toTypeName), Block(mainSetArgv, mainNew)) + def mainDef = DefDef(NoMods, nme.main, Nil, List(mainParameter), scalaDot(nme.Unit.toTypeName), Block(mainSetArgv, mainNew)) // object Main def moduleName = ScriptRunner scriptMain settings @@ -1143,7 +1141,7 @@ self => case WHILE => val start = in.offset atPos(in.skipToken()) { - val lname: Name = freshName(o2p(start), "while$") + val lname: Name = freshName(o2p(start), nme.WHILE_PREFIX) val cond = condExpr() newLinesOpt() val body = expr() @@ -1152,7 +1150,7 @@ self => case DO => val start = in.offset atPos(in.skipToken()) { - val lname: Name = freshName(o2p(start), "doWhile$") + val lname: Name = freshName(o2p(start), nme.DO_WHILE_PREFIX) val body = expr() if (isStatSep) in.nextToken() accept(WHILE) diff --git a/src/compiler/scala/tools/nsc/backend/icode/BasicBlocks.scala b/src/compiler/scala/tools/nsc/backend/icode/BasicBlocks.scala index 32c0d936b2..bdcee1cba7 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/BasicBlocks.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/BasicBlocks.scala @@ -15,7 +15,10 @@ import backend.icode.analysis.ProgramPoint trait BasicBlocks { self: ICodes => + import opcodes._ + import global.{ settings, log, nme } + import nme.isExceptionResultName /** This class represents a basic block. Each * basic block contains a list of instructions that are @@ -249,7 +252,19 @@ trait BasicBlocks { } */ assert(!closed || ignore, "BasicBlock closed") - if (!ignore) { + if (ignore) { + if (settings.debug.value) { + /** Trying to pin down what it's likely to see after a block has been + * put into ignore mode so we hear about it if there's a problem. + */ + instr match { + case JUMP(_) | RETURN(_) | THROW() | SCOPE_EXIT(_) => // ok + case STORE_LOCAL(local) if isExceptionResultName(local.sym.name) => // ok + case x => log("Ignoring instruction, possibly at our peril, at " + pos + ": " + x) + } + } + } + else { instr.setPos(pos) instructionList = instr :: instructionList _lastInstruction = instr @@ -318,7 +333,10 @@ trait BasicBlocks { * added to this basic block. It makes the generation of THROW * and RETURNs easier. */ - def enterIgnoreMode = ignore = true + def enterIgnoreMode = { + log("Entering ignore mode in " + fullString) + ignore = true + } def exitIgnoreMode { assert(ignore, "Exit ignore mode when not in ignore mode.") diff --git a/src/compiler/scala/tools/nsc/backend/icode/Checkers.scala b/src/compiler/scala/tools/nsc/backend/icode/Checkers.scala index a4c186791a..bb09030c17 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/Checkers.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/Checkers.scala @@ -635,9 +635,7 @@ abstract class Checkers { //////////////// Error reporting ///////////////////////// def error(msg: String) { - Console.println("!! ICode checker fatality in " + method + " at:") - Console.println(blockAsString(basicBlock)) - Checkers.this.global.error(method + ":\n " + msg) + Checkers.this.global.error("!! ICode checker fatality in " + method + " at:" + blockAsString(basicBlock) + ":\n " + msg) } def error(msg: String, stack: TypeStack) { diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala index df1e604081..903802759d 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala @@ -617,19 +617,20 @@ abstract class GenICode extends SubComponent { val resCtx: Context = tree match { case LabelDef(name, params, rhs) => val ctx1 = ctx.newBlock - if (isLoopHeaderLabel(name)) - ctx1.bb.loopHeader = true; + if (nme.isLoopHeaderLabel(name)) + ctx1.bb.loopHeader = true ctx1.labels.get(tree.symbol) match { case Some(label) => + log("Found existing label for " + tree.symbol) label.anchor(ctx1.bb) label.patch(ctx.method.code) case None => - ctx1.labels += (tree.symbol -> (new Label(tree.symbol) anchor ctx1.bb setParams (params map (_.symbol)))); + val pair = (tree.symbol -> (new Label(tree.symbol) anchor ctx1.bb setParams (params map (_.symbol)))) + log("Adding label " + tree.symbol + " in genLoad.") + ctx1.labels += pair ctx.method.addLocals(params map (p => new Local(p.symbol, toTypeKind(p.symbol.info), false))); - if (settings.debug.value) - log("Adding label " + tree.symbol); } ctx.bb.closeWith(JUMP(ctx1.bb), tree.pos) @@ -666,31 +667,39 @@ abstract class GenICode extends SubComponent { case Return(expr) => val returnedKind = toTypeKind(expr.tpe) - var ctx1 = genLoad(expr, ctx, returnedKind) - val oldcleanups = ctx1.cleanups - lazy val tmp = ctx1.makeLocal(tree.pos, expr.tpe, "tmp") - var saved = false - - for (op <- ctx1.cleanups) op match { - case MonitorRelease(m) => - if (settings.debug.value) log("removing " + m + " from cleanups: " + ctx1.cleanups) - ctx1.bb.emit(LOAD_LOCAL(m)) - ctx1.bb.emit(MONITOR_EXIT()) - ctx1.exitSynchronized(m) - case Finalizer(f) => - if (settings.debug.value) log("removing " + f + " from cleanups: " + ctx1.cleanups) - if (returnedKind != UNIT && mayCleanStack(f) && !saved) { - ctx1.bb.emit(STORE_LOCAL(tmp)) - saved = true - } - // we have to run this without the same finalizer in - // the list, otherwise infinite recursion happens for - // finalizers that contain 'return' - ctx1 = genLoad(f, ctx1.removeFinalizer(f), UNIT) + log("Return(" + expr + ") with returnedKind = " + returnedKind) + + var ctx1 = genLoad(expr, ctx, returnedKind) + lazy val tmp = ctx1.makeLocal(tree.pos, expr.tpe, "tmp") + val saved = savingCleanups(ctx1) { + ctx1.cleanups exists { + case MonitorRelease(m) => + if (settings.debug.value) + log("removing " + m + " from cleanups: " + ctx1.cleanups) + ctx1.bb.emit(Seq(LOAD_LOCAL(m), MONITOR_EXIT())) + ctx1.exitSynchronized(m) + false + case Finalizer(f) => + if (settings.debug.value) + log("removing " + f + " from cleanups: " + ctx1.cleanups) + + val saved = returnedKind != UNIT && mayCleanStack(f) && { + log("Emitting STORE_LOCAL for " + tmp + " to save finalizer.") + ctx1.bb.emit(STORE_LOCAL(tmp)) + true + } + // we have to run this without the same finalizer in + // the list, otherwise infinite recursion happens for + // finalizers that contain 'return' + ctx1 = genLoad(f, ctx1.removeFinalizer(f), UNIT) + saved + } } - ctx1.cleanups = oldcleanups - if (saved) ctx1.bb.emit(LOAD_LOCAL(tmp)) + if (saved) { + log("Emitting LOAD_LOCAL for " + tmp + " after saving finalizer.") + ctx1.bb.emit(LOAD_LOCAL(tmp)) + } adapt(returnedKind, ctx1.method.returnType, ctx1, tree.pos) ctx1.bb.emit(RETURN(ctx.method.returnType), tree.pos) ctx1.bb.enterIgnoreMode @@ -1753,9 +1762,6 @@ abstract class GenICode extends SubComponent { def getMaxType(ts: List[Type]): TypeKind = ts map toTypeKind reduceLeft (_ maxType _) - def isLoopHeaderLabel(name: Name): Boolean = - name.startsWith("while$") || name.startsWith("doWhile$") - /** Tree transformer that duplicates code and at the same time creates * fresh symbols for existing labels. Since labels may be used before * they are defined (forward jumps), all labels found are mapped to fresh @@ -1801,7 +1807,9 @@ abstract class GenICode extends SubComponent { val tree = treeCopy.LabelDef(t, newSym.name, params, transform(rhs)) tree.symbol = newSym - ctx.labels += (newSym -> (new Label(newSym) setParams (params map (_.symbol)))) + val pair = (newSym -> (new Label(newSym) setParams (params map (_.symbol)))) + log("Added " + pair + " to labels.") + ctx.labels += pair ctx.method.addLocals(params map (p => new Local(p.symbol, toTypeKind(p.symbol.info), false))) tree @@ -1827,6 +1835,12 @@ abstract class GenICode extends SubComponent { (new DuplicateLabels(boundLabels))(targetCtx, finalizer) } + def savingCleanups[T](ctx: Context)(body: => T): T = { + val saved = ctx.cleanups + try body + finally ctx.cleanups = saved + } + /** * The Context class keeps information relative to the current state * in code generation diff --git a/src/compiler/scala/tools/nsc/backend/icode/Members.scala b/src/compiler/scala/tools/nsc/backend/icode/Members.scala index 9d9e3c92e4..8001c30efd 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/Members.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/Members.scala @@ -207,9 +207,9 @@ trait Members { self: ICodes => } toSet if (code != null) { - Console.println("[checking locals of " + this + "]") + log("[checking locals of " + this + "]") locals filterNot localsSet foreach { l => - Console.println("Local " + l + " is not declared in " + this) + log("Local " + l + " is not declared in " + this) } } } diff --git a/src/compiler/scala/tools/nsc/symtab/StdNames.scala b/src/compiler/scala/tools/nsc/symtab/StdNames.scala index aa47441a1a..eee61a4312 100644 --- a/src/compiler/scala/tools/nsc/symtab/StdNames.scala +++ b/src/compiler/scala/tools/nsc/symtab/StdNames.scala @@ -166,6 +166,12 @@ trait StdNames extends reflect.generic.StdNames { self: SymbolTable => def getterName(name: Name): Name = if (isLocalName(name)) localToGetter(name) else name; + def isExceptionResultName(name: Name) = + (name startsWith EXCEPTION_RESULT_PREFIX) + + def isLoopHeaderLabel(name: Name): Boolean = + (name startsWith WHILE_PREFIX) || (name startsWith DO_WHILE_PREFIX) + def isImplClassName(name: Name): Boolean = name endsWith IMPL_CLASS_SUFFIX; @@ -192,6 +198,11 @@ trait StdNames extends reflect.generic.StdNames { self: SymbolTable => /** The name of bitmaps for initialized lazy vals. */ def bitmapName(n: Int): Name = newTermName("bitmap$" + n) + /** The label prefixes for generated while and do loops. */ + val WHILE_PREFIX = "while$" + val DO_WHILE_PREFIX = "doWhile$" + val EXCEPTION_RESULT_PREFIX = "exceptionResult" + val ERROR = newTermName("<error>") val LOCALCHILD = newTypeName("<local child>") diff --git a/src/compiler/scala/tools/nsc/symtab/Types.scala b/src/compiler/scala/tools/nsc/symtab/Types.scala index f014dfde9c..d5dfc37a31 100644 --- a/src/compiler/scala/tools/nsc/symtab/Types.scala +++ b/src/compiler/scala/tools/nsc/symtab/Types.scala @@ -3720,17 +3720,26 @@ A type's typeSymbol should never be inspected directly. def corresponds(sym1: Symbol, sym2: Symbol): Boolean = sym1.name == sym2.name && (sym1.isPackageClass || corresponds(sym1.owner, sym2.owner)) if (!corresponds(sym.owner, rebind0.owner)) { - if (settings.debug.value) Console.println("ADAPT1 pre = "+pre+", sym = "+sym+sym.locationString+", rebind = "+rebind0+rebind0.locationString) + if (settings.debug.value) + log("ADAPT1 pre = "+pre+", sym = "+sym+sym.locationString+", rebind = "+rebind0+rebind0.locationString) val bcs = pre.baseClasses.dropWhile(bc => !corresponds(bc, sym.owner)); if (bcs.isEmpty) assert(pre.typeSymbol.isRefinementClass, pre) // if pre is a refinementclass it might be a structural type => OK to leave it in. else rebind0 = pre.baseType(bcs.head).member(sym.name) - if (settings.debug.value) Console.println("ADAPT2 pre = "+pre+", bcs.head = "+bcs.head+", sym = "+sym+sym.locationString+", rebind = "+rebind0+(if (rebind0 == NoSymbol) "" else rebind0.locationString)) + if (settings.debug.value) log( + "ADAPT2 pre = " + pre + + ", bcs.head = " + bcs.head + + ", sym = " + sym+sym.locationString + + ", rebind = " + rebind0 + ( + if (rebind0 == NoSymbol) "" + else rebind0.locationString + ) + ) } val rebind = rebind0.suchThat(sym => sym.isType || sym.isStable) if (rebind == NoSymbol) { - if (settings.debug.value) Console.println("" + phase + " " +phase.flatClasses+sym.owner+sym.name+" "+sym.isType) + if (settings.debug.value) log("" + phase + " " +phase.flatClasses+sym.owner+sym.name+" "+sym.isType) throw new MalformedType(pre, sym.nameString) } rebind @@ -5383,13 +5392,13 @@ A type's typeSymbol should never be inspected directly. // @M sometimes hkargs != arg.typeParams, the symbol and the type may have very different type parameters val hkparams = param.typeParams - if(settings.debug.value) { - println("checkKindBoundsHK expected: "+ param +" with params "+ hkparams +" by definition in "+ paramowner) - println("checkKindBoundsHK supplied: "+ arg +" with params "+ hkargs +" from "+ owner) - println("checkKindBoundsHK under params: "+ underHKParams +" with args "+ withHKArgs) + if (settings.debug.value) { + log("checkKindBoundsHK expected: "+ param +" with params "+ hkparams +" by definition in "+ paramowner) + log("checkKindBoundsHK supplied: "+ arg +" with params "+ hkargs +" from "+ owner) + log("checkKindBoundsHK under params: "+ underHKParams +" with args "+ withHKArgs) } - if(hkargs.length != hkparams.length) { + if (hkargs.length != hkparams.length) { if(arg == AnyClass || arg == NothingClass) (Nil, Nil, Nil) // Any and Nothing are kind-overloaded else {error = true; (List((arg, param)), Nil, Nil)} // shortcut: always set error, whether explainTypesOrNot } else { @@ -5414,12 +5423,12 @@ A type's typeSymbol should never be inspected directly. if (!(bindHKParams(transformedBounds(hkparam, paramowner)) <:< transform(hkarg.info.bounds, owner))) stricterBound(hkarg, hkparam) - if(settings.debug.value) { - println("checkKindBoundsHK base case: "+ hkparam +" declared bounds: "+ transformedBounds(hkparam, paramowner) +" after instantiating earlier hkparams: "+ bindHKParams(transformedBounds(hkparam, paramowner))) - println("checkKindBoundsHK base case: "+ hkarg +" has bounds: "+ transform(hkarg.info.bounds, owner)) + if (settings.debug.value) { + log("checkKindBoundsHK base case: "+ hkparam +" declared bounds: "+ transformedBounds(hkparam, paramowner) +" after instantiating earlier hkparams: "+ bindHKParams(transformedBounds(hkparam, paramowner))) + log("checkKindBoundsHK base case: "+ hkarg +" has bounds: "+ transform(hkarg.info.bounds, owner)) } } else { - if(settings.debug.value) println("checkKindBoundsHK recursing to compare params of "+ hkparam +" with "+ hkarg) + if(settings.debug.value) log("checkKindBoundsHK recursing to compare params of "+ hkparam +" with "+ hkarg) val (am, vm, sb) = checkKindBoundsHK(hkarg.typeParams, hkarg, hkparam, paramowner, underHKParams ++ hkparam.typeParams, withHKArgs ++ hkarg.typeParams) arityMismatches(am) varianceMismatches(vm) diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala index 073fd3d4b2..602b3a8637 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala @@ -888,7 +888,7 @@ abstract class ClassfileParser { case nme.ScalaSignatureATTR => if (!isScalaAnnot) { if (settings.debug.value) - global.inform("warning: symbol " + sym.fullName + " has pickled signature in attribute") + log("warning: symbol " + sym.fullName + " has pickled signature in attribute") unpickler.unpickle(in.buf, in.bp, clazz, staticModule, in.file.toString()) } in.skip(attrLen) @@ -916,7 +916,7 @@ abstract class ClassfileParser { throw new RuntimeException("Scala class file does not contain Scala annotation") } if (settings.debug.value) - global.inform("" + sym + "; annotations = " + sym.rawAnnotations) + log("" + sym + "; annotations = " + sym.rawAnnotations) } else in.skip(attrLen) @@ -1033,8 +1033,8 @@ abstract class ClassfileParser { case f: FatalError => throw f // don't eat fatal errors, they mean a class was not found case ex: Throwable => if (settings.debug.value) - global.inform("dropping annotation on " + sym + - ", an error occured during parsing (e.g. annotation class not found)") + log("dropping annotation on " + sym + ", an error occured during parsing (e.g. annotation class not found)") + None // ignore malformed annotations ==> t1135 } diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala index db577d04a1..0739deec5f 100644 --- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala +++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala @@ -501,8 +501,10 @@ abstract class CleanUp extends Transform with ast.TreeDSL { ) case _ => "" } - Console.printf("""Dynamically application '%s.%s(%s)' %s - resulting code: '%s'""", - List(qual, ad.symbol.name, paramsToString(params), mstr, t) map (_.toString) : _* + log( + """Dynamically application '%s.%s(%s)' %s - resulting code: '%s'""".format( + qual, ad.symbol.name, paramsToString(params), mstr, t + ) ) } @@ -554,8 +556,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL { case theTry @ Try(block, catches, finalizer) if theTry.tpe.typeSymbol != definitions.UnitClass && theTry.tpe.typeSymbol != definitions.NothingClass => val tpe = theTry.tpe.widen - val tempVar = currentOwner.newValue(theTry.pos, unit.fresh.newName(theTry.pos, "exceptionResult")) - .setInfo(tpe).setFlag(Flags.MUTABLE) + val tempVar = currentOwner.newVariable(theTry.pos, unit.fresh.newName(theTry.pos, nme.EXCEPTION_RESULT_PREFIX)).setInfo(tpe) def assignBlock(rhs: Tree) = super.transform(BLOCK(Ident(tempVar) === transform(rhs))) val newBlock = assignBlock(block) @@ -563,10 +564,11 @@ abstract class CleanUp extends Transform with ast.TreeDSL { (CASE(super.transform(pattern)) IF (super.transform(guard))) ==> assignBlock(body) val newTry = Try(newBlock, newCatches, super.transform(finalizer)) - localTyper typed { BLOCK(VAL(tempVar) === EmptyTree, newTry, Ident(tempVar)) } + typedWithPos(theTry.pos)(BLOCK(VAL(tempVar) === EmptyTree, newTry, Ident(tempVar))) /* Adds @serializable annotation to anonymous function classes */ case cdef @ ClassDef(mods, name, tparams, impl) => + /** XXX This check is overly specific and bound to break if it hasn't already. */ if (settings.target.value == "jvm-1.5") { val sym = cdef.symbol // is this an anonymous function class? diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala index d22930c336..420ec6b3ba 100644 --- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala +++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala @@ -1193,7 +1193,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { val tree1 = addBody(ddef, target) (new ChangeOwnerTraverser(target, tree1.symbol))(tree1.rhs) if (settings.debug.value) - println("changed owners, now: " + tree1) + log("changed owners, now: " + tree1) val DefDef(mods, name, tparams, vparamss, tpt, rhs) = tree1 treeCopy.DefDef(tree1, mods, name, tparams, vparamss, tpt, transform(rhs)) diff --git a/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala b/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala index e039b00ee8..0e2920a852 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Analyzer.scala @@ -78,6 +78,7 @@ trait Analyzer extends AnyRef resetTyper() // this does not in fact to the reset for each compilation run! override def run { val start = startTimer(typerNanos) + global.echoPhaseSummary(this) currentRun.units foreach applyPhase stopTimer(typerNanos, start) } diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index 5c90a69c94..d7b8d6f2c5 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -966,7 +966,8 @@ abstract class RefChecks extends InfoTransform { typed(ValDef(vsym, EmptyTree)) :: typed(lazyDef) :: Nil } else { if (tree.symbol.isLocal && index <= currentLevel.maxindex && !tree.symbol.hasFlag(LAZY)) { - if (settings.debug.value) Console.println(currentLevel.refsym); + if (settings.debug.value) + Console.println(currentLevel.refsym) unit.error(currentLevel.refpos, "forward reference extends over definition of " + tree.symbol); } List(tree1) diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala index 976c063efc..f4f089931e 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala @@ -201,7 +201,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT sym.alias) setPos tree.pos } if (settings.debug.value) - Console.println("alias replacement: " + tree + " ==> " + result);//debug + log("alias replacement: " + tree + " ==> " + result);//debug localTyper.typed(gen.maybeMkAsInstanceOf(transformSuperSelect(result), sym.tpe, sym.alias.tpe, true)) } else mayNeedProtectedAccessor(sel, List(EmptyTree), false) diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 742f792e84..619aad94dc 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -1866,11 +1866,8 @@ trait Typers { self: Analyzer => } } - private def isLoopHeaderLabel(name: Name): Boolean = - name.startsWith("while$") || name.startsWith("doWhile$") - def typedLabelDef(ldef: LabelDef): LabelDef = { - if (!isLoopHeaderLabel(ldef.symbol.name) || phase.id > currentRun.typerPhase.id) { + if (!nme.isLoopHeaderLabel(ldef.symbol.name) || phase.id > currentRun.typerPhase.id) { val restpe = ldef.symbol.tpe.resultType val rhs1 = typed(ldef.rhs, restpe) ldef.params foreach (param => param.tpe = param.symbol.tpe) @@ -3602,7 +3599,14 @@ trait Typers { self: Analyzer => if (tree1 != EmptyTree) return typed1(tree1, mode, pt) } - if (settings.debug.value) Console.err.println("qual = "+qual+":"+qual.tpe+"\nSymbol="+qual.tpe.termSymbol+"\nsymbol-info = "+qual.tpe.termSymbol.info+"\nscope-id = "+qual.tpe.termSymbol.info.decls.hashCode()+"\nmembers = "+qual.tpe.members+"\nname = "+name+"\nfound = "+sym+"\nowner = "+context.enclClass.owner) + if (settings.debug.value) { + log( + "qual = "+qual+":"+qual.tpe+ + "\nSymbol="+qual.tpe.termSymbol+"\nsymbol-info = "+qual.tpe.termSymbol.info+ + "\nscope-id = "+qual.tpe.termSymbol.info.decls.hashCode()+"\nmembers = "+qual.tpe.members+ + "\nname = "+name+"\nfound = "+sym+"\nowner = "+context.enclClass.owner + ) + } def makeErrorTree = { val tree1 = tree match { @@ -4195,7 +4199,8 @@ trait Typers { self: Analyzer => def typed(tree: Tree, mode: Int, pt: Type): Tree = { indentTyping() def dropExistential(tp: Type): Type = tp match { case ExistentialType(tparams, tpe) => - if (settings.debug.value) println("drop ex "+tree+" "+tp) + if (settings.debug.value) + log("Dropping existential: " + tree + " " + tp) new SubstWildcardMap(tparams).apply(tp) case TypeRef(_, sym, _) if sym.isAliasType => val tp0 = tp.normalize |