Reimplemented Modifer.

Couldn't live with a scala.Enumeration being a permanent
fixture in the reflection library.  Rolled it by hand.

8 files changed, 94 insertions, 44 deletions

diff --git a/src/compiler/scala/reflect/internal/Flags.scala b/src/compiler/scala/reflect/internal/Flags.scala
index 66af92be5f..aa696bc6e8 100644
--- a/src/compiler/scala/reflect/internal/Flags.scala
+++ b/src/compiler/scala/reflect/internal/Flags.scala
@@ -466,7 +466,7 @@ class Flags extends ModifierFlags {
   }
   protected final val rawFlagPickledOrder: Array[Long] = pickledListOrder.toArray
 
-  def flagOfModifier(mod: Modifier.Value): Long = mod match {
+  def flagOfModifier(mod: Modifier): Long = mod match {
     case Modifier.`protected` => PROTECTED
     case Modifier.`private` => PRIVATE
     case Modifier.`override` => OVERRIDE
@@ -496,13 +496,13 @@ class Flags extends ModifierFlags {
     case Modifier.bynameParameter => BYNAMEPARAM
   }
 
-  def flagsOfModifiers(mods: List[Modifier.Value]): Long =
+  def flagsOfModifiers(mods: List[Modifier]): Long =
     (mods :\ 0L) { (mod, curr) => curr | flagOfModifier(mod) }
 
-  def modifierOfFlag(flag: Long): Option[Modifier.Value] =
+  def modifierOfFlag(flag: Long): Option[Modifier] =
     Modifier.values find { mod => flagOfModifier(mod) == flag }
 
-  def modifiersOfFlags(flags: Long): List[Modifier.Value] =
+  def modifiersOfFlags(flags: Long): List[Modifier] =
     pickledListOrder map (mask => modifierOfFlag(flags & mask)) flatMap { mod => mod }
 }
 
diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala
index e777491300..b9ba269ee3 100644
--- a/src/compiler/scala/reflect/internal/Symbols.scala
+++ b/src/compiler/scala/reflect/internal/Symbols.scala
@@ -103,12 +103,12 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     def pos = rawpos
     def setPos(pos: Position): this.type = { this.rawpos = pos; this }
 
-    override def hasModifier(mod: Modifier.Value) =
+    override def hasModifier(mod: Modifier) =
       hasFlag(flagOfModifier(mod)) &&
       (!(mod == Modifier.bynameParameter) || isTerm) &&
       (!(mod == Modifier.covariant) || isType)
 
-    override def allModifiers: Set[Modifier.Value] =
+    override def allModifiers: Set[Modifier] =
       Modifier.values filter hasModifier
 
 // ------ creators -------------------------------------------------------------------
diff --git a/src/compiler/scala/reflect/internal/Trees.scala b/src/compiler/scala/reflect/internal/Trees.scala
index 076a7722ae..f982c93656 100644
--- a/src/compiler/scala/reflect/internal/Trees.scala
+++ b/src/compiler/scala/reflect/internal/Trees.scala
@@ -72,9 +72,9 @@ trait Trees extends api.Trees { self: SymbolTable =>
     def withPosition(flag: Long, position: Position) =
       copy() setPositions positions + (flag -> position)
 
-    override def hasModifier(mod: Modifier.Value) =
+    override def hasModifier(mod: Modifier) =
       hasFlag(flagOfModifier(mod))
-    override def allModifiers: Set[Modifier.Value] =
+    override def allModifiers: Set[Modifier] =
       Modifier.values filter hasModifier
     override def mapAnnotations(f: List[Tree] => List[Tree]): Modifiers =
       Modifiers(flags, privateWithin, f(annotations)) setPositions positions
@@ -85,7 +85,7 @@ trait Trees extends api.Trees { self: SymbolTable =>
   def Modifiers(flags: Long, privateWithin: Name): Modifiers = Modifiers(flags, privateWithin, List())
   def Modifiers(flags: Long): Modifiers = Modifiers(flags, tpnme.EMPTY)
 
-  def Modifiers(mods: Set[Modifier.Value],
+  def Modifiers(mods: Set[Modifier],
                 privateWithin: Name,
                 annotations: List[Tree]): Modifiers = {
     val flagSet = mods map flagOfModifier
diff --git a/src/compiler/scala/tools/nsc/ast/ReifyPrinters.scala b/src/compiler/scala/tools/nsc/ast/ReifyPrinters.scala
index aebde18703..98135fadda 100644
--- a/src/compiler/scala/tools/nsc/ast/ReifyPrinters.scala
+++ b/src/compiler/scala/tools/nsc/ast/ReifyPrinters.scala
@@ -18,16 +18,6 @@ trait ReifyPrinters { self: NodePrinters =>
   object reifiedNodeToString extends Function1[Tree, String] {
     def apply(tree: Tree): String = {
       import scala.reflect.api.Modifier
-      import scala.reflect.api.Modifier._
-
-      def copypasteModifier(mod: Modifier.Value): String = mod match {
-        case mod @ (
-             `protected` | `private` | `override` |
-             `abstract` | `final` | `sealed` |
-             `implicit` | `lazy` | `macro` |
-             `case` | `trait`) => "`" + mod.toString + "`"
-        case mod => mod.toString
-      }
 
       // @PP: I fervently hope this is a test case or something, not anything being
       // depended upon.  Of more fragile code I cannot conceive.
@@ -47,7 +37,7 @@ trait ReifyPrinters { self: NodePrinters =>
           val buf = new StringBuilder
 
           val flags = m.group(1).toLong
-          val s_flags = Flags.modifiersOfFlags(flags) map copypasteModifier mkString ", "
+          val s_flags = Flags.modifiersOfFlags(flags) map (_.sourceString) mkString ", "
           if (s_flags != "")
             buf.append("Set(" + s_flags + ")")
 
@@ -63,7 +53,7 @@ trait ReifyPrinters { self: NodePrinters =>
         })
         s = """setInternalFlags\((\d+)L\)""".r.replaceAllIn(s, m => {
           val flags = m.group(1).toLong
-          val mods = Flags.modifiersOfFlags(flags) map copypasteModifier
+          val mods = Flags.modifiersOfFlags(flags) map (_.sourceString)
           "setInternalFlags(flagsOfModifiers(List(" + mods.mkString(", ") + ")))"
         })
 
diff --git a/src/library/scala/reflect/api/Modifier.scala b/src/library/scala/reflect/api/Modifier.scala
index 8569b103cf..c0123ed955 100644
--- a/src/library/scala/reflect/api/Modifier.scala
+++ b/src/library/scala/reflect/api/Modifier.scala
@@ -1,11 +1,82 @@
 package scala.reflect.api
 
-object Modifier extends Enumeration {
+import collection.{ immutable, mutable }
 
-   val `protected`, `private`, `override`, `abstract`, `final`,
-        `sealed`, `implicit`, `lazy`, `macro`, `case`, `trait`,
-        deferred, interface, mutable, parameter, covariant, contravariant,
-        preSuper, abstractOverride, local, java, static, caseAccessor,
-        defaultParameter, defaultInit, paramAccessor, bynameParameter = Value
+sealed abstract class Modifier {
+  def name: String
+  def isKeyword: Boolean
+  def sourceString: String = if (isKeyword) "`" + name + "`" else name
 
+  override def equals(that: Any) = this eq that.asInstanceOf[AnyRef]
+  override def hashCode = name.hashCode
+  override def toString = name
+}
+final class SymbolModifier private (val name: String, val isKeyword: Boolean) extends Modifier {
+  def this(name: String) = this(name, false)
+}
+final class SourceModifier private (val name: String) extends Modifier {
+  def isKeyword = true
+}
+
+object SymbolModifier {
+  private val seen = mutable.ListBuffer[SymbolModifier]()
+  private[api] def apply(name: String): SymbolModifier = {
+    val mod = name match {
+      case "case" | "trait" => new SymbolModifier(name, isKeyword = true)
+      case _                => new SymbolModifier(name)
+    }
+    seen += mod
+    mod
+  }
+  private[api] def all = seen.toList
+}
+object SourceModifier {
+  private val seen = mutable.ListBuffer[SourceModifier]()
+  private[api] def apply(name: String): SourceModifier = {
+    val mod = new SourceModifier(name)
+    seen += mod
+    mod
+  }
+  private[api] def all = seen.toList
+}
+
+object Modifier extends immutable.Set[Modifier] {
+  val `abstract`       = SourceModifier("abstract")
+  val `final`          = SourceModifier("final")
+  val `implicit`       = SourceModifier("implicit")
+  val `lazy`           = SourceModifier("lazy")
+  val `macro`          = SourceModifier("macro")
+  val `override`       = SourceModifier("override")
+  val `private`        = SourceModifier("private")
+  val `protected`      = SourceModifier("protected")
+  val `sealed`         = SourceModifier("sealed")
+
+  val `case`           = SymbolModifier("case")
+  val `trait`          = SymbolModifier("trait")
+  val abstractOverride = SymbolModifier("abstractOverride")
+  val bynameParameter  = SymbolModifier("bynameParameter")
+  val caseAccessor     = SymbolModifier("caseAccessor")
+  val contravariant    = SymbolModifier("contravariant")
+  val covariant        = SymbolModifier("covariant")
+  val defaultInit      = SymbolModifier("defaultInit")
+  val defaultParameter = SymbolModifier("defaultParameter")
+  val deferred         = SymbolModifier("deferred")
+  val interface        = SymbolModifier("interface")
+  val java             = SymbolModifier("java")
+  val local            = SymbolModifier("local")
+  val mutable          = SymbolModifier("mutable")
+  val paramAccessor    = SymbolModifier("paramAccessor")
+  val parameter        = SymbolModifier("parameter")
+  val preSuper         = SymbolModifier("preSuper")
+  val static           = SymbolModifier("static")
+  
+  val sourceModifiers: Set[SourceModifier] = SourceModifier.all.toSet
+  val symbolModifiers: Set[SymbolModifier] = SymbolModifier.all.toSet
+  val allModifiers: Set[Modifier]          = sourceModifiers ++ symbolModifiers
+  def values                               = allModifiers
+
+  def contains(key: Modifier) = allModifiers(key)
+  def iterator                = allModifiers.iterator
+  def -(elem: Modifier)       = allModifiers - elem
+  def +(elem: Modifier)       = allModifiers + elem
 }
diff --git a/src/library/scala/reflect/api/Symbols.scala b/src/library/scala/reflect/api/Symbols.scala
index 17d9b06324..65a3680fdd 100755
--- a/src/library/scala/reflect/api/Symbols.scala
+++ b/src/library/scala/reflect/api/Symbols.scala
@@ -9,11 +9,11 @@ trait Symbols { self: Universe =>
 
     /** The modifiers of this symbol
      */
-    def allModifiers: Set[Modifier.Value]
+    def allModifiers: Set[Modifier]
 
     /** Does this symbol have given modifier?
      */
-    def hasModifier(mod: Modifier.Value): Boolean
+    def hasModifier(mod: Modifier): Boolean
 
     /** The owner of this symbol. This is the symbol
      *  that directly contains the current symbol's definition.
diff --git a/src/library/scala/reflect/api/TreePrinters.scala b/src/library/scala/reflect/api/TreePrinters.scala
index 88ef450ed9..70a100015b 100644
--- a/src/library/scala/reflect/api/TreePrinters.scala
+++ b/src/library/scala/reflect/api/TreePrinters.scala
@@ -31,17 +31,6 @@ trait TreePrinters { self: Universe =>
   // emits more or less verbatim representation of the provided tree
   // todo. when LiftCode becomes a macro, throw this code away and use that macro
   class RawTreePrinter(out: PrintWriter) extends TreePrinter {
-    import scala.reflect.api.Modifier
-    import scala.reflect.api.Modifier._
-
-    def copypasteModifier(mod: Modifier.Value): String = mod match {
-      case mod @ (
-           `protected` | `private` | `override` |
-           `abstract` | `final` | `sealed` |
-           `implicit` | `lazy` | `macro` |
-           `case` | `trait`) => "`" + mod.toString + "`"
-      case mod => mod.toString
-    }
 
     def print(args: Any*): Unit = args foreach {
       case EmptyTree =>
@@ -77,7 +66,7 @@ trait TreePrinters { self: Universe =>
         print(")")
       case mods: Modifiers =>
         val parts = collection.mutable.ListBuffer[String]() 
-        parts += "Set(" + mods.allModifiers.map{copypasteModifier}.mkString(", ") + ")"
+        parts += "Set(" + mods.allModifiers.map(_.sourceString).mkString(", ") + ")"
         parts += "newTypeName(\"" + mods.privateWithin.toString + "\")"
         parts += "List(" + mods.annotations.map{showRaw}.mkString(", ") + ")"
         
diff --git a/src/library/scala/reflect/api/Trees.scala b/src/library/scala/reflect/api/Trees.scala
index b8b32477dd..3b48a02949 100644
--- a/src/library/scala/reflect/api/Trees.scala
+++ b/src/library/scala/reflect/api/Trees.scala
@@ -16,14 +16,14 @@ trait Trees { self: Universe =>
   type Modifiers <: AbsModifiers
 
   abstract class AbsModifiers {
-    def hasModifier(mod: Modifier.Value): Boolean
-    def allModifiers: Set[Modifier.Value]
+    def hasModifier(mod: Modifier): Boolean
+    def allModifiers: Set[Modifier]
     def privateWithin: Name  // default: EmptyTypeName
     def annotations: List[Tree] // default: List()
     def mapAnnotations(f: List[Tree] => List[Tree]): Modifiers
   }
 
-  def Modifiers(mods: Set[Modifier.Value] = Set(),
+  def Modifiers(mods: Set[Modifier] = Set(),
                 privateWithin: Name = EmptyTypeName,
                 annotations: List[Tree] = List()): Modifiers