diff options
author | Paul Phillips <paulp@improving.org> | 2011-05-01 05:10:58 +0000 |
---|---|---|
committer | Paul Phillips <paulp@improving.org> | 2011-05-01 05:10:58 +0000 |
commit | 269ea9ab579f0e7ff14df31caa0981627f051958 (patch) | |
tree | 962682a6522e59ee96fb66724d4a48cf24069868 /src | |
parent | a02b2daa2a46661a3c108d26c738b4dbb836ea4d (diff) | |
download | scala-269ea9ab579f0e7ff14df31caa0981627f051958.tar.gz scala-269ea9ab579f0e7ff14df31caa0981627f051958.tar.bz2 scala-269ea9ab579f0e7ff14df31caa0981627f051958.zip |
Since I don't want to commit anything "interest...
Since I don't want to commit anything "interesting" until we ship 2.9, a
few uninteresting cleanups involving how types are printed, getting some
debugging code in shape to prepare for the long winter ahead, etc. No
review.
Diffstat (limited to 'src')
12 files changed, 131 insertions, 94 deletions
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index bdf9718e2a..6af7fe991f 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -881,7 +881,7 @@ class Global(var settings: Settings, var reporter: Reporter) extends SymbolTable atPhase(phase.next) { trackers foreach { t => t.snapshot() - inform(t.show()) + inform(t.show("Heading from " + phase.prev.name + " to " + phase.name)) } } } diff --git a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala index 405da29a57..db616e9657 100644 --- a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala +++ b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala @@ -449,7 +449,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { thisFactory else if (bSym.isMethod && !bSym.hasAccessorFlag && !bSym.isConstructor && !bSym.isModule) { val cSym = { // This unsightly hack closes issue #4086. if (bSym == definitions.Object_synchronized) { - val cSymInfo = bSym.info match { + val cSymInfo = (bSym.info: @unchecked) match { case PolyType(ts, MethodType(List(bp), mt)) => val cp = bp.cloneSymbol.setInfo(appliedType(definitions.ByNameParamClass.typeConstructor, List(bp.info))) PolyType(ts, MethodType(List(cp), mt)) diff --git a/src/compiler/scala/tools/nsc/interpreter/Power.scala b/src/compiler/scala/tools/nsc/interpreter/Power.scala index 8e546519e5..5a0830841d 100644 --- a/src/compiler/scala/tools/nsc/interpreter/Power.scala +++ b/src/compiler/scala/tools/nsc/interpreter/Power.scala @@ -106,11 +106,12 @@ abstract class Power[G <: Global]( val modClass = pkgSymbol.moduleClass /** Looking for dwindling returns */ - def droppedEnough() = unseenHistory.size >= 4 && ( - unseenHistory.takeRight(4).sliding(2) map (_.toList) forall { - case List(a, b) => a > b + def droppedEnough() = unseenHistory.size >= 4 && { + unseenHistory takeRight 4 sliding 2 forall { it => + val List(a, b) = it.toList + a > b } - ) + } def isRecur(sym: Symbol) = true def isIgnore(sym: Symbol) = sym.isAnonOrRefinementClass || (sym.name.toString contains "$mc") diff --git a/src/compiler/scala/tools/nsc/symtab/NameManglers.scala b/src/compiler/scala/tools/nsc/symtab/NameManglers.scala index ce372b6e50..c40e1765ce 100644 --- a/src/compiler/scala/tools/nsc/symtab/NameManglers.scala +++ b/src/compiler/scala/tools/nsc/symtab/NameManglers.scala @@ -66,6 +66,7 @@ trait NameManglers { self: nme.type => val IMPL_CLASS_SUFFIX = "$class" + val SINGLETON_SUFFIX = ".type" val LOCALDUMMY_PREFIX = "<local " // owner of local blocks val PROTECTED_PREFIX = "protected$" val PROTECTED_SET_PREFIX = PROTECTED_PREFIX + "set" @@ -84,6 +85,7 @@ trait NameManglers { def isProtectedAccessorName(name: Name) = name startsWith PROTECTED_PREFIX def isSetterName(name: Name) = name endsWith SETTER_SUFFIX def isTraitSetterName(name: Name) = isSetterName(name) && (name containsName TRAIT_SETTER_SEPARATOR_STRING) + def isSingletonName(name: Name) = name endsWith SINGLETON_SUFFIX def isOpAssignmentName(name: Name) = name match { case raw.NE | raw.LE | raw.GE | EMPTY => false @@ -152,6 +154,8 @@ trait NameManglers { else name } + def dropSingletonName(name: Name): TypeName = name stripEnd SINGLETON_SUFFIX toTypeName + def singletonName(name: Name): TypeName = name append SINGLETON_SUFFIX toTypeName def implClassName(name: Name): TypeName = name append IMPL_CLASS_SUFFIX toTypeName def interfaceName(implname: Name): TypeName = implname stripEnd IMPL_CLASS_SUFFIX toTypeName def localDummyName(clazz: Symbol): TermName = newTermName(LOCALDUMMY_PREFIX + clazz.name + ">") diff --git a/src/compiler/scala/tools/nsc/symtab/StdNames.scala b/src/compiler/scala/tools/nsc/symtab/StdNames.scala index f60bd17b32..4a7f52f2b5 100644 --- a/src/compiler/scala/tools/nsc/symtab/StdNames.scala +++ b/src/compiler/scala/tools/nsc/symtab/StdNames.scala @@ -191,7 +191,6 @@ trait StdNames extends reflect.generic.StdNames with NameManglers { val copy: NameType = "copy" val delayedInit: NameType = "delayedInit" val delayedInitArg: NameType = "delayedInit$body" - val dottype: NameType = ".type" val drop: NameType = "drop" val elem: NameType = "elem" val eq: NameType = "eq" diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolTrackers.scala b/src/compiler/scala/tools/nsc/symtab/SymbolTrackers.scala index 870787a9ea..1f32355bf7 100644 --- a/src/compiler/scala/tools/nsc/symtab/SymbolTrackers.scala +++ b/src/compiler/scala/tools/nsc/symtab/SymbolTrackers.scala @@ -131,7 +131,11 @@ trait SymbolTrackers { else " (" + Flags.flagsToString(masked) + ")" } def symString(sym: Symbol) = ( - sym + changedOwnerString + flagSummaryString + if (settings.debug.value && sym.hasRawInfo && sym.rawInfo.isComplete) { + val s = sym.defString take 240 + if (s.length == 240) s + "..." else s + } + else sym + changedOwnerString + flagSummaryString ) def flatten = children.foldLeft(Set(root))(_ ++ _.flatten) @@ -173,7 +177,7 @@ trait SymbolTrackers { prevFlags = current map (s => (s, (s.flags & flagsMask))) toMap; history = change :: history } - def show(): String = { + def show(label: String): String = { val hierarchy = Node(current) val Change(added, removed, symMap, owners, flags) = history.head def detailString(sym: Symbol) = { @@ -194,7 +198,7 @@ trait SymbolTrackers { "" + hierarchy + ( if (removed.isEmpty) "" - else "\n\n!!! %s symbols vanished:\n".format(removed.size) + removedString + else "\n\n!!! " + label + ", " + removed.size + " symbols vanished:\n" + removedString ) } } diff --git a/src/compiler/scala/tools/nsc/symtab/Symbols.scala b/src/compiler/scala/tools/nsc/symtab/Symbols.scala index 5eb8b1ced4..faa698bfe8 100644 --- a/src/compiler/scala/tools/nsc/symtab/Symbols.scala +++ b/src/compiler/scala/tools/nsc/symtab/Symbols.scala @@ -339,8 +339,9 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => final def isCapturedVariable = isVariable && hasFlag(CAPTURED) final def isGetter = isTerm && hasAccessorFlag && !nme.isSetterName(name) + // todo: make independent of name, as this can be forged. final def isSetter = isTerm && hasAccessorFlag && nme.isSetterName(name) - //todo: make independent of name, as this can be forged. + def isSetterParameter = isValueParameter && owner.isSetter final def hasGetter = isTerm && nme.isLocalName(name) @@ -1561,7 +1562,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => // ToString ------------------------------------------------------------------- /** A tag which (in the ideal case) uniquely identifies class symbols */ - final def tag: Int = fullName.hashCode() + final def tag = fullName.## /** The simple name of this Symbol */ final def simpleName: Name = name @@ -1571,7 +1572,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => * (the initial Name) before falling back on id, which varies depending * on exactly when a symbol is loaded. */ - final def sealedSortName: String = initName.toString + "#" + id + final def sealedSortName = initName + "#" + id /** String representation of symbol's definition key word */ final def keyString: String = @@ -1586,12 +1587,21 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => else if (isTerm && (!isParameter || isParamAccessor)) "val" else "" - /** String representation of symbol's kind */ - final def kindString: String = - if (isPackageClass) - if (settings.debug.value) "package class" else "package" - else if (isModuleClass) - if (settings.debug.value) "singleton class" else "object" + /** Accurate string representation of symbols' kind, suitable for developers. */ + final def accurateKindString: String = + if (isPackage) "package" + else if (isPackageClass) "package class" + else if (isPackageObject) "package object" + else if (isPackageObjectClass) "package object class" + else if (isRefinementClass) "refinement class" + else if (isModule) "module" + else if (isModuleClass) "module class" + else sanitizedKindString + + /** String representation of symbol's kind, suitable for the masses. */ + private def sanitizedKindString: String = + if (isPackage || isPackageClass) "package" + else if (isModule || isModuleClass) "object" else if (isAnonymousClass) "anonymous class" else if (isRefinementClass) "" else if (isTrait) "trait" @@ -1599,42 +1609,61 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => else if (isType) "type" else if (isTerm && isLazy) "lazy value" else if (isVariable) "variable" - else if (isPackage) "package" - else if (isModule) "object" else if (isClassConstructor) "constructor" else if (isSourceMethod) "method" else if (isTerm) "value" else "" + final def kindString: String = + if (settings.debug.value) accurateKindString + else sanitizedKindString + + /** If the name of the symbol's owner should be used when you care about + * seeing an interesting name: in such cases this symbol is e.g. a method + * parameter with a synthetic name, a constructor named "this", an object + * "package", etc. The kind string, if non-empty, will be phrased relative + * to the name of the owner. + */ + def hasMeaninglessName = ( + isSetterParameter // x$1 + || isClassConstructor // this + || isPackageObject // package + || isPackageObjectClass // package$ + || isRefinementClass // <refinement> + ) + /** String representation of symbol's simple name. * If !settings.debug translates expansions of operators back to operator symbol. * E.g. $eq => =. - * If settings.uniquId adds id. + * If settings.uniqid, adds id. */ - def nameString: String = decodedName + idString + def nameString = decodedName + idString /** If settings.uniqid is set, the symbol's id, else "" */ - final def idString: String = - if (settings.uniqid.value) "#"+id // +" in "+owner.name+"#"+owner.id // DEBUG - else "" + final def idString = if (settings.uniqid.value) "#"+id else "" - /** String representation, including symbol's kind - * e.g., "class Foo", "method Bar". + /** String representation, including symbol's kind e.g., "class Foo", "method Bar". + * If hasMeaninglessName is true, uses the owner's name to disambiguate identity. */ - override def toString(): String = - if (isValueParameter && owner.isSetter) - "parameter of setter "+owner.nameString - else if (isPackageObject || isPackageObjectClass) - "package object "+owner.nameString - else - compose(List(kindString, - if (isClassConstructor) owner.simpleName.decode+idString else nameString)) + override def toString = compose( + kindString, + if (hasMeaninglessName) owner.nameString else nameString + ) - /** String representation of location. */ - def locationString: String = { + /** String representation of location. + */ + def ownsString = { val owns = owner.skipPackageObject - if (!owns.isClass || (owns.printWithoutPrefix && owns != ScalaPackageClass)) "" - else " in " + owns + if (owns.isClass && !owns.printWithoutPrefix && !isScalaPackageClass) "" + owns + else "" + } + + /** String representation of location, plus a preposition. Doesn't do much, + * for backward compatibility reasons. + */ + def locationString = ownsString match { + case "" => "" + case s => " in " + s } def fullLocationString = toString + locationString @@ -1696,23 +1725,24 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => def defaultFlagString = hasFlagsToString(defaultFlagMask) /** String representation of symbol's definition */ - def defString: String = { - compose(List(defaultFlagString, keyString, varianceString + nameString + - (if (hasRawInfo) infoString(rawInfo) else "<_>"))) - } + def defString = compose( + defaultFlagString, + keyString, + varianceString + nameString + ( + if (hasRawInfo) infoString(rawInfo) else "<_>" + ) + ) /** Concatenate strings separated by spaces */ - private def compose(ss: List[String]): String = - ss.filter("" !=).mkString("", " ", "") + private def compose(ss: String*) = ss filter (_ != "") mkString " " - def isSingletonExistential: Boolean = - (name endsWith nme.dottype) && (info.bounds.hi.typeSymbol isSubClass SingletonClass) + def isSingletonExistential = + nme.isSingletonName(name) && (info.bounds.hi.typeSymbol isSubClass SingletonClass) /** String representation of existentially bound variable */ def existentialToString = if (isSingletonExistential && !settings.debug.value) - "val "+name.subName(0, name.length - nme.dottype.length)+": "+ - dropSingletonType(info.bounds.hi) + "val " + nme.dropSingletonName(name) + ": " + dropSingletonType(info.bounds.hi) else defString } diff --git a/src/compiler/scala/tools/nsc/symtab/TypeDebugging.scala b/src/compiler/scala/tools/nsc/symtab/TypeDebugging.scala index 5ed7344bd8..62e812704b 100644 --- a/src/compiler/scala/tools/nsc/symtab/TypeDebugging.scala +++ b/src/compiler/scala/tools/nsc/symtab/TypeDebugging.scala @@ -14,6 +14,7 @@ trait TypeDebugging { // @M toString that is safe during debugging (does not normalize, ...) object TypeDebugStrings { object str { + def parentheses(xs: List[_]): String = xs.mkString("(", ", ", ")") def brackets(xs: List[_]): String = if (xs.isEmpty) "" else xs.mkString("[", ", ", "]") def tparams(tparams: List[Type]): String = brackets(tparams map debug) def parents(ps: List[Type]): String = (ps map debug).mkString(" with ") @@ -47,7 +48,7 @@ trait TypeDebugging { println("toLongString = " + toLongString) } - def debug(tp: Type): String = tp match { + private def debug(tp: Type): String = tp match { case TypeRef(pre, sym, args) => debug(pre) + "." + sym.nameString + str.tparams(args) case ThisType(sym) => sym.nameString + ".this" case SingleType(pre, sym) => debug(pre) +"."+ sym.nameString +".type" @@ -59,8 +60,13 @@ trait TypeDebugging { case ExistentialType(tparams, qtpe) => "forSome "+ str.brackets(tparams) + " " + debug(qtpe) case _ => tp.toString } + def debugString(tp: Type) = debug(tp) } + private def TDS = TypeDebugStrings - def debugString(tp: Type) = TypeDebugStrings.debug(tp) + def paramString(tp: Type) = TDS.str parentheses (tp.params map (_.defString)) + def typeParamsString(tp: Type) = TDS.str brackets (tp.typeParams map (_.defString)) + def typeArgsString(tp: Type) = TDS.str brackets (tp.typeArgs map (_.safeToString)) + def debugString(tp: Type) = TDS debugString tp } diff --git a/src/compiler/scala/tools/nsc/symtab/Types.scala b/src/compiler/scala/tools/nsc/symtab/Types.scala index 7f2a7f42bd..61e1d118c5 100644 --- a/src/compiler/scala/tools/nsc/symtab/Types.scala +++ b/src/compiler/scala/tools/nsc/symtab/Types.scala @@ -1372,7 +1372,7 @@ trait Types extends reflect.generic.Types { self: SymbolTable => // parents forall (p => p.isNullable && !p.typeSymbol.isAbstractType); override def safeToString: String = - parents.mkString("", " with ", "") + + parents.mkString(" with ") + (if (settings.debug.value || parents.isEmpty || (decls.elems ne null)) decls.mkString("{", "; ", "}") else "") } @@ -1910,8 +1910,6 @@ A type's typeSymbol should never be inspected directly. pre.prefixString + sym.nameString var str = monopart + (if (args.isEmpty) "" else args.mkString("[", ",", "]")) - //if (sym.nameString startsWith "moduleType") - // str += ("_in_"+sym.ownerChain) if (sym.isPackageClass) packagePrefix + str else if (sym.isModuleClass) @@ -1930,19 +1928,19 @@ A type's typeSymbol should never be inspected directly. else str } - override def prefixString = + override def prefixString = "" + ( if (settings.debug.value) super.prefixString else if (sym.printWithoutPrefix) "" else if (sym.isPackageClass) sym.fullName + "." - else if (isStable && (sym.name endsWith ".type")) - sym.name.toString dropRight 4 + else if (isStable && nme.isSingletonName(sym.name)) + nme.dropSingletonName(sym.name) + "." else super.prefixString - - override def kind = "TypeRef" + ) + override def kind = "TypeRef" } object TypeRef extends TypeRefExtractor { @@ -2006,8 +2004,7 @@ A type's typeSymbol should never be inspected directly. override def finalResultType: Type = resultType.finalResultType - override def safeToString: String = - params.map(_.defString).mkString("(", ",", ")") + resultType + override def safeToString = paramString(this) + resultType override def cloneInfo(owner: Symbol) = { val vparams = cloneSymbols(params, owner) @@ -2099,8 +2096,7 @@ A type's typeSymbol should never be inspected directly. override def isHigherKinded = !typeParams.isEmpty - override def safeToString: String = - (typeParams map (_.defString) mkString ("[", ",", "]"))+ resultType + override def safeToString = typeParamsString(this) + resultType override def cloneInfo(owner: Symbol) = { val tparams = cloneSymbols(typeParams, owner) @@ -2451,32 +2447,31 @@ A type's typeSymbol should never be inspected directly. } } - override val isHigherKinded = typeArgs.isEmpty && !params.isEmpty + override val isHigherKinded = typeArgs.isEmpty && params.nonEmpty override def normalize: Type = - if (constr.instValid) constr.inst - else if (isHigherKinded) { // get here when checking higher-order subtyping of the typevar by itself (TODO: check whether this ever happens?) - typeFun(params, applyArgs(params map (_.typeConstructor))) - } else { - super.normalize - } + if (constr.instValid) constr.inst + // get here when checking higher-order subtyping of the typevar by itself + // TODO: check whether this ever happens? + else if (isHigherKinded) typeFun(params, applyArgs(params map (_.typeConstructor))) + else super.normalize override def typeSymbol = origin.typeSymbol - override def safeToString: String = { - def varString = "?"+(if (settings.explaintypes.value) level else "")+ - origin+ - (if(typeArgs.isEmpty) "" else (typeArgs map (_.safeToString)).mkString("[ ", ", ", " ]")) // +"#"+tid //DEBUG - if (constr.inst eq null) "<null " + origin + ">" - // else if (settings.debug.value) varString+"(@"+constr.## +")"+constr.toString - else if (constr.inst eq NoType) varString - else constr.inst.toString - } override def isStable = origin.isStable override def isVolatile = origin.isVolatile + + private def levelString = if (settings.explaintypes.value) level else "" + override def safeToString = constr.inst match { + case null => "<null " + origin + ">" + case NoType => "?" + levelString + origin + typeArgsString(this) + case x => "" + x + } override def kind = "TypeVar" def cloneInternal = { - assert(!suspended) // cloning a suspended type variable when it's suspended will cause the clone to never be resumed with the current implementation + // cloning a suspended type variable when it's suspended will cause the clone + // to never be resumed with the current implementation + assert(!suspended) TypeVar(origin, constr cloneInternal, typeArgs, params) // @M TODO: clone args/params? } } @@ -2523,14 +2518,12 @@ A type's typeSymbol should never be inspected directly. override def withSelfsym(sym: Symbol) = AnnotatedType(annotations, underlying, sym) - /** Drop the annotations on the bounds, unless but the low and high bounds are - * exactly tp. */ - override def bounds: TypeBounds = { - val oftp = underlying.bounds - oftp match { - case TypeBounds(lo, hi) if ((lo eq this) && (hi eq this)) => TypeBounds(this,this) - case _ => oftp - } + /** Drop the annotations on the bounds, unless but the low and high + * bounds are exactly tp. + */ + override def bounds: TypeBounds = underlying.bounds match { + case TypeBounds(_: this.type, _: this.type) => TypeBounds(this, this) + case oftp => oftp } // ** Replace formal type parameter symbols with actual type arguments. * / diff --git a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala index fcf5c077d7..78541db82a 100644 --- a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala +++ b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala @@ -48,8 +48,8 @@ abstract class AddInterfaces extends InfoTransform { private val implMethodMap = new mutable.HashMap[Symbol, Symbol] override def newPhase(prev: scala.tools.nsc.Phase): StdPhase = { - implClassMap.clear - implMethodMap.clear + implClassMap.clear() + implMethodMap.clear() super.newPhase(prev) } diff --git a/src/library/scala/collection/immutable/Range.scala b/src/library/scala/collection/immutable/Range.scala index 2b1e4bff13..7bd3764e3e 100644 --- a/src/library/scala/collection/immutable/Range.scala +++ b/src/library/scala/collection/immutable/Range.scala @@ -328,7 +328,7 @@ object Range { def inclusive(start: Int, end: Int, step: Int) = NumericRange.inclusive(start, end, step) } - @deprecated("use Range instead") + @deprecated("use Range instead", "2.9.0") trait ByOne extends Range { @bridge override def foreach[@specialized(Unit) U](f: Int => U) = super.foreach(f) diff --git a/src/library/scala/collection/immutable/TrieIterator.scala b/src/library/scala/collection/immutable/TrieIterator.scala index 088b280b8a..c2cd0b2efd 100644 --- a/src/library/scala/collection/immutable/TrieIterator.scala +++ b/src/library/scala/collection/immutable/TrieIterator.scala @@ -37,8 +37,8 @@ private[collection] abstract class TrieIterator[+T](elems: Array[Iterable[T]]) e private[this] var subIter = initSubIter private[this] def getElems(x: Iterable[T]): Array[Iterable[T]] = (x match { - case x: HashTrieMap[a, b] => x.elems - case x: HashTrieSet[T] => x.elems + case x: HashTrieMap[_, _] => x.elems + case x: HashTrieSet[_] => x.elems }).asInstanceOf[Array[Iterable[T]]] private[this] def collisionToArray(x: Iterable[T]): Array[Iterable[T]] = (x match { |