diff options
| author | Paul Phillips <paulp@improving.org> | 2010-12-02 17:28:58 +0000 |
|---|---|---|
| committer | Paul Phillips <paulp@improving.org> | 2010-12-02 17:28:58 +0000 |
| commit | 765f9aa2bfd16fc066fcfe6f068bc9ab54b863c2 (patch) | |
| tree | 1b8d31bab45162415d6cc6372c7336fc62bbad2b /src/compiler/scala/tools/nsc | |
| parent | a69c1afd4ba602bd4ccc9f9aced9bfc0f6f3c5e7 (diff) | |
| download | scala-765f9aa2bfd16fc066fcfe6f068bc9ab54b863c2.tar.gz scala-765f9aa2bfd16fc066fcfe6f068bc9ab54b863c2.tar.bz2 scala-765f9aa2bfd16fc066fcfe6f068bc9ab54b863c2.zip | |
It's a big one!
TermName and TypeName are exposed throughout the compiler based on what
kind of name a given abstraction ought to have. (There remain places
where one needs to create a name without knowing yet what it will be,
and those will always be Names.)
The nme object in the compiler now holds only term names. To reference a
known type name, use tpnme:
nme.List == ("List": TermName)
tpnme.List == ("List": TypeName)
The contents of nme and tpname are defined in traits, many of which
are shared, so if a name should exist only as a Type and not a
Term, it should be defined in CompilerTypeNames, but otherwise in
CompilerTermNames or CompilerCommonNames. This is partially complete but
I'm sure there are still many shared which should pick a side.
Usage of .toTermName and .toTypeName is strongly discouraged. After the
dust has settled, there will be very few places where it will make sense
to hop between namespaces like that.
There are some implicits to smooth everything out, most of which should
be removable eventually.
// these two are in no hurry to go anywhere
String => TermName
String => TypeName
// but not String => Name: def view in the compiler is no longer implicit
// these two are temporary, and can log when they kick off to help us
flush // out remaining issues of "name migration" Name => TermName
Name => TypeName
There is more work to be done before we're properly protected from
naming errors, but I will not allow another eight hour tragedy to befall
lukas or anyone else!
Review by rytz. (Formality.)
Diffstat (limited to 'src/compiler/scala/tools/nsc')
43 files changed, 972 insertions, 891 deletions
diff --git a/src/compiler/scala/tools/nsc/CompilationUnits.scala b/src/compiler/scala/tools/nsc/CompilationUnits.scala index 3c5e033c74..d3dae52895 100644 --- a/src/compiler/scala/tools/nsc/CompilationUnits.scala +++ b/src/compiler/scala/tools/nsc/CompilationUnits.scala @@ -18,6 +18,9 @@ trait CompilationUnits { self: Global => /** the fresh name creator */ var fresh: FreshNameCreator = new FreshNameCreator.Default + def freshTermName(prefix: String): TermName = newTermName(fresh.newName(prefix)) + def freshTypeName(prefix: String): TypeName = newTypeName(fresh.newName(prefix)) + /** the content of the compilation unit in tree form */ var body: Tree = EmptyTree diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala index 1ac2c3442a..d93496a7c4 100644 --- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala +++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala @@ -22,11 +22,11 @@ abstract class TreeGen { def rootId(name: Name) = Select(Ident(nme.ROOTPKG), name) def rootScalaDot(name: Name) = Select(rootId(nme.scala_) setSymbol ScalaPackage, name) def scalaDot(name: Name) = Select(Ident(nme.scala_) setSymbol ScalaPackage, name) - def scalaAnyRefConstr = scalaDot(nme.AnyRef.toTypeName) - def scalaUnitConstr = scalaDot(nme.Unit.toTypeName) - def scalaScalaObjectConstr = scalaDot(nme.ScalaObject.toTypeName) - def productConstr = scalaDot(nme.Product.toTypeName) - def serializableConstr = scalaDot(nme.Serializable.toTypeName) + def scalaAnyRefConstr = scalaDot(tpnme.AnyRef) + def scalaUnitConstr = scalaDot(tpnme.Unit) + def scalaScalaObjectConstr = scalaDot(tpnme.ScalaObject) + def productConstr = scalaDot(tpnme.Product) + def serializableConstr = scalaDot(tpnme.Serializable) private def isRootOrEmptyPackageClass(s: Symbol) = s.isRoot || s.isEmptyPackageClass @@ -317,7 +317,7 @@ abstract class TreeGen { Apply(Select(monitor, Object_synchronized), List(body)) def wildcardStar(tree: Tree) = - atPos(tree.pos) { Typed(tree, Ident(nme.WILDCARD_STAR)) } + atPos(tree.pos) { Typed(tree, Ident(tpnme.WILDCARD_STAR)) } def paramToArg(vparam: Symbol) = { val arg = Ident(vparam) @@ -363,12 +363,12 @@ abstract class TreeGen { /** Try to convert Select(qual, name) to a SelectFromTypeTree. */ - def convertToSelectFromType(qual: Tree, name: Name): Tree = { - def selFromType(qual1: Tree) = SelectFromTypeTree(qual1 setPos qual.pos, name) + def convertToSelectFromType(qual: Tree, origName: Name): Tree = { + def selFromType(qual1: Tree) = SelectFromTypeTree(qual1 setPos qual.pos, origName) qual match { case Select(qual1, name) => selFromType(Select(qual1, name.toTypeName)) - case Ident(name) => selFromType(Ident(name.toTypeName)) - case _ => EmptyTree + case Ident(name) => selFromType(Ident(name.toTypeName)) + case _ => EmptyTree } } @@ -379,7 +379,7 @@ abstract class TreeGen { if (treeInfo.isPureExpr(expr)) { within(() => if (used) expr.duplicate else { used = true; expr }) } else { - val temp = owner.newValue(expr.pos.makeTransparent, unit.fresh.newName("ev$")) + val temp = owner.newValue(expr.pos.makeTransparent, unit.freshTermName("ev$")) .setFlag(SYNTHETIC).setInfo(expr.tpe) val containing = within(() => Ident(temp) setPos temp.pos.focus setType expr.tpe) ensureNonOverlapping(containing, List(expr)) @@ -399,7 +399,7 @@ abstract class TreeGen { () => if (used(idx)) expr.duplicate else { used(idx) = true; expr } } } else { - val temp = owner.newValue(expr.pos.makeTransparent, unit.fresh.newName("ev$")) + val temp = owner.newValue(expr.pos.makeTransparent, unit.freshTermName("ev$")) .setFlag(SYNTHETIC).setInfo(expr.tpe) vdefs += ValDef(temp, expr) exprs1 += (() => Ident(temp) setPos temp.pos.focus setType expr.tpe) diff --git a/src/compiler/scala/tools/nsc/ast/TreeInfo.scala b/src/compiler/scala/tools/nsc/ast/TreeInfo.scala index 8be793343e..8e663c32dd 100644 --- a/src/compiler/scala/tools/nsc/ast/TreeInfo.scala +++ b/src/compiler/scala/tools/nsc/ast/TreeInfo.scala @@ -176,15 +176,15 @@ abstract class TreeInfo { /** Is tpt of the form T* ? */ def isRepeatedParamType(tpt: Tree) = tpt match { case TypeTree() => definitions.isRepeatedParamType(tpt.tpe) - case AppliedTypeTree(Select(_, nme.REPEATED_PARAM_CLASS_NAME), _) => true - case AppliedTypeTree(Select(_, nme.JAVA_REPEATED_PARAM_CLASS_NAME), _) => true + case AppliedTypeTree(Select(_, tpnme.REPEATED_PARAM_CLASS_NAME), _) => true + case AppliedTypeTree(Select(_, tpnme.JAVA_REPEATED_PARAM_CLASS_NAME), _) => true case _ => false } /** Is tpt a by-name parameter type? */ def isByNameParamType(tpt: Tree) = tpt match { case TypeTree() => definitions.isByNameParamType(tpt.tpe) - case AppliedTypeTree(Select(_, nme.BYNAME_PARAM_CLASS_NAME), _) => true + case AppliedTypeTree(Select(_, tpnme.BYNAME_PARAM_CLASS_NAME), _) => true case _ => false } @@ -217,7 +217,7 @@ abstract class TreeInfo { /** Is this argument node of the form <expr> : _* ? */ def isWildcardStarArg(tree: Tree): Boolean = tree match { - case Typed(_, Ident(nme.WILDCARD_STAR)) => true + case Typed(_, Ident(tpnme.WILDCARD_STAR)) => true case _ => false } def isWildcardStarArgList(trees: List[Tree]) = diff --git a/src/compiler/scala/tools/nsc/ast/Trees.scala b/src/compiler/scala/tools/nsc/ast/Trees.scala index ad73d45dd0..293c32c8a5 100644 --- a/src/compiler/scala/tools/nsc/ast/Trees.scala +++ b/src/compiler/scala/tools/nsc/ast/Trees.scala @@ -17,6 +17,8 @@ trait Trees extends reflect.generic.Trees { self: SymbolTable => var body: Tree val source: SourceFile def fresh : FreshNameCreator + def freshTermName(prefix: String): TermName + def freshTypeName(prefix: String): TypeName } type CompilationUnit <: CompilationUnitTrait @@ -36,25 +38,24 @@ trait Trees extends reflect.generic.Trees { self: SymbolTable => implicit def treeWrapper(tree: Tree): TreeOps = new TreeOps(tree) class TreeOps(tree: Tree) { - def isTerm: Boolean = tree match { - case _: TermTree => true - case Bind(name, _) => name.isTermName - case Select(_, name) => name.isTermName - case Ident(name) => name.isTermName + case _: TermTree => true + case Bind(name, _) => name.isTermName + case Select(_, name) => name.isTermName + case Ident(name) => name.isTermName case Annotated(_, arg) => arg.isTerm - case DocDef(_, defn) => defn.isTerm - case _ => false + case DocDef(_, defn) => defn.isTerm + case _ => false } def isType: Boolean = tree match { - case _: TypTree => true - case Bind(name, _) => name.isTypeName - case Select(_, name) => name.isTypeName - case Ident(name) => name.isTypeName + case _: TypTree => true + case Bind(name, _) => name.isTypeName + case Select(_, name) => name.isTypeName + case Ident(name) => name.isTypeName case Annotated(_, arg) => arg.isType - case DocDef(_, defn) => defn.isType - case _ => false + case DocDef(_, defn) => defn.isType + case _ => false } def isErroneous = (tree.tpe ne null) && tree.tpe.isErroneous @@ -254,7 +255,7 @@ trait Trees extends reflect.generic.Trees { self: SymbolTable => if (vparamss1.isEmpty || !vparamss1.head.isEmpty && vparamss1.head.head.mods.isImplicit) vparamss1 = List() :: vparamss1; val superRef: Tree = atPos(superPos) { - Select(Super(nme.EMPTY.toTypeName, nme.EMPTY.toTypeName), nme.CONSTRUCTOR) + Select(Super(tpnme.EMPTY, tpnme.EMPTY), nme.CONSTRUCTOR) } val superCall = (superRef /: argss) (Apply) List( diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index 1ae9a9d8c0..1ffb29809a 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -73,7 +73,9 @@ self => val in = new UnitScanner(unit, patches) in.init() - def freshName(prefix: String): Name = unit.fresh.newName(prefix) + def freshName(prefix: String): Name = freshTermName(prefix) + def freshTermName(prefix: String): TermName = unit.freshTermName(prefix) + def freshTypeName(prefix: String): TypeName = unit.freshTypeName(prefix) def o2p(offset: Int): Position = new OffsetPosition(unit.source,offset) def r2p(start: Int, mid: Int, end: Int): Position = rangePos(unit.source, start, mid, end) @@ -136,20 +138,15 @@ self => final val Local = 0 final val InBlock = 1 final val InTemplate = 2 - final val MINUS: Name = "-" - final val PLUS : Name = "+" - final val BANG : Name = "!" - final val TILDE: Name = "~" - final val AMP : Name = "&" - final val SLASH: Name = "/" - final val STAR : Name = "*" - final val BAR : Name = "|" - final val LT : Name = "<" + + import nme.raw abstract class Parser { val in: Scanner def freshName(prefix: String): Name + def freshTermName(prefix: String): TermName + def freshTypeName(prefix: String): TypeName def o2p(offset: Int): Position def r2p(start: Int, mid: Int, end: Int): Position @@ -158,7 +155,9 @@ self => object treeBuilder extends TreeBuilder { val global: self.global.type = self.global - def freshName(prefix: String): Name = Parser.this.freshName(prefix) + def freshName(prefix: String): Name = freshTermName(prefix) + def freshTermName(prefix: String): TermName = Parser.this.freshTermName(prefix) + def freshTypeName(prefix: String): TypeName = Parser.this.freshTypeName(prefix) def o2p(offset: Int) = Parser.this.o2p(offset) def r2p(start: Int, point: Int, end: Int) = Parser.this.r2p(start, point, end) } @@ -258,11 +257,11 @@ self => ) // def main - def mainParamType = AppliedTypeTree(Ident(nme.Array.toTypeName), List(Ident(nme.String.toTypeName))) + def mainParamType = AppliedTypeTree(Ident(tpnme.Array), List(Ident(tpnme.String))) 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, nme.main, Nil, List(mainParameter), scalaDot(nme.Unit.toTypeName), Block(mainSetArgv, mainNew)) + def mainDef = DefDef(NoMods, nme.main, Nil, List(mainParameter), scalaDot(tpnme.Unit), Block(mainSetArgv, mainNew)) // object Main def moduleName = ScriptRunner scriptMain settings @@ -488,10 +487,9 @@ self => case INTLIT | LONGLIT | FLOATLIT | DOUBLELIT => true case _ => false } - def isUnaryOp: Boolean = isIdent && (in.name match { - case MINUS | PLUS | TILDE | BANG => true - case _ => false - }) + def isUnaryOp = isIdent && raw.isUnary(in.name) + def isRawStar = isIdent && in.name == raw.STAR + def isRawBar = isIdent && in.name == raw.BAR def isIdent = in.token == IDENTIFIER || in.token == BACKQUOTED_IDENT @@ -675,6 +673,7 @@ self => /* -------- IDENTIFIERS AND LITERALS ------------------------------------------- */ + /** Assumed (provisionally) to be TermNames. */ def ident(skipIt: Boolean): Name = if (in.token == IDENTIFIER || in.token == BACKQUOTED_IDENT) { val name = in.name.encode @@ -684,9 +683,12 @@ self => syntaxErrorOrIncomplete(expectedMsg(IDENTIFIER), skipIt) nme.ERROR } - def ident(): Name = ident(true) + /** For when it's known already to be a type name. */ + def identForType(): TypeName = ident().toTypeName + def identForType(skipIt: Boolean): TypeName = ident(skipIt).toTypeName + def selector(t: Tree): Tree = { val point = in.offset //assert(t.pos.isDefined, t) @@ -702,13 +704,13 @@ self => var t: Tree = null if (in.token == THIS) { in.nextToken() - t = atPos(start) { This(nme.EMPTY.toTypeName) } + t = atPos(start) { This(tpnme.EMPTY) } if (!thisOK || in.token == DOT) { t = selectors(t, typeOK, accept(DOT)) } } else if (in.token == SUPER) { in.nextToken() - t = atPos(start) { Super(nme.EMPTY.toTypeName, mixinQualifierOpt()) } + t = atPos(start) { Super(tpnme.EMPTY, mixinQualifierOpt()) } accept(DOT) t = selector(t) if (in.token == DOT) t = selectors(t, typeOK, in.skipToken()) @@ -752,14 +754,14 @@ self => /** MixinQualifier ::= `[' Id `]' */ - def mixinQualifierOpt(): Name = + def mixinQualifierOpt(): TypeName = if (in.token == LBRACKET) { in.nextToken() - val name = ident().toTypeName + val name = identForType() accept(RBRACKET) name } else { - nme.EMPTY.toTypeName + tpnme.EMPTY } /** StableId ::= Id @@ -904,8 +906,8 @@ self => val opOffset = in.offset val leftAssoc = treeInfo.isLeftAssoc(in.name) if (mode != InfixMode.FirstOp) checkAssoc(opOffset, in.name, mode == InfixMode.LeftOp) - val op = ident() - val tycon = atPos(opOffset) { Ident(op.toTypeName) } + val op = identForType() + val tycon = atPos(opOffset) { Ident(op) } newLineOptWhenFollowing(isTypeIntroToken) def mkOp(t1: Tree) = atPos(t.pos.startOrPoint, opOffset) { AppliedTypeTree(tycon, List(t, t1)) } if (leftAssoc) @@ -985,9 +987,9 @@ self => if (in.token == HASH) { val hashOffset = in.skipToken() val nameOffset = in.offset - val name = ident(false) - val sel = atPos(t.pos.startOrPoint, if (name == nme.ERROR) hashOffset else nameOffset) { - SelectFromTypeTree(t, name.toTypeName) + val name = identForType(false) + val sel = atPos(t.pos.startOrPoint, if (name == tpnme.ERROR) hashOffset else nameOffset) { + SelectFromTypeTree(t, name) } simpleTypeRest(sel, isPattern) } else if (in.token == LBRACKET) { @@ -999,7 +1001,7 @@ self => /** WildcardType ::= `_' TypeBounds */ def wildcardType(start: Int) = { - val pname = freshName("_$").toTypeName + val pname = freshTypeName("_$") val t = atPos(start) { Ident(pname) } val bounds = typeBounds() val param = atPos(t.pos union bounds.pos) { makeSyntheticTypeParam(pname, bounds) } @@ -1024,9 +1026,9 @@ self => if (in.token == USCORE) { in.nextToken() if (in.token == SUBTYPE || in.token == SUPERTYPE) wildcardType(start) - else atPos(start) { Bind(nme.WILDCARD.toTypeName, EmptyTree) } - } else if (in.token == IDENTIFIER && treeInfo.isVariableName(in.name.toTypeName)) { - atPos(start) { Bind(ident().toTypeName, EmptyTree) } + else atPos(start) { Bind(tpnme.WILDCARD, EmptyTree) } + } else if (in.token == IDENTIFIER && treeInfo.isVariableName(in.name)) { + atPos(start) { Bind(identForType(), EmptyTree) } } else { typ(true) } @@ -1034,12 +1036,12 @@ self => // copy-paste (with change) from def paramType if (in.token == ARROW) { in.nextToken() - val tycon = atPos(start) { rootScalaDot(nme.BYNAME_PARAM_CLASS_NAME) } + val tycon = atPos(start) { rootScalaDot(tpnme.BYNAME_PARAM_CLASS_NAME) } atPos(start) { AppliedTypeTree(tycon, List(typ())) } } else { val t = typ() - if (isIdent && in.name == STAR) { - val tycon = atPos(in.skipToken()) { rootScalaDot(nme.REPEATED_PARAM_CLASS_NAME) } + if (isRawStar) { + val tycon = atPos(in.skipToken()) { rootScalaDot(tpnme.REPEATED_PARAM_CLASS_NAME) } atPos(start) { AppliedTypeTree(tycon, List(t)) } } else t } @@ -1138,7 +1140,7 @@ self => case WHILE => val start = in.offset atPos(in.skipToken()) { - val lname: Name = freshName(nme.WHILE_PREFIX) + val lname: Name = freshTermName(nme.WHILE_PREFIX) val cond = condExpr() newLinesOpt() val body = expr() @@ -1147,7 +1149,7 @@ self => case DO => val start = in.offset atPos(in.skipToken()) { - val lname: Name = freshName(nme.DO_WHILE_PREFIX) + val lname: Name = freshTermName(nme.DO_WHILE_PREFIX) val body = expr() if (isStatSep) in.nextToken() accept(WHILE) @@ -1193,7 +1195,7 @@ self => if (isIdent && in.name == nme.STAR) { in.nextToken() t = atPos(t.pos.startOrPoint, colonPos) { - Typed(t, atPos(uscorePos) { Ident(nme.WILDCARD_STAR) }) + Typed(t, atPos(uscorePos) { Ident(tpnme.WILDCARD_STAR) }) } } else { syntaxErrorOrIncomplete("`*' expected", true) @@ -1299,7 +1301,7 @@ self => if (isUnaryOp) { atPos(in.offset) { val name: Name = "unary_" + ident() - if (in.name == MINUS && isNumericLit) simpleExprRest(atPos(in.offset)(literal(true)), true) + if (in.name == raw.MINUS && isNumericLit) simpleExprRest(atPos(in.offset)(literal(true)), true) else Select(stripParens(simpleExpr()), name) } } @@ -1523,9 +1525,9 @@ self => def pattern(seqOK: Boolean): Tree = { val start = in.offset val t = pattern1(seqOK) - if (isIdent && in.name == BAR) { + if (isRawBar) { val ts = new ListBuffer[Tree] += t - while (isIdent && in.name == BAR) { + while (isRawBar) { in.nextToken(); ts += pattern1(seqOK) } atPos(start) { makeAlternative(ts.toList) } @@ -1558,22 +1560,16 @@ self => */ def pattern2(seqOK: Boolean): Tree = { val p = pattern3(seqOK) - if (in.token == AT) { - p match { - case Ident(name) => - if (name == nme.WILDCARD) { - in.nextToken() - pattern3(seqOK) - } else if (treeInfo.isVarPattern(p)) { - in.nextToken() - atPos(p.pos.startOrPoint) { Bind(name, pattern3(seqOK)) } - } else { - p - } - case _ => - p - } - } else p + if (in.token != AT) p + else p match { + case Ident(nme.WILDCARD) => + in.nextToken() + pattern3(seqOK) + case Ident(name) if treeInfo.isVarPattern(p) => + in.nextToken() + atPos(p.pos.startOrPoint) { Bind(name, pattern3(seqOK)) } + case _ => p + } } /* Pattern3 ::= SimplePattern @@ -1587,10 +1583,10 @@ self => // See ticket #3189 for the motivation for the null check. // TODO: dredge out the remnants of regexp patterns. // ... and now this is back the way it was because it caused #3480. - if (seqOK && isIdent && in.name == STAR) + if (seqOK && isRawStar) return atPos(top.pos.startOrPoint, in.skipToken())(Star(stripParens(top))) - while (isIdent && in.name != BAR) { + while (isIdent && in.name != raw.BAR) { top = reduceStack( false, base, top, precedence(in.name), treeInfo.isLeftAssoc(in.name)) val op = in.name @@ -1627,7 +1623,7 @@ self => in.token match { case INTLIT | LONGLIT | FLOATLIT | DOUBLELIT => t match { - case Ident(name) if name == nme.MINUS => + case Ident(nme.MINUS) => return atPos(start) { literal(true) } case _ => } @@ -1699,7 +1695,7 @@ self => if (mods.hasAccessBoundary) syntaxError("duplicate private/protected qualifier", false) result = if (in.token == THIS) { in.nextToken(); mods | Flags.LOCAL } - else Modifiers(mods.flags, ident().toTypeName) + else Modifiers(mods.flags, identForType()) accept(RBRACKET) } result @@ -1912,15 +1908,15 @@ self => if (in.token == ARROW) { atPos(in.skipToken()) { AppliedTypeTree( - rootScalaDot(nme.BYNAME_PARAM_CLASS_NAME), List(typ())) + rootScalaDot(tpnme.BYNAME_PARAM_CLASS_NAME), List(typ())) } } else { val t = typ() - if (isIdent && in.name == STAR) { + if (isRawStar) { in.nextToken() atPos(t.pos.startOrPoint, t.pos.point) { AppliedTypeTree( - rootScalaDot(nme.REPEATED_PARAM_CLASS_NAME), List(t)) + rootScalaDot(tpnme.REPEATED_PARAM_CLASS_NAME), List(t)) } } else t } @@ -1937,20 +1933,20 @@ self => var mods = ms | Flags.PARAM val start = in.offset if (owner.isTypeName && isIdent) { - if (in.name == PLUS) { + if (in.name == raw.PLUS) { in.nextToken() mods |= Flags.COVARIANT - } else if (in.name == MINUS) { + } else if (in.name == raw.MINUS) { in.nextToken() mods |= Flags.CONTRAVARIANT } } val nameOffset = in.offset - val pname = + val pname: TypeName = (if (in.token == USCORE) { // TODO AM: freshName(o2p(in.skipToken()), "_$$"), will need to update test suite in.nextToken() - nme.WILDCARD - } else ident()).toTypeName + tpnme.WILDCARD + } else identForType()) val param = atPos(start, nameOffset) { val tparams = typeParamClauseOpt(pname, null) // @M TODO null --> no higher-order context bounds for now TypeDef(mods, pname, tparams, typeBounds()) @@ -1987,15 +1983,15 @@ self => */ def typeBounds(): TypeBoundsTree = { val t = TypeBoundsTree( - bound(SUPERTYPE, nme.Nothing), - bound(SUBTYPE, nme.Any)) + bound(SUPERTYPE, tpnme.Nothing), + bound(SUBTYPE, tpnme.Any)) t setPos (wrappingPos(List(t.hi, t.lo))) t } - def bound(tok: Int, default: Name): Tree = + def bound(tok: Int, default: TypeName): Tree = if (in.token == tok) { in.nextToken(); typ() } - else atPos(o2p(in.lastOffset)) { rootScalaDot(default.toTypeName) } + else atPos(o2p(in.lastOffset)) { rootScalaDot(default) } /* -------- DEFS ------------------------------------------- */ @@ -2021,7 +2017,7 @@ self => var t: Tree = null if (in.token == THIS) { in.nextToken() - t = atPos(start) { This(nme.EMPTY.toTypeName) } + t = atPos(start) { This(tpnme.EMPTY) } accept(DOT) t = selector(t) accept(DOT) @@ -2315,7 +2311,7 @@ self => in.nextToken newLinesOpt() atPos(start, in.offset) { - val name = ident().toTypeName + val name = identForType() // @M! a type alias as well as an abstract type may declare type parameters val tparams = typeParamClauseOpt(name, null) in.token match { @@ -2369,8 +2365,9 @@ self => def classDef(start: Int, mods: Modifiers): ClassDef = { in.nextToken val nameOffset = in.offset - val name = ident().toTypeName - atPos(start, if (name == nme.ERROR.toTypeName) start else nameOffset) { + val name = identForType() + + atPos(start, if (name == tpnme.ERROR) start else nameOffset) { val savedContextBounds = classContextBounds val contextBoundBuf = new ListBuffer[Tree] val tparams = typeParamClauseOpt(name, contextBoundBuf) @@ -2411,7 +2408,7 @@ self => val tstart = in.offset atPos(start, if (name == nme.ERROR) start else nameOffset) { val mods1 = if (in.token == SUBTYPE) mods | Flags.DEFERRED else mods - val template = templateOpt(mods1, name, NoMods, List(), tstart) + val template = templateOpt(mods1, name, NoMods, Nil, tstart) ModuleDef(mods1, name, template) } } @@ -2474,8 +2471,7 @@ self => * TraitTemplateOpt ::= TraitExtends TraitTemplate | [['extends'] TemplateBody] | '<:' TemplateBody * TraitExtends ::= 'extends' | `<:' */ - def templateOpt(mods: Modifiers, name: Name, constrMods: Modifiers, - vparamss: List[List[ValDef]], tstart: Int): Template = { + def templateOpt(mods: Modifiers, name: Name, constrMods: Modifiers, vparamss: List[List[ValDef]], tstart: Int): Template = { val (parents0, argss, self, body) = if (in.token == EXTENDS || settings.YvirtClasses && mods.hasTraitFlag && in.token == SUBTYPE) { in.nextToken() @@ -2489,7 +2485,7 @@ self => (List(), List(List()), self, body) } var parents = parents0 - if (!isInterface(mods, body) && !(inScalaPackage && name == nme.Array.toTypeName)) + if (!isInterface(mods, body) && !(inScalaPackage && name == tpnme.Array)) parents = parents ::: List(scalaScalaObjectConstr) if (parents.isEmpty) parents = List(scalaAnyRefConstr) @@ -2628,7 +2624,7 @@ self => val first = expr(InTemplate) // @S: first statement is potentially converted so cannot be stubbed. if (in.token == ARROW) { first match { - case Typed(tree @ This(name), tpt) if (name == nme.EMPTY.toTypeName) => + case Typed(tree @ This(tpnme.EMPTY), tpt) => self = atPos(tree.pos union tpt.pos) { makeSelfDef(nme.WILDCARD, tpt) } case _ => convertToParam(first) match { diff --git a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala index 66a3dc356e..25b65f0791 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala @@ -34,7 +34,7 @@ trait Scanners { var lastOffset: Offset = 0 /** the name of an identifier */ - var name: Name = null + var name: TermName = null /** the string value of a literal */ var strVal: String = null @@ -898,14 +898,14 @@ trait Scanners { /** The highest name index of a keyword token */ private var maxKey = 0 /** An array of all keyword token names */ - private var keyName = new Array[Name](128) + private var keyName = new Array[TermName](128) /** The highest keyword token plus one */ private var tokenCount = 0 /** Enter keyword with given name and token id */ - protected def enterKeyword(n: Name, tokenId: Int) { + protected def enterKeyword(n: TermName, tokenId: Int) { while (tokenId >= keyName.length) { - val newTokName = new Array[Name](keyName.length * 2) + val newTokName = new Array[TermName](keyName.length * 2) compat.Platform.arraycopy(keyName, 0, newTokName, 0, newTokName.length) keyName = newTokName } diff --git a/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala index f0d1c536c4..81bb5db286 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala @@ -22,43 +22,55 @@ import scala.tools.util.StringOps.splitWhere * @author Burak Emir * @version 1.0 */ -abstract class SymbolicXMLBuilder(p: Parsers#Parser, preserveWS: Boolean) -{ +abstract class SymbolicXMLBuilder(p: Parsers#Parser, preserveWS: Boolean) { val global: Global import global._ - def freshName(prefix: String): Name var isPattern: Boolean = _ - def _Comment = global.newTypeName("Comment") - def _Elem = global.newTypeName("Elem") - def _EntityRef = global.newTypeName("EntityRef") - def _Group = global.newTypeName("Group") - def _MetaData = global.newTypeName("MetaData") - def _NamespaceBinding = global.newTypeName("NamespaceBinding") - def _NodeBuffer = global.newTypeName("NodeBuffer") - def _PrefixedAttribute = global.newTypeName("PrefixedAttribute") - def _ProcInstr = global.newTypeName("ProcInstr") - def _Text = global.newTypeName("Text") - def _Unparsed = global.newTypeName("Unparsed") - def _UnprefixedAttribute = global.newTypeName("UnprefixedAttribute") - - def __Elem = global.newTermName("Elem") - def __Text = global.newTermName("Text") - def _Null = global.newTermName("Null") - def _plus = global.newTermName("$amp$plus") - def _xml = global.newTermName("xml") - - final def _buf = global.newTermName("$buf") - final def _md = global.newTermName("$md") - final def _scope = global.newTermName("$scope") - final def _tmpscope = global.newTermName("$tmpscope") + trait XMLTypeNames extends LibraryTypeNames { + val _Comment: NameType = "Comment" + val _Elem: NameType = "Elem" + val _EntityRef: NameType = "EntityRef" + val _Group: NameType = "Group" + val _MetaData: NameType = "MetaData" + val _NamespaceBinding: NameType = "NamespaceBinding" + val _NodeBuffer: NameType = "NodeBuffer" + val _PrefixedAttribute: NameType = "PrefixedAttribute" + val _ProcInstr: NameType = "ProcInstr" + val _Text: NameType = "Text" + val _Unparsed: NameType = "Unparsed" + val _UnprefixedAttribute: NameType = "UnprefixedAttribute" + } + + trait XMLTermNames extends LibraryTermNames { + val _Null: NameType = "Null" + val __Elem: NameType = "Elem" + val __Text: NameType = "Text" + val _buf: NameType = "$buf" + val _md: NameType = "$md" + val _plus: NameType = "$amp$plus" + val _scope: NameType = "$scope" + val _tmpscope: NameType = "$tmpscope" + val _xml: NameType = "xml" + } + + private object xmltypes extends XMLTypeNames { + type NameType = TypeName + implicit def createNameType(name: String): TypeName = newTypeName(name) + } + private object xmlterms extends XMLTermNames { + type NameType = TermName + implicit def createNameType(name: String): TermName = newTermName(name) + } + import xmltypes._ + import xmlterms._ // convenience methods private def LL[A](x: A*): List[List[A]] = List(List(x:_*)) private def const(x: Any) = Literal(Constant(x)) private def wild = Ident(nme.WILDCARD) - private def wildStar = Ident(nme.WILDCARD_STAR) + private def wildStar = Ident(tpnme.WILDCARD_STAR) private def _scala(name: Name) = Select(Select(Ident(nme.ROOTPKG), nme.scala_), name) private def _scala_xml(name: Name) = Select(_scala(_xml), name) diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala index de5f342a7d..01cfc440c5 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala @@ -68,7 +68,7 @@ abstract class TreeBuilder { val buf = new ListBuffer[(Name, Tree, Position)] def namePos(tree: Tree, name: Name): Position = - if (!tree.pos.isRange || name.containsName(nme.DOLLARraw)) tree.pos.focus + if (!tree.pos.isRange || name.containsName(nme.raw.DOLLAR)) tree.pos.focus else { val start = tree.pos.start val end = start + name.decode.length @@ -137,21 +137,27 @@ abstract class TreeBuilder { def makeAnnotated(t: Tree, annot: Tree): Tree = atPos(annot.pos union t.pos)(Annotated(annot, t)) - def makeSelfDef(name: Name, tpt: Tree): ValDef = + def makeSelfDef(name: TermName, tpt: Tree): ValDef = ValDef(Modifiers(PRIVATE), name, tpt, EmptyTree) /** If tree is a variable pattern, return Some("its name and type"). * Otherwise return none */ - private def matchVarPattern(tree: Tree): Option[(Name, Tree)] = tree match { - case Ident(name) => Some((name, TypeTree())) - case Bind(name, Ident(nme.WILDCARD)) => Some((name, TypeTree())) - case Typed(Ident(name), tpt) => Some((name, tpt)) - case Bind(name, Typed(Ident(nme.WILDCARD), tpt)) => Some((name, tpt)) - case _ => None + private def matchVarPattern(tree: Tree): Option[(Name, Tree)] = { + def wildType(t: Tree): Option[Tree] = t match { + case Ident(x) if x.toTermName == nme.WILDCARD => Some(TypeTree()) + case Typed(Ident(x), tpt) if x.toTermName == nme.WILDCARD => Some(tpt) + case _ => None + } + tree match { + case Ident(name) => Some((name, TypeTree())) + case Bind(name, body) => wildType(body) map (x => (name, x)) + case Typed(Ident(name), tpt) => Some((name, tpt)) + case _ => None + } } /** Create tree representing (unencoded) binary operation expression or pattern. */ - def makeBinop(isExpr: Boolean, left: Tree, op: Name, right: Tree, opPos: Position): Tree = { + def makeBinop(isExpr: Boolean, left: Tree, op: TermName, right: Tree, opPos: Position): Tree = { def mkNamed(args: List[Tree]) = if (isExpr) args map { case a @ Assign(id @ Ident(name), rhs) => @@ -187,7 +193,7 @@ abstract class TreeBuilder { else if (parents.tail.isEmpty && stats.isEmpty) atPos(npos union cpos) { New(parents.head, argss) } else { - val x = nme.ANON_CLASS_NAME.toTypeName + val x = tpnme.ANON_CLASS_NAME atPos(npos union cpos) { Block( List( @@ -219,14 +225,14 @@ abstract class TreeBuilder { else CompoundTypeTree(Template(tps, emptyValDef, Nil)) /** Create tree representing a while loop */ - def makeWhile(lname: Name, cond: Tree, body: Tree): Tree = { + def makeWhile(lname: TermName, cond: Tree, body: Tree): Tree = { val continu = atPos(o2p(body.pos.endOrPoint)) { Apply(Ident(lname), Nil) } val rhs = If(cond, Block(List(body), continu), Literal(())) LabelDef(lname, Nil, rhs) } /** Create tree representing a do-while loop */ - def makeDoWhile(lname: Name, body: Tree, cond: Tree): Tree = { + def makeDoWhile(lname: TermName, body: Tree, cond: Tree): Tree = { val continu = Apply(Ident(lname), Nil) val rhs = Block(List(body), If(cond, continu, Literal(()))) LabelDef(lname, Nil, rhs) @@ -264,10 +270,10 @@ abstract class TreeBuilder { if (valeq) ValEq(pos, pat1, rhs1) else ValFrom(pos, pat1, rhs1) } - def makeSyntheticParam(pname: Name) = + def makeSyntheticParam(pname: TermName) = ValDef(Modifiers(PARAM | SYNTHETIC), pname, TypeTree(), EmptyTree) - def makeSyntheticTypeParam(pname: Name, bounds: Tree) = + def makeSyntheticTypeParam(pname: TypeName, bounds: Tree) = TypeDef(Modifiers(DEFERRED | SYNTHETIC), pname, Nil, bounds) abstract class Enumerator { def pos: Position } @@ -323,7 +329,7 @@ abstract class TreeBuilder { * @param enums The enumerators in the for expression * @param body The body of the for expression */ - private def makeFor(mapName: Name, flatMapName: Name, enums: List[Enumerator], body: Tree): Tree = { + private def makeFor(mapName: TermName, flatMapName: TermName, enums: List[Enumerator], body: Tree): Tree = { /** make a closure pat => body. * The closure is assigned a transparent position with the point at pos.point and @@ -345,7 +351,7 @@ abstract class TreeBuilder { /** Make an application qual.meth(pat => body) positioned at `pos`. */ - def makeCombination(pos: Position, meth: Name, qual: Tree, pat: Tree, body: Tree): Tree = + def makeCombination(pos: Position, meth: TermName, qual: Tree, pat: Tree, body: Tree): Tree = Apply(Select(qual, meth) setPos qual.pos, List(makeClosure(pos, pat, body))) setPos pos /** Optionally, if pattern is a `Bind`, the bound name, otherwise None. diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala index 9bbedb6f53..7744a57547 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala @@ -1771,7 +1771,7 @@ abstract class GenICode extends SubComponent { val sym = t.symbol def getLabel(pos: Position, name: Name) = labels.getOrElseUpdate(sym, - method.newLabel(sym.pos, unit.fresh.newName(name.toString)) setInfo sym.tpe + method.newLabel(sym.pos, unit.freshTermName(name.toString)) setInfo sym.tpe ) t match { @@ -2024,7 +2024,7 @@ abstract class GenICode extends SubComponent { /** Make a fresh local variable. It ensures the 'name' is unique. */ def makeLocal(pos: Position, tpe: Type, name: String): Local = { - val sym = method.symbol.newVariable(pos, unit.fresh.newName(name)) + val sym = method.symbol.newVariable(pos, unit.freshTermName(name)) .setInfo(tpe) .setFlag(Flags.SYNTHETIC) this.method.addLocal(new Local(sym, toTypeKind(tpe), false)) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala index f2c3a1c788..4fd59ba0b0 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala @@ -27,6 +27,7 @@ import reflect.generic.{ PickleFormat, PickleBuffer } * */ abstract class GenJVM extends SubComponent { + val global: Global import global._ import icodes._ import icodes.opcodes._ @@ -35,6 +36,7 @@ abstract class GenJVM extends SubComponent { AnyClass, ObjectClass, ThrowsClass, ThrowableClass, ClassfileAnnotationClass, SerializableClass, StringClass, ClassClass, FunctionClass, DeprecatedAttr, SerializableAttr, SerialVersionUIDAttr, VolatileAttr, + AndroidParcelableInterface, AndroidCreatorClass, TransientAttr, CloneableAttr, RemoteAttr, getPrimitiveCompanion } @@ -89,10 +91,10 @@ abstract class GenJVM extends SubComponent { val PublicStatic = ACC_PUBLIC | ACC_STATIC val PublicStaticFinal = ACC_PUBLIC | ACC_STATIC | ACC_FINAL - val StringBuilderClass = definitions.getClass("scala.collection.mutable.StringBuilder").fullName + val StringBuilderClassName = definitions.StringBuilderClass.fullName val BoxesRunTime = "scala.runtime.BoxesRunTime" - val StringBuilderType = new JObjectType(StringBuilderClass) + val StringBuilderType = new JObjectType(StringBuilderClassName) val toStringType = new JMethodType(JAVA_LANG_STRING, JType.EMPTY_ARRAY) val arrayCloneType = new JMethodType(JAVA_LANG_OBJECT, JType.EMPTY_ARRAY) val MethodTypeType = new JObjectType("java.dyn.MethodType") @@ -109,12 +111,6 @@ abstract class GenJVM extends SubComponent { lazy val RemoteInterface = definitions.getClass("java.rmi.Remote") lazy val RemoteException = definitions.getClass("java.rmi.RemoteException").tpe - lazy val ParcelableInterface = - try { definitions.getClass("android.os.Parcelable") } - catch { case _: FatalError => NoSymbol } - // only evaluated if ParcelableInterface != NoSymbol - lazy val CreatorClass = definitions.getClass("android.os.Parcelable$Creator") - val versionPickle = { val vp = new PickleBuffer(new Array[Byte](16), -1, 0) assert(vp.writeIndex == 0) @@ -176,7 +172,7 @@ abstract class GenJVM extends SubComponent { currentRun.symData.get(sym) match { case Some(pickle) if !jclass.getName().endsWith("$") => val scalaAttr = - fjbgContext.JOtherAttribute(jclass, jclass, nme.ScalaSignatureATTR.toString, + fjbgContext.JOtherAttribute(jclass, jclass, tpnme.ScalaSignatureATTR.toString, versionPickle.bytes, versionPickle.writeIndex) jclass.addAttribute(scalaAttr) val scalaAnnot = { @@ -189,7 +185,7 @@ abstract class GenJVM extends SubComponent { Some(scalaAnnot) case _ => val markerAttr = - fjbgContext.JOtherAttribute(jclass, jclass, nme.ScalaATTR.toString, new Array[Byte](0), 0) + fjbgContext.JOtherAttribute(jclass, jclass, tpnme.ScalaATTR.toString, new Array[Byte](0), 0) jclass.addAttribute(markerAttr) None } @@ -210,8 +206,8 @@ abstract class GenJVM extends SubComponent { val name = javaName(c.symbol) serialVUID = None isRemoteClass = false - isParcelableClass = (ParcelableInterface != NoSymbol) && - (parents contains ParcelableInterface.tpe) + isParcelableClass = (AndroidParcelableInterface != NoSymbol) && + (parents contains AndroidParcelableInterface.tpe) if (parents.isEmpty) parents = List(ObjectClass.tpe) @@ -399,7 +395,7 @@ abstract class GenJVM extends SubComponent { assert(nattr > 0) buf.putShort(0, nattr.toShort) - addAttribute(jmethod, nme.ExceptionsATTR, buf) + addAttribute(jmethod, tpnme.ExceptionsATTR, buf) } /** Whether an annotation should be emitted as a Java annotation @@ -527,7 +523,7 @@ abstract class GenJVM extends SubComponent { } val buf = ByteBuffer.allocate(2) buf.putShort(index) - addAttribute(jmember, nme.SignatureATTR, buf) + addAttribute(jmember, tpnme.SignatureATTR, buf) } } } @@ -535,7 +531,7 @@ abstract class GenJVM extends SubComponent { def addAnnotations(jmember: JMember, annotations: List[AnnotationInfo]) { if (annotations.exists(_.atp.typeSymbol == definitions.DeprecatedAttr)) { val attr = jmember.getContext().JOtherAttribute( - jmember.getJClass(), jmember, nme.DeprecatedATTR.toString, + jmember.getJClass(), jmember, tpnme.DeprecatedATTR.toString, new Array[Byte](0), 0) jmember addAttribute attr } @@ -545,7 +541,7 @@ abstract class GenJVM extends SubComponent { val buf: ByteBuffer = ByteBuffer.allocate(2048) emitJavaAnnotations(jmember.getConstantPool, buf, toEmit) - addAttribute(jmember, nme.RuntimeAnnotationATTR, buf) + addAttribute(jmember, tpnme.RuntimeAnnotationATTR, buf) } def addParamAnnotations(jmethod: JMethod, pannotss: List[List[AnnotationInfo]]) { @@ -559,7 +555,7 @@ abstract class GenJVM extends SubComponent { for (annots <- annotations) emitJavaAnnotations(jmethod.getConstantPool, buf, annots) - addAttribute(jmethod, nme.RuntimeParamAnnotationATTR, buf) + addAttribute(jmethod, tpnme.RuntimeParamAnnotationATTR, buf) } def addAttribute(jmember: JMember, name: Name, buf: ByteBuffer) { @@ -813,7 +809,7 @@ abstract class GenJVM extends SubComponent { val fieldName = "CREATOR" val fieldSymbol = clasz.symbol.newValue(NoPosition, newTermName(fieldName)) .setFlag(Flags.STATIC | Flags.FINAL) - .setInfo(CreatorClass.tpe) + .setInfo(AndroidCreatorClass.tpe) val methodSymbol = definitions.getMember(clasz.symbol.companionModule, "CREATOR") clasz addField new IField(fieldSymbol) lastBlock emit CALL_METHOD(methodSymbol, Static(false)) @@ -854,7 +850,7 @@ abstract class GenJVM extends SubComponent { if (isParcelableClass) { val fieldName = "CREATOR" - val creatorType = javaType(CreatorClass) + val creatorType = javaType(AndroidCreatorClass) jclass.addNewField(PublicStaticFinal, fieldName, creatorType) @@ -1648,9 +1644,9 @@ abstract class GenJVM extends SubComponent { jcode.emitARRAYLENGTH() case StartConcat => - jcode emitNEW StringBuilderClass + jcode emitNEW StringBuilderClassName jcode.emitDUP() - jcode.emitINVOKESPECIAL(StringBuilderClass, + jcode.emitINVOKESPECIAL(StringBuilderClassName, JMethod.INSTANCE_CONSTRUCTOR_NAME, JMethodType.ARGLESS_VOID_FUNCTION) @@ -1659,12 +1655,12 @@ abstract class GenJVM extends SubComponent { case REFERENCE(_) | ARRAY(_) => JAVA_LANG_OBJECT case _ => javaType(el) } - jcode.emitINVOKEVIRTUAL(StringBuilderClass, + jcode.emitINVOKEVIRTUAL(StringBuilderClassName, "append", new JMethodType(StringBuilderType, Array(jtype))) case EndConcat => - jcode.emitINVOKEVIRTUAL(StringBuilderClass, + jcode.emitINVOKEVIRTUAL(StringBuilderClassName, "toString", toStringType) @@ -1728,7 +1724,7 @@ abstract class GenJVM extends SubComponent { val attr = fjbgContext.JOtherAttribute(jclass, jmethod, - nme.LocalVariableTableATTR.toString, + tpnme.LocalVariableTableATTR.toString, lvTab.array()) jcode addAttribute attr } diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala index 6f8448ad0a..68412098e3 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala @@ -271,13 +271,12 @@ abstract class DeadCodeElimination extends SubComponent { abort("could not find init in: " + method) } - lazy val RuntimePackage = definitions.getModule("scala.runtime") /** Is 'sym' a side-effecting method? TODO: proper analysis. */ private def isSideEffecting(sym: Symbol): Boolean = { !((sym.isGetter && !sym.isLazy) || (sym.isConstructor && !(sym.owner == method.symbol.owner && method.symbol.isConstructor) // a call to another constructor - && sym.owner.owner == RuntimePackage.moduleClass) + && sym.owner.owner == definitions.RuntimePackage.moduleClass) || (sym.isConstructor && inliner.isClosureClass(sym.owner)) /* || definitions.isBox(sym) || definitions.isUnbox(sym)*/) diff --git a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala index 63c62d8d1e..d6cfdd24b1 100644 --- a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala +++ b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala @@ -22,7 +22,7 @@ trait JavaParsers extends JavaScanners { class JavaUnitParser(val unit: global.CompilationUnit) extends JavaParser { val in = new JavaUnitScanner(unit) - def freshName(prefix : String) = unit.fresh.newName(prefix) + def freshName(prefix : String) = unit.freshTermName(prefix) implicit def i2p(offset : Int) : Position = new OffsetPosition(unit.source, offset) def warning(pos : Int, msg : String) : Unit = unit.warning(pos, msg) def syntaxError(pos: Int, msg: String) : Unit = unit.error(pos, msg) @@ -106,10 +106,10 @@ trait JavaParsers extends JavaScanners { def javaLangDot(name: Name): Tree = Select(javaDot(nme.lang), name) - def javaLangObject(): Tree = javaLangDot(nme.Object.toTypeName) + def javaLangObject(): Tree = javaLangDot(tpnme.Object) def arrayOf(tpt: Tree) = - AppliedTypeTree(scalaDot(nme.Array.toTypeName), List(tpt)) + AppliedTypeTree(scalaDot(tpnme.Array), List(tpt)) def blankExpr = Ident(nme.WILDCARD) @@ -192,14 +192,18 @@ trait JavaParsers extends JavaScanners { } def acceptClosingAngle() { - if (in.token == GTGTGTEQ) in.token = GTGTEQ - else if (in.token == GTGTGT) in.token = GTGT - else if (in.token == GTGTEQ) in.token = GTEQ - else if (in.token == GTGT) in.token = GT - else if (in.token == GTEQ) in.token = ASSIGN + val closers: PartialFunction[Int, Int] = { + case GTGTGTEQ => GTGTEQ + case GTGTGT => GTGT + case GTGTEQ => GTEQ + case GTGT => GT + case GTEQ => ASSIGN + } + if (closers isDefinedAt in.token) in.token = closers(in.token) else accept(GT) } + def identForType(): TypeName = ident().toTypeName def ident(): Name = if (in.token == IDENTIFIER) { val name = in.name @@ -279,7 +283,7 @@ trait JavaParsers extends JavaScanners { // turns out to be an instance ionner class instead of a static inner class. def typeSelect(t: Tree, name: Name) = t match { case Ident(_) | Select(_, _) => Select(t, name) - case _ => SelectFromTypeTree(t, name) + case _ => SelectFromTypeTree(t, name.toTypeName) } while (in.token == DOT) { in.nextToken @@ -431,7 +435,7 @@ trait JavaParsers extends JavaScanners { case _ => val privateWithin: Name = if (isPackageAccess && !inInterface) thisPackageName - else nme.EMPTY.toTypeName + else tpnme.EMPTY return Modifiers(flags, privateWithin) withAnnotations annots } @@ -449,16 +453,16 @@ trait JavaParsers extends JavaScanners { def typeParam(): TypeDef = atPos(in.currentPos) { - val name = ident().toTypeName + val name = identForType() val hi = if (in.token == EXTENDS) { in.nextToken bound() } else { - scalaDot(nme.Any.toTypeName) + scalaDot(tpnme.Any) } TypeDef(Modifiers(Flags.JAVA | Flags.DEFERRED | Flags.PARAM), name, List(), - TypeBoundsTree(scalaDot(nme.Nothing.toTypeName), hi)) + TypeBoundsTree(scalaDot(tpnme.Nothing), hi)) } def bound(): Tree = @@ -487,7 +491,7 @@ trait JavaParsers extends JavaScanners { if (in.token == DOTDOTDOT) { in.nextToken t = atPos(t.pos) { - AppliedTypeTree(scalaDot(nme.JAVA_REPEATED_PARAM_CLASS_NAME), List(t)) + AppliedTypeTree(scalaDot(tpnme.JAVA_REPEATED_PARAM_CLASS_NAME), List(t)) } } varDecl(in.currentPos, Modifiers(Flags.JAVA | Flags.PARAM), t, ident()) @@ -548,7 +552,7 @@ trait JavaParsers extends JavaScanners { if (parentToken == AT && in.token == DEFAULT) { val annot = atPos(pos) { - New(Select(scalaDot(newTermName("runtime")), nme.AnnotationDefaultATTR.toTypeName), List(List())) + New(Select(scalaDot(newTermName("runtime")), tpnme.AnnotationDefaultATTR), List(List())) } mods1 = Modifiers(mods1.flags, mods1.privateWithin, annot :: mods1.annotations, mods1.positions) skipTo(SEMI) @@ -613,7 +617,7 @@ trait JavaParsers extends JavaScanners { buf.toList } - def varDecl(pos: Position, mods: Modifiers, tpt: Tree, name: Name): ValDef = { + def varDecl(pos: Position, mods: Modifiers, tpt: Tree, name: TermName): ValDef = { val tpt1 = optArrayBrackets(tpt) if (in.token == ASSIGN && !mods.isParameter) skipTo(COMMA, SEMI) val mods1 = if (mods.isFinal) mods &~ Flags.FINAL else mods | Flags.MUTABLE @@ -714,7 +718,7 @@ trait JavaParsers extends JavaScanners { def classDecl(mods: Modifiers): List[Tree] = { accept(CLASS) val pos = in.currentPos - val name = ident().toTypeName + val name = identForType() val tparams = typeParams() val superclass = if (in.token == EXTENDS) { @@ -733,7 +737,7 @@ trait JavaParsers extends JavaScanners { def interfaceDecl(mods: Modifiers): List[Tree] = { accept(INTERFACE) val pos = in.currentPos - val name = ident().toTypeName + val name = identForType() val tparams = typeParams() val parents = if (in.token == EXTENDS) { @@ -795,7 +799,7 @@ trait JavaParsers extends JavaScanners { accept(AT) accept(INTERFACE) val pos = in.currentPos - val name = ident().toTypeName + val name = identForType() val parents = List(scalaDot(newTypeName("Annotation")), Select(javaLangDot(newTermName("annotation")), newTypeName("Annotation")), scalaDot(newTypeName("ClassfileAnnotation"))) @@ -815,7 +819,7 @@ trait JavaParsers extends JavaScanners { def enumDecl(mods: Modifiers): List[Tree] = { accept(ENUM) val pos = in.currentPos - val name = ident().toTypeName + val name = identForType() def enumType = Ident(name) val interfaces = interfacesOpt() accept(LBRACE) diff --git a/src/compiler/scala/tools/nsc/javac/JavaScanners.scala b/src/compiler/scala/tools/nsc/javac/JavaScanners.scala index fccb1746fe..fd69f15edc 100644 --- a/src/compiler/scala/tools/nsc/javac/JavaScanners.scala +++ b/src/compiler/scala/tools/nsc/javac/JavaScanners.scala @@ -37,7 +37,7 @@ trait JavaScanners { var lastPos: Int = 0 /** the name of an identifier or token */ - var name: Name = null + var name: TermName = null /** the base of a number */ var base: Int = 0 @@ -165,7 +165,7 @@ trait JavaScanners { //Token representation ----------------------------------------------------- /** Convert name to token */ - def name2token(name: Name): Int = + def name2token(name: TermName): Int = if (name.start <= maxKey) key(name.start) else IDENTIFIER /** Returns the string representation of given token. */ diff --git a/src/compiler/scala/tools/nsc/matching/Matrix.scala b/src/compiler/scala/tools/nsc/matching/Matrix.scala index d914f1c17f..a1f260519b 100644 --- a/src/compiler/scala/tools/nsc/matching/Matrix.scala +++ b/src/compiler/scala/tools/nsc/matching/Matrix.scala @@ -206,8 +206,6 @@ trait Matrix extends MatrixAdditions { override def toString() = "%s: %s = %s".format(lhs, lhs.info, rhs) } - def newName(s: String) = cunit.fresh.newName(s) - /** Sets the rhs to EmptyTree, which makes the valDef ignored in Scrutinee. */ def specialVar(lhs: Symbol, checked: Boolean) = @@ -223,7 +221,7 @@ trait Matrix extends MatrixAdditions { label: String = "temp"): PatternVar = { val tpe = ifNull(_tpe, root.tpe) - val name = newName(label) + val name = cunit.freshTermName(label) val sym = newVar(root.pos, tpe, flags(checked), name) tracing("copy", new PatternVar(sym, root, checked)) @@ -243,9 +241,9 @@ trait Matrix extends MatrixAdditions { pos: Position, tpe: Type, flags: List[Long] = Nil, - name: Name = null): Symbol = + name: TermName = null): Symbol = { - val n: Name = if (name == null) newName("temp") else name + val n = if (name == null) cunit.freshTermName("temp") else name // careful: pos has special meaning recordSyntheticSym(owner.newVariable(pos, n) setInfo tpe setFlag (SYNTHETIC.toLong /: flags)(_|_)) } diff --git a/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala b/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala index 4b717f209c..169518b9ab 100644 --- a/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala +++ b/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala @@ -544,7 +544,7 @@ trait ParallelMatching extends ast.TreeDSL } lazy val label = - owner.newLabel(scrut.pos, newName("failCont%")) setInfo MethodType(Nil, labelBody.tpe) + owner.newLabel(scrut.pos, cunit.freshTermName("failCont%")) setInfo MethodType(Nil, labelBody.tpe) lazy val cond = handleOuter(rhs MEMBER_== scrut.id ) diff --git a/src/compiler/scala/tools/nsc/symtab/Definitions.scala b/src/compiler/scala/tools/nsc/symtab/Definitions.scala index db757a66f5..789f803965 100644 --- a/src/compiler/scala/tools/nsc/symtab/Definitions.scala +++ b/src/compiler/scala/tools/nsc/symtab/Definitions.scala @@ -28,7 +28,7 @@ trait Definitions extends reflect.generic.StandardDefinitions { RootClass.sourceModule = rp rp } - lazy val RootClass: ModuleClassSymbol = NoSymbol.newModuleClass(NoPosition, nme.ROOT.toTypeName) + lazy val RootClass: ModuleClassSymbol = NoSymbol.newModuleClass(NoPosition, tpnme.ROOT) .setFlag(FINAL | MODULE | PACKAGE | JAVA).setInfo(rootLoader) lazy val EmptyPackage = RootClass.newPackage(NoPosition, nme.EMPTY_PACKAGE_NAME).setFlag(FINAL) @@ -66,24 +66,22 @@ trait Definitions extends reflect.generic.StandardDefinitions { private def stringtype = StringClass.typeConstructor // top types - lazy val AnyClass = newClass(ScalaPackageClass, nme.Any, Nil) setFlag (ABSTRACT) - lazy val AnyValClass = newClass(ScalaPackageClass, nme.AnyVal, anyparam) setFlag (ABSTRACT | SEALED) - lazy val AnyRefClass = newAlias(ScalaPackageClass, nme.AnyRef, ObjectClass.typeConstructor) + lazy val AnyClass = newClass(ScalaPackageClass, tpnme.Any, Nil) setFlag (ABSTRACT) + lazy val AnyValClass = newClass(ScalaPackageClass, tpnme.AnyVal, anyparam) setFlag (ABSTRACT | SEALED) + lazy val AnyRefClass = newAlias(ScalaPackageClass, tpnme.AnyRef, ObjectClass.typeConstructor) lazy val ObjectClass = getClass(sn.Object) // bottom types - lazy val NullClass = newClass(ScalaPackageClass, nme.Null, anyrefparam) setFlag (ABSTRACT | TRAIT | FINAL) - lazy val NothingClass = newClass(ScalaPackageClass, nme.Nothing, anyparam) setFlag (ABSTRACT | TRAIT | FINAL) + lazy val NullClass = newClass(ScalaPackageClass, tpnme.Null, anyrefparam) setFlag (ABSTRACT | TRAIT | FINAL) + lazy val NothingClass = newClass(ScalaPackageClass, tpnme.Nothing, anyparam) setFlag (ABSTRACT | TRAIT | FINAL) lazy val RuntimeNothingClass = getClass(ClassfileConstants.SCALA_NOTHING) lazy val RuntimeNullClass = getClass(ClassfileConstants.SCALA_NULL) lazy val AnyValCompanionClass = getClass("scala.runtime.AnyValCompanion").setFlag(SEALED | ABSTRACT | TRAIT) // the scala value classes - lazy val UnitClass = - newClass(ScalaPackageClass, nme.Unit, anyvalparam).setFlag(ABSTRACT | FINAL) - import ClassfileConstants._ + lazy val UnitClass = newClass(ScalaPackageClass, tpnme.Unit, anyvalparam).setFlag(ABSTRACT | FINAL) lazy val ByteClass = newValueClass(nme.Byte, BYTE_TAG, 2) lazy val ShortClass = newValueClass(nme.Short, SHORT_TAG, 4) lazy val CharClass = newValueClass(nme.Char, CHAR_TAG, 3) @@ -112,7 +110,7 @@ trait Definitions extends reflect.generic.StandardDefinitions { lazy val IndexOutOfBoundsExceptionClass = getClass(sn.IOOBException) lazy val InvocationTargetExceptionClass = getClass(sn.InvTargetException) lazy val MatchErrorClass = getClass("scala.MatchError") - lazy val NonLocalReturnControlClass = getClass(sn.NLRControl) + lazy val NonLocalReturnControlClass = getClass("scala.runtime.NonLocalReturnControl") lazy val NullPointerExceptionClass = getClass(sn.NPException) lazy val ThrowableClass = getClass(sn.Throwable) lazy val UninitializedErrorClass = getClass("scala.UninitializedFieldError") @@ -169,28 +167,29 @@ trait Definitions extends reflect.generic.StandardDefinitions { def scalaRuntimeSameElements = getMember(ScalaRunTimeModule, nme.sameElements) // classes with special meanings - lazy val NotNullClass = getClass("scala.NotNull") - lazy val DelayedInitClass = getClass("scala.DelayedInit") + lazy val NotNullClass = getClass("scala.NotNull") + lazy val DelayedInitClass = getClass("scala.DelayedInit") def delayedInitMethod = getMember(DelayedInitClass, nme.delayedInit) // a dummy value that communicates that a delayedInit call is compiler-generated // from phase UnCurry to phase Constructors def delayedInitArgVal = EmptyPackageClass.newValue(NoPosition, nme.delayedInitArg) .setInfo(UnitClass.tpe) + lazy val TypeConstraintClass = getClass("scala.TypeConstraint") - lazy val SingletonClass = newClass(ScalaPackageClass, nme.Singleton, anyparam) setFlag (ABSTRACT | TRAIT | FINAL) + lazy val SingletonClass = newClass(ScalaPackageClass, tpnme.Singleton, anyparam) setFlag (ABSTRACT | TRAIT | FINAL) lazy val SerializableClass = getClass("scala.Serializable") lazy val JavaSerializableClass = getClass(sn.JavaSerializable) lazy val ComparableClass = getClass("java.lang.Comparable") lazy val RepeatedParamClass = newCovariantPolyClass( ScalaPackageClass, - nme.REPEATED_PARAM_CLASS_NAME, + tpnme.REPEATED_PARAM_CLASS_NAME, tparam => seqType(tparam.typeConstructor) ) lazy val JavaRepeatedParamClass = newCovariantPolyClass( ScalaPackageClass, - nme.JAVA_REPEATED_PARAM_CLASS_NAME, + tpnme.JAVA_REPEATED_PARAM_CLASS_NAME, tparam => arrayType(tparam.typeConstructor) ) @@ -214,21 +213,22 @@ trait Definitions extends reflect.generic.StandardDefinitions { lazy val ByNameParamClass = newCovariantPolyClass( ScalaPackageClass, - nme.BYNAME_PARAM_CLASS_NAME, + tpnme.BYNAME_PARAM_CLASS_NAME, tparam => AnyClass.typeConstructor ) lazy val EqualsPatternClass = { - val clazz = newClass(ScalaPackageClass, nme.EQUALS_PATTERN_NAME, Nil) + val clazz = newClass(ScalaPackageClass, tpnme.EQUALS_PATTERN_NAME, Nil) clazz setInfo PolyType(List(newTypeParam(clazz, 0)), ClassInfoType(anyparam, new Scope, clazz)) } // collections classes - lazy val ConsClass = getClass("scala.collection.immutable.$colon$colon") - lazy val IterableClass = getClass("scala.collection.Iterable") - lazy val IteratorClass = getClass("scala.collection.Iterator") - lazy val ListClass = getClass("scala.collection.immutable.List") - lazy val SeqClass = getClass("scala.collection.Seq") - lazy val TraversableClass = getClass("scala.collection.Traversable") + lazy val ConsClass = getClass("scala.collection.immutable.$colon$colon") + lazy val IterableClass = getClass("scala.collection.Iterable") + lazy val IteratorClass = getClass("scala.collection.Iterator") + lazy val ListClass = getClass("scala.collection.immutable.List") + lazy val SeqClass = getClass("scala.collection.Seq") + lazy val StringBuilderClass = getClass("scala.collection.mutable.StringBuilder") + lazy val TraversableClass = getClass("scala.collection.Traversable") lazy val ListModule = getModule("scala.collection.immutable.List") lazy val NilModule = getModule("scala.collection.immutable.Nil") @@ -287,10 +287,10 @@ trait Definitions extends reflect.generic.StandardDefinitions { def longType = typeRef(LongClass.typeConstructor.prefix, LongClass, List()) // Product, Tuple, Function - private def mkArityArray(name: String, arity: Int, countFrom: Int = 1) = { - val list = (countFrom to arity).toList map (i => getClass(("scala." + name + i): Name)) + private def mkArityArray(name: String, arity: Int, countFrom: Int = 1): Array[Symbol] = { + val list = countFrom to arity map (i => getClass("scala." + name + i)) if (countFrom == 0) list.toArray - else (NoSymbol :: list).toArray + else (NoSymbol +: list).toArray } val MaxTupleArity, MaxProductArity, MaxFunctionArity = 22 @@ -490,33 +490,48 @@ trait Definitions extends reflect.generic.StandardDefinitions { lazy val VolatileAttr: Symbol = getClass("scala.volatile") lazy val AnnotationDefaultAttr: Symbol = { - val attr = newClass(RuntimePackageClass, nme.AnnotationDefaultATTR, List(AnnotationClass.typeConstructor)) + val attr = newClass(RuntimePackageClass, tpnme.AnnotationDefaultATTR, List(AnnotationClass.typeConstructor)) // This attribute needs a constructor so that modifiers in parsed Java code make sense attr.info.decls enter (attr newConstructor NoPosition setInfo MethodType(Nil, attr.tpe)) attr } + // Android. I moved it into definitions because it threw an expensive + // exception on every repl line. + lazy val AndroidParcelableInterface = + try getClass("android.os.Parcelable") + catch { case _: FatalError => NoSymbol } + lazy val AndroidCreatorClass = + if (AndroidParcelableInterface == NoSymbol) NoSymbol + else getClass("android.os.Parcelable$Creator") + def getModule(fullname: Name): Symbol = - getModuleOrClass(fullname, true) + getModuleOrClass(fullname.toTermName) def getClass(fullname: Name): Symbol = { - var result = getModuleOrClass(fullname, false) + var result = getModuleOrClass(fullname.toTypeName) while (result.isAliasType) result = result.info.typeSymbol result } def getMember(owner: Symbol, name: Name): Symbol = { - if (owner == NoSymbol) return NoSymbol - val result = owner.info.nonPrivateMember(name) - if (result == NoSymbol) { - throw new FatalError(owner.toString() + " does not have a member " + name) + if (owner == NoSymbol) NoSymbol + else owner.info.nonPrivateMember(name) match { + case NoSymbol => throw new FatalError(owner + " does not have a member " + name) + case result => result } - result } - private def getModuleOrClass(fullname: Name, module: Boolean): Symbol = { - if (fullname == nme.NOSYMBOL) return NoSymbol - var sym:Symbol = RootClass + /** If you're looking for a class, pass a type name. + * If a module, a term name. + */ + private def getModuleOrClass(path: Name): Symbol = { + val module = path.isTermName + val fullname = path.toTermName + if (fullname == nme.NO_NAME) + return NoSymbol + + var sym: Symbol = RootClass var i = 0 var j = fullname.pos('.', i) while (j < fullname.length) { @@ -532,20 +547,21 @@ trait Definitions extends reflect.generic.StandardDefinitions { { log(sym.info); log(sym.info.members) }//debug throw new MissingRequirementError((if (module) "object " else "class ") + fullname) } + result } - private def newClass(owner: Symbol, name: Name, parents: List[Type]): Symbol = { - val clazz = owner.newClass(NoPosition, name.toTypeName) + private def newClass(owner: Symbol, name: TypeName, parents: List[Type]): Symbol = { + val clazz = owner.newClass(NoPosition, name) clazz.setInfo(ClassInfoType(parents, new Scope, clazz)) owner.info.decls.enter(clazz) clazz } - private def newCovariantPolyClass(owner: Symbol, name: Name, parent: Symbol => Type): Symbol = { - val clazz = newClass(owner, name, List()) + private def newCovariantPolyClass(owner: Symbol, name: TypeName, parent: Symbol => Type): Symbol = { + val clazz = newClass(owner, name, List()) val tparam = newTypeParam(clazz, 0) setFlag COVARIANT - val p = parent(tparam) + val p = parent(tparam) /* p.typeSymbol.initialize println(p.typeSymbol + " flags: " + Flags.flagsToString(p.typeSymbol.flags)) val parents = /*if (p.typeSymbol.isTrait) @@ -558,41 +574,41 @@ trait Definitions extends reflect.generic.StandardDefinitions { ClassInfoType(List(AnyRefClass.tpe, p), new Scope, clazz))) } - private def newAlias(owner: Symbol, name: Name, alias: Type): Symbol = { - val tpsym = owner.newAliasType(NoPosition, name.toTypeName) + private def newAlias(owner: Symbol, name: TypeName, alias: Type): Symbol = { + val tpsym = owner.newAliasType(NoPosition, name) tpsym.setInfo(alias) owner.info.decls.enter(tpsym) tpsym } - private def newMethod(owner: Symbol, name: Name): Symbol = { + private def newMethod(owner: Symbol, name: TermName): Symbol = { val msym = owner.newMethod(NoPosition, name.encode) owner.info.decls.enter(msym) msym } - private def newMethod(owner: Symbol, name: Name, formals: List[Type], restpe: Type): Symbol = { + private def newMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type): Symbol = { val msym = newMethod(owner, name) val params = msym.newSyntheticValueParams(formals) msym.setInfo(MethodType(params, restpe)) } /** tcon receives the type parameter symbol as argument */ - private def newPolyMethod(owner: Symbol, name: Name, tcon: Symbol => Type): Symbol = + private def newPolyMethod(owner: Symbol, name: TermName, tcon: Symbol => Type): Symbol = newPolyMethodCon(owner, name, tparam => msym => tcon(tparam)) /** tcon receives the type parameter symbol and the method symbol as arguments */ - private def newPolyMethodCon(owner: Symbol, name: Name, tcon: Symbol => Symbol => Type): Symbol = { + private def newPolyMethodCon(owner: Symbol, name: TermName, tcon: Symbol => Symbol => Type): Symbol = { val msym = newMethod(owner, name) val tparam = newTypeParam(msym, 0) msym.setInfo(PolyType(List(tparam), tcon(tparam)(msym))) } - private def newParameterlessMethod(owner: Symbol, name: Name, restpe: Type) = + private def newParameterlessMethod(owner: Symbol, name: TermName, restpe: Type) = newMethod(owner, name).setInfo(PolyType(List(),restpe)) private def newTypeParam(owner: Symbol, index: Int): Symbol = - owner.newTypeParameter(NoPosition, "T" + index) + owner.newTypeParameter(NoPosition, newTypeName("T" + index)) .setInfo(TypeBounds(NothingClass.typeConstructor, AnyClass.typeConstructor)) val boxedClass = new HashMap[Symbol, Symbol] @@ -635,10 +651,11 @@ trait Definitions extends reflect.generic.StandardDefinitions { primitiveCompanions += module } - private[symtab] def newValueClass(name: Name, tag: Char, weight: Int): Symbol = { - val boxedName = sn.Boxed(name) + private[symtab] def newValueClass(name: TermName, tag: Char, weight: Int): Symbol = { + val tpName = name.toTypeName + val boxedName = sn.Boxed(tpName).toTermName - val clazz = newClass(ScalaPackageClass, name, anyvalparam) setFlag (ABSTRACT | FINAL) + val clazz = newClass(ScalaPackageClass, tpName, anyvalparam) setFlag (ABSTRACT | FINAL) boxedClass(clazz) = getClass(boxedName) boxedModule(clazz) = getModule(boxedName) refClass(clazz) = getClass("scala.runtime." + name + "Ref") @@ -646,17 +663,15 @@ trait Definitions extends reflect.generic.StandardDefinitions { abbrvTag(clazz) = tag if (weight > 0) numericWeight(clazz) = weight - val module = ScalaPackageClass.newModule(NoPosition, name) + val module = ScalaPackageClass.newModule(NoPosition, name.toTermName) ScalaPackageClass.info.decls.enter(module) val mclass = module.moduleClass mclass.setInfo(ClassInfoType(List(AnyRefClass.tpe, AnyValCompanionClass.tpe), new Scope, mclass)) module.setInfo(mclass.tpe) primitiveCompanions += module - val box = newMethod(mclass, nme.box, List(clazz.typeConstructor), boxedClass(clazz).tpe) - boxMethod(clazz) = box - val unbox = newMethod(mclass, nme.unbox, List(ObjectClass.typeConstructor), clazz.typeConstructor) - unboxMethod(clazz) = unbox + boxMethod(clazz) = newMethod(mclass, nme.box, List(clazz.typeConstructor), boxedClass(clazz).tpe) + unboxMethod(clazz) = newMethod(mclass, nme.unbox, List(ObjectClass.typeConstructor), clazz.typeConstructor) clazz } @@ -728,11 +743,11 @@ trait Definitions extends reflect.generic.StandardDefinitions { List(ByteClass, ShortClass, CharClass, IntClass, LongClass) foreach (x => initValueClass(x, true)) List(FloatClass, DoubleClass) foreach (x => initValueClass(x, false)) - def addModuleMethod(clazz: Symbol, name: Name, value: Any) = { + def addModuleMethod(clazz: Symbol, name: TermName, value: Any) = { val owner = clazz.linkedClassOfClass newParameterlessMethod(owner, name, ConstantType(Constant(value))) } - def addDeprecatedModuleMethod(clazz: Symbol, name: Name, value: Any, msg: String) = { + def addDeprecatedModuleMethod(clazz: Symbol, name: TermName, value: Any, msg: String) = { val m = addModuleMethod(clazz, name, value) val arg = Literal(Constant(msg)) m.addAnnotation(AnnotationInfo(DeprecatedAttr.tpe, List(arg), List())) diff --git a/src/compiler/scala/tools/nsc/symtab/NameManglers.scala b/src/compiler/scala/tools/nsc/symtab/NameManglers.scala index 525fcced84..d9a1da7731 100644 --- a/src/compiler/scala/tools/nsc/symtab/NameManglers.scala +++ b/src/compiler/scala/tools/nsc/symtab/NameManglers.scala @@ -20,7 +20,6 @@ trait NameManglers { val IMPL_CLASS_SUFFIX = "$class" val LOCALDUMMY_PREFIX = "<local " // owner of local blocks - val LOCAL_SUFFIX = newTermName(LOCAL_SUFFIX_STRING) val PROTECTED_PREFIX = "protected$" val PROTECTED_SET_PREFIX = PROTECTED_PREFIX + "set" val SELECTOR_DUMMY = "<unapply-selector>" @@ -32,15 +31,15 @@ trait NameManglers { def isExceptionResultName(name: Name) = name startsWith EXCEPTION_RESULT_PREFIX def isImplClassName(name: Name) = name endsWith IMPL_CLASS_SUFFIX def isLocalDummyName(name: Name) = name startsWith LOCALDUMMY_PREFIX - def isLocalName(name: Name) = name endsWith LOCAL_SUFFIX + def isLocalName(name: Name) = name endsWith LOCAL_SUFFIX_STRING def isLoopHeaderLabel(name: Name) = (name startsWith WHILE_PREFIX) || (name startsWith DO_WHILE_PREFIX) 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 isOpAssignmentName(name: Name) = name match { - case NEraw | LEraw | GEraw | EMPTY => false - case _ => + case raw.NE | raw.LE | raw.GE | EMPTY => false + case _ => name.endChar == '=' && name.startChar != '=' && isOperatorPart(name.startChar) } @@ -75,16 +74,16 @@ trait NameManglers { val name1 = name.subName(0, name.length - 3) val idxC = name1.lastPos('c') val idxM = name1.lastPos('m', idxC) - (name1.subName(0, idxM - 1).toString, + (name1.subName(0, idxM - 1), name1.subName(idxC + 1, name1.length).toString, name1.subName(idxM + 1, idxC).toString) } else (name, "", "") def getterName(name: Name): Name = if (isLocalName(name)) localToGetter(name) else name - def getterToLocal(name: Name): Name = name append LOCAL_SUFFIX + def getterToLocal(name: Name): Name = name append LOCAL_SUFFIX_STRING def getterToSetter(name: Name): Name = name append SETTER_SUFFIX - def localToGetter(name: Name): Name = name stripEnd LOCAL_SUFFIX + def localToGetter(name: Name): Name = name stripEnd LOCAL_SUFFIX_STRING def setterToGetter(name: Name): Name = { val p = name.pos(TRAIT_SETTER_SEPARATOR_STRING) diff --git a/src/compiler/scala/tools/nsc/symtab/Names.scala b/src/compiler/scala/tools/nsc/symtab/Names.scala index 0c473c33ef..04cd8a8d84 100644 --- a/src/compiler/scala/tools/nsc/symtab/Names.scala +++ b/src/compiler/scala/tools/nsc/symtab/Names.scala @@ -100,7 +100,7 @@ trait Names extends reflect.generic.Names { /** Create a term name from the characters in cs[offset..offset+len-1]. */ - def newTermName(cs: Array[Char], offset: Int, len: Int): Name = { + def newTermName(cs: Array[Char], offset: Int, len: Int): TermName = { val h = hashValue(cs, offset, len) & HASH_MASK var n = termHashtable(h) while ((n ne null) && (n.length != len || !equals(n.start, cs, offset, len))) @@ -114,41 +114,51 @@ trait Names extends reflect.generic.Names { /** create a term name from string */ - def newTermName(s: String): Name = + def newTermName(s: String): TermName = newTermName(s.toCharArray(), 0, s.length()) /** Create a term name from the UTF8 encoded bytes in bs[offset..offset+len-1]. */ - def newTermName(bs: Array[Byte], offset: Int, len: Int): Name = + def newTermName(bs: Array[Byte], offset: Int, len: Int): TermName = newTermName(Codec toUTF8 bs.slice(offset, offset + len) mkString) /** Create a type name from the characters in cs[offset..offset+len-1]. */ - def newTypeName(cs: Array[Char], offset: Int, len: Int): Name = + def newTypeName(cs: Array[Char], offset: Int, len: Int): TypeName = newTermName(cs, offset, len).toTypeName /** Create a type name from string */ - def newTypeName(s: String): Name = + def newTypeName(s: String): TypeName = newTermName(s).toTypeName /** Create a type name from the UTF8 encoded bytes in bs[offset..offset+len-1]. */ - def newTypeName(bs: Array[Byte], offset: Int, len: Int): Name = + def newTypeName(bs: Array[Byte], offset: Int, len: Int): TypeName = newTermName(bs, offset, len).toTypeName - def mkTermName(name: Name) = name.toTermName - def mkTypeName(name: Name) = name.toTypeName + def mkTermName(name: Name): TermName = name.toTermName + def mkTypeName(name: Name): TypeName = name.toTypeName + def isTermName(name: Name): Boolean = name.isTermName + def isTypeName(name: Name): Boolean = name.isTypeName def nameChars: Array[Char] = chrs - - implicit def view(s: String): Name = newTermName(s) + @deprecated("") def view(s: String): TermName = newTermName(s) + + override def onNameTranslate(name: Name): Unit = { + if (nameDebug) { + Console println "Translating %s '%s' to %s.".format( + if (isTypeName(name)) "type" else "term", + name, + if (isTypeName(name)) "term" else "type" + ) + } + } // Classes ---------------------------------------------------------------------- /** The name class. */ abstract class Name(index: Int, len: Int) extends Function1[Int, Char] { - /** Index into name table */ def start: Int = index @@ -164,8 +174,8 @@ trait Names extends reflect.generic.Names { def isTermName: Boolean def isTypeName: Boolean - def toTermName: Name - def toTypeName: Name + def toTermName: TermName + def toTypeName: TypeName /** Copy bytes of this name to buffer cs, starting at position `offset`. */ @@ -183,6 +193,7 @@ trait Names extends reflect.generic.Names { /** return the string representation of this name */ final override def toString(): String = new String(chrs, index, len) + def debugString() = NameTransformer.decode(toString) + (if (isTypeName) "!" else "") /** Write to UTF8 representation of this name to given character array. * Start copying to index `to'. Return index of next free byte in array. @@ -199,6 +210,29 @@ trait Names extends reflect.generic.Names { */ final override def hashCode(): Int = index + // Presently disabled. + // override def equals(other: Any) = paranoidEquals(other) + private def paranoidEquals(other: Any): Boolean = { + val cmp = this eq other.asInstanceOf[AnyRef] + if (cmp || !nameDebug) + return cmp + + other match { + case x: String => + Console.println("Compared " + debugString + " and String '" + x + "'") + case x: Name => + if (this.isTermName != x.isTermName) { + val panic = this.toTermName == x.toTermName + Console.println("Compared '%s' and '%s', one term, one type.%s".format(this, x, + if (panic) " And they contain the same name string!" + else "" + )) + } + case _ => + } + false + } + /** return the i'th Char of this name */ final def apply(i: Int): Char = chrs(index + i) @@ -250,7 +284,7 @@ trait Names extends reflect.generic.Names { */ final def lastPos(c: Char): Int = lastPos(c, len - 1) - final def lastPos(s: String): Int = lastPos(s, len - s.length()) + final def lastPos(s: String): Int = lastPos(s, len - s.length) /** return the index of the last occurrence of char c in this * name from start, -1 if not found. @@ -313,6 +347,7 @@ trait Names extends reflect.generic.Names { i > suffix.length } + final def containsName(subname: String): Boolean = containsName(newTermName(subname)) final def containsName(subname: Name): Boolean = { var start = 0 val last = len - subname.length @@ -323,15 +358,16 @@ trait Names extends reflect.generic.Names { /** Some thoroughly self-explanatory convenience functions. They * assume that what they're being asked to do is known to be valid. */ - final def startChar: Char = apply(0) - final def endChar: Char = apply(len - 1) - final def startsWith(char: Char): Boolean = len > 0 && startChar == char - final def endsWith(char: Char): Boolean = len > 0 && endChar == char - final def stripStart(prefix: Name): Name = subName(prefix.length, len) - final def stripEnd(suffix: Name): Name = subName(0, len - suffix.length) - final def append(suffix: Name): Name = - if (isTermName) newTermName(this.toString + suffix) - else newTypeName(this.toString + suffix) + final def startChar: Char = apply(0) + final def endChar: Char = apply(len - 1) + final def startsWith(char: Char): Boolean = len > 0 && startChar == char + final def startsWith(name: String): Boolean = startsWith(newTermName(name)) + final def endsWith(char: Char): Boolean = len > 0 && endChar == char + final def endsWith(name: String): Boolean = endsWith(newTermName(name)) + final def stripStart(prefix: Name): Name = subName(prefix.length, len) + 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) /** Return the subname with characters from start to end-1. */ @@ -361,6 +397,13 @@ trait Names extends reflect.generic.Names { else newTermName(res) } + def append(suffix: String): Name = { + val chars = this + suffix + if (isTypeName) newTypeName(chars) + else newTermName(chars) + } + def append(suffix: Name): Name = append(suffix.toString) + /** Replace $op_name by corresponding operator symbol. */ def decode: String = ( @@ -370,13 +413,13 @@ trait Names extends reflect.generic.Names { def isOperatorName: Boolean = decode != toString } - private class TermName(index: Int, len: Int, hash: Int) extends Name(index, len) { + final class TermName(index: Int, len: Int, hash: Int) extends Name(index, len) { next = termHashtable(hash) termHashtable(hash) = this def isTermName: Boolean = true def isTypeName: Boolean = false - def toTermName: Name = this - def toTypeName = { + def toTermName: TermName = this + def toTypeName: TypeName = { val h = hashValue(chrs, index, len) & HASH_MASK var n = typeHashtable(h) while ((n ne null) && n.start != index) @@ -385,16 +428,16 @@ trait Names extends reflect.generic.Names { n = new TypeName(index, len, h); n } - def subName(from: Int, to: Int): Name = + def subName(from: Int, to: Int): TermName = newTermName(chrs, start + from, to - from) } - private class TypeName(index: Int, len: Int, hash: Int) extends Name(index, len) { + final class TypeName(index: Int, len: Int, hash: Int) extends Name(index, len) { next = typeHashtable(hash) typeHashtable(hash) = this def isTermName: Boolean = false def isTypeName: Boolean = true - def toTermName: Name = { + def toTermName: TermName = { val h = hashValue(chrs, index, len) & HASH_MASK var n = termHashtable(h) while ((n ne null) && n.start != index) @@ -403,8 +446,8 @@ trait Names extends reflect.generic.Names { n = new TermName(index, len, h); n } - def toTypeName: Name = this - def subName(from: Int, to: Int): Name = + def toTypeName: TypeName = this + def subName(from: Int, to: Int): TypeName = newTypeName(chrs, start + from, to - from) } } diff --git a/src/compiler/scala/tools/nsc/symtab/StdNames.scala b/src/compiler/scala/tools/nsc/symtab/StdNames.scala index e3a23b2b43..54c3ff9310 100644 --- a/src/compiler/scala/tools/nsc/symtab/StdNames.scala +++ b/src/compiler/scala/tools/nsc/symtab/StdNames.scala @@ -6,12 +6,271 @@ package scala.tools.nsc package symtab -import scala.collection.{ mutable, immutable } +import scala.collection.immutable trait StdNames extends reflect.generic.StdNames with NameManglers { self: SymbolTable => - object nme extends StandardNames with NameMangling { + trait CompilerCommonNames extends LibraryCommonNames { + final val Any: NameType = "Any" + final val AnyRef: NameType = "AnyRef" + final val AnyVal: NameType = "AnyVal" + final val Array: NameType = "Array" + final val Boolean: NameType = "Boolean" + final val Byte: NameType = "Byte" + final val Char: NameType = "Char" + final val Double: NameType = "Double" + final val Float: NameType = "Float" + final val Function: NameType = "Function" + final val Int: NameType = "Int" + final val List: NameType = "List" + final val Long: NameType = "Long" + final val Nil: NameType = "Nil" + final val Object: NameType = "Object" + final val PartialFunction: NameType = "PartialFunction" + final val Predef: NameType = "Predef" + final val Product: NameType = "Product" + final val ScalaObject: NameType = "ScalaObject" + final val ScalaRunTime: NameType = "ScalaRunTime" + final val Seq: NameType = "Seq" + final val Short: NameType = "Short" + final val Some: NameType = "Some" + final val String: NameType = "String" + final val Symbol: NameType = "Symbol" + final val Unit: NameType = "Unit" + + final val ERROR: NameType = "<error>" + final val NO_NAME: NameType = "<none>" // formerly NOSYMBOL + final val STAR: NameType = "*" + final val WILDCARD: NameType = "_" + } + + trait CompilerTermNames extends CompilerCommonNames { + // Scala keywords + final val ABSTRACTkw: NameType = "abstract" + final val CASEkw: NameType = "case" + final val CLASSkw: NameType = "class" + final val CATCHkw: NameType = "catch" + final val DEFkw: NameType = "def" + final val DOkw: NameType = "do" + final val ELSEkw: NameType = "else" + final val EXTENDSkw: NameType = "extends" + final val FALSEkw: NameType = "false" + final val FINALkw: NameType = "final" + final val FINALLYkw: NameType = "finally" + final val FORkw: NameType = "for" + final val FORSOMEkw: NameType = "forSome" + final val IFkw: NameType = "if" + final val IMPLICITkw: NameType = "implicit" + final val IMPORTkw: NameType = "import" + final val LAZYkw: NameType = "lazy" + final val MATCHkw: NameType = "match" + final val NEWkw: NameType = "new" + final val NULLkw: NameType = "null" + final val OBJECTkw: NameType = "object" + final val OVERRIDEkw: NameType = "override" + final val PACKAGEkw: NameType = "package" + final val PRIVATEkw: NameType = "private" + final val PROTECTEDkw: NameType = "protected" + final val RETURNkw: NameType = "return" + final val REQUIRESkw: NameType = "requires" + final val SEALEDkw: NameType = "sealed" + final val SUPERkw: NameType = "super" + final val THISkw: NameType = "this" + final val THROWkw: NameType = "throw" + final val TRAITkw: NameType = "trait" + final val TRUEkw: NameType = "true" + final val TRYkw: NameType = "try" + final val TYPEkw: NameType = "type" + final val VALkw: NameType = "val" + final val VARkw: NameType = "var" + final val WITHkw: NameType = "with" + final val WHILEkw: NameType = "while" + final val YIELDkw: NameType = "yield" + final val DOTkw: NameType = "." + final val USCOREkw: NameType = "_" + final val COLONkw: NameType = ":" + final val EQUALSkw: NameType = "=" + final val ARROWkw: NameType = "=>" + final val LARROWkw: NameType = "<-" + final val SUBTYPEkw: NameType = "<:" + final val VIEWBOUNDkw: NameType = "<%" + final val SUPERTYPEkw: NameType = ">:" + final val HASHkw: NameType = "#" + final val ATkw: NameType = "@" + + // Compiler internal names + val ANYNAME: NameType = "<anyname>" + val CONSTRUCTOR: NameType = "<init>" + val FAKE_LOCAL_THIS: NameType = "this$" + val INITIALIZER: NameType = CONSTRUCTOR // Is this buying us something? + val MIXIN_CONSTRUCTOR: NameType = "$init$" + val MODULE_INSTANCE_FIELD: NameType = "MODULE$" + val OUTER: NameType = "$outer" + val OUTER_LOCAL: NameType = "$outer " // note the space + val SELF: NameType = "$this" + val SPECIALIZED_INSTANCE: NameType = "specInstance$" + val THIS: NameType = "_$this" + + // Compiler utilized names + // val productElementName: NameType = "productElementName" + val TYPE_ : NameType = "TYPE" + val add_ : NameType = "add" + val apply: NameType = "apply" + val arrayValue: NameType = "arrayValue" + val arraycopy: NameType = "arraycopy" + val asInstanceOf_ : NameType = "asInstanceOf" + val assert_ : NameType = "assert" + val assume_ : NameType = "assume" + val box: NameType = "box" + val bytes: NameType = "bytes" + val canEqual_ : NameType = "canEqual" + val checkInitialized: NameType = "checkInitialized" + val classOf: NameType = "classOf" + val clone_ : NameType = "clone" + val conforms: NameType = "conforms" + 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" + val equals_ : NameType = "equals" + val error: NameType = "error" + val ex: NameType = "ex" + val false_ : NameType = "false" + val filter: NameType = "filter" + val finalize_ : NameType = "finalize" + val find_ : NameType = "find" + val flatMap: NameType = "flatMap" + val foreach: NameType = "foreach" + val genericArrayOps: NameType = "genericArrayOps" + val get: NameType = "get" + val hasNext: NameType = "hasNext" + val hashCode_ : NameType = "hashCode" + val hash_ : NameType = "hash" + val head: NameType = "head" + val identity: NameType = "identity" + val inlinedEquals: NameType = "inlinedEquals" + val isArray: NameType = "isArray" + val isDefinedAt: NameType = "isDefinedAt" + val isEmpty: NameType = "isEmpty" + val isInstanceOf_ : NameType = "isInstanceOf" + val java: NameType = "java" + val lang: NameType = "lang" + val length: NameType = "length" + val lengthCompare: NameType = "lengthCompare" + val lift_ : NameType = "lift" + val main: NameType = "main" + val map: NameType = "map" + val ne: NameType = "ne" + val newArray: NameType = "newArray" + val next: NameType = "next" + val notifyAll_ : NameType = "notifyAll" + val notify_ : NameType = "notify" + val null_ : NameType = "null" + val ofDim: NameType = "ofDim" + val productArity: NameType = "productArity" + val productElement: NameType = "productElement" + val productPrefix: NameType = "productPrefix" + val readResolve: NameType = "readResolve" + val sameElements: NameType = "sameElements" + val scala_ : NameType = "scala" + val self: NameType = "self" + val setAccessible: NameType = "setAccessible" + val synchronized_ : NameType = "synchronized" + val tail: NameType = "tail" + val this_ : NameType = "this" + val throw_ : NameType = "throw" + val toArray: NameType = "toArray" + val toList: NameType = "toList" + val toSeq: NameType = "toSeq" + val toString_ : NameType = "toString" + val true_ : NameType = "true" + val unapply: NameType = "unapply" + val unapplySeq: NameType = "unapplySeq" + val unbox: NameType = "unbox" + val update: NameType = "update" + val value: NameType = "value" + val view_ : NameType = "view" + val wait_ : NameType = "wait" + val withFilter: NameType = "withFilter" + val zip: NameType = "zip" + + // unencoded operators + object raw { + final val AMP : NameType = "&" + final val BANG : NameType = "!" + final val BAR : NameType = "|" + final val DOLLAR: NameType = "$" + final val GE: NameType = ">=" + final val LE: NameType = "<=" + final val MINUS: NameType = "-" + final val NE: NameType = "!=" + final val PLUS : NameType = "+" + final val SLASH: NameType = "/" + final val STAR : NameType = "*" + final val TILDE: NameType = "~" + + final val isUnary: Set[Name] = Set(MINUS, PLUS, TILDE, BANG) + } + + // value-conversion methods + val toByte: NameType = "toByte" + val toShort: NameType = "toShort" + val toChar: NameType = "toChar" + val toInt: NameType = "toInt" + val toLong: NameType = "toLong" + val toFloat: NameType = "toFloat" + val toDouble: NameType = "toDouble" + } + + trait CompilerTypeNames extends CompilerCommonNames { + final val BYNAME_PARAM_CLASS_NAME: NameType = "<byname>" + final val EQUALS_PATTERN_NAME: NameType = "<equals>" + final val JAVA_REPEATED_PARAM_CLASS_NAME: NameType = "<repeated...>" + final val LOCAL_CHILD: NameType = "<local child>" + final val REPEATED_PARAM_CLASS_NAME: NameType = "<repeated>" + final val WILDCARD_STAR: NameType = "_*" + + final val Nothing: NameType = "Nothing" + final val Null: NameType = "Null" + final val Serializable: NameType = "Serializable" + final val Singleton: NameType = "Singleton" + final val Throwable: NameType = "Throwable" + + // Stores Java annotations on parameters with RetentionPolicy.RUNTIME + // Stores Java annotations with RetentionPolicy.CLASS. Currently not used (Apr 2009). + // Stores Java annotations with RetentionPolicy.RUNTIME + final val AnnotationDefaultATTR: NameType = "AnnotationDefault" + final val BridgeATTR: NameType = "Bridge" + final val ClassfileAnnotationATTR: NameType = "RuntimeInvisibleAnnotations" + final val CodeATTR: NameType = "Code" + final val ConstantValueATTR: NameType = "ConstantValue" + final val DeprecatedATTR: NameType = "Deprecated" + final val ExceptionsATTR: NameType = "Exceptions" + final val InnerClassesATTR: NameType = "InnerClasses" + final val JacoMetaATTR: NameType = "JacoMeta" + final val LineNumberTableATTR: NameType = "LineNumberTable" + final val LocalVariableTableATTR: NameType = "LocalVariableTable" + final val RuntimeAnnotationATTR: NameType = "RuntimeVisibleAnnotations" + final val RuntimeParamAnnotationATTR: NameType = "RuntimeVisibleParameterAnnotations" + final val ScalaATTR: NameType = "Scala" + final val ScalaSignatureATTR: NameType = "ScalaSig" + final val SignatureATTR: NameType = "Signature" + final val SourceFileATTR: NameType = "SourceFile" + final val SyntheticATTR: NameType = "Synthetic" + } + + object tpnme extends CompilerTypeNames with LibraryTypeNames { + type NameType = TypeName + implicit def createNameType(name: String): TypeName = newTypeName(name) + } + + object nme extends CompilerTermNames with LibraryTermNames with NameMangling { + type NameType = TermName + implicit def createNameType(name: String): TermName = newTermName(name) /** Translate a String into a list of simple TypeNames and TermNames. * In all segments before the last, type/term is determined by whether @@ -49,429 +308,181 @@ trait StdNames extends reflect.generic.StdNames with NameManglers { } } - // Scala keywords - val ABSTRACTkw = newTermName("abstract") - val CASEkw = newTermName("case") - val CLASSkw = newTermName("class") - val CATCHkw = newTermName("catch") - val DEFkw = newTermName("def") - val DOkw = newTermName("do") - val ELSEkw = newTermName("else") - val EXTENDSkw = newTermName("extends") - val FALSEkw = newTermName("false") - val FINALkw = newTermName("final") - val FINALLYkw = newTermName("finally") - val FORkw = newTermName("for") - val FORSOMEkw = newTermName("forSome") - val IFkw = newTermName("if") - val IMPLICITkw = newTermName("implicit") - val IMPORTkw = newTermName("import") - val LAZYkw = newTermName("lazy") - val MATCHkw = newTermName("match") - val NEWkw = newTermName("new") - val NULLkw = newTermName("null") - val OBJECTkw = newTermName("object") - val OVERRIDEkw = newTermName("override") - val PACKAGEkw = newTermName("package") - val PRIVATEkw = newTermName("private") - val PROTECTEDkw = newTermName("protected") - val RETURNkw = newTermName("return") - val REQUIRESkw = newTermName("requires") - val SEALEDkw = newTermName("sealed") - val SUPERkw = newTermName("super") - val THISkw = newTermName("this") - val THROWkw = newTermName("throw") - val TRAITkw = newTermName("trait") - val TRUEkw = newTermName("true") - val TRYkw = newTermName("try") - val TYPEkw = newTermName("type") - val VALkw = newTermName("val") - val VARkw = newTermName("var") - val WITHkw = newTermName("with") - val WHILEkw = newTermName("while") - val YIELDkw = newTermName("yield") - val DOTkw = newTermName(".") - val USCOREkw = newTermName("_") - val COLONkw = newTermName(":") - val EQUALSkw = newTermName("=") - val ARROWkw = newTermName("=>") - val LARROWkw = newTermName("<-") - val SUBTYPEkw = newTermName("<:") - val VIEWBOUNDkw = newTermName("<%") - val SUPERTYPEkw = newTermName(">:") - val HASHkw = newTermName("#") - val ATkw = newTermName("@") - - val INTERPRETER_IMPORT_WRAPPER = "$iw" - val INTERPRETER_LINE_PREFIX = "line" - val INTERPRETER_SYNTHVAR_PREFIX = "synthvar$" - val INTERPRETER_VAR_PREFIX = "res" - val INTERPRETER_WRAPPER_SUFFIX = "$object" - - private def bitmapName(n: Int, suffix: String): Name = + private def bitmapName(n: Int, suffix: String): TermName = newTermName(BITMAP_PREFIX + suffix + n) /** The name of bitmaps for initialized (public or protected) lazy vals. */ - def bitmapName(n: Int): Name = bitmapName(n, "") + def bitmapName(n: Int): TermName = bitmapName(n, "") /** The name of bitmaps for initialized transient lazy vals. */ - def bitmapNameForTransitive(n: Int): Name = bitmapName(n, "trans$") + def bitmapNameForTransitive(n: Int): TermName = bitmapName(n, "trans$") /** The name of bitmaps for initialized private lazy vals. */ - def bitmapNameForPrivate(n: Int): Name = bitmapName(n, "priv$") + def bitmapNameForPrivate(n: Int): TermName = bitmapName(n, "priv$") /** Base strings from which synthetic names are derived. */ - val BITMAP_PREFIX = "bitmap$" - val CHECK_IF_REFUTABLE_STRING = "check$ifrefutable$" - val DEFAULT_GETTER_STRING = "$default$" - val DO_WHILE_PREFIX = "doWhile$" - val EQEQ_LOCAL_VAR = "eqEqTemp$" - val EVIDENCE_PARAM_PREFIX = "evidence$" - val EXCEPTION_RESULT_PREFIX = "exceptionResult" - val WHILE_PREFIX = "while$" - - /** Internal names */ - val ANYNAME = newTermName("<anyname>") - val EQUALS_PATTERN_NAME = newTermName("<equals>") - val ERROR = newTermName("<error>") - val NOSYMBOL = newTermName("<none>") - - /** TYPE names. */ - val BYNAME_PARAM_CLASS_NAME = newTypeName("<byname>") - val JAVA_REPEATED_PARAM_CLASS_NAME = newTypeName("<repeated...>") - val LOCALCHILD = newTypeName("<local child>") - val REPEATED_PARAM_CLASS_NAME = newTypeName("<repeated>") - val WILDCARD_STAR = newTypeName("_*") - - val CONSTRUCTOR = newTermName("<init>") - val INITIALIZER = newTermName("<init>") - val INLINED_INITIALIZER = newTermName("$init$") - val MIXIN_CONSTRUCTOR = newTermName("$init$") - - val OUTER = newTermName("$outer") - val OUTER_LOCAL = newTermName("$outer ") - val SELF = newTermName("$this") - val THIS = newTermName("_$this") - val FAKE_LOCAL_THIS = newTermName("this$") - - val MODULE_INSTANCE_FIELD = newTermName("MODULE$") - val SPECIALIZED_INSTANCE = newTermName("specInstance$") - - val TYPE_ = newTermName("TYPE") - val WILDCARD = newTermName("_") - val STAR = newTermName("*") - - val MINUS = encode("-") - val PLUS = encode("+") - val PLUSPLUS = encode("++") - val TILDE = encode("~") - val BANG = encode("!") - val BANGEQ = encode("!=") - val BARBAR = encode("||") - val AMPAMP = encode("&&") - val COLONCOLON = encode("::") - val PERCENT = encode("%") - val EQL = encode("=") - val HASHHASH = encode("##") - - val Nothing = newTermName("Nothing") - val Null = newTermName("Null") - val Any = newTermName("Any") - val AnyVal = newTermName("AnyVal") - val AnyRef = newTermName("AnyRef") - val Array = newTermName("Array") - val Boolean = newTermName("Boolean") - val Byte = newTermName("Byte") - val Char = newTermName("Char") - val Do = newTermName("Do") - val Double = newTermName("Double") - val Float = newTermName("Float") - val Function = newTermName("Function") - val Int = newTermName("Int") - val List = newTermName("List") - val Long = newTermName("Long") - val Nil = newTermName("Nil") - val Object = newTermName("Object") - val PartialFunction = newTermName("PartialFunction") - val Predef = newTermName("Predef") - val Product = newTermName("Product") - val ScalaObject = newTermName("ScalaObject") - val ScalaRunTime = newTermName("ScalaRunTime") - val Seq = newTermName("Seq") - val Serializable = newTermName("Serializable") - val Short = newTermName("Short") - val Singleton = newTermName("Singleton") - val Some = newTermName("Some") - val String = newTermName("String") - val Symbol = newTermName("Symbol") - val System = newTermName("System") - val Throwable = newTermName("Throwable") - val Tuple = newTermName("Tuple") - val Unit = newTermName("Unit") - - val apply = newTermName("apply") - val arrayValue = newTermName("arrayValue") - val arraycopy = newTermName("arraycopy") - val assert_ = newTermName("assert") - val assume_ = newTermName("assume") - val asInstanceOf_ = newTermName("asInstanceOf") - val box = newTermName("box") - val bytes = newTermName("bytes") - val canEqual_ = newTermName("canEqual") - val checkInitialized = newTermName("checkInitialized") - val classOf = newTermName("classOf") - val identity = newTermName("identity") - val conforms = newTermName("conforms") - val copy = newTermName("copy") - val delayedInit = newTermName("delayedInit") - val delayedInitArg = newTermName("delayedInit$body") - val dottype = newTermName(".type") - val drop = newTermName("drop") - val elem = newTermName("elem") - val eq = newTermName("eq") - val equals_ = newTermName("equals") - val inlinedEquals = newTermName("inlinedEquals") - val error = newTermName("error") - val ex = newTermName("ex") - val add_ = newTermName("add") - val false_ = newTermName("false") - val filter = newTermName("filter") - val finalize_ = newTermName("finalize") - val find_ = newTermName("find") - val flatMap = newTermName("flatMap") - val foreach = newTermName("foreach") - val get = newTermName("get") - def getCause = sn.GetCause - def getClass_ = sn.GetClass + val BITMAP_PREFIX = "bitmap$" + val CHECK_IF_REFUTABLE_STRING = "check$ifrefutable$" + val DEFAULT_GETTER_STRING = "$default$" + val DO_WHILE_PREFIX = "doWhile$" + val EQEQ_LOCAL_VAR = "eqEqTemp$" + val EVIDENCE_PARAM_PREFIX = "evidence$" + val EXCEPTION_RESULT_PREFIX = "exceptionResult" + val INTERPRETER_IMPORT_WRAPPER = "$iw" + val INTERPRETER_LINE_PREFIX = "line" + val INTERPRETER_SYNTHVAR_PREFIX = "synthvar$" + val INTERPRETER_VAR_PREFIX = "res" + val INTERPRETER_WRAPPER_SUFFIX = "$object" + val WHILE_PREFIX = "while$" + + def getCause = sn.GetCause + def getClass_ = sn.GetClass def getMethod_ = sn.GetMethod - val hash_ = newTermName("hash") - val hashCode_ = newTermName("hashCode") - val hasNext = newTermName("hasNext") - val head = newTermName("head") - def invoke_ = sn.Invoke - val isArray = newTermName("isArray") - val isInstanceOf_ = newTermName("isInstanceOf") - val isDefinedAt = newTermName("isDefinedAt") - val isEmpty = newTermName("isEmpty") - val java = newTermName("java") - val lang = newTermName("lang") - val length = newTermName("length") - val lengthCompare = newTermName("lengthCompare") - val lift_ = newTermName("lift") - val main = newTermName("main") - val map = newTermName("map") - val ne = newTermName("ne") - val newArray = newTermName("newArray") - val next = newTermName("next") - val notify_ = newTermName("notify") - val notifyAll_ = newTermName("notifyAll") - val null_ = newTermName("null") - val ofDim = newTermName("ofDim") - val productArity = newTermName("productArity") - val productElement = newTermName("productElement") - // val productElementName = newTermName("productElementName") - val productPrefix = newTermName("productPrefix") - val readResolve = newTermName("readResolve") - val sameElements = newTermName("sameElements") - val scala_ = newTermName("scala") - val self = newTermName("self") - val setAccessible = newTermName("setAccessible") - val synchronized_ = newTermName("synchronized") - val tail = newTermName("tail") - val toArray = newTermName("toArray") - val toList = newTermName("toList") - val toSeq = newTermName("toSeq") - val toString_ = newTermName("toString") - val clone_ = newTermName("clone") - val this_ = newTermName("this") - val throw_ = newTermName("throw") - val true_ = newTermName("true") - val unapply = newTermName("unapply") - val unapplySeq = newTermName("unapplySeq") - val unbox = newTermName("unbox") - val update = newTermName("update") - val value = newTermName("value") - val view_ = newTermName("view") - val wait_ = newTermName("wait") - val withFilter = newTermName("withFilter") - val zip = newTermName("zip") - val genericArrayOps = newTermName("genericArrayOps") - - val ZAND = encode("&&") - val ZOR = encode("||") - val ADD = encode("+") - val SUB = encode("-") - val MUL = encode("*") - val DIV = encode("/") - val MOD = encode("%") - val EQ = encode("==") - val NE = encode("!=") - val LT = encode("<") - val LE = encode("<=") - val GT = encode(">") - val GE = encode(">=") - val OR = encode("|") - val XOR = encode("^") - val AND = encode("&") - val LSL = encode("<<") - val LSR = encode(">>>") - val ASR = encode(">>") + def invoke_ = sn.Invoke + + val ADD = encode("+") + val AND = encode("&") + val ASR = encode(">>") + val DIV = encode("/") + val EQ = encode("==") + val EQL = encode("=") + val GE = encode(">=") + val GT = encode(">") + val HASHHASH = encode("##") + val LE = encode("<=") + val LSL = encode("<<") + val LSR = encode(">>>") + val LT = encode("<") + val MINUS = encode("-") + val MOD = encode("%") + val MUL = encode("*") + val NE = encode("!=") + val OR = encode("|") + val PLUS = encode("+") + val SUB = encode("-") + val XOR = encode("^") + val ZAND = encode("&&") + val ZOR = encode("||") // unary operators val UNARY_~ = encode("unary_~") val UNARY_+ = encode("unary_+") val UNARY_- = encode("unary_-") val UNARY_! = encode("unary_!") - - // unencoded comparisons - val EQraw = newTermName("==") - val NEraw = newTermName("!=") - val LEraw = newTermName("<=") - val GEraw = newTermName(">=") - val DOLLARraw = newTermName("$") - - // value-conversion methods - val toByte = newTermName("toByte") - val toShort = newTermName("toShort") - val toChar = newTermName("toChar") - val toInt = newTermName("toInt") - val toLong = newTermName("toLong") - val toFloat = newTermName("toFloat") - val toDouble = newTermName("toDouble") - - val SourceFileATTR = newTermName("SourceFile") - val SyntheticATTR = newTermName("Synthetic") - val BridgeATTR = newTermName("Bridge") - val DeprecatedATTR = newTermName("Deprecated") - val CodeATTR = newTermName("Code") - val ExceptionsATTR = newTermName("Exceptions") - val ConstantValueATTR = newTermName("ConstantValue") - val LineNumberTableATTR = newTermName("LineNumberTable") - val LocalVariableTableATTR = newTermName("LocalVariableTable") - val InnerClassesATTR = newTermName("InnerClasses") - val JacoMetaATTR = newTermName("JacoMeta") - val SignatureATTR = newTermName("Signature") - val ScalaSignatureATTR = newTermName("ScalaSig") - val AnnotationDefaultATTR = newTermName("AnnotationDefault") - // Stores Java annotations with RetentionPolicy.RUNTIME - val RuntimeAnnotationATTR = newTermName("RuntimeVisibleAnnotations") - // Stores Java annotations with RetentionPolicy.CLASS. Currently not used (Apr 2009). - val ClassfileAnnotationATTR = newTermName("RuntimeInvisibleAnnotations") - // Stores Java annotations on parameters with RetentionPolicy.RUNTIME - val RuntimeParamAnnotationATTR = newTermName("RuntimeVisibleParameterAnnotations") - val ScalaATTR = newTermName("Scala") } abstract class SymbolNames { - val BeanProperty : Name - val BooleanBeanProperty : Name - val BoxedBoolean : Name - val BoxedCharacter : Name - val BoxedNumber : Name - val Class : Name - val Code : Name - val Delegate : Name - val ForName : Name - val GetCause : Name - val GetClass : Name - val GetMethod : Name - val IOOBException : Name // IndexOutOfBoundsException - val InvTargetException : Name // InvocationTargetException - val Invoke : Name - val JavaLang : Name - val MethodAsObject : Name - val NLRControl : Name = newTermName("scala.runtime.NonLocalReturnControl") - val NPException : Name // NullPointerException - val Object : Name - val JavaSerializable : Name - val String : Name - val Throwable : Name - val ValueType : Name - - val Boxed: immutable.Map[Name, Name] + val BeanProperty : TypeName + val BooleanBeanProperty : TypeName + val BoxedBoolean : TypeName + val BoxedCharacter : TypeName + val BoxedNumber : TypeName + val Class : TypeName + val Code : TypeName + val Delegate : TypeName + val IOOBException : TypeName // IndexOutOfBoundsException + val InvTargetException : TypeName // InvocationTargetException + val JavaSerializable : TypeName + val MethodAsObject : TypeName + val NPException : TypeName // NullPointerException + val Object : TypeName + val String : TypeName + val Throwable : TypeName + val ValueType : TypeName + + val ForName : TermName + val GetCause : TermName + val GetClass : TermName + val GetMethod : TermName + val Invoke : TermName + val JavaLang : TermName + + val Boxed: immutable.Map[TypeName, TypeName] } private abstract class JavaNames extends SymbolNames { - final val BoxedBoolean = newTermName("java.lang.Boolean") - final val BoxedByte = newTermName("java.lang.Byte") - final val BoxedCharacter = newTermName("java.lang.Character") - final val BoxedDouble = newTermName("java.lang.Double") - final val BoxedFloat = newTermName("java.lang.Float") - final val BoxedInteger = newTermName("java.lang.Integer") - final val BoxedLong = newTermName("java.lang.Long") - final val BoxedNumber = newTermName("java.lang.Number") - final val BoxedShort = newTermName("java.lang.Short") - final val Class = newTermName("java.lang.Class") - final val Delegate = nme.NOSYMBOL - final val ForName = newTermName("forName") - final val GetCause = newTermName("getCause") - final val GetClass = newTermName("getClass") - final val GetMethod = newTermName("getMethod") - final val IOOBException = newTermName("java.lang.IndexOutOfBoundsException") - final val InvTargetException = newTermName("java.lang.reflect.InvocationTargetException") - final val Invoke = newTermName("invoke") - final val JavaLang = newTermName("java.lang") - final val MethodAsObject = newTermName("java.lang.reflect.Method") - final val NPException = newTermName("java.lang.NullPointerException") - final val Object = newTermName("java.lang.Object") - final val String = newTermName("java.lang.String") - final val Throwable = newTermName("java.lang.Throwable") - final val ValueType = nme.NOSYMBOL - - val Boxed = immutable.Map[Name, Name]( - nme.Boolean -> BoxedBoolean, - nme.Byte -> BoxedByte, - nme.Char -> BoxedCharacter, - nme.Short -> BoxedShort, - nme.Int -> BoxedInteger, - nme.Long -> BoxedLong, - nme.Float -> BoxedFloat, - nme.Double -> BoxedDouble + final val BoxedBoolean: TypeName = "java.lang.Boolean" + final val BoxedByte: TypeName = "java.lang.Byte" + final val BoxedCharacter: TypeName = "java.lang.Character" + final val BoxedDouble: TypeName = "java.lang.Double" + final val BoxedFloat: TypeName = "java.lang.Float" + final val BoxedInteger: TypeName = "java.lang.Integer" + final val BoxedLong: TypeName = "java.lang.Long" + final val BoxedNumber: TypeName = "java.lang.Number" + final val BoxedShort: TypeName = "java.lang.Short" + final val Class: TypeName = "java.lang.Class" + final val Delegate: TypeName = tpnme.NO_NAME + final val IOOBException: TypeName = "java.lang.IndexOutOfBoundsException" + final val InvTargetException: TypeName = "java.lang.reflect.InvocationTargetException" + final val MethodAsObject: TypeName = "java.lang.reflect.Method" + final val NPException: TypeName = "java.lang.NullPointerException" + final val Object: TypeName = "java.lang.Object" + final val String: TypeName = "java.lang.String" + final val Throwable: TypeName = "java.lang.Throwable" + final val ValueType: TypeName = tpnme.NO_NAME + + final val ForName: TermName = "forName" + final val GetCause: TermName = "getCause" + final val GetClass: TermName = "getClass" + final val GetMethod: TermName = "getMethod" + final val Invoke: TermName = "invoke" + final val JavaLang: TermName = "java.lang" + + val Boxed = immutable.Map[TypeName, TypeName]( + tpnme.Boolean -> BoxedBoolean, + tpnme.Byte -> BoxedByte, + tpnme.Char -> BoxedCharacter, + tpnme.Short -> BoxedShort, + tpnme.Int -> BoxedInteger, + tpnme.Long -> BoxedLong, + tpnme.Float -> BoxedFloat, + tpnme.Double -> BoxedDouble ) } private class MSILNames extends SymbolNames { - final val BeanProperty = nme.NOSYMBOL - final val BooleanBeanProperty = nme.NOSYMBOL - final val BoxedBoolean = newTermName("System.IConvertible") - final val BoxedCharacter = newTermName("System.IConvertible") - final val BoxedNumber = newTermName("System.IConvertible") - final val Class = newTermName("System.Type") - final val Code = nme.NOSYMBOL - final val Delegate = newTermName("System.MulticastDelegate") - final val ForName = newTermName("GetType") - final val GetCause = newTermName("InnerException") /* System.Reflection.TargetInvocationException.InnerException */ - final val GetClass = newTermName("GetType") - final val GetMethod = newTermName("GetMethod") - final val IOOBException = newTermName("System.IndexOutOfRangeException") - final val InvTargetException = newTermName("System.Reflection.TargetInvocationException") - final val Invoke = newTermName("Invoke") - final val JavaLang = newTermName("System") - final val MethodAsObject = newTermName("System.Reflection.MethodInfo") - final val NPException = newTermName("System.NullReferenceException") - final val Object = newTermName("System.Object") - final val JavaSerializable = nme.NOSYMBOL - final val String = newTermName("System.String") - final val Throwable = newTermName("System.Exception") - final val ValueType = newTermName("System.ValueType") - - val Boxed = immutable.Map[Name, Name]( - nme.Boolean -> newTermName("System.Boolean"), - nme.Byte -> newTermName("System.Byte"), - nme.Char -> newTermName("System.Char"), - nme.Short -> newTermName("System.Int16"), - nme.Int -> newTermName("System.Int32"), - nme.Long -> newTermName("System.Int64"), - nme.Float -> newTermName("System.Single"), - nme.Double -> newTermName("System.Double") + final val BeanProperty: TypeName = tpnme.NO_NAME + final val BooleanBeanProperty: TypeName = tpnme.NO_NAME + final val BoxedBoolean: TypeName = "System.IConvertible" + final val BoxedCharacter: TypeName = "System.IConvertible" + final val BoxedNumber: TypeName = "System.IConvertible" + final val Class: TypeName = "System.Type" + final val Code: TypeName = tpnme.NO_NAME + final val Delegate: TypeName = "System.MulticastDelegate" + final val IOOBException: TypeName = "System.IndexOutOfRangeException" + final val InvTargetException: TypeName = "System.Reflection.TargetInvocationException" + final val JavaSerializable: TypeName = tpnme.NO_NAME + final val MethodAsObject: TypeName = "System.Reflection.MethodInfo" + final val NPException: TypeName = "System.NullReferenceException" + final val Object: TypeName = "System.Object" + final val String: TypeName = "System.String" + final val Throwable: TypeName = "System.Exception" + final val ValueType: TypeName = "System.ValueType" + + final val ForName: TermName = "GetType" + final val GetCause: TermName = "InnerException" /* System.Reflection.TargetInvocationException.InnerException */ + final val GetClass: TermName = "GetType" + final val GetMethod: TermName = "GetMethod" + final val Invoke: TermName = "Invoke" + final val JavaLang: TermName = "System" + + val Boxed = immutable.Map[TypeName, TypeName]( + tpnme.Boolean -> "System.Boolean", + tpnme.Byte -> "System.Byte", + tpnme.Char -> "System.Char", + tpnme.Short -> "System.Int16", + tpnme.Int -> "System.Int32", + tpnme.Long -> "System.Int64", + tpnme.Float -> "System.Single", + tpnme.Double -> "System.Double" ) } private class J2SENames extends JavaNames { - final val BeanProperty = newTermName("scala.reflect.BeanProperty") - final val BooleanBeanProperty = newTermName("scala.reflect.BooleanBeanProperty") - final val Code = newTermName("scala.reflect.Code") - final val JavaSerializable = newTermName("java.io.Serializable") + final val BeanProperty: TypeName = "scala.reflect.BeanProperty" + final val BooleanBeanProperty: TypeName = "scala.reflect.BooleanBeanProperty" + final val Code: TypeName = "scala.reflect.Code" + final val JavaSerializable: TypeName = "java.io.Serializable" } lazy val sn: SymbolNames = diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala index 695e95b72d..d168c259e9 100644 --- a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala +++ b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala @@ -109,9 +109,8 @@ abstract class SymbolLoaders { def enterClassAndModule(root: Symbol, name: String, completer: SymbolLoader) { val owner = if (root.isRoot) definitions.EmptyPackageClass else root - val className = newTermName(name) assert(owner.info.decls.lookup(name) == NoSymbol, owner.fullName + "." + name) - val clazz = owner.newClass(NoPosition, name.toTypeName) + val clazz = owner.newClass(NoPosition, newTypeName(name)) val module = owner.newModule(NoPosition, name) clazz setInfo completer module setInfo completer @@ -167,7 +166,7 @@ abstract class SymbolLoaders { // if there's a $member object, enter its members as well. val pkgModule = root.info.decl(nme.PACKAGEkw) if (pkgModule.isModule && !pkgModule.rawInfo.isInstanceOf[SourcefileLoader]) { - //println("open "+pkgModule)//DEBUG + // println("open "+pkgModule)//DEBUG openPackageModule(pkgModule)() } } @@ -233,7 +232,6 @@ abstract class SymbolLoaders { protected def newPackageLoader(pkg: ClassPath[MSILType]) = new NamespaceLoader(pkg) - } class ClassfileLoader(val classfile: AbstractFile) extends SymbolLoader { diff --git a/src/compiler/scala/tools/nsc/symtab/Symbols.scala b/src/compiler/scala/tools/nsc/symtab/Symbols.scala index 31992c5d0b..81cd62d550 100644 --- a/src/compiler/scala/tools/nsc/symtab/Symbols.scala +++ b/src/compiler/scala/tools/nsc/symtab/Symbols.scala @@ -39,7 +39,6 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => /** The class for all symbols */ abstract class Symbol(initOwner: Symbol, initPos: Position, initName: Name) extends AbsSymbol { - var rawowner = initOwner /** The original owner of this class. Used by the backend to generate @@ -108,36 +107,36 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => // Creators ------------------------------------------------------------------- - final def newValue(pos: Position, name: Name) = + final def newValue(pos: Position, name: TermName) = new TermSymbol(this, pos, name) - final def newValue(name: Name, pos: Position = NoPosition) = + final def newValue(name: TermName, pos: Position = NoPosition) = new TermSymbol(this, pos, name) - final def newVariable(pos: Position, name: Name) = + final def newVariable(pos: Position, name: TermName) = newValue(pos, name).setFlag(MUTABLE) - final def newValueParameter(pos: Position, name: Name) = + final def newValueParameter(pos: Position, name: TermName) = newValue(pos, name).setFlag(PARAM) /** Create local dummy for template (owner of local blocks) */ final def newLocalDummy(pos: Position) = newValue(pos, nme.localDummyName(this)).setInfo(NoType) - final def newMethod(pos: Position, name: Name) = + final def newMethod(pos: Position, name: TermName) = new MethodSymbol(this, pos, name).setFlag(METHOD) - final def newMethod(name: Name, pos: Position = NoPosition) = + final def newMethod(name: TermName, pos: Position = NoPosition) = new MethodSymbol(this, pos, name).setFlag(METHOD) - final def newLabel(pos: Position, name: Name) = + final def newLabel(pos: Position, name: TermName) = newMethod(pos, name).setFlag(LABEL) final def newConstructor(pos: Position) = newMethod(pos, nme.CONSTRUCTOR) - final def newModule(pos: Position, name: Name, clazz: ClassSymbol) = + final def newModule(pos: Position, name: TermName, clazz: ClassSymbol) = new ModuleSymbol(this, pos, name).setFlag(MODULE | FINAL) .setModuleClass(clazz) - final def newModule(name: Name, clazz: Symbol, pos: Position = NoPosition) = + final def newModule(name: TermName, clazz: Symbol, pos: Position = NoPosition) = new ModuleSymbol(this, pos, name).setFlag(MODULE | FINAL) .setModuleClass(clazz.asInstanceOf[ClassSymbol]) - final def newModule(pos: Position, name: Name) = { + final def newModule(pos: Position, name: TermName) = { val m = new ModuleSymbol(this, pos, name).setFlag(MODULE | FINAL) m.setModuleClass(new ModuleClassSymbol(m)) } - final def newPackage(pos: Position, name: Name) = { + final def newPackage(pos: Position, name: TermName) = { assert(name == nme.ROOT || isPackageClass) val m = newModule(pos, name).setFlag(JAVA | PACKAGE) m.moduleClass.setFlag(JAVA | PACKAGE) @@ -167,7 +166,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => * pre.memberType(m) */ final def newOverloaded(pre: Type, alternatives: List[Symbol]): Symbol = - newValue(alternatives.head.pos, alternatives.head.name) + newValue(alternatives.head.pos, alternatives.head.name.toTermName) .setFlag(OVERLOADED) .setInfo(OverloadedType(pre, alternatives)) @@ -181,26 +180,26 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => sym } - final def newErrorValue(name: Name) = + final def newErrorValue(name: TermName) = newValue(pos, name).setFlag(SYNTHETIC | IS_ERROR).setInfo(ErrorType) /** Symbol of a type definition type T = ... */ - final def newAliasType(pos: Position, name: Name) = + final def newAliasType(pos: Position, name: TypeName) = new TypeSymbol(this, pos, name) - final def newAliasType(name: Name, pos: Position = NoPosition) = + final def newAliasType(name: TypeName, pos: Position = NoPosition) = new TypeSymbol(this, pos, name) /** Symbol of an abstract type type T >: ... <: ... */ - final def newAbstractType(pos: Position, name: Name) = + final def newAbstractType(pos: Position, name: TypeName) = new TypeSymbol(this, pos, name).setFlag(DEFERRED) - final def newAbstractType(name: Name, pos: Position = NoPosition) = + final def newAbstractType(name: TypeName, pos: Position = NoPosition) = new TypeSymbol(this, pos, name).setFlag(DEFERRED) /** Symbol of a type parameter */ - final def newTypeParameter(pos: Position, name: Name) = + final def newTypeParameter(pos: Position, name: TypeName) = newAbstractType(pos, name).setFlag(PARAM) /** Synthetic value parameters when parameter symbols are not available @@ -220,8 +219,8 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => * @param owner The owner of the variable * @param bounds The variable's bounds */ - final def newExistential(pos: Position, name: Name): Symbol = - newAbstractType(pos, name.toTypeName).setFlag(EXISTENTIAL) + final def newExistential(pos: Position, name: TypeName): Symbol = + newAbstractType(pos, name).setFlag(EXISTENTIAL) final def freshExistential(suffix: String): Symbol = newExistential(pos, freshExistentialName()+suffix) @@ -247,27 +246,26 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => new TypeSkolem(owner, pos, name, this) .setFlag(flags) - final def newClass(pos: Position, name: Name) = + final def newClass(pos: Position, name: TypeName) = new ClassSymbol(this, pos, name) - final def newClass(name: Name, pos: Position = NoPosition) = + final def newClass(name: TypeName, pos: Position = NoPosition) = new ClassSymbol(this, pos, name) - final def newModuleClass(pos: Position, name: Name) = + final def newModuleClass(pos: Position, name: TypeName) = new ModuleClassSymbol(this, pos, name) - final def newModuleClass(name: Name, pos: Position = NoPosition) = + final def newModuleClass(name: TypeName, pos: Position = NoPosition) = new ModuleClassSymbol(this, pos, name) final def newAnonymousClass(pos: Position) = - newClass(pos, nme.ANON_CLASS_NAME.toTypeName) - + newClass(pos, tpnme.ANON_CLASS_NAME) final def newAnonymousFunctionClass(pos: Position) = - newClass(pos, nme.ANON_FUN_NAME.toTypeName) + newClass(pos, tpnme.ANON_FUN_NAME) /** Refinement types P { val x: String; type T <: Number } * also have symbols, they are refinementClasses */ final def newRefinementClass(pos: Position) = - newClass(pos, nme.REFINE_CLASS_NAME.toTypeName) + newClass(pos, tpnme.REFINE_CLASS_NAME) /** Create a new getter for current symbol (which must be a field) */ @@ -277,14 +275,15 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => getter.setInfo(MethodType(List(), tpe)) } - final def newErrorClass(name: Name) = { + final def newErrorClass(name: TypeName) = { val clazz = newClass(pos, name).setFlag(SYNTHETIC | IS_ERROR) clazz.setInfo(ClassInfoType(List(), new ErrorScope(this), clazz)) clazz } final def newErrorSymbol(name: Name): Symbol = - if (name.isTypeName) newErrorClass(name) else newErrorValue(name) + if (name.isTypeName) newErrorClass(name) + else newErrorValue(name) // Locking and unlocking ------------------------------------------------------ @@ -371,8 +370,8 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => // class C extends D( { class E { ... } ... } ). Here, E is a class local to a constructor final def isClassLocalToConstructor = isClass && hasFlag(INCONSTRUCTOR) - final def isAnonymousClass = isClass && (name containsName nme.ANON_CLASS_NAME) // todo: find out why we can't use containsName here. - final def isAnonymousFunction = hasFlag(SYNTHETIC) && (name containsName nme.ANON_FUN_NAME) + final def isAnonymousClass = isClass && (name containsName tpnme.ANON_CLASS_NAME) + final def isAnonymousFunction = isSynthetic && (name containsName tpnme.ANON_FUN_NAME) final def isClassOfModule = isModuleClass || isClass && nme.isLocalName(name) final def isPackageObject = isModule && name == nme.PACKAGEkw && owner.isPackageClass @@ -866,9 +865,8 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => val current = phase try { while ((phase.prev ne NoPhase) && phase.prev.keepsTypeParams) phase = phase.prev -// while (phase.keepsTypeParams && (phase.prev ne NoPhase)) phase = phase.prev if (phase ne current) phase = phase.next - if (settings.debug.value && (phase ne current)) + if (settings.debug.value && settings.verbose.value && (phase ne current)) log("checking unsafeTypeParams(" + this + ") at: " + current + " reading at: " + phase) rawInfo.typeParams } finally { @@ -1452,7 +1450,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => setter(owner).expandName(base) } name = nme.expandedName(name, base) - if (isType) name = name.toTypeName + if (isType) name = name } } /* code for fixing nested objects @@ -1654,7 +1652,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => } /** A class for term symbols */ - class TermSymbol(initOwner: Symbol, initPos: Position, initName: Name) + class TermSymbol(initOwner: Symbol, initPos: Position, initName: TermName) extends Symbol(initOwner, initPos, initName) { override def isTerm = true @@ -1741,7 +1739,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => } /** A class for module symbols */ - class ModuleSymbol(initOwner: Symbol, initPos: Position, initName: Name) + class ModuleSymbol(initOwner: Symbol, initPos: Position, initName: TermName) extends TermSymbol(initOwner, initPos, initName) { private var flatname = nme.EMPTY // This method could use a better name from someone clearer on what the condition expresses. @@ -1751,7 +1749,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => if (isFlatAdjusted) rawowner.owner else rawowner - override def name: Name = + override def name: TermName = if (isFlatAdjusted) { if (flatname == nme.EMPTY) { assert(rawowner.isClass, "fatal: %s has owner %s, but a class owner is required".format(rawname, rawowner)) @@ -1765,7 +1763,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => } /** A class for method symbols */ - class MethodSymbol(initOwner: Symbol, initPos: Position, initName: Name) + class MethodSymbol(initOwner: Symbol, initPos: Position, initName: TermName) extends TermSymbol(initOwner, initPos, initName) { private var mtpePeriod = NoPeriod @@ -1795,7 +1793,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => /** A class of type symbols. Alias and abstract types are direct instances * of this class. Classes are instances of a subclass. */ - class TypeSymbol(initOwner: Symbol, initPos: Position, initName: Name) + class TypeSymbol(initOwner: Symbol, initPos: Position, initName: TypeName) extends Symbol(initOwner, initPos, initName) { privateWithin = NoSymbol private var tyconCache: Type = null @@ -1897,7 +1895,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => * origin.isInstanceOf[Symbol] == !hasFlag(EXISTENTIAL) */ class TypeSkolem(initOwner: Symbol, initPos: Position, - initName: Name, origin: AnyRef) + initName: TypeName, origin: AnyRef) extends TypeSymbol(initOwner, initPos, initName) { /** The skolemization level in place when the skolem was constructed */ @@ -1926,7 +1924,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => /** A class for class symbols */ - class ClassSymbol(initOwner: Symbol, initPos: Position, initName: Name) + class ClassSymbol(initOwner: Symbol, initPos: Position, initName: TypeName) extends TypeSymbol(initOwner, initPos, initName) { /** The classfile from which this class was loaded. Maybe null. */ @@ -1956,17 +1954,17 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => thissym = this } - private var flatname = nme.EMPTY + private var flatname: TypeName = tpnme.EMPTY override def owner: Symbol = if (phase.flatClasses && rawowner != NoSymbol && !rawowner.isPackageClass) rawowner.owner else rawowner - override def name: Name = + override def name: TypeName = if ((rawflags & notDEFERRED) != 0L && phase.devirtualized && !phase.erasedTypes) { newTypeName(rawname+"$trait") // (part of DEVIRTUALIZE) } else if (phase.flatClasses && rawowner != NoSymbol && !rawowner.isPackageClass) { - if (flatname == nme.EMPTY) { + if (flatname == tpnme.EMPTY) { assert(rawowner.isClass, "fatal: %s has owner %s, but a class owner is required".format(rawname+idString, rawowner)) flatname = newTypeName(compactify(rawowner.name.toString() + "$" + rawname)) } @@ -2024,7 +2022,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => * Note: Not all module classes are of this type; when unpickled, we get * plain class symbols! */ - class ModuleClassSymbol(owner: Symbol, pos: Position, name: Name) + class ModuleClassSymbol(owner: Symbol, pos: Position, name: TypeName) extends ClassSymbol(owner, pos, name) { private var module: Symbol = null def this(module: TermSymbol) = { @@ -2038,7 +2036,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => } /** An object representing a missing symbol */ - object NoSymbol extends Symbol(null, NoPosition, nme.NOSYMBOL) { + object NoSymbol extends Symbol(null, NoPosition, nme.NO_NAME) { setInfo(NoType) privateWithin = this override def info_=(info: Type) { diff --git a/src/compiler/scala/tools/nsc/symtab/Types.scala b/src/compiler/scala/tools/nsc/symtab/Types.scala index 972c900418..6f9b92b60f 100644 --- a/src/compiler/scala/tools/nsc/symtab/Types.scala +++ b/src/compiler/scala/tools/nsc/symtab/Types.scala @@ -3284,7 +3284,7 @@ A type's typeSymbol should never be inspected directly. val termSym = pre.typeSymbol.owner.newValue( pre.typeSymbol.pos, - pre.typeSymbol.name).setInfo(pre) // what symbol should really be used? + pre.typeSymbol.name.toTermName).setInfo(pre) // what symbol should really be used? mkAttributedQualifier(pre, termSym) } else giveup() @@ -4574,7 +4574,7 @@ A type's typeSymbol should never be inspected directly. tp1.isStable || fourthTry else if (isRaw(sym2, tp2.args)) isSubType(tp1, rawToExistential(tp2), depth) - else if (sym2.name == nme.REFINE_CLASS_NAME.toTypeName) + else if (sym2.name == tpnme.REFINE_CLASS_NAME) isSubType(tp1, sym2.info, depth) else fourthTry @@ -4656,7 +4656,7 @@ A type's typeSymbol should never be inspected directly. else if (isRaw(sym1, tr1.args)) isSubType(rawToExistential(tp1), tp2, depth) else - sym1.name == nme.REFINE_CLASS_NAME.toTypeName && + sym1.name == tpnme.REFINE_CLASS_NAME && isSubType(sym1.info, tp2, depth) case _: TypeSymbol => if (sym1 hasFlag DEFERRED) { diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala index a051177a87..109de180a4 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala @@ -153,25 +153,30 @@ abstract class ClassfileParser { } } - /** Return the name found at given index. The returned name is a term name. */ + /** Return the name found at given index. */ def getName(index: Int): Name = { - if (index <= 0 || len <= index) errorBadIndex(index) - var name = values(index).asInstanceOf[Name] - if (name eq null) { - val start = starts(index) - if (in.buf(start).toInt != CONSTANT_UTF8) errorBadTag(start) - name = newTermName(in.buf, start + 3, in.getChar(start + 1)) - values(index) = name + if (index <= 0 || len <= index) + errorBadIndex(index) + + values(index) match { + case name: Name => name + case null => + val start = starts(index) + if (in.buf(start).toInt != CONSTANT_UTF8) errorBadTag(start) + val name = newTermName(in.buf, start + 3, in.getChar(start + 1)) + values(index) = name + name } - name } /** Return the name found at given index in the constant pool, with '/' replaced by '.'. */ def getExternalName(index: Int): Name = { - if (index <= 0 || len <= index) errorBadIndex(index) - if (internalized(index) eq null) { + if (index <= 0 || len <= index) + errorBadIndex(index) + + if (internalized(index) == null) internalized(index) = getName(index).replace('/', '.') - } + internalized(index) } @@ -182,10 +187,11 @@ abstract class ClassfileParser { val start = starts(index) if (in.buf(start).toInt != CONSTANT_CLASS) errorBadTag(start) val name = getExternalName(in.getChar(start + 1)) - if (name.endsWith("$")) - c = definitions.getModule(name.subName(0, name.length - 1)) + if (name endsWith '$') + c = definitions.getModule(name stripEnd "$") else c = classNameToSymbol(name) + values(index) = c } c @@ -205,7 +211,7 @@ abstract class ClassfileParser { * - If the member refers to special MODULE$ static field, return * the symbol of the corresponding module. * - If the member is a field, and is not found with the given name, - * another try is made by appending nme.LOCAL_SUFFIX + * another try is made by appending nme.LOCAL_SUFFIX_STRING * - If no symbol is found in the right tpe, a new try is made in the * companion class, in case the owner is an implementation class. */ @@ -242,7 +248,7 @@ abstract class ClassfileParser { // println("\t" + owner.info.member(name).tpe.widen + " =:= " + tpe) f = owner.info.member(origName).suchThat(_.tpe.widen =:= tpe) if (f == NoSymbol) - f = owner.info.member(newTermName(origName.toString + nme.LOCAL_SUFFIX)).suchThat(_.tpe =:= tpe) + f = owner.info.member(newTermName(origName + nme.LOCAL_SUFFIX_STRING)).suchThat(_.tpe =:= tpe) if (f == NoSymbol) { // if it's an impl class, try to find it's static member inside the class if (ownerTpe.typeSymbol.isImplClass) { @@ -871,10 +877,10 @@ abstract class ClassfileParser { c convertTo pt } def parseAttribute() { - val attrName = pool.getName(in.nextChar) + val attrName = pool.getName(in.nextChar).toTypeName val attrLen = in.nextInt attrName match { - case nme.SignatureATTR => + case tpnme.SignatureATTR => if (!isScala && !isScalaRaw) { val sig = pool.getExternalName(in.nextChar) val newType = sigToType(sym, sig) @@ -884,40 +890,40 @@ abstract class ClassfileParser { hasMeta = true } else in.skip(attrLen) - case nme.SyntheticATTR => + case tpnme.SyntheticATTR => sym.setFlag(SYNTHETIC) in.skip(attrLen) - case nme.BridgeATTR => + case tpnme.BridgeATTR => sym.setFlag(BRIDGE) in.skip(attrLen) - case nme.DeprecatedATTR => + case tpnme.DeprecatedATTR => val arg = Literal(Constant("see corresponding Javadoc for more information.")) sym.addAnnotation(AnnotationInfo(definitions.DeprecatedAttr.tpe, List(arg), List())) in.skip(attrLen) - case nme.ConstantValueATTR => + case tpnme.ConstantValueATTR => val c = pool.getConstant(in.nextChar) val c1 = convertTo(c, symtype) if (c1 ne null) sym.setInfo(ConstantType(c1)) else println("failure to convert " + c + " to " + symtype); //debug - case nme.ScalaSignatureATTR => + case tpnme.ScalaSignatureATTR => if (!isScalaAnnot) { if (settings.debug.value) log("warning: symbol " + sym.fullName + " has pickled signature in attribute") unpickler.unpickle(in.buf, in.bp, clazz, staticModule, in.file.toString()) } in.skip(attrLen) - case nme.ScalaATTR => + case tpnme.ScalaATTR => isScalaRaw = true - case nme.JacoMetaATTR => + case tpnme.JacoMetaATTR => val meta = pool.getName(in.nextChar).toString().trim() metaParser.parse(meta, sym, symtype) this.hasMeta = true // Attribute on methods of java annotation classes when that method has a default - case nme.AnnotationDefaultATTR => + case tpnme.AnnotationDefaultATTR => sym.addAnnotation(AnnotationInfo(definitions.AnnotationDefaultAttr.tpe, List(), List())) in.skip(attrLen) // Java annotations on classes / methods / fields with RetentionPolicy.RUNTIME - case nme.RuntimeAnnotationATTR => + case tpnme.RuntimeAnnotationATTR => if (isScalaAnnot || !isScala) { val scalaSigAnnot = parseAnnotations(attrLen) if (isScalaAnnot) @@ -935,15 +941,15 @@ abstract class ClassfileParser { in.skip(attrLen) // TODO 1: parse runtime visible annotations on parameters - // case nme.RuntimeParamAnnotationATTR + // case tpnme.RuntimeParamAnnotationATTR // TODO 2: also parse RuntimeInvisibleAnnotation / RuntimeInvisibleParamAnnotation, // i.e. java annotations with RetentionPolicy.CLASS? - case nme.ExceptionsATTR if (!isScala) => + case tpnme.ExceptionsATTR if (!isScala) => parseExceptions(attrLen) - case nme.SourceFileATTR => + case tpnme.SourceFileATTR => val srcfileLeaf = pool.getName(in.nextChar).toString.trim val srcpath = sym.enclosingPackage match { case NoSymbol => srcfileLeaf @@ -1102,7 +1108,7 @@ abstract class ClassfileParser { var sflags = transFlags(jflags, true) val innerClass = getOwner(jflags).newClass(NoPosition, name.toTypeName).setInfo(completer).setFlag(sflags) - val innerModule = getOwner(jflags).newModule(NoPosition, name).setInfo(completer).setFlag(sflags) + val innerModule = getOwner(jflags).newModule(NoPosition, name.toTermName).setInfo(completer).setFlag(sflags) innerModule.moduleClass.setInfo(global.loaders.moduleClassLoader) getScope(jflags).enter(innerClass) @@ -1142,26 +1148,26 @@ abstract class ClassfileParser { skipMembers() // methods val attrs = in.nextChar for (i <- 0 until attrs) { - val attrName = pool.getName(in.nextChar) + val attrName = pool.getName(in.nextChar).toTypeName val attrLen = in.nextInt attrName match { - case nme.SignatureATTR => + case tpnme.SignatureATTR => if (!isScala) hasMeta = true in.skip(attrLen) - case nme.JacoMetaATTR => + case tpnme.JacoMetaATTR => this.hasMeta = true in.skip(attrLen) - case nme.ScalaSignatureATTR => + case tpnme.ScalaSignatureATTR => isScala = true val pbuf = new PickleBuffer(in.buf, in.bp, in.bp + attrLen) pbuf.readNat; pbuf.readNat; if (pbuf.readNat == 0) // a scala signature attribute with no entries means that the actual scala signature isScalaAnnot = true // is in a ScalaSignature annotation. in.skip(attrLen) - case nme.ScalaATTR => + case tpnme.ScalaATTR => isScalaRaw = true - case nme.InnerClassesATTR if !isScala => + case tpnme.InnerClassesATTR if !isScala => val entries = in.nextChar.toInt for (i <- 0 until entries) { val innerIndex = in.nextChar.toInt @@ -1182,9 +1188,9 @@ abstract class ClassfileParser { /** An entry in the InnerClasses attribute of this class file. */ case class InnerClassEntry(external: Int, outer: Int, name: Int, jflags: Int) { - def externalName: Name = pool.getClassName(external) - def outerName: Name = pool.getClassName(outer) - def originalName: Name = pool.getName(name) + def externalName = pool.getClassName(external) + def outerName = pool.getClassName(outer) + def originalName = pool.getName(name) override def toString = originalName + " in " + outerName + "(" + externalName +")" diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala index ecd34d02b0..3d19ceb04f 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala @@ -91,11 +91,10 @@ abstract class ICodeReader extends ClassfileParser { } private def parseMember(field: Boolean): (Int, Symbol) = { - val jflags = in.nextChar - val name = pool.getName(in.nextChar) - - val owner = getOwner(jflags) - val dummySym = owner.newMethod(owner.pos, name).setFlag(javaToScalaFlags(jflags)) + val jflags = in.nextChar + val name = pool.getName(in.nextChar) + val owner = getOwner(jflags) + val dummySym = owner.newMethod(owner.pos, name) setFlag javaToScalaFlags(jflags) try { val ch = in.nextChar @@ -107,7 +106,7 @@ abstract class ICodeReader extends ClassfileParser { val owner = getOwner(jflags) var sym = owner.info.member(name).suchThat(old => sameType(old.tpe, tpe)); if (sym == NoSymbol) - sym = owner.info.member(newTermName(name.toString + nme.LOCAL_SUFFIX)).suchThat(old => old.tpe =:= tpe); + sym = owner.info.member(newTermName(name + nme.LOCAL_SUFFIX_STRING)).suchThat(old => old.tpe =:= tpe); if (sym == NoSymbol) { log("Could not find symbol for " + name + ": " + tpe) log(owner.info.member(name).tpe + " : " + tpe) @@ -177,10 +176,10 @@ abstract class ICodeReader extends ClassfileParser { } def parseAttribute() { - val attrName = pool.getName(in.nextChar) + val attrName = pool.getName(in.nextChar).toTypeName val attrLen = in.nextInt attrName match { - case nme.CodeATTR => + case tpnme.CodeATTR => parseByteCode() case _ => in.skip(attrLen) diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala index 7db6e72a6c..246bb6a88d 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala @@ -133,7 +133,7 @@ abstract class Pickler extends SubComponent { val children = if (locals.isEmpty) globals else { - val localChildDummy = sym.newClass(sym.pos, nme.LOCALCHILD) + val localChildDummy = sym.newClass(sym.pos, tpnme.LOCAL_CHILD) localChildDummy.setInfo(ClassInfoType(List(sym.tpe), EmptyScope, localChildDummy)) localChildDummy :: globals } diff --git a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala index 98ae175dad..e3a90fadd3 100644 --- a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala +++ b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala @@ -329,7 +329,7 @@ abstract class AddInterfaces extends InfoTransform { /* !!! case Super(qual, mix) => val mix1 = mix - if (mix == nme.EMPTY.toTypeName) mix + if (mix == tpnme.EMPTY) mix else { val ps = atPhase(currentRun.erasurePhase) { sym.info.parents dropWhile (p => p.symbol.name != mix) diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala index 943960c3f7..5955a48499 100644 --- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala +++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala @@ -25,6 +25,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL { private val newStaticMembers = mutable.Buffer.empty[Tree] private val newStaticInits = mutable.Buffer.empty[Tree] private val symbolsStoredAsStatic = mutable.Map.empty[String, Symbol] + private def mkTerm(prefix: String): TermName = unit.freshTermName(prefix) //private val classConstantMeth = new HashMap[String, Symbol] //private val symbolStaticFields = new HashMap[String, (Symbol, Tree, Tree)] @@ -91,10 +92,6 @@ abstract class CleanUp extends Transform with ast.TreeDSL { * refinement, where the refinement defines a parameter based on a * type variable. */ case ad@ApplyDynamic(qual0, params) => - def mkName(s: String = "") = - if (s == "") unit.fresh.newName() - else unit.fresh.newName(s) - def mkTerm(s: String = "") = newTermName(mkName(s)) val typedPos = typedWithPos(ad.pos) _ assert(ad.symbol.isPublic) @@ -103,7 +100,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL { /* ### CREATING THE METHOD CACHE ### */ def addStaticVariableToClass(forName: String, forType: Type, forInit: Tree, isFinal: Boolean): Symbol = { - val varSym = currentClass.newVariable(ad.pos, mkName(forName)) + val varSym = currentClass.newVariable(ad.pos, mkTerm(forName)) .setFlag(PRIVATE | STATIC | SYNTHETIC) .setInfo(forType) if (isFinal) varSym setFlag FINAL else varSym addAnnotation AnnotationInfo(VolatileAttr.tpe, Nil, Nil) @@ -120,7 +117,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL { def addStaticMethodToClass(forName: String, forArgsTypes: List[Type], forResultType: Type) (forBody: Pair[Symbol, List[Symbol]] => Tree): Symbol = { - val methSym = currentClass.newMethod(ad.pos, mkName(forName)) + val methSym = currentClass.newMethod(ad.pos, mkTerm(forName)) .setFlag(STATIC | SYNTHETIC) methSym.setInfo(MethodType(methSym.newSyntheticValueParams(forArgsTypes), forResultType)) @@ -387,7 +384,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL { def invocation = (lookup DOT invokeName)(qual, invokeArgs) // .invoke(qual, ...) // exception catching machinery - val invokeExc = currentOwner.newValue(ad.pos, mkTerm()) setInfo InvocationTargetExceptionClass.tpe + val invokeExc = currentOwner.newValue(ad.pos, mkTerm("")) setInfo InvocationTargetExceptionClass.tpe def catchVar = Bind(invokeExc, Typed(Ident(nme.WILDCARD), TypeTree(InvocationTargetExceptionClass.tpe))) def catchBody = Throw(Apply(Select(Ident(invokeExc), nme.getCause), Nil)) @@ -431,7 +428,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL { if (settings.refinementMethodDispatch.value == "invoke-dynamic") { /* val guardCallSite: Tree = { val cachedClass = addStaticVariableToClass("cachedClass", definitions.ClassClass.tpe, EmptyTree) - val tmpVar = currentOwner.newVariable(ad.pos, unit.fresh.newName(ad.pos, "x")).setInfo(definitions.AnyRefClass.tpe) + val tmpVar = currentOwner.newVariable(ad.pos, unit.freshTermName(ad.pos, "x")).setInfo(definitions.AnyRefClass.tpe) atPos(ad.pos)(Block(List( ValDef(tmpVar, transform(qual))), If(Apply(Select(gen.mkAttributedRef(cachedClass), nme.EQ), List(getClass(Ident(tmpVar)))), @@ -551,7 +548,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.newVariable(theTry.pos, unit.fresh.newName(nme.EXCEPTION_RESULT_PREFIX)).setInfo(tpe) + val tempVar = currentOwner.newVariable(theTry.pos, mkTerm(nme.EXCEPTION_RESULT_PREFIX)).setInfo(tpe) def assignBlock(rhs: Tree) = super.transform(BLOCK(Ident(tempVar) === transform(rhs))) val newBlock = assignBlock(block) @@ -612,11 +609,10 @@ abstract class CleanUp extends Transform with ast.TreeDSL { */ private def getSymbolStaticField(pos: Position, symname: String, rhs: Tree, tree: Tree): Symbol = symbolsStoredAsStatic.getOrElseUpdate(symname, { - val freshname = unit.fresh.newName("symbol$") val theTyper = typer.atOwner(tree, currentClass) // create a symbol for the static field - val stfieldSym = currentClass.newVariable(pos, freshname) + val stfieldSym = currentClass.newVariable(pos, mkTerm("symbol$")) .setFlag(PRIVATE | STATIC | SYNTHETIC | FINAL) .setInfo(symbolType) currentClass.info.decls enter stfieldSym diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala index 7a25df6dc3..3607d517ec 100644 --- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala +++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala @@ -353,7 +353,7 @@ abstract class ExplicitOuter extends InfoTransform var nselector = transform(selector) def makeGuardDef(vs: List[Symbol], guard: Tree) = { - val gdname = unit.fresh.newName("gd") + val gdname = unit.freshTermName("gd") val method = currentOwner.newMethod(tree.pos, gdname) setFlag SYNTHETIC val fmls = vs map (_.tpe) val tpe = new MethodType(method newSyntheticValueParams fmls, BooleanClass.tpe) diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala index b32f0ed6bf..a12997226e 100644 --- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala +++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala @@ -254,8 +254,10 @@ abstract class LambdaLift extends InfoTransform { sym.owner.name + "$" else "" ) - val fresh = unit.fresh.newName(base) - sym.name = if (sym.name.isTypeName) fresh.toTypeName else fresh + sym.name = + if (sym.name.isTypeName) unit.freshTypeName(base) + else unit.freshTermName(base) + if (settings.debug.value) log("renamed: " + sym.name) } diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala index 5b6f19c18e..c47d1d1d73 100644 --- a/src/compiler/scala/tools/nsc/transform/Mixin.scala +++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala @@ -632,7 +632,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { def completeSuperAccessor(stat: Tree) = stat match { case DefDef(mods, name, tparams, List(vparams), tpt, EmptyTree) if (stat.symbol.isSuperAccessor) => - val rhs0 = (Super(clazz, nme.EMPTY.toTypeName) DOT stat.symbol.alias)(vparams map (v => Ident(v.symbol)): _*) + val rhs0 = (Super(clazz, tpnme.EMPTY) DOT stat.symbol.alias)(vparams map (v => Ident(v.symbol)): _*) val rhs1 = localTyper.typed(atPos(stat.pos)(rhs0), stat.symbol.tpe.resultType) val rhs2 = atPhase(currentRun.mixinPhase)(transform(rhs1)) if (settings.debug.value) @@ -1114,7 +1114,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { // - if `m' refers to a trait, insert a static call to the corresponding static // implementation // - otherwise return tree unchanged - if (mix == nme.EMPTY.toTypeName && currentOwner.enclClass.isImplClass) + if (mix == tpnme.EMPTY && currentOwner.enclClass.isImplClass) assert(false, "illegal super in trait: " + currentOwner.enclClass + " " + tree); if (sym.owner hasFlag lateINTERFACE) { if (sym.hasAccessorFlag) { diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala index 34015ef092..6df4595022 100644 --- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala +++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala @@ -210,7 +210,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { * guarantees the same result regardless of the map order by sorting * type variables alphabetically. */ - private def specializedName(sym: Symbol, env: TypeEnv): Name = { + private def specializedName(sym: Symbol, env: TypeEnv): TermName = { val tvars = if (sym.isClass) env.keySet else specializedTypeVars(sym).intersect(env.keySet) val (methparams, others) = tvars.toList.partition(_.owner.isMethod) @@ -223,7 +223,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { /** Specialize name for the two list of types. The first one denotes * specialization on method type parameters, the second on outer environment. */ - private def specializedName(name: Name, types1: List[Type], types2: List[Type]): Name = { + private def specializedName(name: Name, types1: List[Type], types2: List[Type]): TermName = { if (nme.INITIALIZER == name || (types1.isEmpty && types2.isEmpty)) name else if (nme.isSetterName(name)) @@ -1143,7 +1143,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { case ddef @ DefDef(mods, name, tparams, vparamss, tpt, rhs) if info.isDefinedAt(symbol) => if (symbol.isConstructor) { val t = atOwner(symbol) { - val superRef: Tree = Select(Super(nme.EMPTY.toTypeName, nme.EMPTY.toTypeName), nme.CONSTRUCTOR) + val superRef: Tree = Select(Super(tpnme.EMPTY, tpnme.EMPTY), nme.CONSTRUCTOR) forwardCtorCall(tree.pos, superRef, vparamss, symbol.owner) } if (symbol.isPrimaryConstructor) localTyper typed { diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala index 0d87ba1203..497450c6c4 100644 --- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala +++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala @@ -209,7 +209,7 @@ abstract class UnCurry extends InfoTransform with TypingTransformers with ast.Tr /** Return non-local return key for given method */ private def nonLocalReturnKey(meth: Symbol) = nonLocalReturnKeys.getOrElseUpdate(meth, { - meth.newValue(meth.pos, unit.fresh.newName("nonLocalReturnKey")) + meth.newValue(meth.pos, unit.freshTermName("nonLocalReturnKey")) .setFlag (SYNTHETIC) .setInfo (ObjectClass.tpe) }) @@ -249,7 +249,7 @@ abstract class UnCurry extends InfoTransform with TypingTransformers with ast.Tr val pat = Bind(ex, Typed(Ident(nme.WILDCARD), AppliedTypeTree(Ident(NonLocalReturnControlClass), - List(Bind(nme.WILDCARD.toTypeName, + List(Bind(tpnme.WILDCARD, EmptyTree))))) val rhs = If( @@ -503,7 +503,7 @@ abstract class UnCurry extends InfoTransform with TypingTransformers with ast.Tr def liftTree(tree: Tree) = { if (settings.debug.value) log("lifting tree at: " + (tree.pos)) - val sym = currentOwner.newMethod(tree.pos, unit.fresh.newName("liftedTree")) + val sym = currentOwner.newMethod(tree.pos, unit.freshTermName("liftedTree")) sym.setInfo(MethodType(List(), tree.tpe)) new ChangeOwnerTraverser(currentOwner, sym).traverse(tree) localTyper.typed { @@ -676,7 +676,7 @@ abstract class UnCurry extends InfoTransform with TypingTransformers with ast.Tr case Try(body, catches, finalizer) => if (catches forall treeInfo.isCatchCase) tree else { - val exname = unit.fresh.newName("ex$") + val exname = unit.freshTermName("ex$") val cases = if ((catches exists treeInfo.isDefaultCase) || (catches.last match { // bq: handle try { } catch { ... case ex:Throwable => ...} case CaseDef(Typed(Ident(nme.WILDCARD), tpt), EmptyTree, _) if (tpt.tpe =:= ThrowableClass.tpe) => @@ -702,7 +702,7 @@ abstract class UnCurry extends InfoTransform with TypingTransformers with ast.Tr case Apply(Apply(fn, args), args1) => treeCopy.Apply(tree, fn, args ::: args1) case Ident(name) => - assert(name != nme.WILDCARD_STAR) + assert(name != tpnme.WILDCARD_STAR) applyUnary() case Select(_, _) | TypeApply(_, _) => applyUnary() diff --git a/src/compiler/scala/tools/nsc/typechecker/DeVirtualize.scala b/src/compiler/scala/tools/nsc/typechecker/DeVirtualize.scala index 077cc1d057..64b05d46f3 100644 --- a/src/compiler/scala/tools/nsc/typechecker/DeVirtualize.scala +++ b/src/compiler/scala/tools/nsc/typechecker/DeVirtualize.scala @@ -463,7 +463,7 @@ abstract class DeVirtualize extends InfoTransform with TypingTransformers { val bridge = meth.cloneSymbol(cclazz) .resetFlag(notOVERRIDE | notFINAL) cclazz.info.decls.enter(bridge) - val superRef: Tree = Select(Super(cclazz, nme.EMPTY.toTypeName), meth) + val superRef: Tree = Select(Super(cclazz, tpnme.EMPTY), meth) DefDef(bridge, gen.mkForwarder(superRef, bridge.paramss)) } diff --git a/src/compiler/scala/tools/nsc/typechecker/EtaExpansion.scala b/src/compiler/scala/tools/nsc/typechecker/EtaExpansion.scala index c24d5c0505..df3a82defd 100644 --- a/src/compiler/scala/tools/nsc/typechecker/EtaExpansion.scala +++ b/src/compiler/scala/tools/nsc/typechecker/EtaExpansion.scala @@ -52,7 +52,7 @@ trait EtaExpansion { self: Analyzer => var cnt = 0 // for NoPosition def freshName() = { cnt += 1 - newTermName(unit.fresh.newName("eta$" + (cnt - 1) + "$")) + unit.freshTermName("eta$" + (cnt - 1) + "$") } val defs = new ListBuffer[Tree] diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index eb775f2301..8de11943cf 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -711,9 +711,9 @@ self: Analyzer => tp match { case TypeRef(pre, sym, args) => if (sym.isClass) { - if (!((sym.name == nme.REFINE_CLASS_NAME.toTypeName) || - (sym.name startsWith nme.ANON_CLASS_NAME) || - (sym.name == nme.ROOT.toTypeName))) + if (!((sym.name == tpnme.REFINE_CLASS_NAME) || + (sym.name startsWith tpnme.ANON_CLASS_NAME) || + (sym.name == tpnme.ROOT))) partMap get sym match { case Some(pre1) => if (!(pre =:= pre1)) partMap(sym) = NoType // ambiguous prefix - ignore implicit members diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index 4ced09795f..3ffe25c61c 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -181,7 +181,7 @@ trait Infer { tp1 // @MAT aliases already handled by subtyping } - private val stdErrorClass = RootClass.newErrorClass(nme.ERROR.toTypeName) + private val stdErrorClass = RootClass.newErrorClass(tpnme.ERROR) private val stdErrorValue = stdErrorClass.newErrorValue(nme.ERROR) /** The context-dependent inferencer part */ @@ -1309,7 +1309,7 @@ trait Infer { def isLocalBinding(sym: Symbol) = sym.isAbstractType && ((bound contains sym) || - sym.name == nme.WILDCARD.toTypeName || { + sym.name == tpnme.WILDCARD || { val e = context.scope.lookupEntry(sym.name) (e ne null) && e.sym == sym && e.owner == context.scope }) diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index 0d614af3ac..e1a8daf6c8 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -1206,7 +1206,7 @@ trait Namers { self: Analyzer => if (currentRun.compileSourceFor(expr, from)) return typeSig(tree) // for Java code importing Scala objects - if (from.endsWith(nme.DOLLARraw)) + if (from.endsWith(nme.raw.DOLLAR)) isValidSelector(from.subName(0, from.length -1)) { context.error(tree.pos, from.decode + " is not a member of " + expr) } diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala index 9ad7776898..09544e6ab4 100644 --- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala +++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala @@ -148,7 +148,7 @@ trait NamesDefaults { self: Analyzer => // never used for constructor calls, they always have a stable qualifier def blockWithQualifier(qual: Tree, selected: Name) = { - val sym = blockTyper.context.owner.newValue(qual.pos, unit.fresh.newName("qual$")) + val sym = blockTyper.context.owner.newValue(qual.pos, unit.freshTermName("qual$")) .setInfo(qual.tpe) blockTyper.context.scope.enter(sym) val vd = atPos(sym.pos)(ValDef(sym, qual).setType(NoType)) @@ -253,32 +253,32 @@ trait NamesDefaults { self: Analyzer => val byName = isByNameParamType(tpe) val (argTpe, repeated) = if (isScalaRepeatedParamType(tpe)) arg match { - case Typed(expr, Ident(nme.WILDCARD_STAR)) => + case Typed(expr, Ident(tpnme.WILDCARD_STAR)) => (expr.tpe, true) case _ => (seqType(arg.tpe), true) } else (arg.tpe, false) - val s = context.owner.newValue(arg.pos, unit.fresh.newName("x$")) + val s = context.owner.newValue(arg.pos, unit.freshTermName("x$")) val valType = if (byName) functionType(List(), argTpe) else if (repeated) argTpe else argTpe s.setInfo(valType) (context.scope.enter(s), byName, repeated) }) - (symPs, args).zipped map ((symP, arg) => { - val (sym, byName, repeated) = symP - // resetAttrs required for #2290. given a block { val x = 1; x }, when wrapping into a function - // () => { val x = 1; x }, the owner of symbol x must change (to the apply method of the function). - val body = if (byName) blockTyper.typed(Function(List(), resetLocalAttrs(arg))) - else if (repeated) arg match { - case Typed(expr, Ident(nme.WILDCARD_STAR)) => - expr - case _ => - val factory = Select(gen.mkAttributedRef(SeqModule), nme.apply) - blockTyper.typed(Apply(factory, List(resetLocalAttrs(arg)))) - } else arg - atPos(body.pos)(ValDef(sym, body).setType(NoType)) - }) + (symPs, args).zipped map { + case ((sym, byName, repeated), arg) => + // resetAttrs required for #2290. given a block { val x = 1; x }, when wrapping into a function + // () => { val x = 1; x }, the owner of symbol x must change (to the apply method of the function). + val body = if (byName) blockTyper.typed(Function(List(), resetLocalAttrs(arg))) + else if (repeated) arg match { + case Typed(expr, Ident(tpnme.WILDCARD_STAR)) => + expr + case _ => + val factory = Select(gen.mkAttributedRef(SeqModule), nme.apply) + blockTyper.typed(Apply(factory, List(resetLocalAttrs(arg)))) + } else arg + atPos(body.pos)(ValDef(sym, body).setType(NoType)) + } } // begin transform @@ -315,7 +315,7 @@ trait NamesDefaults { self: Analyzer => atPos(vDef.pos.focus) { // for by-name parameters, the local value is a nullary function returning the argument if (isByNameParamType(tpe)) Apply(ref, List()) - else if (isScalaRepeatedParamType(tpe)) Typed(ref, Ident(nme.WILDCARD_STAR)) + else if (isScalaRepeatedParamType(tpe)) Typed(ref, Ident(tpnme.WILDCARD_STAR)) else ref } }) diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index 1e45ce72e7..5c8e474d58 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -993,11 +993,14 @@ abstract class RefChecks extends InfoTransform { tree match { case ModuleDef(mods, name, impl) => val sym = tree.symbol - if (sym.isStatic) { - val cdef = ClassDef(mods | MODULE, name, List(), impl) + def mkClassDef(transformedInfo: Boolean) = { + ClassDef(mods | MODULE, name.toTypeName, Nil, impl) .setPos(tree.pos) - .setSymbol(sym.moduleClass) + .setSymbol(if (transformedInfo) sym.lazyAccessor else sym.moduleClass) .setType(NoType) + } + if (sym.isStatic) { + val cdef = mkClassDef(false) if (!sym.allOverriddenSymbols.isEmpty) { val factory = sym.owner.newMethod(sym.pos, sym.name) @@ -1020,11 +1023,7 @@ abstract class RefChecks extends InfoTransform { // that the object info was already run through the transformInfo. // Since we do not want to have duplicate lazy accessors // (through duplicate nested object -> lazy val transformation) we have this check here. - val cdef = ClassDef(mods | MODULE, name, List(), impl) - .setPos(tree.pos) - .setSymbol(if (!transformedInfo) sym.moduleClass else sym.lazyAccessor) - .setType(NoType) - + val cdef = mkClassDef(transformedInfo) val vdef = localTyper.typedPos(tree.pos){ if (!transformedInfo) gen.mkModuleVarDef(sym) @@ -1128,7 +1127,7 @@ abstract class RefChecks extends InfoTransform { (args corresponds clazz.primaryConstructor.tpe.asSeenFrom(seltpe, clazz).paramTypes)(isIrrefutable) // @PP: corresponds case Typed(pat, tpt) => seltpe <:< tpt.tpe - case Ident(nme.WILDCARD) => + case Ident(tpnme.WILDCARD) => true case Bind(_, pat) => isIrrefutable(pat, seltpe) @@ -1297,7 +1296,7 @@ abstract class RefChecks extends InfoTransform { def checkSuper(mix: Name) = // term should have been eliminated by super accessors - assert(!(qual.symbol.isTrait && sym.isTerm && mix == nme.EMPTY.toTypeName)) + assert(!(qual.symbol.isTrait && sym.isTerm && mix == tpnme.EMPTY)) transformCaseApply(tree, qual match { @@ -1387,15 +1386,15 @@ abstract class RefChecks extends InfoTransform { enterReference(tree.pos, tpt.tpe.typeSymbol) tree - case Typed(_, Ident(nme.WILDCARD_STAR)) if !isRepeatedParamArg(tree) => + case Typed(_, Ident(tpnme.WILDCARD_STAR)) if !isRepeatedParamArg(tree) => unit.error(tree.pos, "no `: _*' annotation allowed here\n"+ "(such annotations are only allowed in arguments to *-parameters)") tree case Ident(name) => transformCaseApply(tree, - if (name != nme.WILDCARD && name != nme.WILDCARD_STAR) { - assert(sym != NoSymbol, tree) //debug + if (name != nme.WILDCARD && name != tpnme.WILDCARD_STAR) { + assert(sym != NoSymbol, "transformCaseApply: name = " + name.debugString + " tree = " + tree + " / " + tree.getClass) //debug enterReference(tree.pos, sym) } ) diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala index 023d159d07..09a0f4cfe4 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala @@ -87,12 +87,12 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT if (sym.isDeferred) { val member = sym.overridingSymbol(clazz); - if (mix != nme.EMPTY.toTypeName || member == NoSymbol || + if (mix != tpnme.EMPTY || member == NoSymbol || !((member hasFlag ABSOVERRIDE) && member.isIncompleteIn(clazz))) unit.error(tree.pos, ""+sym+sym.locationString+" is accessed from super. It may not be abstract "+ "unless it is overridden by a member declared `abstract' and `override'"); } - if (tree.isTerm && mix == nme.EMPTY.toTypeName && + if (tree.isTerm && mix == tpnme.EMPTY && (clazz.isTrait || clazz != currentOwner.enclClass || !validCurrentOwner)) { val supername = nme.superName(sym.name) var superAcc = clazz.info.decl(supername).suchThat(_.alias == sym) @@ -191,7 +191,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT if (sym.isParamAccessor && sym.alias != NoSymbol) { val result = localTyper.typed { Select( - Super(qual.symbol, nme.EMPTY.toTypeName/*qual.symbol.info.parents.head.symbol.name*/) setPos qual.pos, + Super(qual.symbol, tpnme.EMPTY/*qual.symbol.info.parents.head.symbol.name*/) setPos qual.pos, sym.alias) setPos tree.pos } if (settings.debug.value) diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala index 1c8414671c..a1f152c39c 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala @@ -182,7 +182,7 @@ trait SyntheticMethods extends ast.TreeDSL { // returns (Apply, Bind) def makeTrees(acc: Symbol, cpt: Type): (Tree, Bind) = { - val varName = context.unit.fresh.newName(acc.name + "$") + val varName = context.unit.freshTermName(acc.name + "$") val isRepeated = isRepeatedParamType(cpt) val binding = if (isRepeated) Star(WILD()) else WILD() val eqMethod: Tree = @@ -221,7 +221,7 @@ trait SyntheticMethods extends ast.TreeDSL { def newAccessorMethod(tree: Tree): Tree = tree match { case DefDef(_, _, _, _, _, rhs) => var newAcc = tree.symbol.cloneSymbol - newAcc.name = context.unit.fresh.newName(tree.symbol.name + "$") + newAcc.name = context.unit.freshTermName(tree.symbol.name + "$") newAcc setFlag SYNTHETIC resetFlag (ACCESSOR | PARAMACCESSOR | PRIVATE | PROTECTED) newAcc.privateWithin = NoSymbol newAcc = newAcc.owner.info.decls enter newAcc diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index b6e45fe58c..a36ba92c88 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -3051,7 +3051,7 @@ trait Typers { self: Analyzer => def typedBind(name: Name, body: Tree) = { var vble = tree.symbol if (name.isTypeName) { - assert(body == EmptyTree) + assert(body == EmptyTree, context.unit + " typedBind: " + name.debugString + " " + body + " " + body.getClass) if (vble == NoSymbol) vble = if (isFullyDefined(pt)) @@ -3060,7 +3060,7 @@ trait Typers { self: Analyzer => context.owner.newAbstractType(tree.pos, name) setInfo TypeBounds(NothingClass.tpe, AnyClass.tpe) val rawInfo = vble.rawInfo - vble = if (vble.name == nme.WILDCARD.toTypeName) context.scope.enter(vble) + vble = if (vble.name == tpnme.WILDCARD) context.scope.enter(vble) else namer.enterInScope(vble) tree setSymbol vble setType vble.tpe } else { @@ -3899,7 +3899,7 @@ trait Typers { self: Analyzer => val params = for (i <- List.range(0, arity)) yield atPos(tree.pos.focusStart) { ValDef(Modifiers(PARAM | SYNTHETIC), - unit.fresh.newName("x" + i + "$"), TypeTree(), EmptyTree) + unit.freshTermName("x" + i + "$"), TypeTree(), EmptyTree) } val ids = for (p <- params) yield Ident(p.name) val selector1 = atPos(tree.pos.focusStart) { if (arity == 1) ids.head else gen.mkTuple(ids) } @@ -3940,7 +3940,7 @@ trait Typers { self: Analyzer => case Typed(expr, Function(List(), EmptyTree)) => typedEta(checkDead(typed1(expr, mode, pt))) - case Typed(expr, tpt @ Ident(nme.WILDCARD_STAR)) => + case Typed(expr, tpt @ Ident(tpnme.WILDCARD_STAR)) => val expr0 = typed(expr, mode & stickyModes, WildcardType) def subArrayType(pt: Type) = if (isValueClass(pt.typeSymbol) || !isFullyDefined(pt)) arrayType(pt) @@ -4077,7 +4077,7 @@ trait Typers { self: Analyzer => case Ident(name) => incCounter(typedIdentCount) if ((name == nme.WILDCARD && (mode & (PATTERNmode | FUNmode)) == PATTERNmode) || - (name == nme.WILDCARD.toTypeName && (mode & TYPEmode) != 0)) + (name == tpnme.WILDCARD && (mode & TYPEmode) != 0)) tree setType makeFullyDefined(pt) else typedIdent(name) diff --git a/src/compiler/scala/tools/nsc/util/FreshNameCreator.scala b/src/compiler/scala/tools/nsc/util/FreshNameCreator.scala index cf6994da51..c3e242de03 100644 --- a/src/compiler/scala/tools/nsc/util/FreshNameCreator.scala +++ b/src/compiler/scala/tools/nsc/util/FreshNameCreator.scala @@ -24,7 +24,7 @@ trait FreshNameCreator { object FreshNameCreator { class Default extends FreshNameCreator { protected var counter = 0 - protected val counters = new HashMap[String, Int] + protected val counters = new HashMap[String, Int] withDefaultValue 0 /** * Create a fresh name with the given prefix. It is guaranteed @@ -32,10 +32,10 @@ object FreshNameCreator { * 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 + val safePrefix = prefix.replaceAll("""[<>]""", """\$""") + counters(safePrefix) += 1 + + safePrefix + counters(safePrefix) } def newName(): String = { counter += 1 |