Encapsulating name strings in StdNames and elim...

Encapsulating name strings in StdNames and eliminating misc duplication.
No review.

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())