Putting some of the symbol potential to work.

Renamed the parameter to all the newXXX symbol creators to "newFlags"
because I've seen too many bugs which arose from having a parameter name
which shadows a field and where mistakes can inflict subtle bugs which
won't be found until much later (yes I'm trying to describe "flags" right
now.) Opportunistically cleaned up some symbol creations.

1 files changed, 65 insertions, 58 deletions

diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala
index df6720d497..1b9ff54141 100644
--- a/src/compiler/scala/reflect/internal/Symbols.scala
+++ b/src/compiler/scala/reflect/internal/Symbols.scala
@@ -44,8 +44,8 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
   }
   /** Create a new free variable.  Its owner is NoSymbol.
    */
-  def newFreeVar(name: TermName, tpe: Type, value: Any, flags: Long = 0L): FreeVar =
-    new FreeVar(name, value) initFlags flags setInfo tpe
+  def newFreeVar(name: TermName, tpe: Type, value: Any, newFlags: Long = 0L): FreeVar =
+    new FreeVar(name, value) initFlags newFlags setInfo tpe
 
   /** The original owner of a class. Used by the backend to generate
    *  EnclosingMethod attributes.
@@ -53,9 +53,9 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
   val originalOwner = perRunCaches.newMap[Symbol, Symbol]()
 
   abstract class AbsSymbolImpl extends AbsSymbol { this: Symbol =>
-    def newNestedSymbol(name: Name, pos: Position, flags: Long) = name match {
-      case n: TermName => newTermSymbol(n, pos, flags)
-      case n: TypeName => newTypeSymbol(n, pos, flags)
+    def newNestedSymbol(name: Name, pos: Position, newFlags: Long) = name match {
+      case n: TermName => newTermSymbol(n, pos, newFlags)
+      case n: TypeName => newTypeSymbol(n, pos, newFlags)
     }
     def typeSig: Type = info
     def typeSigIn(site: Type): Type = site.memberInfo(this)
@@ -99,24 +99,24 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
 // ------ creators -------------------------------------------------------------------
 
-    final def newValue(name: TermName, pos: Position = NoPosition, flags: Long = 0L): TermSymbol =
-      newTermSymbol(name, pos, flags)
-    final def newVariable(name: TermName, pos: Position = NoPosition, flags: Long = 0L): TermSymbol =
-      newTermSymbol(name, pos, MUTABLE | flags)
-    final def newValueParameter(name: TermName, pos: Position = NoPosition, flags: Long = 0L): TermSymbol =
-      newTermSymbol(name, pos, PARAM | flags)
+    final def newValue(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): TermSymbol =
+      newTermSymbol(name, pos, newFlags)
+    final def newVariable(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): TermSymbol =
+      newTermSymbol(name, pos, MUTABLE | newFlags)
+    final def newValueParameter(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): TermSymbol =
+      newTermSymbol(name, pos, PARAM | newFlags)
 
     /** Create local dummy for template (owner of local blocks) */
     final def newLocalDummy(pos: Position) =
       newTermSymbol(nme.localDummyName(this), pos) setInfo NoType
-    final def newMethod(name: TermName, pos: Position = NoPosition, flags: Long = 0L): MethodSymbol =
-      newMethodSymbol(name, pos, METHOD | flags)
+    final def newMethod(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): MethodSymbol =
+      newMethodSymbol(name, pos, METHOD | newFlags)
     final def newLabel(name: TermName, pos: Position = NoPosition): MethodSymbol =
       newMethod(name, pos, LABEL)
 
     /** Propagates ConstrFlags (JAVA, specifically) from owner to constructor. */
-    final def newConstructor(pos: Position, flags: Long = 0L) =
-      newMethod(nme.CONSTRUCTOR, pos, getFlag(ConstrFlags) | flags)
+    final def newConstructor(pos: Position, newFlags: Long = 0L) =
+      newMethod(nme.CONSTRUCTOR, pos, getFlag(ConstrFlags) | newFlags)
 
     /** Static constructor with info set. */
     def newStaticConstructor(pos: Position) =
@@ -131,19 +131,19 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       if (isPackage || !settings.overrideObjects.value) MODULE | FINAL
       else MODULE
     )
-    def newLinkedModule(clazz: Symbol, flags: Long = 0L): ModuleSymbol = {
-      val m = newModuleSymbol(clazz.name.toTermName, clazz.pos, ModuleFlags | flags)
+    def newLinkedModule(clazz: Symbol, newFlags: Long = 0L): ModuleSymbol = {
+      val m = newModuleSymbol(clazz.name.toTermName, clazz.pos, ModuleFlags | newFlags)
       connectModuleToClass(m, clazz.asInstanceOf[ClassSymbol])
     }
-    final def newModule(name: TermName, pos: Position = NoPosition, flags: Long = 0L): ModuleSymbol = {
-      val m     = newModuleSymbol(name, pos, flags | ModuleFlags)
+    final def newModule(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): ModuleSymbol = {
+      val m     = newModuleSymbol(name, pos, newFlags | ModuleFlags)
       val clazz = newModuleClassSymbol(name.toTypeName, pos, (m getFlag ModuleToClassFlags) | MODULE)
       connectModuleToClass(m, clazz)
     }
 
-    final def newPackage(name: TermName, pos: Position = NoPosition, flags: Long = 0L): ModuleSymbol = {
+    final def newPackage(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): ModuleSymbol = {
       assert(name == nme.ROOT || isPackageClass, this)
-      newModule(name, pos, JAVA | PACKAGE | flags)
+      newModule(name, pos, JAVA | PACKAGE | newFlags)
     }
     final def newThisSym(pos: Position) =
       newTermSymbol(nme.this_, pos, SYNTHETIC)
@@ -153,41 +153,41 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     /** Direct symbol factories.
      *  For internal use; these are unlikely to be what you want.
      */
-    def newTermSymbol(name: TermName, pos: Position = NoPosition, flags: Long = 0L): TermSymbol =
-      new TermSymbol(this, pos, name) initFlags flags
+    def newTermSymbol(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): TermSymbol =
+      new TermSymbol(this, pos, name) initFlags newFlags
   
-    def newAbstractTypeSymbol(name: TypeName, pos: Position = NoPosition, flags: Long = 0L): AbstractTypeSymbol =
-      new AbstractTypeSymbol(this, pos, name) initFlags flags
+    def newAbstractTypeSymbol(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): AbstractTypeSymbol =
+      new AbstractTypeSymbol(this, pos, name) initFlags newFlags
     
-    def newAliasTypeSymbol(name: TypeName, pos: Position = NoPosition, flags: Long = 0L): AliasTypeSymbol =
-      new AliasTypeSymbol(this, pos, name) initFlags flags
+    def newAliasTypeSymbol(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): AliasTypeSymbol =
+      new AliasTypeSymbol(this, pos, name) initFlags newFlags
 
-    def newModuleSymbol(name: TermName, pos: Position = NoPosition, flags: Long = 0L): ModuleSymbol =
-      new ModuleSymbol(this, pos, name) initFlags flags
+    def newModuleSymbol(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): ModuleSymbol =
+      new ModuleSymbol(this, pos, name) initFlags newFlags
 
-    def newMethodSymbol(name: TermName, pos: Position = NoPosition, flags: Long = 0L): MethodSymbol =
-      new MethodSymbol(this, pos, name) initFlags flags
+    def newMethodSymbol(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): MethodSymbol =
+      new MethodSymbol(this, pos, name) initFlags newFlags
 
-    def newClassSymbol(name: TypeName, pos: Position = NoPosition, flags: Long = 0L): ClassSymbol =
-      new ClassSymbol(this, pos, name) initFlags flags
+    def newClassSymbol(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): ClassSymbol =
+      new ClassSymbol(this, pos, name) initFlags newFlags
       
-    def newModuleClassSymbol(name: TypeName, pos: Position = NoPosition, flags: Long = 0L): ModuleClassSymbol =
-      new ModuleClassSymbol(this, pos, name) initFlags flags
+    def newModuleClassSymbol(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): ModuleClassSymbol =
+      new ModuleClassSymbol(this, pos, name) initFlags newFlags
   
     /** Derive whether it is an abstract type from the flags; after creation
      *  the DEFERRED flag will be ignored.
      */
-    def newTypeSymbol(name: TypeName, pos: Position = NoPosition, flags: Long = 0L): TypeSymbol =
-      if ((flags & DEFERRED) == 0L)
-        newAliasTypeSymbol(name, pos, flags)
+    def newTypeSymbol(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): TypeSymbol =
+      if ((newFlags & DEFERRED) == 0L)
+        newAliasTypeSymbol(name, pos, newFlags)
       else
-        newAbstractTypeSymbol(name, pos, flags)
+        newAbstractTypeSymbol(name, pos, newFlags)
     
-    def newTypeSkolemSymbol(name: TypeName, origin: AnyRef, pos: Position = NoPosition, flags: Long = 0L): TypeSkolem =
-      if ((flags & DEFERRED) == 0L)
-        new TypeSkolem(this, pos, name, origin) initFlags flags
+    def newTypeSkolemSymbol(name: TypeName, origin: AnyRef, pos: Position = NoPosition, newFlags: Long = 0L): TypeSkolem =
+      if ((newFlags & DEFERRED) == 0L)
+        new TypeSkolem(this, pos, name, origin) initFlags newFlags
       else
-        new TypeSkolem(this, pos, name, origin) with AbstractTypeMixin initFlags flags
+        new TypeSkolem(this, pos, name, origin) with AbstractTypeMixin initFlags newFlags
 
     /** @param pre   type relative to which alternatives are seen.
      *  for instance:
@@ -228,18 +228,18 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
     /** Symbol of a type definition  type T = ...
      */
-    final def newAliasType(name: TypeName, pos: Position = NoPosition, flags: Long = 0L): Symbol =
-      newAliasTypeSymbol(name, pos, flags)
+    final def newAliasType(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): Symbol =
+      newAliasTypeSymbol(name, pos, newFlags)
       
     /** Symbol of an abstract type  type T >: ... <: ...
      */
-    final def newAbstractType(name: TypeName, pos: Position = NoPosition, flags: Long = 0L): Symbol =
-      newAbstractTypeSymbol(name, pos, DEFERRED | flags)
+    final def newAbstractType(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): Symbol =
+      newAbstractTypeSymbol(name, pos, DEFERRED | newFlags)
 
     /** Symbol of a type parameter
      */
-    final def newTypeParameter(name: TypeName, pos: Position = NoPosition, flags: Long = 0L) =
-      newAbstractType(name, pos, PARAM | flags)
+    final def newTypeParameter(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L) =
+      newAbstractType(name, pos, PARAM | newFlags)
 
     /** Synthetic value parameters when parameter symbols are not available
      */
@@ -257,8 +257,8 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       skolem setInfo (basis.info cloneInfo skolem)
     }
 
-    final def newExistential(name: TypeName, pos: Position = NoPosition, flags: Long = 0L): Symbol =
-      newAbstractType(name, pos, EXISTENTIAL | flags)
+    final def newExistential(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): Symbol =
+      newAbstractType(name, pos, EXISTENTIAL | newFlags)
 
     final def freshExistential(suffix: String): Symbol =
       newExistential(freshExistentialName(suffix), pos)
@@ -283,8 +283,8 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     final def newTypeSkolem: Symbol =
       owner.newTypeSkolemSymbol(name.toTypeName, this, pos, flags)
 
-    final def newClass(name: TypeName, pos: Position = NoPosition) =
-      newClassSymbol(name, pos)
+    final def newClass(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L) =
+      newClassSymbol(name, pos, newFlags)
 
     final def newModuleClass(name: TypeName, pos: Position = NoPosition) =
       newModuleClassSymbol(name, pos)
@@ -292,11 +292,11 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     final def newAnonymousClass(pos: Position) =
       newClassSymbol(tpnme.ANON_CLASS_NAME, pos)
 
-    final def newAnonymousFunctionClass(pos: Position, flags: Long = 0L) =
-      newClassSymbol(tpnme.ANON_FUN_NAME, pos, FINAL | SYNTHETIC | flags)
+    final def newAnonymousFunctionClass(pos: Position, newFlags: Long = 0L) =
+      newClassSymbol(tpnme.ANON_FUN_NAME, pos, FINAL | SYNTHETIC | newFlags)
 
-    final def newAnonymousFunctionValue(pos: Position, flags: Long = 0L) =
-      newTermSymbol(nme.ANON_FUN_NAME, pos, SYNTHETIC | flags) setInfo NoType
+    final def newAnonymousFunctionValue(pos: Position, newFlags: Long = 0L) =
+      newTermSymbol(nme.ANON_FUN_NAME, pos, SYNTHETIC | newFlags) setInfo NoType
 
     /** Refinement types P { val x: String; type T <: Number }
      *  also have symbols, they are refinementClasses
@@ -307,7 +307,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     /** Create a new getter for current symbol (which must be a field)
      */
     final def newGetter: Symbol = (
-      owner.newMethod(nme.getterName(name.toTermName), flags = getterFlags(flags))
+      owner.newMethod(nme.getterName(name.toTermName), NoPosition, getterFlags(flags))
         setPrivateWithin privateWithin
         setInfo MethodType(Nil, tpe)
     )
@@ -1002,6 +1002,13 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     /** Substitute second list of symbols for first in current info. */
     def substInfo(syms0: List[Symbol], syms1: List[Symbol]) = modifyInfo(_.substSym(syms0, syms1))
     def setInfoOwnerAdjusted(info: Type): this.type         = setInfo(info atOwner this)
+    
+    /** Set the info and enter this symbol into the owner's scope. */
+    def setInfoAndEnter(info: Type): this.type = {
+      setInfo(info)
+      owner.info.decls enter this
+      this
+    }
 
     /** Set new info valid from start of this phase. */
     final def updateInfo(info: Type): Symbol = {