A total rewrite of "runtimeClass", discarding t...

A total rewrite of "runtimeClass", discarding the user-space approach in
favor of simply fixing getClass.

  def f1 = 5.getClass                       // Class[Int]
  def f2 = (5: AnyVal).getClass             // Class[_ <: AnyVal]
  def f3 = (5: java.lang.Integer).getClass  // Class[_ <: java.lang.Integer]

  class A
  class B extends A

  def f1 = (new B: Any).getClass().newInstance()      // Any
  def f2 = (new B: AnyRef).getClass().newInstance()   // AnyRef
  def f3 = (new B: A).getClass().newInstance()        // A
  def f4 = (new B: B).getClass().newInstance()        // B

But that's not all!

  def f0[T >: B] = (new B: T).getClass().newInstance()

  def f5 = f0[Any]        // Any
  def f6 = f0[AnyRef]     // AnyRef
  def f7 = f0[A]          // A
  def f8 = f0[B]          // B

Closes #490, #896, #4696. Review by moors. (Note: I think this is pretty
good, but picky review requested.)

2 files changed, 84 insertions, 0 deletions

diff --git a/test/files/run/getClassTest.check b/test/files/run/getClassTest.check
new file mode 100644
index 0000000000..94e86c3889
--- /dev/null
+++ b/test/files/run/getClassTest.check
@@ -0,0 +1,18 @@
+f1: java.lang.Class<?>
+f2: java.lang.Class<?>
+f3: java.lang.Class<java.lang.Object>
+f4: java.lang.Class<? extends java.lang.Integer>
+f5: java.lang.Class<?>
+f0: T
+f1: class java.lang.Object
+f2: class java.lang.Object
+f3: class AnyRefs$A
+f4: class AnyRefs$B
+f5: class java.lang.Object
+f6: class java.lang.Object
+f7: class AnyRefs$A
+f8: class AnyRefs$B
+f1: java.lang.Class<? extends MoreAnyRefs$A>
+f2: java.lang.Class<? extends MoreAnyRefs$B>
+f3: java.lang.Class<?>
+f4: java.lang.Class<? extends MoreAnyRefs$A>
diff --git a/test/files/run/getClassTest.scala b/test/files/run/getClassTest.scala
new file mode 100644
index 0000000000..951cc8d931
--- /dev/null
+++ b/test/files/run/getClassTest.scala
@@ -0,0 +1,66 @@
+class AnyVals {
+  def f1 = (5: Any).getClass
+  def f2 = (5: AnyVal).getClass
+  def f3 = 5.getClass
+  def f4 = (5: java.lang.Integer).getClass
+  def f5 = (5.asInstanceOf[AnyRef]).getClass
+
+  // scalap says:
+  //
+  // def f1 : java.lang.Class[?0] forSome {type ?0} = { /* compiled code */ }
+  // def f2 : java.lang.Class[?0] forSome {type ?0} = { /* compiled code */ }
+  // def f3 : java.lang.Class[scala.Int] = { /* compiled code */ }
+  // def f4 : java.lang.Class[?0] forSome {type ?0 <: java.lang.Integer} = { /* compiled code */ }
+  // def f5 : java.lang.Class[?0] forSome {type ?0 <: scala.AnyRef} = { /* compiled code */ }
+  //
+  // java generic signature says:
+  //
+  // f1: java.lang.Class<?>
+  // f2: java.lang.Class<?>
+  // f3: java.lang.Class<java.lang.Object>
+  // f4: java.lang.Class<? extends java.lang.Integer>
+  // f5: java.lang.Class<?>
+}
+
+class AnyRefs {
+  class A
+  class B extends A
+
+  def f1 = (new B: Any).getClass().newInstance()
+  def f2 = (new B: AnyRef).getClass().newInstance()
+  def f3 = (new B: A).getClass().newInstance()
+  def f4 = (new B: B).getClass().newInstance()
+
+  def f0[T >: B] = (new B: T).getClass().newInstance()
+
+  def f5 = f0[Any]
+  def f6 = f0[AnyRef]
+  def f7 = f0[A]
+  def f8 = f0[B]
+}
+
+class MoreAnyRefs {
+  trait A
+  trait B
+
+  // don't leak anon/refinements
+  def f1 = (new A with B { }).getClass()
+  def f2 = (new B with A { }).getClass()
+  def f3 = (new { def bippy() = 5 }).getClass()
+  def f4 = (new A { def bippy() = 5 }).getClass()
+}
+
+object Test {
+  def returnTypes[T: Manifest] = (
+    manifest[T].erasure.getMethods.toList
+      filter (_.getName startsWith "f")
+      sortBy (_.getName)
+      map (m => m.getName + ": " + m.getGenericReturnType.toString)
+  )
+
+  def main(args: Array[String]): Unit = {
+    returnTypes[AnyVals] foreach println
+    returnTypes[AnyRefs] foreach println
+    returnTypes[MoreAnyRefs] foreach println
+  }
+}