Symbol creation followup.

Changed most symbol creations to be consistent with all the others.
Opportunistically streamlined various call sites.  Moved some phase-specific
methods out of Symbol to somewhere more appropriate (like that phase.)

5 files changed, 41 insertions, 52 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 918eb749c8..53e88b33c8 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -192,12 +192,10 @@ trait Implicits {
    */
   def memberWildcardType(name: Name, tp: Type) = {
     val result = refinedType(List(WildcardType), NoSymbol)
-    var psym = name match {
-      case x: TypeName  => result.typeSymbol.newAbstractType(NoPosition, x)
-      case x: TermName  => result.typeSymbol.newValue(NoPosition, x)
+    name match {
+      case x: TermName => result.typeSymbol.newValue(x) setInfoAndEnter tp
+      case x: TypeName => result.typeSymbol.newAbstractType(x) setInfoAndEnter tp
     }
-    psym setInfo tp
-    result.decls enter psym
     result
   }
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
index 07b08e52da..79cb211215 100644
--- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
@@ -154,10 +154,9 @@ 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.freshTermName("qual$"))
-                            .setInfo(qual.tpe)
-        blockTyper.context.scope.enter(sym)
-        val vd = atPos(sym.pos)(ValDef(sym, qual).setType(NoType))
+        val sym = blockTyper.context.owner.newValue(unit.freshTermName("qual$"), qual.pos) setInfo qual.tpe
+        blockTyper.context.scope enter sym
+        val vd = atPos(sym.pos)(ValDef(sym, qual) setType NoType)
 
         var baseFunTransformed = atPos(baseFun.pos.makeTransparent) {
           // don't use treeCopy: it would assign opaque position.
diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
index cde531adc1..4e4fbe35cb 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
@@ -97,18 +97,13 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
           var superAcc = clazz.info.decl(supername).suchThat(_.alias == sym)
           if (superAcc == NoSymbol) {
             debuglog("add super acc " + sym + sym.locationString + " to `" + clazz);//debug
-            superAcc =
-              clazz.newMethod(tree.pos, supername)
-                .setFlag(SUPERACCESSOR | PRIVATE)
-                .setAlias(sym)
+            superAcc = clazz.newMethod(supername, tree.pos, SUPERACCESSOR | PRIVATE) setAlias sym
             var superAccTpe = clazz.thisType.memberType(sym)
             if (sym.isModule && !sym.isMethod) {
               // the super accessor always needs to be a method. See #231
               superAccTpe = NullaryMethodType(superAccTpe)
             }
-            superAcc.setInfo(superAccTpe.cloneInfo(superAcc))
-            //println("creating super acc "+superAcc+":"+superAcc.tpe)//DEBUG
-            clazz.info.decls enter superAcc
+            superAcc setInfoAndEnter (superAccTpe cloneInfo superAcc)
             storeAccessorDefinition(clazz, DefDef(superAcc, EmptyTree))
           }
           atPos(sup.pos) {
@@ -312,14 +307,12 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
                      memberType.cloneInfo(protAcc).asSeenFrom(qual.tpe, sym.owner))
       }
 
-      var protAcc = clazz.info.decl(accName).suchThat(s => s == NoSymbol || s.tpe =:= accType(s))
-      if (protAcc == NoSymbol) {
-        protAcc = clazz.newMethod(tree.pos, nme.protName(sym.originalName))
-        protAcc.setInfo(accType(protAcc))
-        clazz.info.decls.enter(protAcc);
+      val protAcc = clazz.info.decl(accName).suchThat(s => s == NoSymbol || s.tpe =:= accType(s)) orElse {
+        val newAcc = clazz.newMethod(nme.protName(sym.originalName), tree.pos)
+        newAcc setInfoAndEnter accType(newAcc)
 
-        val code = DefDef(protAcc, {
-          val (receiver :: _) :: tail = protAcc.paramss
+        val code = DefDef(newAcc, {
+          val (receiver :: _) :: tail = newAcc.paramss
           val base: Tree              = Select(Ident(receiver), sym)
           val allParamTypes           = mapParamss(sym)(_.tpe)
           val args = map2(tail, allParamTypes)((params, tpes) => map2(params, tpes)(makeArg(_, receiver, _)))
@@ -328,12 +321,15 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
 
         debuglog("" + code)
         storeAccessorDefinition(clazz, code)
+        newAcc
       }
-      var res: Tree = atPos(tree.pos) {
-        if (targs.head == EmptyTree)
-          Apply(Select(This(clazz), protAcc), List(qual))
-        else
-          Apply(TypeApply(Select(This(clazz), protAcc), targs), List(qual))
+      val selection = Select(This(clazz), protAcc)
+      def mkApply(fn: Tree) = Apply(fn, qual :: Nil)
+      val res = atPos(tree.pos) { 
+        targs.head match {
+          case EmptyTree  => mkApply(selection)
+          case _          => mkApply(TypeApply(selection, targs))
+        }
       }
       debuglog("Replaced " + tree + " with " + res)
       if (hasArgs) localTyper.typedOperator(res) else localTyper.typed(res)
@@ -371,25 +367,21 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
       val clazz = hostForAccessorOf(field, currentOwner.enclClass)
       assert(clazz != NoSymbol, field)
       debuglog("Decided for host class: " + clazz)
+      
       val accName = nme.protSetterName(field.originalName)
-      var protAcc = clazz.info.decl(accName)
-      if (protAcc == NoSymbol) {
-        protAcc = clazz.newMethod(field.pos, nme.protSetterName(field.originalName))
-        protAcc.setInfo(MethodType(protAcc.newSyntheticValueParams(List(clazz.typeOfThis, field.tpe)),
-                                   UnitClass.tpe))
-        clazz.info.decls.enter(protAcc)
-        val code = DefDef(protAcc, {
-          val obj :: value :: Nil = protAcc.paramss.head
-          atPos(tree.pos) {
-            Assign(
-              Select(Ident(obj), field.name),
-              Ident(value))
-          }
-        })
-        debuglog("" + code)
-        storeAccessorDefinition(clazz, code)
+      val protectedAccessor = clazz.info decl accName orElse {
+        val protAcc      = clazz.newMethod(accName, field.pos)
+        val paramTypes   = List(clazz.typeOfThis, field.tpe)
+        val params       = protAcc newSyntheticValueParams paramTypes
+        val accessorType = MethodType(params, UnitClass.tpe)
+        
+        protAcc setInfoAndEnter accessorType
+        val obj :: value :: Nil = params
+        storeAccessorDefinition(clazz, DefDef(protAcc, Assign(Select(Ident(obj), field.name), Ident(value))))
+      
+        protAcc
       }
-      atPos(tree.pos)(Select(This(clazz), protAcc))
+      atPos(tree.pos)(Select(This(clazz), protectedAccessor))
     }
 
     /** Does `sym` need an accessor when accessed from `currentOwner`?
diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
index 1df7cd86d3..4e986dc5aa 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
@@ -110,12 +110,12 @@ trait SyntheticMethods extends ast.TreeDSL {
     }
 
     private def createInternal(name: Name, f: Symbol => Tree, info: Type): Tree = {
-      val m = clazz.newMethod(clazz.pos.focus, name.toTermName)
+      val m = clazz.newMethod(name.toTermName, clazz.pos.focus)
       m setInfo info
       finishMethod(m, f)
     }
     private def createInternal(name: Name, f: Symbol => Tree, infoFn: Symbol => Type): Tree = {
-      val m = clazz.newMethod(clazz.pos.focus, name.toTermName)
+      val m = clazz.newMethod(name.toTermName, clazz.pos.focus)
       m setInfo infoFn(m)
       finishMethod(m, f)
     }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 243d922732..884ad7af3d 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -2817,7 +2817,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
         }
         val bound      = sym.existentialBound
         val sowner     = if (isRawParameter(sym)) context.owner else sym.owner
-        val quantified = sowner.newExistential(sym.pos, name)
+        val quantified = sowner.newExistential(name, sym.pos)
 
         quantified setInfo bound.cloneInfo(quantified)
       }
@@ -3079,7 +3079,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
                    * */
                   ( context.owner
                       newLocalDummy (ann.pos)
-                      newValue (ann.pos, nme.self)
+                      newValue (nme.self, ann.pos)
                       setInfo (arg1.tpe.withoutAnnotations)
                   )
                 }
@@ -3120,9 +3120,9 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
           if (vble == NoSymbol)
             vble =
               if (isFullyDefined(pt))
-                context.owner.newAliasType(tree.pos, name) setInfo pt
+                context.owner.newAliasType(name, tree.pos) setInfo pt
               else
-                context.owner.newAbstractType(tree.pos, name) setInfo TypeBounds.empty
+                context.owner.newAbstractType(name, tree.pos) setInfo TypeBounds.empty
           val rawInfo = vble.rawInfo
           vble = if (vble.name == tpnme.WILDCARD) context.scope.enter(vble)
                  else namer.enterInScope(vble)
@@ -3130,7 +3130,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
         }
         def typedBindTerm(name: TermName) = {
           if (vble == NoSymbol)
-            vble = context.owner.newValue(tree.pos, name)
+            vble = context.owner.newValue(name, tree.pos)
           if (vble.name.toTermName != nme.WILDCARD) {
             if ((mode & ALTmode) != 0)
               error(tree.pos, "illegal variable in pattern alternative")