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.

Author: paulp

src/compiler/scala/reflect/internal/Definitions.scala

@@ -16,14 +16,12 @@ trait Definitions extends reflect.api.StandardDefinitions {
 
   private def newClass(owner: Symbol, name: TypeName, parents: List[Type], flags: Long = 0L): Symbol = {
     val clazz = owner.newClassSymbol(name, NoPosition, flags)
-    clazz setInfo ClassInfoType(parents, new Scope, clazz)
-    owner.info.decls enter clazz
+    clazz setInfoAndEnter ClassInfoType(parents, new Scope, clazz)
   }
   private def newMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type, flags: Long = 0L): Symbol = {
     val msym   = owner.newMethod(name.encode, NoPosition, flags)
     val params = msym.newSyntheticValueParams(formals)
-    msym setInfo MethodType(params, restpe)
-    owner.info.decls enter msym
+    msym setInfoAndEnter MethodType(params, restpe)
   }
 
   // the scala value classes
@@ -130,7 +128,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
     // the source level, but _root_ is essentially a function () => <root>.
     lazy val RootPackage: Symbol = {
       val rp = (
-        NoSymbol.newValue(nme.ROOTPKG, flags = FINAL | MODULE | PACKAGE | JAVA)
+        NoSymbol.newValue(nme.ROOTPKG, NoPosition, FINAL | MODULE | PACKAGE | JAVA)
           setInfo NullaryMethodType(RootClass.tpe)
       )
       RootClass.sourceModule = rp
@@ -139,11 +137,11 @@ trait Definitions extends reflect.api.StandardDefinitions {
 
     // This is the actual root of everything, including the package _root_.
     lazy val RootClass: ModuleClassSymbol = (
-      NoSymbol.newModuleClassSymbol(tpnme.ROOT, flags = FINAL | MODULE | PACKAGE | JAVA)
+      NoSymbol.newModuleClassSymbol(tpnme.ROOT, NoPosition, FINAL | MODULE | PACKAGE | JAVA)
         setInfo rootLoader
     )
     // The empty package, which holds all top level types without given packages.
-    lazy val EmptyPackage       = RootClass.newPackage(nme.EMPTY_PACKAGE_NAME, flags = FINAL)
+    lazy val EmptyPackage       = RootClass.newPackage(nme.EMPTY_PACKAGE_NAME, NoPosition, FINAL)
     lazy val EmptyPackageClass  = EmptyPackage.moduleClass
 
     lazy val JavaLangPackage      = getModule(sn.JavaLang)
@@ -208,8 +206,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
     sealed abstract class BottomClassSymbol(name: TypeName, parent: Symbol) extends ClassSymbol(ScalaPackageClass, NoPosition, name) {
       locally {
         this initFlags ABSTRACT | TRAIT | FINAL
-        this setInfo ClassInfoType(List(parent.tpe), new Scope, this)
-        owner.info.decls enter this
+        this setInfoAndEnter ClassInfoType(List(parent.tpe), new Scope, this)
       }
       final override def isBottomClass = true
     }
@@ -829,12 +826,8 @@ trait Definitions extends reflect.api.StandardDefinitions {
           ClassInfoType(List(AnyRefClass.tpe, p), new Scope, clazz)))
     }
 
-    private def newAlias(owner: Symbol, name: TypeName, alias: Type): Symbol = {
-      val tpsym = owner.newAliasType(name)
-      tpsym.setInfo(alias)
-      owner.info.decls.enter(tpsym)
-      tpsym
-    }
+    private def newAlias(owner: Symbol, name: TypeName, alias: Type): Symbol =
+      owner.newAliasType(name) setInfoAndEnter alias
 
     /** tcon receives the type parameter symbol as argument */
     private def newPolyMethod(owner: Symbol, name: TermName, tcon: Symbol => Type): Symbol =

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

@@ -44,18 +44,18 @@ 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.
    */
   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,20 +283,20 @@ 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)
 
     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 = {