tests and fixes for the mirror API

48 files changed, 471 insertions, 108 deletions

diff --git a/src/reflect/scala/reflect/api/Mirrors.scala b/src/reflect/scala/reflect/api/Mirrors.scala
index 2fcee8f227..348ab3656b 100644
--- a/src/reflect/scala/reflect/api/Mirrors.scala
+++ b/src/reflect/scala/reflect/api/Mirrors.scala
@@ -5,10 +5,6 @@ trait Mirrors { self: Universe =>
 
   type RuntimeClass >: Null
 
-  // [Eugene++ to Martin] how do we reflect against inner classes?
-  // presumably, we should add `reflectClass` to both InstanceMirror (inner classes) and TemplateMirror (nested classes)
-  // in the former case, the resulting ClassMirror should remember the outer instance that spawned it to use it in reflective construction
-
   // [Eugene] also, it might make sense to provide shortcuts for the API
   //
   // for example, right now to invoke the same method for several different instances, you need:
@@ -31,8 +27,8 @@ trait Mirrors { self: Universe =>
     /** The instance value reflected by this mirror */
     def instance: Any
 
-    /** The mirror corresponding to the run-time class of the reflected instance. */
-    def reflectClass: ClassMirror
+    /** The symbol corresponding to the run-time class of the reflected instance. */
+    def symbol: ClassSymbol
 
     /** Get value of field in reflected instance.
      *  @field  A field symbol that should represent a field of the instance class.
@@ -48,6 +44,12 @@ trait Mirrors { self: Universe =>
      *  @throws ???
      */
     def reflectMethod(method: MethodSymbol): MethodMirror
+
+    /** .. */
+    def reflectClass(cls: ClassSymbol): ClassMirror
+
+    /** .. */
+    def reflectModule(mod: ModuleSymbol): ModuleMirror
   }
 
   /** A mirror that reflects a field */
@@ -57,7 +59,7 @@ trait Mirrors { self: Universe =>
     def receiver: AnyRef
 
     /** The field symbol representing the field */
-    def field: TermSymbol
+    def symbol: TermSymbol
 
     /** Retrieves the value stored in the field */
     def get: Any
@@ -73,9 +75,10 @@ trait Mirrors { self: Universe =>
     def receiver: AnyRef
 
     /** The method symbol representing the method */
-    def method: MethodSymbol
+    def symbol: MethodSymbol
 
     /** The result of applying the method to the given arguments */
+    // [Eugene+++] If it's a constructor, it should account for inner classes
     def apply(args: Any*): Any
   }
 
@@ -97,8 +100,6 @@ trait Mirrors { self: Universe =>
     /** The Scala symbol corresponding to the reflected runtime class or module. */
     def symbol: Symbol
 
-    // [Eugene++ to Martin] I've removed `typeSignature`, because we can obtain it via `symbol.typeSignature`
-
     /** Optionally, the mirror of the companion reflected by this mirror.
      *  If this mirror reflects a Scala object, the mirror for the companion class, or None
      *  if the mirror represents a Scala object that comes without a class.
@@ -157,8 +158,8 @@ trait Mirrors { self: Universe =>
     def companion: Option[ModuleMirror]
   }
 
-  /** The API of a mirror for a reflective universe */
-  trait RuntimeMirror extends MirrorOf[Mirrors.this.type] { self =>
+  /** A mirror that reflects instances and static classes */
+  trait ReflectiveMirror extends MirrorOf[Mirrors.this.type] {
 
     /** A reflective mirror for the given object
      *  @param  obj   An arbitrary value
@@ -166,37 +167,15 @@ trait Mirrors { self: Universe =>
      */
     def reflect(obj: Any): InstanceMirror
 
-    /** A reflective mirror for the given Runtime class
-     *  @param  runtimeClass  A Runtime class object
-     *  @return The mirror for `runtimeClass`
-     */
-    def reflectClass(runtimeClass: RuntimeClass): ClassMirror
-
-    /** A reflective mirror for the Runtime class with the given name in the
-     *  current classloader.
-     *  @param  name  The fully qualified name of the class
-     *  @return       The mirror for the runtime class with fully qualified name
-     *                `name` in the current class loader.
-     *  @throws java.lang.ClassNotFoundException if no class with that name exists
-     *  to do: throws anything else?
-     */
-    def reflectClass(fullName: String): ClassMirror
+    /** .. */
+    def reflectClass(cls: ClassSymbol): ClassMirror
 
-    /** A reflective mirror for the given Runtime class
-     *  @param  runtimeClass  A Runtime class object
-     *  @return The mirror for `runtimeClass`
-     */
-    def reflectModule(runtimeClass: RuntimeClass): ModuleMirror
+    /** .. */
+    def reflectModule(mod: ModuleSymbol): ModuleMirror
+  }
 
-    /** A reflective mirror for the Runtime class with the given name in the
-     *  current classloader.
-     *  @param  name  The fully qualified name of the class
-     *  @return       The mirror for the runtime class with fully qualified name
-     *                `name` in the current class loader.
-     *  @throws java.lang.ClassNotFoundException if no class with that name exists
-     *  to do: throws anything else?
-     */
-    def reflectModule(fullName: String): ModuleMirror
+  /** The API of a mirror for a reflective universe */
+  trait RuntimeMirror extends ReflectiveMirror { self =>
 
     /** Maps a Scala type to the corresponding Java class object
      */
@@ -209,5 +188,21 @@ trait Mirrors { self: Universe =>
      *        because there is no unique Java class corresponding to a Scala generic array
      */
     def runtimeClass(cls: ClassSymbol): RuntimeClass
+
+    /** A class symbol for the specified runtime class.
+     *  @return The class symbol for the runtime class in the current class loader.
+     *  @throws java.lang.ClassNotFoundException if no class with that name exists
+     *  @throws scala.reflect.internal.MissingRequirementError if no corresponding symbol exists
+     *  to do: throws anything else?
+     */
+    def classSymbol(rtcls: RuntimeClass): ClassSymbol
+
+    /** A module symbol for the specified runtime class.
+     *  @return       The module symbol for the runtime class in the current class loader.
+     *  @throws java.lang.ClassNotFoundException if no class with that name exists
+     *  @throws scala.reflect.internal.MissingRequirementError if no corresponding symbol exists
+     *  to do: throws anything else?
+     */
+    def moduleSymbol(rtcls: RuntimeClass): ModuleSymbol
   }
 }
diff --git a/src/reflect/scala/reflect/api/TagInterop.scala b/src/reflect/scala/reflect/api/TagInterop.scala
index 95c4e78cf4..f1938083b5 100644
--- a/src/reflect/scala/reflect/api/TagInterop.scala
+++ b/src/reflect/scala/reflect/api/TagInterop.scala
@@ -25,7 +25,7 @@ trait TagInterop { self: JavaUniverse =>
         mirror.universe match {
           case ju: JavaUniverse =>
             val jm = mirror.asInstanceOf[ju.Mirror]
-            val sym = jm.reflectClass(manifest.erasure).symbol
+            val sym = jm.classSymbol(manifest.erasure)
             val tpe =
               if (manifest.typeArguments.isEmpty) sym.asType
               else ju.appliedType(sym.asTypeConstructor, manifest.typeArguments map (targ => ju.manifestToTypeTag(jm, targ)) map (_.in(jm).tpe))
diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
index ed03ac30f9..38d280ec73 100644
--- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala
+++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
@@ -32,6 +32,8 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
     jm
   }
 
+  override type RuntimeClass = java.lang.Class[_]
+
   override type Mirror = JavaMirror
 
   override lazy val rootMirror: Mirror = createMirror(NoSymbol, rootClassLoader)
@@ -105,30 +107,32 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
 
 // ----------- Implementations of mirror operations and classes  -------------------
 
-    def reflect(obj: Any): InstanceMirror =
-      new JavaInstanceMirror(obj.asInstanceOf[AnyRef])
-
-    def reflectClass(runtimeClass: RuntimeClass): ClassMirror =
-      new JavaClassMirror(classToScala(runtimeClass))
-
-    def reflectClass(fullName: String): ClassMirror =
-      reflectClass(java.lang.Class.forName(fullName))
+    def reflect(obj: Any): InstanceMirror = new JavaInstanceMirror(obj.asInstanceOf[AnyRef])
 
-    def reflectModule(runtimeClass: RuntimeClass): ModuleMirror =
-      new JavaModuleMirror(classToScala(runtimeClass).companionModule.asModuleSymbol)
+    def reflectClass(cls: ClassSymbol): ClassMirror = {
+      if (!cls.isStatic) throw new Error("this is an inner class, use reflectClass on an InstanceMirror to obtain its ClassMirror")
+      new JavaClassMirror(null, cls)
+    }
 
-    def reflectModule(fullName: String): ModuleMirror =
-      reflectModule(java.lang.Class.forName(fullName))
+    def reflectModule(mod: ModuleSymbol): ModuleMirror = {
+      if (!mod.isStatic) throw new Error("this is an inner module, use reflectModule on an InstanceMirror to obtain its ModuleMirror")
+      new JavaModuleMirror(null, mod)
+    }
 
     def runtimeClass(tpe: Type): RuntimeClass = typeToJavaClass(tpe)
 
     def runtimeClass(cls: ClassSymbol): RuntimeClass = classToJava(cls)
 
+    def classSymbol(rtcls: RuntimeClass): ClassSymbol = classToScala(rtcls)
+
+    def moduleSymbol(rtcls: RuntimeClass): ModuleSymbol = classToScala(rtcls).companionModule.asModuleSymbol
+
     private class JavaInstanceMirror(obj: AnyRef)
             extends InstanceMirror {
       def instance = obj
-      def reflectClass = wholemirror.reflectClass(obj.getClass)
+      def symbol = wholemirror.classSymbol(obj.getClass)
       def reflectField(field: TermSymbol): FieldMirror = {
+        // [Eugene+++] check whether `field` represents a member of a `symbol`
         if (field.isMethod || field.isModule) throw new Error(s"""
           |expected a field symbol, you provided a ${field.kind} symbol
           |A typical cause of this problem is using a field accessor symbol instead of a field symbol.
@@ -139,79 +143,101 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
         """.trim.stripMargin)
         new JavaFieldMirror(obj, field)
       }
-      def reflectMethod(method: MethodSymbol): MethodMirror = new JavaMethodMirror(obj, method)
+      def reflectMethod(method: MethodSymbol): MethodMirror = {
+        // [Eugene+++] check whether `method` represents a member of a `symbol`
+        new JavaMethodMirror(obj, method)
+      }
+      def reflectClass(cls: ClassSymbol): ClassMirror = {
+        // [Eugene+++] check whether `cls` represents a member of a `symbol`
+        if (cls.isStatic) throw new Error("this is a static class, use reflectClass on a RuntimeMirror to obtain its ClassMirror")
+        new JavaClassMirror(instance, cls)
+      }
+      def reflectModule(mod: ModuleSymbol): ModuleMirror = {
+        // [Eugene+++] check whether `mod` represents a member of a `symbol`
+        if (mod.isStatic) throw new Error("this is a static module, use reflectModule on a RuntimeMirror to obtain its ModuleMirror")
+        new JavaModuleMirror(instance, mod)
+      }
     }
 
-    private class JavaFieldMirror(val receiver: AnyRef, val field: TermSymbol)
+    private class JavaFieldMirror(val receiver: AnyRef, val symbol: TermSymbol)
             extends FieldMirror {
       lazy val jfield = {
-        val jfield = fieldToJava(field)
+        val jfield = fieldToJava(symbol)
         if (!jfield.isAccessible) jfield.setAccessible(true)
         jfield
       }
       def get = jfield.get(receiver)
       def set(value: Any) = {
-        if (!field.isMutable) throw new Error("cannot set an immutable field")
+        if (!symbol.isMutable) throw new Error("cannot set an immutable field")
         jfield.set(receiver, value)
       }
     }
 
-    private class JavaMethodMirror(val receiver: AnyRef, val method: MethodSymbol)
+    private class JavaMethodMirror(val receiver: AnyRef, val symbol: MethodSymbol)
             extends MethodMirror {
       lazy val jmeth = {
-        val jmeth = methodToJava(method)
+        val jmeth = methodToJava(symbol)
         if (!jmeth.isAccessible) jmeth.setAccessible(true)
         jmeth
       }
       def apply(args: Any*): Any =
-        if (method.owner == ArrayClass)
-          method.name match {
+        if (symbol.owner == ArrayClass)
+          symbol.name match {
             case nme.length => jArray.getLength(receiver)
             case nme.apply => jArray.get(receiver, args(0).asInstanceOf[Int])
             case nme.update => jArray.set(receiver, args(0).asInstanceOf[Int], args(1))
-            case _ => throw new Error(s"unexpected array method $method")
+            case _ => throw new Error(s"unexpected array method $symbol")
           }
         else
           jmeth.invoke(receiver, args.asInstanceOf[Seq[AnyRef]]: _*)
     }
 
-    private class JavaConstructorMirror(val method: MethodSymbol)
+    private class JavaConstructorMirror(val outer: AnyRef, val symbol: MethodSymbol)
             extends MethodMirror {
-      override val receiver = null
+      override val receiver = outer
       lazy val jconstr = {
-        val jconstr = constructorToJava(method)
+        val jconstr = constructorToJava(symbol)
         if (!jconstr.isAccessible) jconstr.setAccessible(true)
         jconstr
       }
-      def apply(args: Any*): Any = jconstr.newInstance(args.asInstanceOf[Seq[AnyRef]]: _*)
+      def apply(args: Any*): Any = {
+        val effectiveArgs =
+          if (outer == null) args.asInstanceOf[Seq[AnyRef]]
+          else outer +: args.asInstanceOf[Seq[AnyRef]]
+        jconstr.newInstance(effectiveArgs: _*)
+      }
     }
 
 
     private abstract class JavaTemplateMirror
             extends TemplateMirror {
+      def outer: AnyRef
       def erasure: ClassSymbol
       lazy val runtimeClass = classToJava(erasure)
       lazy val signature = typeToScala(runtimeClass)
     }
 
-    private class JavaClassMirror(val symbol: ClassSymbol)
+    private class JavaClassMirror(val outer: AnyRef, val symbol: ClassSymbol)
             extends JavaTemplateMirror with ClassMirror {
       def erasure = symbol
       def isStatic = false
-      def reflectConstructor(constructor: MethodSymbol) = new JavaConstructorMirror(constructor)
+      def reflectConstructor(constructor: MethodSymbol) = new JavaConstructorMirror(outer, constructor)
       def companion: Option[ModuleMirror] = symbol.companionModule match {
-       case module: ModuleSymbol => Some(new JavaModuleMirror(module))
+       case module: ModuleSymbol => Some(new JavaModuleMirror(outer, module))
        case _ => None
       }
     }
 
-    private class JavaModuleMirror(val symbol: ModuleSymbol)
+    private class JavaModuleMirror(val outer: AnyRef, val symbol: ModuleSymbol)
             extends JavaTemplateMirror with ModuleMirror {
       def erasure = symbol.moduleClass.asClassSymbol
       def isStatic = true
-      def instance = singletonInstance(classLoader, symbol.fullName)
+      def instance = {
+        if (!symbol.owner.isPackageClass) throw new Error("inner and nested modules are not supported yet")
+        singletonInstance(classLoader, symbol.fullName)
+      }
       def companion: Option[ClassMirror] = symbol.companionClass match {
-        case cls: ClassSymbol => Some(new JavaClassMirror(cls))
+        case cls: ClassSymbol => Some(new JavaClassMirror(outer, cls))
         case _ => None
       }
     }
@@ -929,7 +955,10 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
     def constructorToJava(constr: MethodSymbol): jConstructor[_] = constructorCache.toJava(constr) {
       val jclazz = classToJava(constr.owner.asClassSymbol)
       val paramClasses = transformedType(constr).paramTypes map typeToJavaClass
-      jclazz getConstructor (paramClasses: _*)
+      val effectiveParamClasses =
+        if (!constr.owner.owner.isStaticOwner) jclazz.getEnclosingClass +: paramClasses
+        else paramClasses
+      jclazz getConstructor (effectiveParamClasses: _*)
     }
 
     private def jArrayClass(elemClazz: jClass[_]): jClass[_] = {
diff --git a/test/files/run/reflect-overload.scala b/test/files/run/reflect-overload.scala
index ea3767903c..870a200813 100644
--- a/test/files/run/reflect-overload.scala
+++ b/test/files/run/reflect-overload.scala
@@ -5,7 +5,7 @@ object Test extends App {
 
   val s = "hello world"
   val m = cm.reflect(s)
-  val sc = m.reflectClass.symbol
+  val sc = m.symbol
   val st = sc.asType
   val meth = (st member newTermName("indexOf")).asTermSymbol
   val IntType = definitions.IntClass.asType
diff --git a/test/files/run/reflection-constructormirror-inner-badpath.check b/test/files/run/reflection-constructormirror-inner-badpath.check
new file mode 100644
index 0000000000..28b936eca1
--- /dev/null
+++ b/test/files/run/reflection-constructormirror-inner-badpath.check
@@ -0,0 +1,2 @@
+this is an inner class, use reflectClass on an InstanceMirror to obtain its ClassMirror

+()

diff --git a/test/files/run/reflection-constructormirror-inner-badpath.scala b/test/files/run/reflection-constructormirror-inner-badpath.scala
new file mode 100644
index 0000000000..a42bedea83
--- /dev/null
+++ b/test/files/run/reflection-constructormirror-inner-badpath.scala
@@ -0,0 +1,32 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.ClassTag
+
+class Foo{
+  case class R(
+    sales : Int,
+    name : String
+  )
+
+ def foo = {
+  val expectedType = implicitly[TypeTag[R]]
+  val classTag = implicitly[ClassTag[R]]
+  val cl = classTag.runtimeClass.getClassLoader
+  val cm = runtimeMirror(cl)
+  val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethodSymbol
+  val sig = constructor.typeSignature
+  val sym = cm.classSymbol( classTag.runtimeClass )
+  try {
+    val cls = cm.reflectClass( sym )
+    cls.reflectConstructor( constructor )( 5,"test" ).asInstanceOf[R]
+    println("this indicates a failure")
+  } catch {
+    case ex: Throwable =>
+      println(ex.getMessage)
+  }
+ }
+
+}
+object Test extends App{
+  val foo = new Foo
+  println( foo.foo )
+}
\ No newline at end of file
diff --git a/test/files/run/reflection-constructormirror-inner-good.check b/test/files/run/reflection-constructormirror-inner-good.check
new file mode 100644
index 0000000000..811ecb2e3f
--- /dev/null
+++ b/test/files/run/reflection-constructormirror-inner-good.check
@@ -0,0 +1 @@
+R(5,test)

diff --git a/test/files/run/reflection-constructormirror-inner-good.scala b/test/files/run/reflection-constructormirror-inner-good.scala
new file mode 100644
index 0000000000..c09f464b24
--- /dev/null
+++ b/test/files/run/reflection-constructormirror-inner-good.scala
@@ -0,0 +1,26 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.ClassTag
+
+class Foo{
+  case class R(
+    sales : Int,
+    name : String
+  )
+
+ def foo = {
+  val expectedType = implicitly[TypeTag[R]]
+  val classTag = implicitly[ClassTag[R]]
+  val cl = classTag.runtimeClass.getClassLoader
+  val cm = runtimeMirror(cl)
+  val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethodSymbol
+  val sig = constructor.typeSignature
+  val sym = cm.classSymbol( classTag.runtimeClass )
+  val cls = cm.reflect( this ).reflectClass( sym )
+  cls.reflectConstructor( constructor )( 5,"test" ).asInstanceOf[R]
+ }
+
+}
+object Test extends App{
+  val foo = new Foo
+  println( foo.foo )
+}
\ No newline at end of file
diff --git a/test/files/run/reflection-constructormirror-nested-badpath.check b/test/files/run/reflection-constructormirror-nested-badpath.check
new file mode 100644
index 0000000000..9ceb603dc2
--- /dev/null
+++ b/test/files/run/reflection-constructormirror-nested-badpath.check
@@ -0,0 +1,2 @@
+this is a static class, use reflectClass on a RuntimeMirror to obtain its ClassMirror

+()

diff --git a/test/files/run/reflection-constructormirror-nested-badpath.scala b/test/files/run/reflection-constructormirror-nested-badpath.scala
new file mode 100644
index 0000000000..ece0044c61
--- /dev/null
+++ b/test/files/run/reflection-constructormirror-nested-badpath.scala
@@ -0,0 +1,32 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.ClassTag
+
+class Foo{
+ import Test._
+ def foo = {
+  val expectedType = implicitly[TypeTag[R]]
+  val classTag = implicitly[ClassTag[R]]
+  val cl = classTag.runtimeClass.getClassLoader
+  val cm = runtimeMirror(cl)
+  val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethodSymbol
+  val sig = constructor.typeSignature
+  val sym = cm.classSymbol( classTag.runtimeClass )
+  try {
+    val cls = cm.reflect( this ).reflectClass( sym )
+    cls.reflectConstructor( constructor )( 5,"test" ).asInstanceOf[R]
+    println("this indicates a failure")
+  } catch {
+    case ex: Throwable =>
+      println(ex.getMessage)
+  }
+ }
+
+}
+object Test extends App{
+  case class R(
+    sales : Int,
+    name : String
+  )
+  val foo = new Foo
+  println( foo.foo )
+}
\ No newline at end of file
diff --git a/test/files/run/reflection-constructormirror-nested-good.check b/test/files/run/reflection-constructormirror-nested-good.check
new file mode 100644
index 0000000000..811ecb2e3f
--- /dev/null
+++ b/test/files/run/reflection-constructormirror-nested-good.check
@@ -0,0 +1 @@
+R(5,test)

diff --git a/test/files/run/reflection-constructormirror-nested-good.scala b/test/files/run/reflection-constructormirror-nested-good.scala
new file mode 100644
index 0000000000..432e9d3707
--- /dev/null
+++ b/test/files/run/reflection-constructormirror-nested-good.scala
@@ -0,0 +1,26 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.ClassTag
+
+class Foo{
+ import Test._
+ def foo = {
+  val expectedType = implicitly[TypeTag[R]]
+  val classTag = implicitly[ClassTag[R]]
+  val cl = classTag.runtimeClass.getClassLoader
+  val cm = runtimeMirror(cl)
+  val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethodSymbol
+  val sig = constructor.typeSignature
+  val sym = cm.classSymbol( classTag.runtimeClass )
+  val cls = cm.reflectClass( sym )
+  cls.reflectConstructor( constructor )( 5,"test" ).asInstanceOf[R]
+ }
+}
+
+object Test extends App{
+  case class R(
+    sales : Int,
+    name : String
+  )
+  val foo = new Foo
+  println( foo.foo )
+}
\ No newline at end of file
diff --git a/test/files/run/reflection-constructormirror-toplevel-badpath.check b/test/files/run/reflection-constructormirror-toplevel-badpath.check
new file mode 100644
index 0000000000..9ceb603dc2
--- /dev/null
+++ b/test/files/run/reflection-constructormirror-toplevel-badpath.check
@@ -0,0 +1,2 @@
+this is a static class, use reflectClass on a RuntimeMirror to obtain its ClassMirror

+()

diff --git a/test/files/run/reflection-constructormirror-toplevel-badpath.scala b/test/files/run/reflection-constructormirror-toplevel-badpath.scala
new file mode 100644
index 0000000000..7a7adbd603
--- /dev/null
+++ b/test/files/run/reflection-constructormirror-toplevel-badpath.scala
@@ -0,0 +1,33 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.ClassTag
+
+case class R(
+  sales : Int,
+  name : String
+)
+
+class Foo{
+ import Test._
+ def foo = {
+  val expectedType = implicitly[TypeTag[R]]
+  val classTag = implicitly[ClassTag[R]]
+  val cl = classTag.runtimeClass.getClassLoader
+  val cm = runtimeMirror(cl)
+  val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethodSymbol
+  val sig = constructor.typeSignature
+  val sym = cm.classSymbol( classTag.runtimeClass )
+  try {
+    val cls = cm.reflect( this ).reflectClass( sym )
+    cls.reflectConstructor( constructor )( 5,"test" ).asInstanceOf[R]
+    println("this indicates a failure")
+  } catch {
+    case ex: Throwable =>
+      println(ex.getMessage)
+  }
+ }
+}
+
+object Test extends App{
+  val foo = new Foo
+  println( foo.foo )
+}
\ No newline at end of file
diff --git a/test/files/run/reflection-constructormirror-toplevel-good.check b/test/files/run/reflection-constructormirror-toplevel-good.check
new file mode 100644
index 0000000000..811ecb2e3f
--- /dev/null
+++ b/test/files/run/reflection-constructormirror-toplevel-good.check
@@ -0,0 +1 @@
+R(5,test)

diff --git a/test/files/run/reflection-constructormirror-toplevel-good.scala b/test/files/run/reflection-constructormirror-toplevel-good.scala
new file mode 100644
index 0000000000..96713a11cb
--- /dev/null
+++ b/test/files/run/reflection-constructormirror-toplevel-good.scala
@@ -0,0 +1,27 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.ClassTag
+
+case class R(
+  sales : Int,
+  name : String
+)
+
+class Foo{
+ import Test._
+ def foo = {
+  val expectedType = implicitly[TypeTag[R]]
+  val classTag = implicitly[ClassTag[R]]
+  val cl = classTag.runtimeClass.getClassLoader
+  val cm = runtimeMirror(cl)
+  val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethodSymbol
+  val sig = constructor.typeSignature
+  val sym = cm.classSymbol( classTag.runtimeClass )
+  val cls = cm.reflectClass( sym )
+  cls.reflectConstructor( constructor )( 5,"test" ).asInstanceOf[R]
+ }
+}
+
+object Test extends App{
+  val foo = new Foo
+  println( foo.foo )
+}
\ No newline at end of file
diff --git a/test/files/run/reflection-fieldmirror-ctorparam.scala b/test/files/run/reflection-fieldmirror-ctorparam.scala
index 286399072e..fa9dd81d7f 100644
--- a/test/files/run/reflection-fieldmirror-ctorparam.scala
+++ b/test/files/run/reflection-fieldmirror-ctorparam.scala
@@ -9,7 +9,7 @@ object Test extends App {
   val a = new A(42)
 
   val im: InstanceMirror = cm.reflect(a)
-  val cs = im.reflectClass.symbol
+  val cs = im.symbol
   val f = cs.typeSignature.declaration(newTermName("x")).asTermSymbol
   try {
     val fm: FieldMirror = im.reflectField(f)
diff --git a/test/files/run/reflection-fieldmirror-getsetval.scala b/test/files/run/reflection-fieldmirror-getsetval.scala
index aeae66b422..af9a6e4c56 100644
--- a/test/files/run/reflection-fieldmirror-getsetval.scala
+++ b/test/files/run/reflection-fieldmirror-getsetval.scala
@@ -9,7 +9,7 @@ object Test extends App {
   val a = new A
 
   val im: InstanceMirror = cm.reflect(a)
-  val cs = im.reflectClass.symbol
+  val cs = im.symbol
   val f = cs.typeSignature.declaration(newTermName("x" + nme.LOCAL_SUFFIX_STRING)).asTermSymbol
   val fm: FieldMirror = im.reflectField(f)
   try {
diff --git a/test/files/run/reflection-fieldmirror-getsetvar.scala b/test/files/run/reflection-fieldmirror-getsetvar.scala
index 99ecc8996c..d9fbdaade0 100644
--- a/test/files/run/reflection-fieldmirror-getsetvar.scala
+++ b/test/files/run/reflection-fieldmirror-getsetvar.scala
@@ -9,7 +9,7 @@ object Test extends App {
   val a = new A
 
   val im: InstanceMirror = cm.reflect(a)
-  val cs = im.reflectClass.symbol
+  val cs = im.symbol
   val f = cs.typeSignature.declaration(newTermName("x" + nme.LOCAL_SUFFIX_STRING)).asTermSymbol
   val fm: FieldMirror = im.reflectField(f)
   println(fm.get)
diff --git a/test/files/run/reflection-fieldmirror-nmelocalsuffixstring.scala b/test/files/run/reflection-fieldmirror-nmelocalsuffixstring.scala
index 9dca7b452c..d89e6a90ef 100644
--- a/test/files/run/reflection-fieldmirror-nmelocalsuffixstring.scala
+++ b/test/files/run/reflection-fieldmirror-nmelocalsuffixstring.scala
@@ -9,8 +9,8 @@ object Test extends App {
   val a = new A
 
   val im: InstanceMirror = cm.reflect(a)
-  val cs = im.reflectClass.symbol
+  val cs = im.symbol
   val f = cs.typeSignature.declaration(newTermName("x" + nme.LOCAL_SUFFIX_STRING)).asTermSymbol
   val fm: FieldMirror = im.reflectField(f)
-  println(fm.field.isVariable)
+  println(fm.symbol.isVariable)
 }
diff --git a/test/files/run/reflection-fieldmirror-privatethis.scala b/test/files/run/reflection-fieldmirror-privatethis.scala
index 844822d449..0c415e09e4 100644
--- a/test/files/run/reflection-fieldmirror-privatethis.scala
+++ b/test/files/run/reflection-fieldmirror-privatethis.scala
@@ -9,10 +9,10 @@ object Test extends App {
   val a = new A
 
   val im: InstanceMirror = cm.reflect(a)
-  val cs = im.reflectClass.symbol
+  val cs = im.symbol
   val f = cs.typeSignature.declaration(newTermName("x")).asTermSymbol
   val fm: FieldMirror = im.reflectField(f)
-  println(fm.field.isVariable)
+  println(fm.symbol.isVariable)
   println(fm.get)
   fm.set(2)
   println(fm.get)
diff --git a/test/files/run/reflection-fieldmirror-sanitycheck.scala b/test/files/run/reflection-fieldmirror-sanitycheck.scala
index abd4cf57c5..6a992dd282 100644
--- a/test/files/run/reflection-fieldmirror-sanitycheck.scala
+++ b/test/files/run/reflection-fieldmirror-sanitycheck.scala
@@ -9,7 +9,7 @@ object Test extends App {
   val a = new A
 
   val im: InstanceMirror = cm.reflect(a)
-  val cs = im.reflectClass.symbol
+  val cs = im.symbol
   //val f = cs.typeSignature.declaration(newTermName("x" + nme.LOCAL_SUFFIX_STRING)).asTermSymbol
   val f = cs.typeSignature.declaration(newTermName("x")).asTermSymbol
   try {
diff --git a/test/files/run/reflection-implClass.scala b/test/files/run/reflection-implClass.scala
index 91288562f4..b3c0081ccf 100644
--- a/test/files/run/reflection-implClass.scala
+++ b/test/files/run/reflection-implClass.scala
@@ -10,8 +10,8 @@ object Test extends App with Outer {
   import scala.reflect.runtime.universe._
   import scala.reflect.runtime.{currentMirror => cm}
 
-  assert(cm.reflectClass(classTag[Foo].runtimeClass).symbol.typeSignature.declaration(newTermName("bar")).typeSignature ==
-    cm.reflectClass(classTag[Bar].runtimeClass).symbol.typeSignature.declaration(newTermName("foo")).typeSignature)
+  assert(cm.classSymbol(classTag[Foo].runtimeClass).typeSignature.declaration(newTermName("bar")).typeSignature ==
+    cm.classSymbol(classTag[Bar].runtimeClass).typeSignature.declaration(newTermName("foo")).typeSignature)
 
   val s1 = implClass(classTag[Foo].runtimeClass)
   assert(s1 != NoSymbol)
@@ -25,7 +25,7 @@ object Test extends App with Outer {
   assert(s2.companionSymbol.typeSignature.declaration(newTermName("foo")) != NoSymbol)
   def implClass(clazz: Class[_]) = {
     val implClass = Class.forName(clazz.getName + "$class")
-    cm.reflectClass(implClass).symbol
+    cm.classSymbol(implClass)
   }
 }
 
diff --git a/test/files/run/reflection-modulemirror-inner-badpath.check b/test/files/run/reflection-modulemirror-inner-badpath.check
new file mode 100644
index 0000000000..d3fe43336e
--- /dev/null
+++ b/test/files/run/reflection-modulemirror-inner-badpath.check
@@ -0,0 +1,2 @@
+this is an inner module, use reflectModule on an InstanceMirror to obtain its ModuleMirror
+()
diff --git a/test/files/run/reflection-modulemirror-inner-badpath.scala b/test/files/run/reflection-modulemirror-inner-badpath.scala
new file mode 100644
index 0000000000..de200c548b
--- /dev/null
+++ b/test/files/run/reflection-modulemirror-inner-badpath.scala
@@ -0,0 +1,24 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.reflect.ClassTag
+
+class Foo{
+ object R { override def toString = "R" }
+ def foo = {
+  val classTag = implicitly[ClassTag[R.type]]
+  val sym = cm.moduleSymbol(classTag.runtimeClass)
+  try {
+    val cls = cm.reflectModule(sym)
+    cls.instance
+    println("this indicates a failure")
+  } catch {
+    case ex: Throwable =>
+      println(ex.getMessage)
+  }
+ }
+}
+
+object Test extends App{
+  val foo = new Foo
+  println(foo.foo)
+}
\ No newline at end of file
diff --git a/test/files/run/reflection-modulemirror-inner-good.check b/test/files/run/reflection-modulemirror-inner-good.check
new file mode 100644
index 0000000000..0bf38a73d1
--- /dev/null
+++ b/test/files/run/reflection-modulemirror-inner-good.check
@@ -0,0 +1,2 @@
+inner and nested modules are not supported yet

+()

diff --git a/test/files/run/reflection-modulemirror-inner-good.scala b/test/files/run/reflection-modulemirror-inner-good.scala
new file mode 100644
index 0000000000..b5540dbe1c
--- /dev/null
+++ b/test/files/run/reflection-modulemirror-inner-good.scala
@@ -0,0 +1,23 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.reflect.ClassTag
+
+class Foo{
+ object R { override def toString = "R" }
+ def foo = {
+  val classTag = implicitly[ClassTag[R.type]]
+  val sym = cm.moduleSymbol(classTag.runtimeClass)
+  val cls = cm.reflect(this).reflectModule(sym)
+  try {
+    cls.instance
+  } catch {
+    case ex: Throwable =>
+      println(ex.getMessage)
+  }
+ }
+}
+
+object Test extends App{
+  val foo = new Foo
+  println(foo.foo)
+}
\ No newline at end of file
diff --git a/test/files/run/reflection-modulemirror-nested-badpath.check b/test/files/run/reflection-modulemirror-nested-badpath.check
new file mode 100644
index 0000000000..16a5b10390
--- /dev/null
+++ b/test/files/run/reflection-modulemirror-nested-badpath.check
@@ -0,0 +1,2 @@
+this is a static module, use reflectModule on a RuntimeMirror to obtain its ModuleMirror
+()
diff --git a/test/files/run/reflection-modulemirror-nested-badpath.scala b/test/files/run/reflection-modulemirror-nested-badpath.scala
new file mode 100644
index 0000000000..43cae00f9c
--- /dev/null
+++ b/test/files/run/reflection-modulemirror-nested-badpath.scala
@@ -0,0 +1,26 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.reflect.ClassTag
+
+class Foo{
+ import Test._
+ def foo = {
+  val classTag = implicitly[ClassTag[R.type]]
+  val sym = cm.moduleSymbol(classTag.runtimeClass)
+  try {
+    val cls = cm.reflect(this).reflectModule(sym)
+    cls.instance
+    println("this indicates a failure")
+  } catch {
+    case ex: Throwable =>
+      println(ex.getMessage)
+  }
+ }
+
+}
+
+object Test extends App{
+  object R { override def toString = "R" }
+  val foo = new Foo
+  println(foo.foo)
+}
diff --git a/test/files/run/reflection-modulemirror-nested-good.check b/test/files/run/reflection-modulemirror-nested-good.check
new file mode 100644
index 0000000000..0bf38a73d1
--- /dev/null
+++ b/test/files/run/reflection-modulemirror-nested-good.check
@@ -0,0 +1,2 @@
+inner and nested modules are not supported yet

+()

diff --git a/test/files/run/reflection-modulemirror-nested-good.scala b/test/files/run/reflection-modulemirror-nested-good.scala
new file mode 100644
index 0000000000..8390bbaac7
--- /dev/null
+++ b/test/files/run/reflection-modulemirror-nested-good.scala
@@ -0,0 +1,24 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.reflect.ClassTag
+
+class Foo{
+ import Test._
+ def foo = {
+  val classTag = implicitly[ClassTag[R.type]]
+  val sym = cm.moduleSymbol(classTag.runtimeClass)
+  val cls = cm.reflectModule(sym)
+  try {
+    cls.instance
+  } catch {
+    case ex: Throwable =>
+      println(ex.getMessage)
+  }
+ }
+}
+
+object Test extends App{
+  object R { override def toString = "R" }
+  val foo = new Foo
+  println(foo.foo)
+}
\ No newline at end of file
diff --git a/test/files/run/reflection-modulemirror-toplevel-badpath.check b/test/files/run/reflection-modulemirror-toplevel-badpath.check
new file mode 100644
index 0000000000..16a5b10390
--- /dev/null
+++ b/test/files/run/reflection-modulemirror-toplevel-badpath.check
@@ -0,0 +1,2 @@
+this is a static module, use reflectModule on a RuntimeMirror to obtain its ModuleMirror
+()
diff --git a/test/files/run/reflection-modulemirror-toplevel-badpath.scala b/test/files/run/reflection-modulemirror-toplevel-badpath.scala
new file mode 100644
index 0000000000..8b2994cabb
--- /dev/null
+++ b/test/files/run/reflection-modulemirror-toplevel-badpath.scala
@@ -0,0 +1,26 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.reflect.ClassTag
+
+object R { override def toString = "R" }
+
+class Foo{
+ import Test._
+ def foo = {
+  val classTag = implicitly[ClassTag[R.type]]
+  val sym = cm.moduleSymbol(classTag.runtimeClass)
+  try {
+    val cls = cm.reflect(this).reflectModule(sym)
+    cls.instance
+    println("this indicates a failure")
+  } catch {
+    case ex: Throwable =>
+      println(ex.getMessage)
+  }
+ }
+}
+
+object Test extends App{
+  val foo = new Foo
+  println(foo.foo)
+}
\ No newline at end of file
diff --git a/test/files/run/reflection-modulemirror-toplevel-good.check b/test/files/run/reflection-modulemirror-toplevel-good.check
new file mode 100644
index 0000000000..ac044e5e46
--- /dev/null
+++ b/test/files/run/reflection-modulemirror-toplevel-good.check
@@ -0,0 +1 @@
+R
\ No newline at end of file
diff --git a/test/files/run/reflection-modulemirror-toplevel-good.scala b/test/files/run/reflection-modulemirror-toplevel-good.scala
new file mode 100644
index 0000000000..0663136a22
--- /dev/null
+++ b/test/files/run/reflection-modulemirror-toplevel-good.scala
@@ -0,0 +1,20 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.reflect.ClassTag
+
+object R { override def toString = "R" }
+
+class Foo{
+ import Test._
+ def foo = {
+  val classTag = implicitly[ClassTag[R.type]]
+  val sym = cm.moduleSymbol(classTag.runtimeClass)
+  val cls = cm.reflectModule(sym)
+  cls.instance
+ }
+}
+
+object Test extends App{
+  val foo = new Foo
+  println(foo.foo)
+}
\ No newline at end of file
diff --git a/test/files/run/reflection-simple.scala b/test/files/run/reflection-simple.scala
index 152d8c4505..ec34b71cec 100644
--- a/test/files/run/reflection-simple.scala
+++ b/test/files/run/reflection-simple.scala
@@ -6,7 +6,7 @@ object Test  {
     System.out.println("Running")
     case class Foo(a: Int, b: Int, c: Int)
     import scala.reflect.runtime.{currentMirror => cm}
-    val props = cm.reflectClass(classOf[Foo]).symbol.typeSignature.members.filter(_.isTerm).map(_.toString)
+    val props = cm.classSymbol(classOf[Foo]).typeSignature.members.filter(_.isTerm).map(_.toString)
     props.toList.sorted foreach System.out.println
   }
 }
diff --git a/test/files/run/t5256a.scala b/test/files/run/t5256a.scala
index e3d22f8a93..84ef97b0d2 100644
--- a/test/files/run/t5256a.scala
+++ b/test/files/run/t5256a.scala
@@ -4,7 +4,7 @@ import scala.reflect.runtime.{currentMirror => cm}
 class A { def foo = ??? }
 
 object Test extends App {
-  val c = cm.reflectClass(classOf[A]).symbol
+  val c = cm.classSymbol(classOf[A])
   println(c)
   println(c.fullName)
   println(c.typeSignature)
diff --git a/test/files/run/t5256b.scala b/test/files/run/t5256b.scala
index fedec6323d..0ffab8a668 100644
--- a/test/files/run/t5256b.scala
+++ b/test/files/run/t5256b.scala
@@ -3,7 +3,7 @@ import scala.reflect.runtime.{currentMirror => cm}
 
 object Test extends App {
   class A { def foo = ??? }
-  val c = cm.reflectClass(classOf[A]).symbol
+  val c = cm.classSymbol(classOf[A])
   println(c)
   println(c.fullName)
   println(c.typeSignature)
diff --git a/test/files/run/t5256c.scala b/test/files/run/t5256c.scala
index a8a3323443..d56215f6eb 100644
--- a/test/files/run/t5256c.scala
+++ b/test/files/run/t5256c.scala
@@ -4,7 +4,7 @@ import scala.reflect.runtime.{currentMirror => cm}
 object Test extends App {
   {
     class A { def foo = ??? }
-    val c = cm.reflectClass(classOf[A]).symbol
+    val c = cm.classSymbol(classOf[A])
     println(c)
     println(c.fullName)
     println(c.typeSignature)
diff --git a/test/files/run/t5256d.check b/test/files/run/t5256d.check
index e466e1e2e8..dd32c05a93 100644
--- a/test/files/run/t5256d.check
+++ b/test/files/run/t5256d.check
@@ -12,7 +12,7 @@ import scala.reflect.runtime.{currentMirror=>cm}
 scala> class A { def foo = ??? }

 defined class A

 

-scala> val c = cm.reflectClass(classOf[A]).symbol

+scala> val c = cm.classSymbol(classOf[A])

 c: reflect.runtime.universe.ClassSymbol = class A

 

 scala> println(c)

diff --git a/test/files/run/t5256d.scala b/test/files/run/t5256d.scala
index 574013f444..24ac1eb316 100644
--- a/test/files/run/t5256d.scala
+++ b/test/files/run/t5256d.scala
@@ -5,7 +5,7 @@ object Test extends ReplTest {
 import scala.reflect.runtime.universe._
 import scala.reflect.runtime.{currentMirror => cm}
 class A { def foo = ??? }
-val c = cm.reflectClass(classOf[A]).symbol
+val c = cm.classSymbol(classOf[A])
 println(c)
 println(c.fullName)
 println(c.typeSignature)
diff --git a/test/files/run/t5256e.check b/test/files/run/t5256e.check
index 20ea35c74d..6c6de90acc 100644
--- a/test/files/run/t5256e.check
+++ b/test/files/run/t5256e.check
@@ -1,6 +1,6 @@
-class A

-Test.C.A

+class A
+Test.C.A
 Object {
   def <init>: <?>
   def foo: <?>
-}

+}
diff --git a/test/files/run/t5256e.scala b/test/files/run/t5256e.scala
index 32031f919a..f83546f2c0 100644
--- a/test/files/run/t5256e.scala
+++ b/test/files/run/t5256e.scala
@@ -3,7 +3,7 @@ import scala.reflect.runtime.{currentMirror => cm}
 
 object Test extends App {
   class C { class A { def foo = ??? } }
-  val c = cm.reflectClass(classOf[C#A]).symbol
+  val c = cm.classSymbol(classOf[C#A])
   println(c)
   println(c.fullName)
   println(c.typeSignature)
diff --git a/test/files/run/t5256f.check b/test/files/run/t5256f.check
index 7a58aa003d..c840793fd5 100644
--- a/test/files/run/t5256f.check
+++ b/test/files/run/t5256f.check
@@ -1,12 +1,12 @@
-class A1

-Test.A1

+class A1
+Test.A1
 Object {
   def <init>: <?>
   def foo: <?>
-}

-class A2

-Test.A2

+}
+class A2
+Test.A2
 Object {
   def <init>: <?>
   def foo: <?>
-}

+}
diff --git a/test/files/run/t5256f.scala b/test/files/run/t5256f.scala
index 072f927abc..80c7ad8018 100644
--- a/test/files/run/t5256f.scala
+++ b/test/files/run/t5256f.scala
@@ -4,7 +4,7 @@ import scala.reflect.runtime.{currentMirror => cm}
 object Test extends App {
   class A1 { def foo = ??? }
 
-  val c1 = cm.reflectClass(classOf[A1]).symbol
+  val c1 = cm.classSymbol(classOf[A1])
   println(c1)
   println(c1.fullName)
   println(c1.typeSignature)
@@ -15,7 +15,7 @@ object Test extends App {
 class Test {
   class A2 { def foo = ??? }
 
-  val c2 = cm.reflectClass(classOf[A2]).symbol
+  val c2 = cm.classSymbol(classOf[A2])
   println(c2)
   println(c2.fullName)
   println(c2.typeSignature)
diff --git a/test/files/run/t5256g.scala b/test/files/run/t5256g.scala
index a4d81a28dc..358c18601a 100644
--- a/test/files/run/t5256g.scala
+++ b/test/files/run/t5256g.scala
@@ -6,7 +6,7 @@ trait B
 
 object Test extends App {
   val mutant = new A with B
-  val c = cm.reflectClass(mutant.getClass).symbol
+  val c = cm.classSymbol(mutant.getClass)
   println(c)
   println(c.fullName)
   println(c.typeSignature)
diff --git a/test/files/run/t5256h.scala b/test/files/run/t5256h.scala
index 723d606a1e..fd4ffd9b12 100644
--- a/test/files/run/t5256h.scala
+++ b/test/files/run/t5256h.scala
@@ -3,7 +3,7 @@ import scala.reflect.runtime.{currentMirror => cm}
 
 object Test extends App {
   val mutant = new { val x = 2 }
-  val c = cm.reflectClass(mutant.getClass).symbol
+  val c = cm.classSymbol(mutant.getClass)
   println(c)
   println(c.fullName)
   println(c.typeSignature)
diff --git a/test/files/run/t5423.scala b/test/files/run/t5423.scala
index 9c73ed0bef..9b8ba090fa 100644
--- a/test/files/run/t5423.scala
+++ b/test/files/run/t5423.scala
@@ -6,6 +6,6 @@ final class table extends annotation.StaticAnnotation
 @table class A
 
 object Test extends App {
-  val s = cm.reflectClass(classOf[A]).symbol
+  val s = cm.classSymbol(classOf[A])
   println(s.getAnnotations)
 }
\ No newline at end of file