diff options
Diffstat (limited to 'src')
7 files changed, 34 insertions, 49 deletions
diff --git a/src/compiler/scala/tools/nsc/ast/TreeInfo.scala b/src/compiler/scala/tools/nsc/ast/TreeInfo.scala index 88f161f22d..a315a81bab 100644 --- a/src/compiler/scala/tools/nsc/ast/TreeInfo.scala +++ b/src/compiler/scala/tools/nsc/ast/TreeInfo.scala @@ -149,12 +149,10 @@ abstract class TreeInfo { } /** The first constructor definitions in `stats' */ - def firstConstructor(stats: List[Tree]): Tree = stats match { - case List() => EmptyTree - case (constr @ DefDef(_, name, _, _, _, _)) :: _ - if (name == nme.CONSTRUCTOR || name == nme.MIXIN_CONSTRUCTOR) => constr - case _ :: stats1 => firstConstructor(stats1) - } + def firstConstructor(stats: List[Tree]): Tree = stats find { + case x: DefDef => nme.isConstructorName(x.name) + case _ => false + } getOrElse EmptyTree /** The arguments to the first constructor in `stats'. */ def firstConstructorArgs(stats: List[Tree]): List[Tree] = firstConstructor(stats) match { diff --git a/src/compiler/scala/tools/nsc/symtab/StdNames.scala b/src/compiler/scala/tools/nsc/symtab/StdNames.scala index 832cc22c54..e0158ecec0 100644 --- a/src/compiler/scala/tools/nsc/symtab/StdNames.scala +++ b/src/compiler/scala/tools/nsc/symtab/StdNames.scala @@ -75,6 +75,7 @@ trait StdNames extends reflect.generic.StdNames { self: SymbolTable => val TRAIT_SETTER_SEPARATOR_STRING = "$_setter_$" val TUPLE_FIELD_PREFIX_STRING = "_" val CHECK_IF_REFUTABLE_STRING = "check$ifrefutable$" + val DEFAULT_GETTER_STRING = "$default$" val INTERPRETER_WRAPPER_SUFFIX = "$object" val INTERPRETER_LINE_PREFIX = "line" @@ -99,6 +100,7 @@ trait StdNames extends reflect.generic.StdNames { self: SymbolTable => def isSetterName(name: Name) = name.endsWith(SETTER_SUFFIX) def isLocalDummyName(name: Name) = name.startsWith(LOCALDUMMY_PREFIX) def isTraitSetterName(name: Name) = isSetterName(name) && name.pos(TRAIT_SETTER_SEPARATOR_STRING) < name.length + def isConstructorName(name: Name) = name == CONSTRUCTOR || name == MIXIN_CONSTRUCTOR def isOpAssignmentName(name: Name) = name(name.length - 1) == '=' && isOperatorPart(name(0)) && @@ -162,6 +164,11 @@ trait StdNames extends reflect.generic.StdNames { self: SymbolTable => name.subName(0, name.length - SETTER_SUFFIX.length) } + def defaultGetterName(name: Name, pos: Int): Name = { + val prefix = if (isConstructorName(name)) "init" else name + newTermName(prefix + DEFAULT_GETTER_STRING + pos) + } + def getterName(name: Name): Name = if (isLocalName(name)) localToGetter(name) else name; diff --git a/src/compiler/scala/tools/nsc/symtab/Symbols.scala b/src/compiler/scala/tools/nsc/symtab/Symbols.scala index a6ae9ef913..5c5d04c99c 100644 --- a/src/compiler/scala/tools/nsc/symtab/Symbols.scala +++ b/src/compiler/scala/tools/nsc/symtab/Symbols.scala @@ -413,7 +413,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => final def isInitializedToDefault = !isType && (getFlag(DEFAULTINIT | ACCESSOR) == (DEFAULTINIT | ACCESSOR)) final def isClassConstructor = isTerm && (name == nme.CONSTRUCTOR) final def isMixinConstructor = isTerm && (name == nme.MIXIN_CONSTRUCTOR) - final def isConstructor = isTerm && (name == nme.CONSTRUCTOR) || (name == nme.MIXIN_CONSTRUCTOR) + final def isConstructor = isTerm && nme.isConstructorName(name) final def isStaticModule = isModule && isStatic && !isMethod final def isThisSym = isTerm && owner.thisSym == this final def isError = hasFlag(IS_ERROR) diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala index 80f32ec66f..023dd9c97d 100644 --- a/src/compiler/scala/tools/nsc/transform/Erasure.scala +++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala @@ -212,18 +212,6 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer with ast. private def needsJavaSig(tp: Type) = !settings.Ynogenericsig.value && NeedsSigCollector.collect(tp) - private lazy val tagOfClass = Map[Symbol,Char]( - ByteClass -> BYTE_TAG, - CharClass -> CHAR_TAG, - DoubleClass -> DOUBLE_TAG, - FloatClass -> FLOAT_TAG, - IntClass -> INT_TAG, - LongClass -> LONG_TAG, - ShortClass -> SHORT_TAG, - BooleanClass -> BOOL_TAG, - UnitClass -> VOID_TAG - ) - /** The Java signature of type 'info', for symbol sym. The symbol is used to give the right return * type for constructors. */ @@ -275,7 +263,7 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer with ast. else if (sym == NullClass) jsig(RuntimeNullClass.tpe) else if (isValueClass(sym)) - tagOfClass(sym).toString + abbrvTag(sym).toString else if (sym.isClass) { val preRebound = pre.baseType(sym.owner) // #2585 @@ -425,10 +413,9 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer with ast. * @pre phase > erasure */ def bridgedSym(bridge: Symbol) = - bridge.owner.info.nonPrivateDecl(bridge.name) suchThat { - sym => !(sym hasFlag BRIDGE) && - matchesType(sym.tpe, bridge.tpe, true) && - sym.tpe.resultType <:< bridge.tpe.resultType + bridge.owner.info.nonPrivateDecl(bridge.name) suchThat { sym => + !sym.isBridge && matchesType(sym.tpe, bridge.tpe, true) && + (sym.tpe.resultType <:< bridge.tpe.resultType) } // -------- erasure on trees ------------------------------------------ diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index 3133449050..a666dee60b 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -96,6 +96,9 @@ trait Namers { self: Analyzer => sym } + private def isCopyGetter(meth: Symbol) = { + meth.name startsWith (nme.copy + nme.DEFAULT_GETTER_STRING) + } private def isTemplateContext(context: Context): Boolean = context.tree match { case Template(_, _, _) => true case Import(_, _) => isTemplateContext(context.outer) @@ -312,7 +315,7 @@ trait Namers { self: Analyzer => if (sym.isTerm) skolemize(tparams) } - if (sym.name == nme.copy || sym.name.startsWith(nme.copy + "$default$")) { + if (sym.name == nme.copy || isCopyGetter(sym)) { // it could be a compiler-generated copy method or one of its default getters setInfo(sym)(mkTypeCompleter(tree)(copySym => { def copyIsSynthetic() = sym.owner.info.member(nme.copy).hasFlag(SYNTHETIC) @@ -718,11 +721,9 @@ trait Namers { self: Analyzer => // add apply and unapply methods to companion objects of case classes, // unless they exist already; here, "clazz" is the module class if (clazz.isModuleClass) { - Namers.this.caseClassOfModuleClass get clazz match { - case Some(cdef) => - addApplyUnapply(cdef, templateNamer) - caseClassOfModuleClass -= clazz - case None => + Namers.this.caseClassOfModuleClass get clazz map { cdef => + addApplyUnapply(cdef, templateNamer) + caseClassOfModuleClass -= clazz } } @@ -732,16 +733,12 @@ trait Namers { self: Analyzer => // @check: this seems to work only if the type completer of the class runs before the one of the // module class: the one from the module class removes the entry form caseClassOfModuleClass (see above). if (clazz.isClass && !clazz.hasFlag(MODULE)) { - Namers.this.caseClassOfModuleClass get companionModuleOf(clazz, context).moduleClass match { - case Some(cdef) => - def hasCopy(decls: Scope) = { - decls.iterator exists (_.name == nme.copy) - } - if (!hasCopy(decls) && - !parents.exists(p => hasCopy(p.typeSymbol.info.decls)) && - !parents.flatMap(_.baseClasses).distinct.exists(bc => hasCopy(bc.info.decls))) - addCopyMethod(cdef, templateNamer) - case None => + Namers.this.caseClassOfModuleClass get companionModuleOf(clazz, context).moduleClass map { cdef => + def hasCopy(decls: Scope) = (decls lookup nme.copy) != NoSymbol + if (!hasCopy(decls) && + !parents.exists(p => hasCopy(p.typeSymbol.info.decls)) && + !parents.flatMap(_.baseClasses).distinct.exists(bc => hasCopy(bc.info.decls))) + addCopyMethod(cdef, templateNamer) } } @@ -918,6 +915,7 @@ trait Namers { self: Analyzer => * flag. */ private def addDefaultGetters(meth: Symbol, vparamss: List[List[ValDef]], tparams: List[TypeDef], overriddenSymbol: => Symbol) { + val isConstr = meth.isConstructor val overridden = if (isConstr || !meth.owner.isClass) NoSymbol else overriddenSymbol @@ -948,7 +946,7 @@ trait Namers { self: Analyzer => if (sym hasFlag DEFAULTPARAM) { // generate a default getter for that argument val oflag = if (baseHasDefault) OVERRIDE else 0 - val name = (if (isConstr) "init" else meth.name) +"$default$"+ posCounter + val name = nme.defaultGetterName(meth.name, posCounter) // Create trees for the defaultGetter. Uses tools from Unapplies.scala var deftParams = tparams map copyUntyped[TypeDef] diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala index aaeb2c0385..808dbcc785 100644 --- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala +++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala @@ -391,12 +391,12 @@ trait NamesDefaults { self: Analyzer => def defaultGetter(param: Symbol, context: Context): Symbol = { val i = param.owner.paramss.flatten.indexWhere(p => p.name == param.name) + 1 if (i > 0) { + val defGetterName = nme.defaultGetterName(param.owner.name, i) if (param.owner.isConstructor) { - val defGetterName = "init$default$"+ i val mod = companionModuleOf(param.owner.owner, context) mod.info.member(defGetterName) - } else { - val defGetterName = param.owner.name +"$default$"+ i + } + else { // isClass also works for methods in objects, owner is the ModuleClassSymbol if (param.owner.owner.isClass) { // .toInterface: otherwise we get the method symbol of the impl class diff --git a/src/library/scala/reflect/generic/UnPickler.scala b/src/library/scala/reflect/generic/UnPickler.scala index d5e2bd9f11..80818ac62a 100755 --- a/src/library/scala/reflect/generic/UnPickler.scala +++ b/src/library/scala/reflect/generic/UnPickler.scala @@ -212,12 +212,7 @@ abstract class UnPickler { sym = NoSymbol case _ => // symbols that were pickled with Pickler.writeSymInfo - var defaultGetter: Symbol = NoSymbol // @deprecated, to be removed for 2.8 final var nameref = readNat() - if (tag == VALsym && isSymbolRef(nameref)) { // @deprecated, to be removed for 2.8 final - defaultGetter = at(nameref, readSymbol) - nameref = readNat() - } val name = at(nameref, readName) val owner = readSymbolRef() val flags = pickledToRawFlags(readLongNat()) |