Changed reflection to allow getting a Scala Sym...

Changed reflection to allow getting a Scala Symbol for the
implementation class of a trait.

Author: amin

src/compiler/scala/reflect/runtime/JavaToScala.scala

@@ -351,7 +351,7 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
    *          not available, wrapped from the Java reflection info.
    */
   def classToScala(jclazz: jClass[_]): Symbol = classCache.toScala(jclazz) {
-    if (jclazz.isMemberClass) {
+    if (jclazz.isMemberClass && !nme.isImplClassName(jclazz.getName)) {
       val sym = sOwner(jclazz).info.decl(newTypeName(jclazz.getSimpleName))
       assert(sym.isType, sym+"/"+jclazz+"/"+sOwner(jclazz)+"/"+jclazz.getSimpleName)
       sym.asInstanceOf[ClassSymbol]
@@ -456,9 +456,11 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
   private def jclassAsScala(jclazz: jClass[_]): Symbol = jclassAsScala(jclazz, sOwner(jclazz))
 
   private def jclassAsScala(jclazz: jClass[_], owner: Symbol): Symbol = {
-    val clazz = owner.newClass(NoPosition, newTypeName(jclazz.getSimpleName))
+    val name = newTypeName(jclazz.getSimpleName)
+    val completer = (clazz: Symbol, module: Symbol) => new FromJavaClassCompleter(clazz, module, jclazz)
+    val (clazz, module) = createClassModule(owner, name, completer)
     classCache enter (jclazz, clazz)
-    clazz setInfo new FromJavaClassCompleter(clazz, NoSymbol, jclazz)
+    clazz
   }
 
   /**
@@ -523,4 +525,4 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
   }
 }
 
-class ReflectError(msg: String) extends java.lang.Error(msg)
+class ReflectError(msg: String) extends java.lang.Error(msg)

test/files/run/reflection-implClass.scala

@@ -4,15 +4,35 @@
  * symbol for them should be created using fallback mechanism
  * that exposes Java reflection information dressed up in
  * a Scala symbol.
- **/
-object Test extends App {
+ */
+object Test extends App with Outer {
   import scala.reflect.mirror
-  val name = manifest[Foo].erasure.getName + "$class"
-  val implClass = Class.forName(name)
-  val symbol = mirror.classToSymbol(implClass)
-  assert(symbol != mirror.NoSymbol)
+
+  assert(mirror.classToSymbol(manifest[Foo].erasure).info.decl(mirror.newTermName("bar")).info ==
+    mirror.classToSymbol(manifest[Bar].erasure).info.decl(mirror.newTermName("foo")).info)
+
+  val s1 = implClass(manifest[Foo].erasure)
+  assert(s1 != mirror.NoSymbol)
+  assert(s1.info != mirror.NoType)
+  assert(s1.companionModule.info != mirror.NoType)
+  assert(s1.companionModule.info.decl(mirror.newTermName("bar")) != mirror.NoSymbol)
+  val s2 = implClass(manifest[Bar].erasure)
+  assert(s2 != mirror.NoSymbol)
+  assert(s2.info != mirror.NoType)
+  assert(s2.companionModule.info != mirror.NoType)
+  assert(s2.companionModule.info.decl(mirror.newTermName("foo")) != mirror.NoSymbol)
+  def implClass(clazz: Class[_]) = {
+    val implClass = Class.forName(clazz.getName + "$class")
+    mirror.classToSymbol(implClass)
+  }
 }
 
 trait Foo {
   def bar = 1
 }
+
+trait Outer {
+  trait Bar {
+    def foo = 1
+  }
+}