diff options
Diffstat (limited to 'src/compiler')
11 files changed, 114 insertions, 87 deletions
diff --git a/src/compiler/scala/reflect/internal/Definitions.scala b/src/compiler/scala/reflect/internal/Definitions.scala index 6ee9347aab..15f89e1382 100644 --- a/src/compiler/scala/reflect/internal/Definitions.scala +++ b/src/compiler/scala/reflect/internal/Definitions.scala @@ -692,10 +692,14 @@ trait Definitions extends reflect.api.StandardDefinitions { result } + def getClassIfDefined(fullname: String): Symbol = + getClassIfDefined(newTypeName(fullname)) def getClassIfDefined(fullname: Name): Symbol = try getClass(fullname.toTypeName) catch { case _: MissingRequirementError => NoSymbol } + def getModuleIfDefined(fullname: String): Symbol = + getModuleIfDefined(newTermName(fullname)) def getModuleIfDefined(fullname: Name): Symbol = try getModule(fullname.toTermName) catch { case _: MissingRequirementError => NoSymbol } diff --git a/src/compiler/scala/reflect/internal/NameManglers.scala b/src/compiler/scala/reflect/internal/NameManglers.scala index 01a93c0ada..d4aa6339ff 100644 --- a/src/compiler/scala/reflect/internal/NameManglers.scala +++ b/src/compiler/scala/reflect/internal/NameManglers.scala @@ -22,7 +22,10 @@ trait NameManglers { val MODULE_SUFFIX_STRING = NameTransformer.MODULE_SUFFIX_STRING val NAME_JOIN_STRING = NameTransformer.NAME_JOIN_STRING - + + val MODULE_SUFFIX_NAME: TermName = MODULE_SUFFIX_STRING + val NAME_JOIN_NAME: TermName = NAME_JOIN_STRING + def flattenedName(segments: Name*): NameType = compactedString(segments mkString NAME_JOIN_STRING) /** @@ -74,8 +77,11 @@ trait NameManglers { val PROTECTED_SET_PREFIX = PROTECTED_PREFIX + "set" val SETTER_SUFFIX = encode("_=") val SINGLETON_SUFFIX = ".type" + val SPECIALIZED_SUFFIX_STRING = "$sp" val SUPER_PREFIX_STRING = "super$" val TRAIT_SETTER_SEPARATOR_STRING = "$_setter_$" + + val SPECIALIZED_SUFFIX_NAME: TermName = SPECIALIZED_SUFFIX_STRING def isConstructorName(name: Name) = name == CONSTRUCTOR || name == MIXIN_CONSTRUCTOR def isExceptionResultName(name: Name) = name startsWith EXCEPTION_RESULT_PREFIX @@ -88,7 +94,7 @@ trait NameManglers { 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 isModuleName(name: Name) = name endsWith MODULE_SUFFIX_STRING + def isModuleName(name: Name) = name endsWith MODULE_SUFFIX_NAME def isOpAssignmentName(name: Name) = name match { case raw.NE | raw.LE | raw.GE | EMPTY => false @@ -112,6 +118,12 @@ trait NameManglers { name.subName(i, name.length) } else name } + + def unspecializedName(name: Name): Name = ( + if (name endsWith SPECIALIZED_SUFFIX_NAME) + name.subName(0, name.lastIndexOf('m') - 1) + else name + ) /** Return the original name and the types on which this name * is specialized. For example, @@ -123,8 +135,8 @@ trait NameManglers { * and another one belonging to the enclosing class, on Double. */ def splitSpecializedName(name: Name): (Name, String, String) = - if (name.endsWith("$sp")) { - val name1 = name stripEnd "$sp" + if (name endsWith SPECIALIZED_SUFFIX_NAME) { + val name1 = name stripEnd SPECIALIZED_SUFFIX_NAME val idxC = name1 lastIndexOf 'c' val idxM = name1 lastIndexOf 'm' @@ -138,6 +150,8 @@ trait NameManglers { def getterToLocal(name: TermName): TermName = name.toTermName append LOCAL_SUFFIX_STRING def getterToSetter(name: TermName): TermName = name.toTermName append SETTER_SUFFIX def localToGetter(name: TermName): TermName = name stripEnd LOCAL_SUFFIX_STRING toTermName + + def dropLocalSuffix(name: Name): Name = if (name endsWith ' ') name dropRight 1 else name def setterToGetter(name: TermName): TermName = { val p = name.pos(TRAIT_SETTER_SEPARATOR_STRING) diff --git a/src/compiler/scala/reflect/internal/Names.scala b/src/compiler/scala/reflect/internal/Names.scala index a6fd2adb34..11be9c80d1 100644 --- a/src/compiler/scala/reflect/internal/Names.scala +++ b/src/compiler/scala/reflect/internal/Names.scala @@ -306,6 +306,16 @@ trait Names extends api.Names { while (start <= last && !startsWith(subname, start)) start += 1 start <= last } + final def containsChar(ch: Char): Boolean = { + var i = index + val max = index + len + while (i < max) { + if (chrs(i) == ch) + return true + i += 1 + } + false + } /** Some thoroughly self-explanatory convenience functions. They * assume that what they're being asked to do is known to be valid. @@ -320,6 +330,8 @@ trait Names extends api.Names { final def stripStart(prefix: String): Name = subName(prefix.length, len) final def stripEnd(suffix: Name): Name = subName(0, len - suffix.length) final def stripEnd(suffix: String): Name = subName(0, len - suffix.length) + + def dropRight(n: Int) = subName(0, len - n) def lastIndexOf(ch: Char) = toChars lastIndexOf ch @@ -349,6 +361,7 @@ trait Names extends api.Names { else newTermName(res) } + def append(ch: Char): Name def append(suffix: String): Name def append(suffix: Name): Name @@ -377,6 +390,7 @@ trait Names extends api.Names { n = new TypeName(index, len, h); n } + def append(ch: Char): TermName = append("" + ch) def append(suffix: String): TermName = newTermName(this + suffix) def append(suffix: Name): TermName = append(suffix.toString) def companionName: TypeName = toTypeName @@ -400,6 +414,7 @@ trait Names extends api.Names { } def toTypeName: TypeName = this + def append(ch: Char): TypeName = append("" + ch) def append(suffix: String): TypeName = newTypeName(this + suffix) def append(suffix: Name): TypeName = append(suffix.toString) def companionName: TermName = toTermName diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala index bc0c81a54b..0c57f0c43a 100644 --- a/src/compiler/scala/reflect/internal/Symbols.scala +++ b/src/compiler/scala/reflect/internal/Symbols.scala @@ -756,7 +756,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => /** If this symbol has an expanded name, its original name, otherwise its name itself. * @see expandName */ - def originalName = nme.originalName(name) + def originalName: Name = nme.originalName(name) /** The name of the symbol before decoding, e.g. `\$eq\$eq` instead of `==`. */ @@ -764,20 +764,28 @@ trait Symbols extends api.Symbols { self: SymbolTable => /** The decoded name of the symbol, e.g. `==` instead of `\$eq\$eq`. */ - def decodedName: String = stripNameString(NameTransformer.decode(encodedName)) + def decodedName: String = nme.dropLocalSuffix(name).decode - /** Either "$" or "" depending on whether this is a module class. - */ + private def addModuleSuffix(n: Name): Name = + if (needsModuleSuffix) n append nme.MODULE_SUFFIX_STRING else n + def moduleSuffix: String = ( - if (hasModuleFlag && !isMethod && !isImplClass && !isJavaDefined) nme.MODULE_SUFFIX_STRING + if (needsModuleSuffix) nme.MODULE_SUFFIX_STRING else "" ) - + /** Whether this symbol needs nme.MODULE_SUFFIX_STRING (aka $) appended on the java platform. + */ + def needsModuleSuffix = ( + hasModuleFlag + && !isMethod + && !isImplClass + && !isJavaDefined + ) /** These should be moved somewhere like JavaPlatform. */ - def javaSimpleName = ("" + simpleName).trim + moduleSuffix - def javaBinaryName = fullNameInternal('/') + moduleSuffix - def javaClassName = fullNameInternal('.') + moduleSuffix + def javaSimpleName: String = addModuleSuffix(nme.dropLocalSuffix(simpleName)).toString + def javaBinaryName: String = addModuleSuffix(fullNameInternal('/')).toString + def javaClassName: String = addModuleSuffix(fullNameInternal('.')).toString /** The encoded full path name of this symbol, where outer names and inner names * are separated by `separator` characters. @@ -785,23 +793,17 @@ trait Symbols extends api.Symbols { self: SymbolTable => * Never adds id. * Drops package objects. */ - final def fullName(separator: Char): String = stripNameString(fullNameInternal(separator)) + final def fullName(separator: Char): String = nme.dropLocalSuffix(fullNameInternal(separator)).toString /** Doesn't drop package objects, for those situations (e.g. classloading) * where the true path is needed. */ - private def fullNameInternal(separator: Char): String = ( - if (isRoot || isRootPackage || this == NoSymbol) this.toString - else if (owner.isEffectiveRoot) encodedName - else effectiveOwner.enclClass.fullName(separator) + separator + encodedName + private def fullNameInternal(separator: Char): Name = ( + if (isRoot || isRootPackage || this == NoSymbol) name + else if (owner.isEffectiveRoot) name + else effectiveOwner.enclClass.fullName(separator) append separator append name ) - /** Strip package objects and any local suffix. - */ - private def stripNameString(s: String) = - if (settings.debug.value) s - else s stripSuffix nme.LOCAL_SUFFIX_STRING - /** The encoded full path name of this symbol, where outer names and inner names * are separated by periods. */ @@ -1702,7 +1704,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => */ final def getter(base: Symbol): Symbol = base.info.decl(getterName) filter (_.hasAccessorFlag) - def getterName = ( + def getterName: Name = ( if (isSetter) nme.setterToGetter(name) else if (nme.isLocalName(name)) nme.localToGetter(name) else name @@ -1800,7 +1802,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => // ------ toString ------------------------------------------------------------------- /** A tag which (in the ideal case) uniquely identifies class symbols */ - final def tag = fullName.## + final def tag: Int = fullName.## /** The simple name of this Symbol */ final def simpleName: Name = name @@ -1810,7 +1812,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => * (the initial Name) before falling back on id, which varies depending * on exactly when a symbol is loaded. */ - final def sealedSortName = initName + "#" + id + final def sealedSortName: String = initName + "#" + id /** String representation of symbol's definition key word */ final def keyString: String = @@ -1878,7 +1880,10 @@ trait Symbols extends api.Symbols { self: SymbolTable => * E.g. $eq => =. * If settings.uniqid, adds id. */ - def nameString = decodedName + idString + def nameString: String = ( + if (settings.uniqid.value) decodedName + "#" + id + else "" + decodedName + ) /** If settings.uniqid is set, the symbol's id, else "" */ final def idString = if (settings.uniqid.value) "#"+id else "" @@ -1886,14 +1891,14 @@ trait Symbols extends api.Symbols { self: SymbolTable => /** 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 = compose( + override def toString: String = compose( kindString, if (hasMeaninglessName) owner.decodedName + idString else nameString ) /** String representation of location. */ - def ownsString = { + def ownsString: String = { val owns = effectiveOwner if (owns.isClass && !owns.isEmptyPrefix) "" + owns else "" } @@ -1901,12 +1906,12 @@ trait Symbols extends api.Symbols { self: SymbolTable => /** String representation of location, plus a preposition. Doesn't do much, * for backward compatibility reasons. */ - def locationString = ownsString match { + def locationString: String = ownsString match { case "" => "" case s => " in " + s } - def fullLocationString = toString + locationString - def signatureString = if (hasRawInfo) infoString(rawInfo) else "<_>" + def fullLocationString: String = toString + locationString + def signatureString: String = if (hasRawInfo) infoString(rawInfo) else "<_>" /** String representation of symbol's definition following its name */ final def infoString(tp: Type): String = { diff --git a/src/compiler/scala/reflect/internal/Types.scala b/src/compiler/scala/reflect/internal/Types.scala index d17747e22a..2db957410b 100644 --- a/src/compiler/scala/reflect/internal/Types.scala +++ b/src/compiler/scala/reflect/internal/Types.scala @@ -5713,7 +5713,7 @@ A type's typeSymbol should never be inspected directly. } val res = lub0(ts) if (printLubs) { - indent = indent dropRight 2 + indent = indent stripSuffix " " println(indent + "lub of " + ts + " is " + res)//debug } if (ts forall (_.isNotNull)) res.notNull else res @@ -6172,7 +6172,7 @@ A type's typeSymbol should never be inspected directly. Console.println(indent + tp1 + " " + op + " " + arg2 + "?" /* + "("+tp1.getClass+","+arg2.getClass+")"*/) indent = indent + " " val result = p(tp1, arg2) - indent = indent dropRight 2 + indent = indent stripSuffix " " Console.println(indent + result) result } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala index e80927f620..a2c4f16bf1 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala @@ -172,7 +172,7 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with val PublicStatic = ACC_PUBLIC | ACC_STATIC val PublicStaticFinal = ACC_PUBLIC | ACC_STATIC | ACC_FINAL - val StringBuilderClassName = definitions.StringBuilderClass.fullName + val StringBuilderClassName = javaName(definitions.StringBuilderClass) val BoxesRunTime = "scala.runtime.BoxesRunTime" val StringBuilderType = new JObjectType(StringBuilderClassName) diff --git a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala index 74eb450960..d56a0740d9 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala @@ -248,10 +248,9 @@ abstract class Inliners extends SubComponent { } private def isMonadicMethod(sym: Symbol) = { - val (origName, _, _) = nme.splitSpecializedName(sym.name) - origName match { + nme.unspecializedName(sym.name) match { case nme.foreach | nme.filter | nme.withFilter | nme.map | nme.flatMap => true - case _ => false + case _ => false } } diff --git a/src/compiler/scala/tools/nsc/interpreter/IMain.scala b/src/compiler/scala/tools/nsc/interpreter/IMain.scala index 861f617ed6..8e4ff8aa37 100644 --- a/src/compiler/scala/tools/nsc/interpreter/IMain.scala +++ b/src/compiler/scala/tools/nsc/interpreter/IMain.scala @@ -186,7 +186,10 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends lazy val compiler: global.type = global import global._ - import definitions.{ ScalaPackage, JavaLangPackage, PredefModule, RootClass } + import definitions.{ + ScalaPackage, JavaLangPackage, PredefModule, RootClass, + getClassIfDefined, getModuleIfDefined + } private implicit def privateTreeOps(t: Tree): List[Tree] = { (new Traversable[Tree] { @@ -1114,35 +1117,18 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends private def findName(name: Name) = definedSymbols find (_.name == name) - private def missingOpt(op: => Symbol): Option[Symbol] = - try Some(op) - catch { case _: MissingRequirementError => None } - private def missingWrap(op: => Symbol): Symbol = - try op - catch { case _: MissingRequirementError => NoSymbol } - - def optCompilerClass(name: String) = missingOpt(definitions.getClass(name)) - def optCompilerModule(name: String) = missingOpt(definitions.getModule(name)) - def getCompilerClass(name: String) = missingWrap(definitions.getClass(name)) - def getCompilerModule(name: String) = missingWrap(definitions.getModule(name)) - /** Translate a repl-defined identifier into a Symbol. */ - def apply(name: String): Symbol = { - val tpname = newTypeName(name) - ( - findName(tpname) - orElse findName(tpname.companionName) - orElse optCompilerClass(name) - orElse optCompilerModule(name) - getOrElse NoSymbol - ) - } + def apply(name: String): Symbol = + types(name) orElse terms(name) + def types(name: String): Symbol = { - findName(newTypeName(name)) getOrElse getCompilerClass(name) + val tpname = newTypeName(name) + findName(tpname) getOrElse getClassIfDefined(tpname) } def terms(name: String): Symbol = { - findName(newTermName(name)) getOrElse getCompilerModule(name) + val termname = newTypeName(name) + findName(termname) getOrElse getModuleIfDefined(termname) } /** the previous requests this interpreter has processed */ diff --git a/src/compiler/scala/tools/nsc/interpreter/Power.scala b/src/compiler/scala/tools/nsc/interpreter/Power.scala index db2f9573ec..ac7c2b1ecc 100644 --- a/src/compiler/scala/tools/nsc/interpreter/Power.scala +++ b/src/compiler/scala/tools/nsc/interpreter/Power.scala @@ -59,10 +59,10 @@ abstract class Power( val intp: IMain ) extends SharesGlobal { import intp.{ - beQuietDuring, typeOfExpression, getCompilerClass, getCompilerModule, - interpret, parse + beQuietDuring, typeOfExpression, interpret, parse } import global._ + import definitions.{ getClassIfDefined, getModuleIfDefined } abstract class SymSlurper { def isKeep(sym: Symbol): Boolean @@ -108,7 +108,7 @@ abstract class Power( } class PackageSlurper(pkgName: String) extends SymSlurper { - val pkgSymbol = getCompilerModule(pkgName) + val pkgSymbol = getModuleIfDefined(pkgName) val modClass = pkgSymbol.moduleClass /** Looking for dwindling returns */ @@ -185,12 +185,13 @@ abstract class Power( // information into the toString method. Boo. private def manifestToType(m: Manifest[_]): Type = m match { case x: AnyValManifest[_] => - getCompilerClass("scala." + x).tpe + getClassIfDefined("scala." + x).tpe case _ => val name = m.erasure.getName - if (name endsWith nme.MODULE_SUFFIX_STRING) getCompilerModule(name dropRight 1).tpe + if (name endsWith nme.MODULE_SUFFIX_STRING) + getModuleIfDefined(name stripSuffix nme.MODULE_SUFFIX_STRING).tpe else { - val sym = getCompilerClass(name) + val sym = getClassIfDefined(name) val args = m.typeArguments if (args.isEmpty) sym.tpe @@ -198,7 +199,7 @@ abstract class Power( } } - def symbol_ : Symbol = getCompilerClass(erasure.getName) + def symbol_ : Symbol = getClassIfDefined(erasure.getName) def tpe_ : Type = manifestToType(man) def name_ : Name = symbol.name def companion = symbol.companionSymbol @@ -222,7 +223,7 @@ abstract class Power( def bts = info.baseTypeSeq.toList def btsmap = bts map (x => (x, x.decls.toList)) toMap def pkgName = Option(erasure.getPackage) map (_.getName) - def pkg = pkgName map getCompilerModule getOrElse NoSymbol + def pkg = pkgName map getModuleIfDefined getOrElse NoSymbol def pkgmates = pkg.tpe.members def pkgslurp = pkgName match { case Some(name) => new PackageSlurper(name) slurp() @@ -369,8 +370,8 @@ abstract class Power( object Implicits extends Implicits2 { } trait ReplUtilities { - def module[T: Manifest] = getCompilerModule(manifest[T].erasure.getName stripSuffix nme.MODULE_SUFFIX_STRING) - def clazz[T: Manifest] = getCompilerClass(manifest[T].erasure.getName) + def module[T: Manifest] = getModuleIfDefined(manifest[T].erasure.getName stripSuffix nme.MODULE_SUFFIX_STRING) + def clazz[T: Manifest] = getClassIfDefined(manifest[T].erasure.getName) def info[T: Manifest] = InternalInfo[T] def ?[T: Manifest] = InternalInfo[T] def url(s: String) = { diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala index 00b72bdc1c..342c298e1d 100644 --- a/src/compiler/scala/tools/nsc/transform/Constructors.scala +++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala @@ -285,10 +285,11 @@ abstract class Constructors extends Transform with ast.TreeDSL { specBuf ++= specializedStats def specializedAssignFor(sym: Symbol): Option[Tree] = - specializedStats.find { - case Assign(sel @ Select(This(_), _), rhs) if sel.symbol.hasFlag(SPECIALIZED) => - val (generic, _, _) = nme.splitSpecializedName(nme.localToGetter(sel.symbol.name)) - generic == nme.localToGetter(sym.name) + specializedStats find { + case Assign(sel @ Select(This(_), _), rhs) => + ( (sel.symbol hasFlag SPECIALIZED) + && (nme.unspecializedName(nme.localToGetter(sel.symbol.name)) == nme.localToGetter(sym.name)) + ) case _ => false } @@ -378,11 +379,12 @@ abstract class Constructors extends Transform with ast.TreeDSL { EmptyTree) List(localTyper.typed(tree)) - } else if (clazz.hasFlag(SPECIALIZED)) { + } + else if (clazz.hasFlag(SPECIALIZED)) { // add initialization from its generic class constructor - val (genericName, _, _) = nme.splitSpecializedName(clazz.name) + val genericName = nme.unspecializedName(clazz.name) val genericClazz = clazz.owner.info.decl(genericName.toTypeName) - assert(genericClazz != NoSymbol) + assert(genericClazz != NoSymbol, clazz) guardedCtorStats.get(genericClazz) match { case Some(stats1) => mergeConstructors(genericClazz, stats1, stats) diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala index 212785a525..9c4889eba9 100644 --- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala +++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala @@ -407,7 +407,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { */ private def typeParamSubAnyRef(sym: Symbol, cls: Symbol) = ( anyrefSpecCache.getOrElseUpdate(sym, - cls.newTypeParameter(sym.pos, newTypeName(sym.name + "$sp")) + cls.newTypeParameter(sym.pos, sym.name append nme.SPECIALIZED_SUFFIX_NAME toTypeName) setInfo TypeBounds(sym.info.bounds.lo, AnyRefClass.tpe) ).tpe ) @@ -1702,10 +1702,11 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { * - there is a getter for the original (non-specialized) field in the same class * - there is a getter for the specialized field in the same class */ - def initializesSpecializedField(f: Symbol): Boolean = - (f.name.endsWith("$sp") - && clazz.info.member(nme.originalName(f.name)).isPublic - && (clazz.info.decl(f.name).suchThat(_.isGetter) != NoSymbol)) + def initializesSpecializedField(f: Symbol) = ( + (f.name endsWith nme.SPECIALIZED_SUFFIX_NAME) + && clazz.info.member(nme.originalName(f.name)).isPublic + && clazz.info.decl(f.name).suchThat(_.isGetter) != NoSymbol + ) val argss = paramss map (_ map (x => if (initializesSpecializedField(x.symbol)) @@ -1717,7 +1718,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { } /** Concrete methods that use a specialized type, or override such methods. */ - private val concreteSpecMethods: mutable.Set[Symbol] = new mutable.HashSet + private val concreteSpecMethods = new mutable.HashSet[Symbol]() /** Add method m to the set of symbols for which we need an implementation tree * in the tree transformer. |