diff options
author | Iulian Dragos <jaguarul@gmail.com> | 2010-04-09 15:43:35 +0000 |
---|---|---|
committer | Iulian Dragos <jaguarul@gmail.com> | 2010-04-09 15:43:35 +0000 |
commit | 53256b43ff73b93f91228d262a09467d7d6bcf29 (patch) | |
tree | 0313a5fc2f2c843afcaef39bd6dca386f3c44a2b | |
parent | 2209c911ce5f2a8a3f2115d83dcac400227aba6e (diff) | |
download | scala-53256b43ff73b93f91228d262a09467d7d6bcf29.tar.gz scala-53256b43ff73b93f91228d262a09467d7d6bcf29.tar.bz2 scala-53256b43ff73b93f91228d262a09467d7d6bcf29.zip |
Less logging unless '-Ydebug', refactorings.
3 files changed, 46 insertions, 38 deletions
diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala index 9f2065f297..f8678ce24e 100644 --- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala +++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala @@ -191,6 +191,19 @@ abstract class TreeGen def mkAsInstanceOf(value: Tree, tpe: Type, any: Boolean = true): Tree = mkTypeApply(value, tpe, (if (any) Any_asInstanceOf else Object_asInstanceOf)) + /** Cast `tree' to 'pt', unless tpe is a subtype of pt, or pt is Unit. */ + def maybeMkAsInstanceOf(tree: Tree, pt: Type, tpe: Type, beforeRefChecks: Boolean = false): Tree = + if ((pt == UnitClass.tpe) || (tpe <:< pt)) { + log("no need to cast from " + tpe + " to " + pt) + tree + } else + atPos(tree.pos) { + if (beforeRefChecks) + TypeApply(mkAttributedSelect(tree, Any_asInstanceOf), List(TypeTree(pt))) + else + mkAsInstanceOf(tree, pt) + } + def mkClassOf(tp: Type): Tree = Literal(Constant(tp)) setType ConstantType(Constant(tp))// ClassType(tp) diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala index ad58ad6758..e43f5e91e5 100644 --- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala +++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala @@ -405,7 +405,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { res.reverse.toList } - var parents = List(applyContext(clazz.tpe)) + var parents = List(applyContext(atPhase(currentRun.typerPhase)(clazz.tpe))) if (parents.head.typeSymbol.isTrait) parents = parents.head.parents.head :: parents val extraSpecializedMixins = specializedParents(clazz.info.parents.map(applyContext)) @@ -462,7 +462,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { log("specializedClass: " + cls) for (m <- normMembers if needsSpecialization(outerEnv ++ env, m) && satisfiable(fullEnv)) { - log(" * looking at: " + m) + if (settings.debug.value) log(" * looking at: " + m) if (!m.isDeferred) concreteSpecMethods += m // specialized members have to be overridable. @@ -490,7 +490,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { } else if (m.isDeferred) { // abstract methods val specMember = enterMember(m.cloneSymbol(cls)).setFlag(SPECIALIZED).resetFlag(DEFERRED) - log("deferred " + specMember.fullName + " is forwarded") + if (settings.debug.value) log("deferred " + specMember.fullName + " is forwarded") info(specMember) = new Forward(specMember) { override def target = m.owner.info.member(specializedName(m, env)) @@ -522,7 +522,8 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { enterMember(specVal) // create accessors - log("m: " + m + " isLocal: " + nme.isLocalName(m.name) + " specVal: " + specVal.name + " isLocal: " + nme.isLocalName(specVal.name)) + if (settings.debug.value) + log("m: " + m + " isLocal: " + nme.isLocalName(m.name) + " specVal: " + specVal.name + " isLocal: " + nme.isLocalName(specVal.name)) if (nme.isLocalName(m.name)) { val specGetter = mkAccessor(specVal, nme.localToGetter(specVal.name)).setInfo(MethodType(List(), specVal.info)) val origGetter = overrideIn(cls, m.getter(clazz)) @@ -557,7 +558,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { typeEnv(specClass) = fullEnv specClass.name = specializedName(specClass, fullEnv) enterMember(specClass) - log("entered specialized class with info " + specClass.fullName + ": " + specClass.info) + log("entered specialized class " + specClass.fullName) info(specClass) = SpecializedInnerClass(m, fullEnv) } } @@ -682,12 +683,14 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { val opc = new overridingPairs.Cursor(clazz) val oms = new mutable.ListBuffer[Symbol] while (opc.hasNext) { - log("\toverriding pairs: " + opc.overridden.fullName + ": " + opc.overridden.info - + " overridden by " + opc.overriding.fullName + ": " + opc.overriding.info) + if (settings.debug.value) + log("\toverriding pairs: " + opc.overridden.fullName + ": " + opc.overridden.info + + " overriden by " + opc.overriding.fullName + ": " + opc.overriding.info) if (opc.overriding.owner == clazz && !specializedTypeVars(opc.overridden.info).isEmpty) { - log("\t\tspecializedTVars: " + specializedTypeVars(opc.overridden.info)) + if (settings.debug.value) log("\t\tspecializedTVars: " + specializedTypeVars(opc.overridden.info)) val env = unify(opc.overridden.info, opc.overriding.info, emptyEnv) - log("\t\tenv: " + env + "isValid: " + if (settings.debug.value) + log("\t\tenv: " + env + "isValid: " + TypeEnv.isValid(env, opc.overridden) + " exists: " + opc.overridden.owner.info.decl(specializedName(opc.overridden, env))) if (!env.isEmpty @@ -960,11 +963,11 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { case TypeApply(Select(qual, name), targs) if (!specializedTypeVars(symbol.info).isEmpty && name != nme.CONSTRUCTOR) => - log("checking typeapp for rerouting: " + tree + " with sym.tpe: " + symbol.tpe + " tree.tpe: " + tree.tpe) + if (settings.debug.value) log("checking typeapp for rerouting: " + tree + " with sym.tpe: " + symbol.tpe + " tree.tpe: " + tree.tpe) val qual1 = transform(qual) specSym(qual1) match { case Some(specMember) => - log("found " + specMember) + if (settings.debug.value) log("found " + specMember) assert(symbol.info.typeParams.length == targs.length) val env = typeEnv(specMember) val residualTargs = @@ -979,10 +982,12 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { } case Select(qual, name) => - log("looking at Select: " + tree + " sym: " + symbol + ": " + symbol.info + "[tree.tpe: " + tree.tpe + "]") + if (settings.debug.value) + log("looking at Select: " + tree + " sym: " + symbol + ": " + symbol.info + "[tree.tpe: " + tree.tpe + "]") //if (settings.debug.value) log("\toverloads: " + overloads.mkString("", "\n", "")) if (!specializedTypeVars(symbol.info).isEmpty && name != nme.CONSTRUCTOR) { - log("checking for unification at " + tree + " with sym.tpe: " + symbol.tpe + " and tree.tpe: " + tree.tpe + " at " + tree.pos.line) + if (settings.debug.value) + log("checking for unification at " + tree + " with sym.tpe: " + symbol.tpe + " and tree.tpe: " + tree.tpe + " at " + tree.pos.line) val env = unify(symbol.tpe, tree.tpe, emptyEnv) log("checking for rerouting: " + tree + " with sym.tpe: " + symbol.tpe + " tree.tpe: " + tree.tpe + " env: " + env) if (!env.isEmpty) { @@ -1016,7 +1021,6 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { case PackageDef(pid, stats) => tree.symbol.info // make sure specializations have been performed - log("PackageDef owner: " + symbol) atOwner(tree, symbol) { val specMembers = implSpecClasses(stats) map localTyper.typed treeCopy.PackageDef(tree, pid, transformStats(stats ::: specMembers, symbol.moduleClass)) @@ -1036,7 +1040,6 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { forwardCall(tree.pos, superRef, vparamss) } val tree1 = atPos(symbol.pos)(treeCopy.DefDef(tree, mods, name, tparams, vparamss, tpt, Block(List(t), Literal(())))) - log(tree1) localTyper.typed(tree1) } else info(symbol) match { @@ -1044,7 +1047,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { assert(body.isDefinedAt(target), "sym: " + symbol.fullName + " target: " + target.fullName) // we have an rhs, specialize it val tree1 = duplicateBody(ddef, target) - log("implementation: " + tree1) + if (settings.debug.value) log("implementation: " + tree1) val DefDef(mods, name, tparams, vparamss, tpt, rhs) = tree1 treeCopy.DefDef(tree1, mods, name, tparams, vparamss, tpt, transform(rhs)) @@ -1076,7 +1079,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { } else { // we have an rhs, specialize it val tree1 = duplicateBody(ddef, target) - log("implementation: " + tree1) + if (settings.debug.value) log("implementation: " + tree1) val DefDef(mods, name, tparams, vparamss, tpt, rhs) = tree1 treeCopy.DefDef(tree1, mods, name, tparams, vparamss, tpt, transform(rhs)) } @@ -1087,16 +1090,17 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { val fun = Apply(Select(This(symbol.owner), original), makeArguments(original, vparamss.head)) - maybeCastTo(symbol.owner.thisType.memberType(symbol).finalResultType, - symbol.owner.thisType.memberType(original).finalResultType, - fun) + gen.maybeMkAsInstanceOf(fun, + symbol.owner.thisType.memberType(symbol).finalResultType, + symbol.owner.thisType.memberType(original).finalResultType) }) log("created " + t) localTyper.typed(t) case fwd @ Forward(_) => val rhs1 = forwardCall(tree.pos, gen.mkAttributedRef(symbol.owner.thisType, fwd.target), vparamss) - log("completed forwarder to specialized overload: " + fwd.target + ": " + rhs1) + if (settings.debug.value) + log("completed forwarder to specialized overload: " + fwd.target + ": " + rhs1) localTyper.typed(treeCopy.DefDef(tree, mods, name, tparams, vparamss, tpt, rhs1)) case SpecializedAccessor(target) => @@ -1110,7 +1114,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { case ValDef(mods, name, tpt, rhs) if symbol.hasFlag(SPECIALIZED) => assert(body.isDefinedAt(symbol.alias)) val tree1 = treeCopy.ValDef(tree, mods, name, tpt, body(symbol.alias).duplicate) - log("now typing: " + tree1 + " in " + tree.symbol.owner.fullName) + if (settings.debug.value) log("now typing: " + tree1 + " in " + tree.symbol.owner.fullName) val d = new Duplicator d.retyped(localTyper.context1.asInstanceOf[d.Context], tree1, @@ -1136,10 +1140,10 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { private def duplicateBody(tree: DefDef, target: Symbol): Tree = { val symbol = tree.symbol - log("specializing body of" + symbol.fullName + ": " + symbol.info) + if (settings.debug.value) log("specializing body of" + symbol.fullName + ": " + symbol.info) val DefDef(mods, name, tparams, vparamss, tpt, _) = tree val (_, origtparams) = splitParams(target.typeParams) - log("substituting " + origtparams + " for " + symbol.typeParams) + if (settings.debug.value) log("substituting " + origtparams + " for " + symbol.typeParams) // skolemize type parameters val (oldtparams, newtparams) = reskolemize(tparams) @@ -1187,17 +1191,17 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { /** All private members that are referenced are made protected, * in order to be accessible from specialized subclasses. */ - override def traverse(tree: Tree): Unit = tree match { + override def transform(tree: Tree): Tree = tree match { case Select(qual, name) => if (tree.symbol.hasFlag(PRIVATE | PROTECTED)) { log("changing private flag of " + tree.symbol) // tree.symbol.resetFlag(PRIVATE).setFlag(PROTECTED) tree.symbol.resetFlag(PRIVATE | PROTECTED) } - super.traverse(tree) + super.transform(tree) case _ => - super.traverse(tree) + super.transform(tree) } } @@ -1330,15 +1334,6 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { else tp.info.bounds.hi } - /** Cast `tree' to 'pt', unless tpe is a subtype of pt, or pt is Unit. */ - def maybeCastTo(pt: Type, tpe: Type, tree: Tree): Tree = - if ((pt == definitions.UnitClass.tpe) || (tpe <:< pt)) { - log("no need to cast from " + tpe + " to " + pt) - tree - } else - gen.mkAsInstanceOf(tree, pt) - - private def makeArguments(fun: Symbol, vparams: List[Symbol]): List[Tree] = { def needsCast(tp1: Type, tp2: Type): Boolean = !(tp1 <:< tp2) diff --git a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala index fc2f71f31b..1dbeb0afd9 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala @@ -181,7 +181,7 @@ abstract class Duplicators extends Analyzer { * namer/typer handle them, or Idents that refer to them. */ override def typed(tree: Tree, mode: Int, pt: Type): Tree = { - log("typing " + tree) + if (settings.debug.value) log("typing " + tree + ": " + tree.tpe) if (tree.hasSymbol && tree.symbol != NoSymbol && !tree.symbol.isLabel // labels cannot be retyped by the type checker as LabelDef has no ValDef/return type trees && invalidSyms.isDefinedAt(tree.symbol)) { @@ -241,7 +241,7 @@ abstract class Duplicators extends Analyzer { case This(_) if (oldClassOwner ne null) && (tree.symbol == oldClassOwner) => // val tree1 = Typed(This(newClassOwner), TypeTree(fixType(tree.tpe.widen))) val tree1 = This(newClassOwner) - log("mapped " + tree + " to " + tree1) + if (settings.debug.value) log("mapped " + tree + " to " + tree1) super.typed(atPos(tree.pos)(tree1), mode, pt) case Super(qual, mix) if (oldClassOwner ne null) && (tree.symbol == oldClassOwner) => |