Towards better reflection APIs.

Author: odersky

src/compiler/scala/reflect/internal/Scopes.scala

@@ -331,13 +331,12 @@ trait Scopes extends api.Scopes { self: SymbolTable =>
    */
   def scopeTransform(owner: Symbol)(op: => Scope): Scope = op
 
-  def newScopeWith(elems: Symbol*) = {
+  def newScopeWith(elems: Symbol*): Scope = {
     val scope = newScope
     elems foreach scope.enter
     scope
   }
 
-
   /** The empty scope (immutable).
    */
   object EmptyScope extends Scope {

src/compiler/scala/reflect/internal/SymbolTable.scala

@@ -18,6 +18,7 @@ abstract class SymbolTable extends api.Universe
                               with Constants
                               with BaseTypeSeqs
                               with InfoTransformers
+                              with transform.Transforms
                               with StdNames
                               with AnnotationInfos
                               with AnnotationCheckers

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

@@ -41,9 +41,24 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
    */
   val originalOwner = perRunCaches.newMap[Symbol, Symbol]()
 
+  abstract class AbsSymbolImpl extends AbsSymbol { this: Symbol =>
+    def newNestedSymbol(pos: Position, name: Name) = name match {
+      case n: TermName => newValue(pos, n)
+      case n: TypeName => newAliasType(pos, n)
+    }
+    def typeSig: Type = info
+    def typeSigIn(site: Type): Type = site.memberInfo(this)
+    def asType: Type = tpe
+    def asTypeIn(site: Type): Type = site.memberType(this)
+    def asTypeConstructor: Type = typeConstructor
+    def setInternalFlags(flag: Long): this.type = { setFlag(flag); this }
+    def setTypeSig(tpe: Type): this.type = { setInfo(tpe); this }
+    def setAnnotations(annots: AnnotationInfo*): this.type = { setAnnotations(annots.toList); this }
+  }
+
   /** The class for all symbols */
   abstract class Symbol(initOwner: Symbol, initPos: Position, initName: Name)
-          extends AbsSymbol
+          extends AbsSymbolImpl
              with HasFlags
              with Annotatable[Symbol] {
 

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

@@ -248,12 +248,6 @@ trait Trees extends api.Trees { self: SymbolTable =>
 
   def This(sym: Symbol): Tree = This(sym.name.toTypeName) setSymbol sym
 
-  def Select(qualifier: Tree, sym: Symbol): Select =
-    Select(qualifier, sym.name) setSymbol sym
-
-  def Ident(sym: Symbol): Ident =
-    Ident(sym.name) setSymbol sym
-
   /** Block factory that flattens directly nested blocks.
    */
   def Block(stats: Tree*): Block = stats match {

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

@@ -235,8 +235,17 @@ trait Types extends api.Types { self: SymbolTable =>
     override def tpe_=(t: Type) = if (t != NoType) throw new UnsupportedOperationException("tpe_=("+t+") inapplicable for <empty>")
   }
 
+  abstract class AbsTypeImpl extends AbsType { this: Type =>
+    def declaration(name: Name): Symbol = decl(name)
+    def nonPrivateDeclaration(name: Name): Symbol = nonPrivateDecl(name)
+    def allDeclarations = decls
+    def allMembers = members
+    def typeArguments = typeArgs
+    def erasedType = transformedType(this)
+  }
+
   /** The base class for all types */
-  abstract class Type extends AbsType with Annotatable[Type] {
+  abstract class Type extends AbsTypeImpl with Annotatable[Type] {
     /** Types for which asSeenFrom always is the identity, no matter what
      *  prefix or owner.
      */
@@ -1063,7 +1072,7 @@ trait Types extends api.Types { self: SymbolTable =>
   /** A base class for types that represent a single value
    *  (single-types and this-types).
    */
-  abstract class SingletonType extends SubType with SimpleTypeProxy {
+  abstract class SingletonType extends SubType with SimpleTypeProxy with AbsSingletonType {
     def supertype = underlying
     override def isTrivial = false
     override def isStable = true
@@ -1435,7 +1444,7 @@ trait Types extends api.Types { self: SymbolTable =>
     override def isHigherKinded = (
       parents.nonEmpty &&
       (parents forall (_.isHigherKinded)) &&
-      !phase.erasedTypes    // @MO to AM: please check this class!
+      !phase.erasedTypes
     )
 
     override def typeParams =

src/compiler/scala/reflect/internal/transform/Transforms.scala

@@ -4,13 +4,36 @@ package transform
 
 trait Transforms { self: SymbolTable =>
 
-  object refChecks extends { val global: Transforms.this.type = self } with RefChecks
-  object uncurry   extends { val global: Transforms.this.type = self } with UnCurry
-  object erasure   extends { val global: Transforms.this.type = self } with Erasure
+  /** We need to encode laziness by hand here because the three components refChecks, uncurry and erasure
+   *  are overwritten by objects in Global.
+   *  It would be best of objects could override lazy values. See SI-5187.
+   *  In the absence of this, the Lazy functionality should probably be somewhere
+   *  in the standard library. Or is it already?
+   */
+  private class Lazy[T](op: => T) {
+    private var value: T = _
+    private var _isDefined = false
+    def isDefined = _isDefined
+    def force: T = {
+      if (!isDefined) { value = op; _isDefined = true }
+      value
+    }
+  }
+
+  private val refChecksLazy = new Lazy(new { val global: Transforms.this.type = self } with RefChecks)
+  private val uncurryLazy = new Lazy(new { val global: Transforms.this.type = self } with UnCurry)
+  private val erasureLazy = new Lazy(new { val global: Transforms.this.type = self } with Erasure)
+
+  def refChecks = refChecksLazy.force
+  def uncurry = uncurryLazy.force
+  def erasure = erasureLazy.force
 
   def transformedType(sym: Symbol) =
     erasure.transformInfo(sym,
       uncurry.transformInfo(sym,
         refChecks.transformInfo(sym, sym.info)))
 
+  def transformedType(tpe: Type) =
+    erasure.scalaErasure(uncurry.uncurry(tpe))
+
 }

src/compiler/scala/reflect/internal/transform/UnCurry.scala

@@ -17,7 +17,7 @@ trait UnCurry {
     case _ => false
   }
 
-  protected val uncurry: TypeMap = new TypeMap {
+  val uncurry: TypeMap = new TypeMap {
     def apply(tp0: Type): Type = {
       // tp0.typeSymbolDirect.initialize
       val tp = expandAlias(tp0)

src/compiler/scala/reflect/runtime/Mirror.scala

@@ -38,6 +38,9 @@ class Mirror extends Universe with RuntimeTypes with TreeBuildUtil with ToolBoxe
   override def classToType(jclazz: java.lang.Class[_]): Type = typeToScala(jclazz)
   override def classToSymbol(jclazz: java.lang.Class[_]): Symbol = classToScala(jclazz)
 
+  override def typeToClass(tpe: Type): java.lang.Class[_] = typeToJavaClass(tpe)
+  override def symbolToClass(sym: Symbol): java.lang.Class[_] = classToJava(sym)
+
 }
 
 object Mirror extends Mirror

src/compiler/scala/reflect/runtime/TreeBuildUtil.scala

@@ -1,12 +1,13 @@
-package scala.reflect.runtime
+package scala.reflect
+package runtime
 
-trait TreeBuildUtil extends Universe {
+trait TreeBuildUtil extends Universe with api.TreeBuildUtil {
 
-  def staticClass(name: String): Symbol = definitions.getClass(newTypeName(name))
-  def staticModule(name: String): Symbol = definitions.getModule(newTermName(name))
+  def staticClass(fullname: String): Symbol = definitions.getClass(newTypeName(fullname))
+  def staticModule(fullname: String): Symbol = definitions.getModule(newTermName(fullname))
 
-  def thisModuleType(name: String) =
-    definitions.getModule(name).moduleClass.thisType
+  def thisModuleType(fullname: String) =
+    definitions.getModule(fullname).moduleClass.thisType
 
  /** Selects type symbol with given name from the defined members of prefix type
    */
@@ -40,9 +41,9 @@ trait TreeBuildUtil extends Universe {
     selectIn(owner.info, idx)
   }
 
-
   def freeVar(name: String, info: Type, value: Any) = new FreeVar(name, info, value)
 
-  def newScopeWith(decls: List[Symbol]) = new Scope(decls)
+  def modifiersFromInternalFlags(flags: Long, privateWithin: Name, annotations: List[Tree]): Modifiers =
+    Modifiers(flags, privateWithin, annotations)
 
 }

src/compiler/scala/reflect/runtime/Universe.scala

@@ -8,7 +8,7 @@ import internal.{SomePhase, NoPhase, Phase, TreeGen}
  *  It also provides methods to go from Java members to Scala members,
  *  using the code in JavaConversions.
  */
-class Universe extends SymbolTable with internal.transform.Transforms {
+class Universe extends SymbolTable {
 
   type AbstractFileType = AbstractFile
 

src/compiler/scala/tools/nsc/Global.scala

@@ -417,7 +417,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) extends Symb
   } with Pickler
 
   // phaseName = "refchecks"
-  object refChecks extends {
+  override object refChecks extends {
     val global: Global.this.type = Global.this
     val runsAfter = List[String]("pickler")
     val runsRightAfter = None
@@ -431,7 +431,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) extends Symb
   } with LiftCode
 
   // phaseName = "uncurry"
-  object uncurry extends {
+  override object uncurry extends {
     val global: Global.this.type = Global.this
     val runsAfter = List[String]("refchecks", "liftcode")
     val runsRightAfter = None
@@ -459,7 +459,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) extends Symb
   } with SpecializeTypes
 
   // phaseName = "erasure"
-  object erasure extends {
+  override object erasure extends {
     val global: Global.this.type = Global.this
     val runsAfter = List[String]("explicitouter")
     val runsRightAfter = Some("explicitouter")