Minor, mostly agreed upon changes to reflection...

Minor, mostly agreed upon changes to reflection api, review by odersky.

7 files changed, 54 insertions, 58 deletions

diff --git a/src/compiler/scala/reflect/api/Names.scala b/src/compiler/scala/reflect/api/Names.scala
index 76e50497de..0ba5ad28f0 100755
--- a/src/compiler/scala/reflect/api/Names.scala
+++ b/src/compiler/scala/reflect/api/Names.scala
@@ -14,17 +14,9 @@ trait Names {
     def toTypeName: TypeName
   }
 
-  def newTermName(cs: Array[Char], offset: Int, len: Int): TermName
-  def newTermName(cs: Array[Byte], offset: Int, len: Int): TermName
   def newTermName(s: String): TermName
-
-  def newTypeName(cs: Array[Char], offset: Int, len: Int): TypeName
-  def newTypeName(cs: Array[Byte], offset: Int, len: Int): TypeName
   def newTypeName(s: String): TypeName
 
-  implicit def promoteTermNamesAsNecessary(name: Name): TermName = name.toTermName
-
   def EmptyTermName: TermName = newTermName("")
   def EmptyTypeName: TypeName = EmptyTermName.toTypeName
 }
-
diff --git a/src/compiler/scala/reflect/api/StandardDefinitions.scala b/src/compiler/scala/reflect/api/StandardDefinitions.scala
index fd76245ea8..6b480ab83d 100755
--- a/src/compiler/scala/reflect/api/StandardDefinitions.scala
+++ b/src/compiler/scala/reflect/api/StandardDefinitions.scala
@@ -11,9 +11,10 @@ trait StandardDefinitions { self: Universe =>
   val definitions: AbsDefinitions
 
   abstract class AbsDefinitions {
-
     // outer packages and their classes
-    def RootPackage: Symbol
+    // Under consideration
+    // def RootPackage: Symbol
+
     def RootClass: Symbol
     def EmptyPackage: Symbol
     def EmptyPackageClass: Symbol
diff --git a/src/compiler/scala/reflect/api/Symbols.scala b/src/compiler/scala/reflect/api/Symbols.scala
index d13d0b40eb..c841417209 100755
--- a/src/compiler/scala/reflect/api/Symbols.scala
+++ b/src/compiler/scala/reflect/api/Symbols.scala
@@ -125,22 +125,25 @@ trait Symbols { self: Universe =>
     def isAliasType    : Boolean
     def isAbstractType : Boolean
 
-    def isAbstractClass: Boolean
-    def isBridge       : Boolean
-    def isContravariant: Boolean
-    def isCovariant    : Boolean
-    def isEarlyInitialized  : Boolean
-    def isExistentiallyBound: Boolean
-    def isImplClass    : Boolean
-    def isLazyAccessor : Boolean
-    def isMethod       : Boolean
-    def isVarargsMethod: Boolean
-    def isModule       : Boolean
-    def isModuleClass  : Boolean
-    def isOverloaded   : Boolean
-    def isRefinementClass: Boolean
-    def isSourceMethod : Boolean
-    def isTypeParameter: Boolean
+    def isAbstractClass      : Boolean
+    def isBridge             : Boolean
+    def isConcreteClass      : Boolean
+    def isContravariant      : Boolean
+    def isCovariant          : Boolean
+    def isEarlyInitialized   : Boolean
+    def isExistentiallyBound : Boolean
+    def isImplClass          : Boolean
+    def isLazyAccessor       : Boolean
+    def isMethod             : Boolean
+    def isModule             : Boolean
+    def isModuleClass        : Boolean
+    def isNumericValueClass  : Boolean
+    def isOverloaded         : Boolean
+    def isRefinementClass    : Boolean
+    def isSourceMethod       : Boolean
+    def isTypeParameter      : Boolean
+    def isValueClass         : Boolean
+    def isVarargsMethod      : Boolean
 
     /** Package tests */
     def isPackage      : Boolean
@@ -149,10 +152,7 @@ trait Symbols { self: Universe =>
     def isRoot         : Boolean
     def isEmptyPackage : Boolean
     def isEmptyPackageClass: Boolean
-
   }
 
   val NoSymbol: Symbol
 }
-
-
diff --git a/src/compiler/scala/reflect/api/Trees.scala b/src/compiler/scala/reflect/api/Trees.scala
index 3374b38b51..5401962ea6 100644
--- a/src/compiler/scala/reflect/api/Trees.scala
+++ b/src/compiler/scala/reflect/api/Trees.scala
@@ -721,15 +721,15 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
     def PackageDef(tree: Tree, pid: RefTree, stats: List[Tree]) =
       new PackageDef(pid, stats).copyAttrs(tree)
     def ModuleDef(tree: Tree, mods: Modifiers, name: Name, impl: Template) =
-      new ModuleDef(mods, name, impl).copyAttrs(tree)
+      new ModuleDef(mods, name.toTermName, impl).copyAttrs(tree)
     def ValDef(tree: Tree, mods: Modifiers, name: Name, tpt: Tree, rhs: Tree) =
-      new ValDef(mods, name, tpt, rhs).copyAttrs(tree)
+      new ValDef(mods, name.toTermName, tpt, rhs).copyAttrs(tree)
     def DefDef(tree: Tree, mods: Modifiers, name: Name, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree) =
-      new DefDef(mods, name, tparams, vparamss, tpt, rhs).copyAttrs(tree)
+      new DefDef(mods, name.toTermName, tparams, vparamss, tpt, rhs).copyAttrs(tree)
     def TypeDef(tree: Tree, mods: Modifiers, name: Name, tparams: List[TypeDef], rhs: Tree) =
       new TypeDef(mods, name.toTypeName, tparams, rhs).copyAttrs(tree)
     def LabelDef(tree: Tree, name: Name, params: List[Ident], rhs: Tree) =
-      new LabelDef(name, params, rhs).copyAttrs(tree)
+      new LabelDef(name.toTermName, params, rhs).copyAttrs(tree)
     def Import(tree: Tree, expr: Tree, selectors: List[ImportSelector]) =
       new Import(expr, selectors).copyAttrs(tree)
     def Template(tree: Tree, parents: List[Tree], self: ValDef, body: List[Tree]) =
diff --git a/src/compiler/scala/reflect/internal/Flags.scala b/src/compiler/scala/reflect/internal/Flags.scala
index f6cfb6680f..201a960ec7 100644
--- a/src/compiler/scala/reflect/internal/Flags.scala
+++ b/src/compiler/scala/reflect/internal/Flags.scala
@@ -216,7 +216,6 @@ class Flags extends ModifierFlags {
   final val notPRIVATE    = (PRIVATE: Long) << AntiShift
   final val notPROTECTED  = (PROTECTED: Long) << AntiShift
 
-
   // ------- masks -----------------------------------------------------------------------
 
   /** These flags can be set when class or module symbol is first created. */
diff --git a/src/compiler/scala/reflect/internal/Names.scala b/src/compiler/scala/reflect/internal/Names.scala
index 4bfc0acfa2..ae5024a44b 100644
--- a/src/compiler/scala/reflect/internal/Names.scala
+++ b/src/compiler/scala/reflect/internal/Names.scala
@@ -16,6 +16,7 @@ import java.security.MessageDigest
  *  @version 1.0, 05/02/2005
  */
 trait Names extends api.Names {
+  implicit def promoteTermNamesAsNecessary(name: Name): TermName = name.toTermName
 
 // Operations -------------------------------------------------------------
 
diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala
index 749368f93e..4e9f6ea0d9 100644
--- a/src/compiler/scala/reflect/internal/Symbols.scala
+++ b/src/compiler/scala/reflect/internal/Symbols.scala
@@ -300,34 +300,34 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     /** Is this symbol a type but not a class? */
     def isNonClassType = false // to be overridden
 
-    override final def isTrait: Boolean = isClass && hasFlag(TRAIT | notDEFERRED)     // A virtual class becomes a trait (part of DEVIRTUALIZE)
-    final def isAbstractClass = isClass && hasFlag(ABSTRACT)
-    final def isConcreteClass = isClass && !hasFlag(ABSTRACT | TRAIT)
-    final def isBridge = hasFlag(BRIDGE)
-    final def isContravariant = isType && hasFlag(CONTRAVARIANT)
-    final def isCovariant = isType && hasFlag(COVARIANT)
-    final def isEarlyInitialized: Boolean = isTerm && hasFlag(PRESUPER)
+    override final def isTrait     = isClass && hasFlag(TRAIT)
+    final def isAbstractClass      = isClass && hasFlag(ABSTRACT)
+    final def isBridge             = hasFlag(BRIDGE)
+    final def isContravariant      = isType && hasFlag(CONTRAVARIANT)
+    final def isConcreteClass      = isClass && !hasFlag(ABSTRACT | TRAIT)
+    final def isCovariant          = isType && hasFlag(COVARIANT)
+    final def isEarlyInitialized   = isTerm && hasFlag(PRESUPER)
     final def isExistentiallyBound = isType && hasFlag(EXISTENTIAL)
-    final def isImplClass = isClass && hasFlag(IMPLCLASS) // Is this symbol an implementation class for a mixin?
-    final def isLazyAccessor = isLazy && lazyAccessor != NoSymbol
-    final def isMethod = isTerm && hasFlag(METHOD)
-    final def isVarargsMethod = isMethod && hasFlag(VARARGS)
-    final def isModule = isTerm && hasFlag(MODULE)
-    final def isModuleClass = isClass && hasFlag(MODULE)
-    final def isOverloaded = hasFlag(OVERLOADED)
-    final def isRefinementClass = isClass && name == tpnme.REFINE_CLASS_NAME
-    final def isPossibleInRefinement = !isConstructor && !isOverridingSymbol
-    final def isStructuralRefinementMember = owner.isStructuralRefinement && isPossibleInRefinement && isPublic
-    final def isSourceMethod = isMethod && !hasFlag(STABLE) // exclude all accessors!!!
-    final def isTypeParameter = isType && isParameter && !isSkolem
+    final def isImplClass          = isClass && hasFlag(IMPLCLASS)
+    final def isLazyAccessor       = isLazy && lazyAccessor != NoSymbol
+    final def isMethod             = isTerm && hasFlag(METHOD)
+    final def isModule             = isTerm && hasFlag(MODULE)
+    final def isModuleClass        = isClass && hasFlag(MODULE)
+    final def isNumericValueClass  = definitions.isNumericValueClass(this)
+    final def isOverloaded         = hasFlag(OVERLOADED)
+    final def isRefinementClass    = isClass && name == tpnme.REFINE_CLASS_NAME
+    final def isSourceMethod       = isMethod && !hasFlag(STABLE) // exclude all accessors!!!
+    final def isTypeParameter      = isType && isParameter && !isSkolem
+    final def isValueClass         = definitions.isValueClass(this)
+    final def isVarargsMethod      = isMethod && hasFlag(VARARGS)
 
     /** Package tests */
-    final def isEmptyPackage = isPackage && name == nme.EMPTY_PACKAGE_NAME
+    final def isEmptyPackage      = isPackage && name == nme.EMPTY_PACKAGE_NAME
     final def isEmptyPackageClass = isPackageClass && name == tpnme.EMPTY_PACKAGE_NAME
-    final def isPackage = isModule && hasFlag(PACKAGE)
-    final def isPackageClass = isClass && hasFlag(PACKAGE)
-    final def isRoot = isPackageClass && owner == NoSymbol
-    final def isRootPackage = isPackage && owner == NoSymbol
+    final def isPackage           = isModule && hasFlag(PACKAGE)
+    final def isPackageClass      = isClass && hasFlag(PACKAGE)
+    final def isRoot              = isPackageClass && owner == NoSymbol
+    final def isRootPackage       = isPackage && owner == NoSymbol
 
     /** Does this symbol denote a wrapper created by the repl? */
     final def isInterpreterWrapper = (
@@ -339,6 +339,9 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
      */
     def isEffectiveRoot = isRoot || isEmptyPackageClass
 
+    final def isPossibleInRefinement       = !isConstructor && !isOverridingSymbol
+    final def isStructuralRefinementMember = owner.isStructuralRefinement && isPossibleInRefinement && isPublic
+
     /** Term symbols with the exception of static parts of Java classes and packages.
      */
     final def isValue = isTerm && !(isModule && hasFlag(PACKAGE | JAVA))