Merge pull request #1039 from scalamacros/topic/ultimate-reflection-pull-request

Ultimate reflection pull request

1 files changed, 45 insertions, 16 deletions

diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
index 0878801715..64c47a5502 100644
--- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala
+++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
@@ -150,7 +150,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
 
     def classSymbol(rtcls: RuntimeClass): ClassSymbol = classToScala(rtcls)
 
-    def moduleSymbol(rtcls: RuntimeClass): ModuleSymbol = classToScala(rtcls).companionModule.asModuleSymbol
+    def moduleSymbol(rtcls: RuntimeClass): ModuleSymbol = classToScala(rtcls).companionModule.asModule
 
     private def checkMemberOf(wannabe: Symbol, owner: Symbol) =
       if (!owner.info.member(wannabe.name).alternatives.contains(wannabe)) ErrorNotMember(wannabe, owner)
@@ -166,7 +166,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
           if (field.isGetter) nme.getterToLocal(field.name)
           else if (field.isSetter) nme.getterToLocal(nme.setterToGetter(field.name))
           else field.name
-        val field1 = (field.owner.info decl name).asTermSymbol
+        val field1 = (field.owner.info decl name).asTerm
         try fieldToJava(field1)
         catch {
           case _: NoSuchFieldException => ErrorNonExistentField(field1)
@@ -187,6 +187,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
         checkMemberOf(mod, symbol)
         new JavaModuleMirror(instance, mod)
       }
+      override def toString = s"instance mirror for $obj"
     }
 
     private class JavaFieldMirror(val receiver: AnyRef, val symbol: TermSymbol)
@@ -201,6 +202,32 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
         if (!symbol.isMutable) ErrorSetImmutableField(symbol)
         jfield.set(receiver, value)
       }
+      override def toString = s"field mirror for ${symbol.fullName} (bound to $receiver)"
+    }
+
+    private def showMethodSig(symbol: MethodSymbol): String = {
+      var sig = s"${symbol.fullName}"
+      if (symbol.typeParams.nonEmpty) {
+        def showTparam(tparam: Symbol) =
+          tparam.typeSignature match {
+            case tpe @ TypeBounds(_, _) => s"${tparam.name}$tpe"
+            case _ => tparam.name
+          }
+        def showTparams(tparams: List[Symbol]) = "[" + (tparams map showTparam mkString ", ") + "]"
+        sig += showTparams(symbol.typeParams)
+      }
+      if (symbol.params.nonEmpty) {
+        def showParam(param: Symbol) = s"${param.name}: ${param.typeSignature}"
+        def showParams(params: List[Symbol]) = {
+          val s_mods = if (params.nonEmpty && params(0).hasFlag(IMPLICIT)) "implicit " else ""
+          val s_params = params map showParam mkString ", "
+          "(" + s_mods + s_params + ")"
+        }
+        def showParamss(paramss: List[List[Symbol]]) = paramss map showParams mkString ""
+        sig += showParamss(symbol.params)
+      }
+      sig += s": ${symbol.returnType}"
+      sig
     }
 
     private class JavaMethodMirror(val receiver: AnyRef, val symbol: MethodSymbol)
@@ -220,6 +247,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
           }
         else
           jmeth.invoke(receiver, args.asInstanceOf[Seq[AnyRef]]: _*)
+      override def toString = s"method mirror for ${showMethodSig(symbol)} (bound to $receiver)"
     }
 
     private class JavaConstructorMirror(val outer: AnyRef, val symbol: MethodSymbol)
@@ -236,9 +264,9 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
           else outer +: args.asInstanceOf[Seq[AnyRef]]
         jconstr.newInstance(effectiveArgs: _*)
       }
+      override def toString = s"constructor mirror for ${showMethodSig(symbol)} (bound to $outer)"
     }
 
-
     private abstract class JavaTemplateMirror
             extends TemplateMirror {
       def outer: AnyRef
@@ -256,11 +284,12 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
        case module: ModuleSymbol => Some(new JavaModuleMirror(outer, module))
        case _ => None
       }
+      override def toString = s"class mirror for ${symbol.fullName} (bound to $outer)"
     }
 
     private class JavaModuleMirror(val outer: AnyRef, val symbol: ModuleSymbol)
             extends JavaTemplateMirror with ModuleMirror {
-      def erasure = symbol.moduleClass.asClassSymbol
+      def erasure = symbol.moduleClass.asClass
       def isStatic = true
       def instance = {
         if (!symbol.owner.isPackageClass) throw new Error("inner and nested modules are not supported yet")
@@ -270,6 +299,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
         case cls: ClassSymbol => Some(new JavaClassMirror(outer, cls))
         case _ => None
       }
+      override def toString = s"module mirror for ${symbol.fullName} (bound to $outer)"
     }
 
 // -------------------- Java to Scala  -----------------------------------
@@ -629,7 +659,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
       val preOwner = classToScala(jOwner)
       val owner = followStatic(preOwner, jmeth.getModifiers)
       (lookup(owner, jmeth.getName) suchThat (erasesTo(_, jmeth)) orElse jmethodAsScala(jmeth))
-        .asMethodSymbol
+        .asMethod
     }
 
     /**
@@ -643,7 +673,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
     private def constructorToScala1(jconstr: jConstructor[_]): MethodSymbol = {
       val owner = followStatic(classToScala(jconstr.getDeclaringClass), jconstr.getModifiers)
       (lookup(owner, jconstr.getName) suchThat (erasesTo(_, jconstr)) orElse jconstrAsScala(jconstr))
-        .asMethodSymbol
+        .asMethod
     }
 
     /**
@@ -657,8 +687,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
 
     private def fieldToScala1(jfield: jField): TermSymbol = {
       val owner = followStatic(classToScala(jfield.getDeclaringClass), jfield.getModifiers)
-      (lookup(owner, jfield.getName) suchThat (!_.isMethod) orElse jfieldAsScala(jfield))
-        .asTermSymbol
+      (lookup(owner, jfield.getName) suchThat (!_.isMethod) orElse jfieldAsScala(jfield)).asTerm
     }
 
     /**
@@ -691,7 +720,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
       val name = (fullname: TermName) drop split + 1
       val opkg = owner.info decl name
       if (opkg.isPackage)
-        opkg.asModuleSymbol
+        opkg.asModule
       else if (opkg == NoSymbol) {
         val pkg = owner.newPackage(name)
         pkg.moduleClass setInfo new LazyPackageType
@@ -758,7 +787,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
           s"""${if (cls == NoSymbol) "not a type: symbol" else "no symbol could be"}
              | loaded from $jclazz in $owner with name $simpleName and classloader $classLoader""".stripMargin)
 
-        cls.asClassSymbol
+        cls.asClass
       }
     }
 
@@ -773,7 +802,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
     private def typeParamToScala1(jparam: jTypeVariable[_ <: GenericDeclaration]): TypeSymbol = {
       val owner = genericDeclarationToScala(jparam.getGenericDeclaration)
       owner.info match {
-        case PolyType(tparams, _) => tparams.find(_.name.toString == jparam.getName).get.asTypeSymbol
+        case PolyType(tparams, _) => tparams.find(_.name.toString == jparam.getName).get.asType
       }
     }
 
@@ -941,7 +970,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
       else if (clazz.owner.isPackageClass)
         javaClass(clazz.javaClassName)
       else if (clazz.owner.isClass)
-        classToJava(clazz.owner.asClassSymbol)
+        classToJava(clazz.owner.asClass)
           .getDeclaredClasses
           .find(_.getSimpleName == clazz.name.toString)
           .getOrElse(noClass)
@@ -957,7 +986,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
      *  @param   meth The Scala field.
      */
     def fieldToJava(fld: TermSymbol): jField = fieldCache.toJava(fld) {
-      val jclazz = classToJava(fld.owner.asClassSymbol)
+      val jclazz = classToJava(fld.owner.asClass)
       val jname = nme.dropLocalSuffix(fld.name).toString
       try jclazz getDeclaredField jname
       catch {
@@ -969,7 +998,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
      *  @param   meth The Scala method
      */
     def methodToJava(meth: MethodSymbol): jMethod = methodCache.toJava(meth) {
-      val jclazz = classToJava(meth.owner.asClassSymbol)
+      val jclazz = classToJava(meth.owner.asClass)
       val paramClasses = transformedType(meth).paramTypes map typeToJavaClass
       val jname = nme.dropLocalSuffix(meth.name).toString
       try jclazz getDeclaredMethod (jname, paramClasses: _*)
@@ -983,7 +1012,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
      *  @param   constr The Scala constructor
      */
     def constructorToJava(constr: MethodSymbol): jConstructor[_] = constructorCache.toJava(constr) {
-      val jclazz = classToJava(constr.owner.asClassSymbol)
+      val jclazz = classToJava(constr.owner.asClass)
       val paramClasses = transformedType(constr).paramTypes map typeToJavaClass
       val effectiveParamClasses =
         if (!constr.owner.owner.isStaticOwner) jclazz.getEnclosingClass +: paramClasses
@@ -1001,7 +1030,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
     def typeToJavaClass(tpe: Type): jClass[_] = tpe match {
       case ExistentialType(_, rtpe) => typeToJavaClass(rtpe)
       case TypeRef(_, ArrayClass, List(elemtpe)) => jArrayClass(typeToJavaClass(elemtpe))
-      case TypeRef(_, sym: ClassSymbol, _) => classToJava(sym.asClassSymbol)
+      case TypeRef(_, sym: ClassSymbol, _) => classToJava(sym.asClass)
       case tpe @ TypeRef(_, sym: AliasTypeSymbol, _) => typeToJavaClass(tpe.dealias)
       case _ => throw new NoClassDefFoundError("no Java class corresponding to "+tpe+" found")
     }