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

Author: paulp

src/compiler/scala/reflect/internal/AnnotationInfos.scala

@@ -230,10 +230,8 @@ trait AnnotationInfos extends api.AnnotationInfos { self: SymbolTable =>
     def refsSymbol(sym: Symbol) = hasArgWhich(_.symbol == sym)
 
     /** Change all ident's with Symbol "from" to instead use symbol "to" */
-    def substIdentSyms(from: Symbol, to: Symbol) = {
-      val subs = new TreeSymSubstituter(List(from), List(to))
-      AnnotationInfo(atp, args.map(subs(_)), assocs).setPos(pos)
-    }
+    def substIdentSyms(from: Symbol, to: Symbol) =
+      AnnotationInfo(atp, args map (_ substTreeSyms (from -> to)), assocs) setPos pos
 
     def stringArg(index: Int) = constantAtIndex(index) map (_.stringValue)
     def intArg(index: Int)    = constantAtIndex(index) map (_.intValue)

src/compiler/scala/reflect/internal/Symbols.scala

@@ -212,17 +212,6 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
         setInfo OverloadedType(pre, alternatives)
     )
 
-    /** for explicit outer phase */
-    final def newOuterAccessor(pos: Position) = {
-      val accFlags = METHOD | STABLE | SYNTHETIC | (
-        if (isTrait) DEFERRED else 0
-      )
-      val sym = newMethodSymbol(nme.OUTER, pos, accFlags)
-      sym.expandName(this)
-      sym.referenced = this
-      sym
-    }
-
     final def newErrorValue(name: TermName) =
       newTermSymbol(name, pos, SYNTHETIC | IS_ERROR) setInfo ErrorType
 
@@ -285,6 +274,14 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
     final def newClass(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L) =
       newClassSymbol(name, pos, newFlags)
+    
+    /** A new class with its info set to a ClassInfoType with given scope and parents. */
+    def newClassWithInfo(name: TypeName, parents: List[Type], scope: Scope, pos: Position = NoPosition, newFlags: Long = 0L) = {
+      val clazz = newClass(name, pos, newFlags)
+      clazz setInfo ClassInfoType(parents, scope, clazz)
+    }
+    final def newErrorClass(name: TypeName) =
+      newClassWithInfo(name, Nil, new ErrorScope(this), pos, SYNTHETIC | IS_ERROR)
 
     final def newModuleClass(name: TypeName, pos: Position = NoPosition) =
       newModuleClassSymbol(name, pos)
@@ -312,11 +309,6 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
         setInfo MethodType(Nil, tpe)
     )
 
-    final def newErrorClass(name: TypeName) = {
-      val clazz = newClassSymbol(name, pos, SYNTHETIC | IS_ERROR)
-      clazz setInfo ClassInfoType(Nil, new ErrorScope(this), clazz)
-    }
-
     final def newErrorSymbol(name: Name): Symbol = name match {
       case x: TypeName  => newErrorClass(x)
       case x: TermName  => newErrorValue(x)
@@ -1196,7 +1188,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
           oldsymbuf += sym
           newsymbuf += (
             if (sym.isClass)
-              tp.typeSymbol.newAbstractType(sym.pos, sym.name.toTypeName).setInfo(sym.existentialBound)
+              tp.typeSymbol.newAbstractType(sym.name.toTypeName, sym.pos).setInfo(sym.existentialBound)
             else
               sym.cloneSymbol(tp.typeSymbol))
         }
@@ -1346,15 +1338,15 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       cloneSymbol(owner)
 
     /** A clone of this symbol, but with given owner. */
-    final def cloneSymbol(owner: Symbol): Symbol = {
-      val newSym = cloneSymbolImpl(owner, this.rawflags)
+    final def cloneSymbol(owner: Symbol): Symbol = cloneSymbol(owner, this.rawflags)
+    final def cloneSymbol(owner: Symbol, newFlags: Long): Symbol = {
+      val newSym = cloneSymbolImpl(owner, newFlags)
       ( newSym
           setPrivateWithin privateWithin
           setInfo (info cloneInfo newSym)
           setAnnotations this.annotations
       )
     }
-    
     /** Internal method to clone a symbol's implementation with the given flags and no info. */
     def cloneSymbolImpl(owner: Symbol, newFlags: Long): Symbol
     def cloneSymbolImpl(owner: Symbol): Symbol = cloneSymbolImpl(owner, 0L)

src/compiler/scala/reflect/internal/Trees.scala

@@ -121,7 +121,12 @@ trait Trees extends api.Trees { self: SymbolTable =>
         new ChangeOwnerTraverser(oldOwner, newOwner) apply t
       }
     }
-
+    
+    def substTreeSyms(pairs: (Symbol, Symbol)*): Tree = {
+      val list  = pairs.toList
+      val subst = new TreeSymSubstituter(list map (_._1), list map (_._2))
+      subst(tree)
+    }
     def shallowDuplicate: Tree = new ShallowDuplicator(tree) transform tree
     def shortClass: String = tree.getClass.getName split "[.$]" last
     /** When you want to know a little more than the class, but a lot

src/compiler/scala/reflect/internal/Types.scala

@@ -3726,7 +3726,7 @@ trait Types extends api.Types { self: SymbolTable =>
 
   def typeParamsToExistentials(clazz: Symbol, tparams: List[Symbol]): List[Symbol] = {
     val eparams = mapWithIndex(tparams)((tparam, i) =>
-      clazz.newExistential(clazz.pos, newTypeName("?"+i)) setInfo tparam.info.bounds)
+      clazz.newExistential(newTypeName("?"+i), clazz.pos) setInfo tparam.info.bounds)
 
     eparams map (_ substInfo (tparams, eparams))
   }
@@ -3848,10 +3848,10 @@ trait Types extends api.Types { self: SymbolTable =>
             if (tree.symbol isNonBottomSubClass clazz) &&
                (pre.widen.typeSymbol isNonBottomSubClass tree.symbol) =>
               if (pre.isStable) { // XXX why is this in this method? pull it out and guard the call `annotationArgRewriter.transform(tree)`?
-                val termSym =
-                  pre.typeSymbol.owner.newValue(
-                    pre.typeSymbol.pos,
-                    pre.typeSymbol.name.toTermName).setInfo(pre)  // what symbol should really be used?
+                val termSym = (
+                  pre.typeSymbol.owner.newValue(pre.typeSymbol.name.toTermName, pre.typeSymbol.pos) // what symbol should really be used?
+                    setInfo pre
+                )
                 gen.mkAttributedQualifier(pre, termSym)
               } else
                 giveup()
@@ -4205,7 +4205,7 @@ trait Types extends api.Types { self: SymbolTable =>
         val symowner = oldSym.owner
         val bound = singletonBounds(actualsIndexed(actualIdx))
 
-        val sym = symowner.newExistential(oldSym.pos, newTypeName(oldSym.name + ".type"))
+        val sym = symowner.newExistential(newTypeName(oldSym.name + ".type"), oldSym.pos)
         sym.setInfo(bound)
         sym.setFlag(oldSym.flags)
 
@@ -5892,7 +5892,7 @@ trait Types extends api.Types { self: SymbolTable =>
               else {
                 def lubBounds(bnds: List[TypeBounds]): TypeBounds =
                   TypeBounds(glb(bnds map (_.lo), decr(depth)), lub(bnds map (_.hi), decr(depth)))
-                lubRefined.typeSymbol.newAbstractType(proto.pos, proto.name.toTypeName)
+                lubRefined.typeSymbol.newAbstractType(proto.name.toTypeName, proto.pos)
                   .setInfoOwnerAdjusted(lubBounds(symtypes map (_.bounds)))
               }
             }

src/compiler/scala/reflect/runtime/JavaToScala.scala

@@ -406,7 +406,7 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
     val tparams = new ListBuffer[Symbol]
     def targToScala(arg: jType): Type = arg match {
       case jwild: WildcardType =>
-        val tparam = owner.newExistential(NoPosition, newTypeName("T$" + tparams.length))
+        val tparam = owner.newExistential(newTypeName("T$" + tparams.length))
           .setInfo(TypeBounds(
             lub(jwild.getLowerBounds.toList map typeToScala),
             glb(jwild.getUpperBounds.toList map typeToScala map objToAny)))
@@ -467,9 +467,11 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
    *  @return A Scala value symbol that wraps all reflection info of `jfield`
    */
   private def jfieldAsScala(jfield: jField): Symbol = fieldCache.toScala(jfield) {
-    val field = sOwner(jfield).newValue(NoPosition, newTermName(jfield.getName))
-      .setFlag(toScalaFieldFlags(jfield.getModifiers) | JAVA)
-      .setInfo(typeToScala(jfield.getGenericType))
+    val field = (
+      sOwner(jfield)
+        newValue(newTermName(jfield.getName), NoPosition, toScalaFieldFlags(jfield.getModifiers))
+        setInfo typeToScala(jfield.getGenericType)
+    )
     fieldCache enter (jfield, field)
     copyAnnotations(field, jfield)
     field
@@ -487,8 +489,7 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
    */
   private def jmethodAsScala(jmeth: jMethod): Symbol = methodCache.toScala(jmeth) {
     val clazz = sOwner(jmeth)
-    val meth = clazz.newMethod(NoPosition, newTermName(jmeth.getName))
-      .setFlag(toScalaMethodFlags(jmeth.getModifiers) | JAVA)
+    val meth = clazz.newMethod(newTermName(jmeth.getName), NoPosition, toScalaMethodFlags(jmeth.getModifiers))
     methodCache enter (jmeth, meth)
     val tparams = jmeth.getTypeParameters.toList map createTypeParameter
     val paramtpes = jmeth.getGenericParameterTypes.toList map typeToScala
@@ -510,8 +511,7 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
   private def jconstrAsScala(jconstr: jConstructor[_]): Symbol = {
     // [Martin] Note: I know there's a lot of duplication wrt jmethodAsScala, but don't think it's worth it to factor this out.
     val clazz = sOwner(jconstr)
-    val constr = clazz.newMethod(NoPosition, nme.CONSTRUCTOR)
-      .setFlag(toScalaMethodFlags(jconstr.getModifiers) | JAVA)
+    val constr = clazz.newConstructor(NoPosition, toScalaMethodFlags(jconstr.getModifiers))
     constructorCache enter (jconstr, constr)
     val tparams = jconstr.getTypeParameters.toList map createTypeParameter
     val paramtpes = jconstr.getGenericParameterTypes.toList map typeToScala

src/compiler/scala/reflect/runtime/ToolBoxes.scala

@@ -41,9 +41,12 @@ trait ToolBoxes extends { self: Universe =>
       private def isFree(t: Tree) = t.isInstanceOf[Ident] && t.symbol.isInstanceOf[FreeVar]
 
       def typedTopLevelExpr(tree: Tree, pt: Type): Tree = {
-        val ownerClass = EmptyPackageClass.newClass(newTypeName("<expression-owner>"))
-        ownerClass.setInfo(new ClassInfoType(List(ObjectClass.tpe), newScope, ownerClass))
-        val owner = ownerClass.newLocalDummy(tree.pos)
+        // !!! Why is this is in the empty package? If it's only to make
+        // it inaccessible then please put it somewhere designed for that
+        // rather than polluting the empty package with synthetics.
+        val ownerClass = EmptyPackageClass.newClassWithInfo(newTypeName("<expression-owner>"), List(ObjectClass.tpe), newScope)
+        val owner      = ownerClass.newLocalDummy(tree.pos)
+
         typer.atOwner(tree, owner).typed(tree, analyzer.EXPRmode, pt)
       }
 

src/compiler/scala/tools/nsc/ast/TreeGen.scala

@@ -218,11 +218,7 @@ abstract class TreeGen extends reflect.internal.TreeGen {
    */
   private def mkPackedValDef(expr: Tree, owner: Symbol, name: Name): (ValDef, () => Ident) = {
     val packedType = typer.packedType(expr, owner)
-    val sym = (
-      owner.newValue(expr.pos.makeTransparent, name)
-      setFlag SYNTHETIC
-      setInfo packedType
-    )
+    val sym = owner.newValue(name, expr.pos.makeTransparent, SYNTHETIC) setInfo packedType
 
     (ValDef(sym, expr), () => Ident(sym) setPos sym.pos.focus setType expr.tpe)
   }

src/compiler/scala/tools/nsc/backend/jvm/GenAndroid.scala

@@ -34,9 +34,10 @@ trait GenAndroid {
 
   def addCreatorCode(codegen: BytecodeGenerator, block: BasicBlock) {
     import codegen._
-    val fieldSymbol = clasz.symbol.newValue(NoPosition, newTermName(fieldName))
-                        .setFlag(Flags.STATIC | Flags.FINAL)
-                        .setInfo(AndroidCreatorClass.tpe)
+    val fieldSymbol = (
+      clasz.symbol.newValue(newTermName(fieldName), NoPosition, Flags.STATIC | Flags.FINAL)
+        setInfo AndroidCreatorClass.tpe
+    )
     val methodSymbol = definitions.getMember(clasz.symbol.companionModule, fieldName)
     clasz addField new IField(fieldSymbol)
     block emit CALL_METHOD(methodSymbol, Static(false))

src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala

@@ -966,9 +966,7 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
           serialVUID foreach { value =>
             import Flags._, definitions._
             val fieldName = "serialVersionUID"
-            val fieldSymbol = clasz.symbol.newValue(NoPosition, newTermName(fieldName))
-                                .setFlag(STATIC | FINAL)
-                                .setInfo(longType)
+            val fieldSymbol = clasz.symbol.newValue(newTermName(fieldName), NoPosition, STATIC | FINAL) setInfo longType
             clasz addField new IField(fieldSymbol)
             lastBlock emit CONSTANT(Constant(value))
             lastBlock emit STORE_FIELD(fieldSymbol, true)

src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala

@@ -203,7 +203,7 @@ abstract class InlineExceptionHandlers extends SubComponent {
                   // Here we could create a single local for all exceptions of a certain type. TODO: try that.
                   val localName   = currentClass.cunit.freshTermName("exception$")
                   val localType   = exceptionType
-                  val localSymbol = bblock.method.symbol.newValue(NoPosition, localName).setInfo(localType.toType)
+                  val localSymbol = bblock.method.symbol.newValue(localName).setInfo(localType.toType)
                   val local       = new Local(localSymbol, localType, false)
 
                   bblock.method.addLocal(local)