SI-5947 works around getDeclaredClasses

Our name mangling scheme w.r.t stuff nested into objects conflicts
with JVM's ideas of beauty, which messes up getDeclaredClasses.

Scala reflection needs getDeclaredClasses to convert between Scala and Java,
so the situation looked grim. Greg suggested a workaround described in:
https://issues.scala-lang.org/browse/SI-4023?focusedCommentId=54759#comment-54759.

Luckily the workaround worked!

19 files changed, 568 insertions, 2 deletions

diff --git a/test/files/run/reflection-enclosed-basic.check b/test/files/run/reflection-enclosed-basic.check
new file mode 100644
index 0000000000..41f6a72f1c
--- /dev/null
+++ b/test/files/run/reflection-enclosed-basic.check
@@ -0,0 +1,18 @@
+class B1

+B1

+1

+class B2

+B2

+2

+object B3

+B3

+3

+object B4

+B4

+4

+object B5

+B5

+5

+object B6

+B6

+6

diff --git a/test/files/run/reflection-enclosed-basic.scala b/test/files/run/reflection-enclosed-basic.scala
new file mode 100644
index 0000000000..1dcb6c2a27
--- /dev/null
+++ b/test/files/run/reflection-enclosed-basic.scala
@@ -0,0 +1,46 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.reflect.{classTag, ClassTag}
+
+class B1 { override def toString = "B1"; def foo = 1 }
+private class B2 { override def toString = "B2"; def foo = 2 }
+object B3 { override def toString = "B3"; def foo = 3 }
+private object B4 { override def toString = "B4"; def foo = 4 }
+object B5 extends B1 { override def toString = "B5"; override def foo = 5 }
+private object B6 extends B2 { override def toString = "B6"; override def foo = 6 }
+
+object Test extends App {
+  def testMethodInvocation(instance: Any) = {
+    val instanceMirror = cm.reflect(instance)
+    val method = instanceMirror.symbol.typeSignature.declaration(newTermName("foo")).asMethod
+    val methodMirror = instanceMirror.reflectMethod(method)
+    println(methodMirror())
+  }
+
+  def testNestedClass(name: String) = {
+    val sym = cm.staticClass(name)
+    println(sym)
+    val ctor = sym.typeSignature.declaration(newTermName("<init>")).asMethod
+    val ctorMirror = cm.reflectClass(sym).reflectConstructor(ctor)
+    val instance = ctorMirror()
+    println(instance)
+    testMethodInvocation(instance)
+  }
+
+  testNestedClass("B1")
+  testNestedClass("B2")
+
+  def testNestedModule(name: String) = {
+    val sym = cm.staticModule(name)
+    println(sym)
+    val moduleMirror = cm.reflectModule(sym)
+    val instance = moduleMirror.instance
+    println(instance)
+    testMethodInvocation(instance)
+  }
+
+  testNestedModule("B3")
+  testNestedModule("B4")
+  testNestedModule("B5")
+  testNestedModule("B6")
+}
diff --git a/test/files/run/reflection-enclosed-inner-basic.check b/test/files/run/reflection-enclosed-inner-basic.check
new file mode 100644
index 0000000000..984fb1ff12
--- /dev/null
+++ b/test/files/run/reflection-enclosed-inner-basic.check
@@ -0,0 +1,20 @@
+class B

+List(constructor B, class B1, class B2, object B3, object B4, object B5, object B6)

+class B1

+B1

+1

+class B2

+B2

+2

+object B3

+B3

+3

+object B4

+B4

+4

+object B5

+B5

+5

+object B6

+B6

+6

diff --git a/test/files/run/reflection-enclosed-inner-basic.scala b/test/files/run/reflection-enclosed-inner-basic.scala
new file mode 100644
index 0000000000..2b2c701993
--- /dev/null
+++ b/test/files/run/reflection-enclosed-inner-basic.scala
@@ -0,0 +1,52 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.reflect.{classTag, ClassTag}
+
+class B {
+  class B1 { override def toString = "B1"; def foo = 1 }
+  private class B2 { override def toString = "B2"; def foo = 2 }
+  object B3 { override def toString = "B3"; def foo = 3 }
+  private object B4 { override def toString = "B4"; def foo = 4 }
+  object B5 extends B1 { override def toString = "B5"; override def foo = 5 }
+  private object B6 extends B2 { override def toString = "B6"; override def foo = 6 }
+}
+
+object Test extends App {
+  val b = cm.classSymbol(classTag[B].runtimeClass)
+  println(b)
+  println(b.typeSignature.declarations.toList)
+
+  def testMethodInvocation(instance: Any) = {
+    val instanceMirror = cm.reflect(instance)
+    val method = instanceMirror.symbol.typeSignature.declaration(newTermName("foo")).asMethod
+    val methodMirror = instanceMirror.reflectMethod(method)
+    println(methodMirror())
+  }
+
+  def testInnerClass(name: String) = {
+    val sym = b.typeSignature.declaration(newTypeName(name)).asClass
+    println(sym)
+    val ctor = sym.typeSignature.declaration(newTermName("<init>")).asMethod
+    val ctorMirror = cm.reflect(new B).reflectClass(sym).reflectConstructor(ctor)
+    val instance = ctorMirror()
+    println(instance)
+    testMethodInvocation(instance)
+  }
+
+  testInnerClass("B1")
+  testInnerClass("B2")
+
+  def testInnerModule(name: String) = {
+    val sym = b.typeSignature.declaration(newTermName(name)).asModule
+    println(sym)
+    val moduleMirror = cm.reflect(new B).reflectModule(sym)
+    val instance = moduleMirror.instance
+    println(instance)
+    testMethodInvocation(instance)
+  }
+
+  testInnerModule("B3")
+  testInnerModule("B4")
+  testInnerModule("B5")
+  testInnerModule("B6")
+}
diff --git a/test/files/run/reflection-enclosed-inner-inner-basic.check b/test/files/run/reflection-enclosed-inner-inner-basic.check
new file mode 100644
index 0000000000..8987f31b18
--- /dev/null
+++ b/test/files/run/reflection-enclosed-inner-inner-basic.check
@@ -0,0 +1,20 @@
+class BB

+List(constructor BB, class B1, class B2, object B3, object B4, object B5, object B6)

+class B1

+B1

+1

+class B2

+B2

+2

+object B3

+B3

+3

+object B4

+B4

+4

+object B5

+B5

+5

+object B6

+B6

+6

diff --git a/test/files/run/reflection-enclosed-inner-inner-basic.scala b/test/files/run/reflection-enclosed-inner-inner-basic.scala
new file mode 100644
index 0000000000..1b9e19d37d
--- /dev/null
+++ b/test/files/run/reflection-enclosed-inner-inner-basic.scala
@@ -0,0 +1,58 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.reflect.{classTag, ClassTag}
+
+class B {
+  class BB {
+    class B1 { override def toString = "B1"; def foo = 1 }
+    private class B2 { override def toString = "B2"; def foo = 2 }
+    object B3 { override def toString = "B3"; def foo = 3 }
+    private object B4 { override def toString = "B4"; def foo = 4 }
+    object B5 extends B1 { override def toString = "B5"; override def foo = 5 }
+    private object B6 extends B2 { override def toString = "B6"; override def foo = 6 }
+  }
+}
+
+object Test extends App {
+  val b = cm.classSymbol(classTag[B#BB].runtimeClass)
+  println(b)
+  println(b.typeSignature.declarations.toList)
+
+  def testMethodInvocation(instance: Any) = {
+    val instanceMirror = cm.reflect(instance)
+    val method = instanceMirror.symbol.typeSignature.declaration(newTermName("foo")).asMethod
+    val methodMirror = instanceMirror.reflectMethod(method)
+    println(methodMirror())
+  }
+
+  def testInnerClass(name: String) = {
+    val sym = b.typeSignature.declaration(newTypeName(name)).asClass
+    println(sym)
+    val ctor = sym.typeSignature.declaration(newTermName("<init>")).asMethod
+    val outer1 = new B
+    val outer2 = new outer1.BB
+    val ctorMirror = cm.reflect(outer2).reflectClass(sym).reflectConstructor(ctor)
+    val instance = ctorMirror()
+    println(instance)
+    testMethodInvocation(instance)
+  }
+
+  testInnerClass("B1")
+  testInnerClass("B2")
+
+  def testInnerModule(name: String) = {
+    val sym = b.typeSignature.declaration(newTermName(name)).asModule
+    println(sym)
+    val outer1 = new B
+    val outer2 = new outer1.BB
+    val moduleMirror = cm.reflect(outer2).reflectModule(sym)
+    val instance = moduleMirror.instance
+    println(instance)
+    testMethodInvocation(instance)
+  }
+
+  testInnerModule("B3")
+  testInnerModule("B4")
+  testInnerModule("B5")
+  testInnerModule("B6")
+}
diff --git a/test/files/run/reflection-enclosed-inner-nested-basic.check b/test/files/run/reflection-enclosed-inner-nested-basic.check
new file mode 100644
index 0000000000..0f5176a6e7
--- /dev/null
+++ b/test/files/run/reflection-enclosed-inner-nested-basic.check
@@ -0,0 +1,20 @@
+object BB
+List(constructor BB, class B1, class B2, object B3, object B4, object B5, object B6)
+class B1
+B1
+1
+class B2
+B2
+2
+object B3
+B3
+3
+object B4
+B4
+4
+object B5
+B5
+5
+object B6
+B6
+6
diff --git a/test/files/run/reflection-enclosed-inner-nested-basic.scala b/test/files/run/reflection-enclosed-inner-nested-basic.scala
new file mode 100644
index 0000000000..2800ee2548
--- /dev/null
+++ b/test/files/run/reflection-enclosed-inner-nested-basic.scala
@@ -0,0 +1,55 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.reflect.{classTag, ClassTag}
+
+class B {
+  object BB {
+    class B1 { override def toString = "B1"; def foo = 1 }
+    private class B2 { override def toString = "B2"; def foo = 2 }
+    object B3 { override def toString = "B3"; def foo = 3 }
+    private object B4 { override def toString = "B4"; def foo = 4 }
+    object B5 extends B1 { override def toString = "B5"; override def foo = 5 }
+    private object B6 extends B2 { override def toString = "B6"; override def foo = 6 }
+  }
+}
+
+object Test extends App {
+  val outer1 = new B()
+  val b = cm.moduleSymbol(classTag[outer1.BB.type].runtimeClass)
+  println(b)
+  println(b.typeSignature.declarations.toList)
+
+  def testMethodInvocation(instance: Any) = {
+    val instanceMirror = cm.reflect(instance)
+    val method = instanceMirror.symbol.typeSignature.declaration(newTermName("foo")).asMethod
+    val methodMirror = instanceMirror.reflectMethod(method)
+    println(methodMirror())
+  }
+
+  def testNestedClass(name: String) = {
+    val sym = b.typeSignature.declaration(newTypeName(name)).asClass
+    println(sym)
+    val ctor = sym.typeSignature.declaration(newTermName("<init>")).asMethod
+    val ctorMirror = cm.reflect(outer1.BB).reflectClass(sym).reflectConstructor(ctor)
+    val instance = ctorMirror()
+    println(instance)
+    testMethodInvocation(instance)
+  }
+
+  testNestedClass("B1")
+  testNestedClass("B2")
+
+  def testNestedModule(name: String) = {
+    val sym = b.typeSignature.declaration(newTermName(name)).asModule
+    println(sym)
+    val moduleMirror = cm.reflect(outer1.BB).reflectModule(sym)
+    val instance = moduleMirror.instance
+    println(instance)
+    testMethodInvocation(instance)
+  }
+
+  testNestedModule("B3")
+  testNestedModule("B4")
+  testNestedModule("B5")
+  testNestedModule("B6")
+}
diff --git a/test/files/run/reflection-enclosed-nested-basic.check b/test/files/run/reflection-enclosed-nested-basic.check
new file mode 100644
index 0000000000..b0e61149f8
--- /dev/null
+++ b/test/files/run/reflection-enclosed-nested-basic.check
@@ -0,0 +1,20 @@
+object B
+List(constructor B, class B1, class B2, object B3, object B4, object B5, object B6)
+class B1
+B1
+1
+class B2
+B2
+2
+object B3
+B3
+3
+object B4
+B4
+4
+object B5
+B5
+5
+object B6
+B6
+6
diff --git a/test/files/run/reflection-enclosed-nested-basic.scala b/test/files/run/reflection-enclosed-nested-basic.scala
new file mode 100644
index 0000000000..8b740c2da2
--- /dev/null
+++ b/test/files/run/reflection-enclosed-nested-basic.scala
@@ -0,0 +1,52 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.reflect.{classTag, ClassTag}
+
+object B {
+  class B1 { override def toString = "B1"; def foo = 1 }
+  private class B2 { override def toString = "B2"; def foo = 2 }
+  object B3 { override def toString = "B3"; def foo = 3 }
+  private object B4 { override def toString = "B4"; def foo = 4 }
+  object B5 extends B1 { override def toString = "B5"; override def foo = 5 }
+  private object B6 extends B2 { override def toString = "B6"; override def foo = 6 }
+}
+
+object Test extends App {
+  val b = cm.moduleSymbol(classTag[B.type].runtimeClass)
+  println(b)
+  println(b.typeSignature.declarations.toList)
+
+  def testMethodInvocation(instance: Any) = {
+    val instanceMirror = cm.reflect(instance)
+    val method = instanceMirror.symbol.typeSignature.declaration(newTermName("foo")).asMethod
+    val methodMirror = instanceMirror.reflectMethod(method)
+    println(methodMirror())
+  }
+
+  def testNestedClass(name: String) = {
+    val sym = b.typeSignature.declaration(newTypeName(name)).asClass
+    println(sym)
+    val ctor = sym.typeSignature.declaration(newTermName("<init>")).asMethod
+    val ctorMirror = cm.reflectClass(sym).reflectConstructor(ctor)
+    val instance = ctorMirror()
+    println(instance)
+    testMethodInvocation(instance)
+  }
+
+  testNestedClass("B1")
+  testNestedClass("B2")
+
+  def testNestedModule(name: String) = {
+    val sym = b.typeSignature.declaration(newTermName(name)).asModule
+    println(sym)
+    val moduleMirror = cm.reflectModule(sym)
+    val instance = moduleMirror.instance
+    println(instance)
+    testMethodInvocation(instance)
+  }
+
+  testNestedModule("B3")
+  testNestedModule("B4")
+  testNestedModule("B5")
+  testNestedModule("B6")
+}
diff --git a/test/files/run/reflection-enclosed-nested-inner-basic.check b/test/files/run/reflection-enclosed-nested-inner-basic.check
new file mode 100644
index 0000000000..add7a81c0a
--- /dev/null
+++ b/test/files/run/reflection-enclosed-nested-inner-basic.check
@@ -0,0 +1,20 @@
+class BB
+List(constructor BB, class B1, class B2, object B3, object B4, object B5, object B6)
+class B1
+B1
+1
+class B2
+B2
+2
+object B3
+B3
+3
+object B4
+B4
+4
+object B5
+B5
+5
+object B6
+B6
+6
diff --git a/test/files/run/reflection-enclosed-nested-inner-basic.scala b/test/files/run/reflection-enclosed-nested-inner-basic.scala
new file mode 100644
index 0000000000..7466733d37
--- /dev/null
+++ b/test/files/run/reflection-enclosed-nested-inner-basic.scala
@@ -0,0 +1,54 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.reflect.{classTag, ClassTag}
+
+object B {
+  class BB {
+    class B1 { override def toString = "B1"; def foo = 1 }
+    private class B2 { override def toString = "B2"; def foo = 2 }
+    object B3 { override def toString = "B3"; def foo = 3 }
+    private object B4 { override def toString = "B4"; def foo = 4 }
+    object B5 extends B1 { override def toString = "B5"; override def foo = 5 }
+    private object B6 extends B2 { override def toString = "B6"; override def foo = 6 }
+  }
+}
+
+object Test extends App {
+  val b = cm.classSymbol(classTag[B.BB].runtimeClass)
+  println(b)
+  println(b.typeSignature.declarations.toList)
+
+  def testMethodInvocation(instance: Any) = {
+    val instanceMirror = cm.reflect(instance)
+    val method = instanceMirror.symbol.typeSignature.declaration(newTermName("foo")).asMethod
+    val methodMirror = instanceMirror.reflectMethod(method)
+    println(methodMirror())
+  }
+
+  def testInnerClass(name: String) = {
+    val sym = b.typeSignature.declaration(newTypeName(name)).asClass
+    println(sym)
+    val ctor = sym.typeSignature.declaration(newTermName("<init>")).asMethod
+    val ctorMirror = cm.reflect(new B.BB).reflectClass(sym).reflectConstructor(ctor)
+    val instance = ctorMirror()
+    println(instance)
+    testMethodInvocation(instance)
+  }
+
+  testInnerClass("B1")
+  testInnerClass("B2")
+
+  def testInnerModule(name: String) = {
+    val sym = b.typeSignature.declaration(newTermName(name)).asModule
+    println(sym)
+    val moduleMirror = cm.reflect(new B.BB).reflectModule(sym)
+    val instance = moduleMirror.instance
+    println(instance)
+    testMethodInvocation(instance)
+  }
+
+  testInnerModule("B3")
+  testInnerModule("B4")
+  testInnerModule("B5")
+  testInnerModule("B6")
+}
diff --git a/test/files/run/reflection-enclosed-nested-nested-basic.check b/test/files/run/reflection-enclosed-nested-nested-basic.check
new file mode 100644
index 0000000000..0f5176a6e7
--- /dev/null
+++ b/test/files/run/reflection-enclosed-nested-nested-basic.check
@@ -0,0 +1,20 @@
+object BB
+List(constructor BB, class B1, class B2, object B3, object B4, object B5, object B6)
+class B1
+B1
+1
+class B2
+B2
+2
+object B3
+B3
+3
+object B4
+B4
+4
+object B5
+B5
+5
+object B6
+B6
+6
diff --git a/test/files/run/reflection-enclosed-nested-nested-basic.scala b/test/files/run/reflection-enclosed-nested-nested-basic.scala
new file mode 100644
index 0000000000..8335ea482a
--- /dev/null
+++ b/test/files/run/reflection-enclosed-nested-nested-basic.scala
@@ -0,0 +1,54 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.reflect.{classTag, ClassTag}
+
+object B {
+  object BB {
+    class B1 { override def toString = "B1"; def foo = 1 }
+    private class B2 { override def toString = "B2"; def foo = 2 }
+    object B3 { override def toString = "B3"; def foo = 3 }
+    private object B4 { override def toString = "B4"; def foo = 4 }
+    object B5 extends B1 { override def toString = "B5"; override def foo = 5 }
+    private object B6 extends B2 { override def toString = "B6"; override def foo = 6 }
+  }
+}
+
+object Test extends App {
+  val b = cm.moduleSymbol(classTag[B.BB.type].runtimeClass)
+  println(b)
+  println(b.typeSignature.declarations.toList)
+
+  def testMethodInvocation(instance: Any) = {
+    val instanceMirror = cm.reflect(instance)
+    val method = instanceMirror.symbol.typeSignature.declaration(newTermName("foo")).asMethod
+    val methodMirror = instanceMirror.reflectMethod(method)
+    println(methodMirror())
+  }
+
+  def testNestedClass(name: String) = {
+    val sym = b.typeSignature.declaration(newTypeName(name)).asClass
+    println(sym)
+    val ctor = sym.typeSignature.declaration(newTermName("<init>")).asMethod
+    val ctorMirror = cm.reflectClass(sym).reflectConstructor(ctor)
+    val instance = ctorMirror()
+    println(instance)
+    testMethodInvocation(instance)
+  }
+
+  testNestedClass("B1")
+  testNestedClass("B2")
+
+  def testNestedModule(name: String) = {
+    val sym = b.typeSignature.declaration(newTermName(name)).asModule
+    println(sym)
+    val moduleMirror = cm.reflectModule(sym)
+    val instance = moduleMirror.instance
+    println(instance)
+    testMethodInvocation(instance)
+  }
+
+  testNestedModule("B3")
+  testNestedModule("B4")
+  testNestedModule("B5")
+  testNestedModule("B6")
+}
diff --git a/test/files/run/reflection-repl-classes.check b/test/files/run/reflection-repl-classes.check
new file mode 100644
index 0000000000..1c7f86c90c
--- /dev/null
+++ b/test/files/run/reflection-repl-classes.check
@@ -0,0 +1,35 @@
+Type in expressions to have them evaluated.

+Type :help for more information.

+

+scala> 

+

+scala> class A

+defined class A

+

+scala> 

+

+scala> class B {

+  def foo(x: A) = 1

+}

+defined class B

+

+scala> 

+

+scala> object defs {

+  val cm = reflect.runtime.currentMirror

+  val u = cm.universe

+  val im = cm.reflect(new B)

+  val method = im.symbol.typeSignature.member(u.newTermName("foo")).asMethod

+  val mm = im.reflectMethod(method)

+}

+defined module defs

+

+scala> import defs._

+import defs._

+

+scala> 

+

+scala> mm(new A)

+res0: Any = 1

+

+scala> 

diff --git a/test/files/run/reflection-repl-classes.scala b/test/files/run/reflection-repl-classes.scala
new file mode 100644
index 0000000000..80e332cde3
--- /dev/null
+++ b/test/files/run/reflection-repl-classes.scala
@@ -0,0 +1,22 @@
+import scala.tools.partest.ReplTest
+
+object Test extends ReplTest {
+  def code = """
+    |class A
+    |
+    |class B {
+    |  def foo(x: A) = 1
+    |}
+    |
+    |object defs {
+    |  val cm = reflect.runtime.currentMirror
+    |  val u = cm.universe
+    |  val im = cm.reflect(new B)
+    |  val method = im.symbol.typeSignature.member(u.newTermName("foo")).asMethod
+    |  val mm = im.reflectMethod(method)
+    |}
+    |import defs._
+    |
+    |mm(new A)
+    |""".stripMargin
+}
diff --git a/test/files/run/reflection-repl.check b/test/files/run/reflection-repl-elementary.check
index 341dd10ab0..341dd10ab0 100644
--- a/test/files/run/reflection-repl.check
+++ b/test/files/run/reflection-repl-elementary.check
diff --git a/test/files/run/reflection-repl.scala b/test/files/run/reflection-repl-elementary.scala
index 72b65a1a70..72b65a1a70 100644
--- a/test/files/run/reflection-repl.scala
+++ b/test/files/run/reflection-repl-elementary.scala
diff --git a/test/files/run/reflection-sanitychecks.check b/test/files/run/reflection-sanitychecks.check
index a1df486b51..821457a999 100644
--- a/test/files/run/reflection-sanitychecks.check
+++ b/test/files/run/reflection-sanitychecks.check
@@ -6,7 +6,7 @@ method #2: 14
 constructor #1: scala.ScalaReflectionException: expected a constructor of class D, you provided method bar
 constructor #2: scala.ScalaReflectionException: expected a constructor of class D, you provided constructor C
 class: CC
-object: java.lang.Error: inner and nested modules are not supported yet
+object: CO
 
 =========members of D in a mirror of D=========
 field #1: 21
@@ -16,7 +16,7 @@ method #2: 14
 constructor #1: scala.ScalaReflectionException: expected a constructor of class D, you provided method bar
 constructor #2: an instance of class D
 class: CC
-object: java.lang.Error: inner and nested modules are not supported yet
+object: CO
 
 =========members of E in a mirror of D=========
 field #1: scala.ScalaReflectionException: expected a member of class D, you provided value E.foo