Reflection refactoring.ō

18 files changed, 173 insertions, 125 deletions

diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala
index 92bd656ed2..f9afd164f5 100644
--- a/src/compiler/scala/reflect/internal/Symbols.scala
+++ b/src/compiler/scala/reflect/internal/Symbols.scala
@@ -1426,7 +1426,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
      * (5) companionSymbol
      */
 
-    /** For a module or case factory: the class with the same name in the same package.
+    /** For a module: the class with the same name in the same package.
      *  For all others: NoSymbol
      *  Note: does not work for classes owned by methods, see Namers.companionClassOf
      *
diff --git a/src/compiler/scala/reflect/runtime/JavaToScala.scala b/src/compiler/scala/reflect/runtime/JavaToScala.scala
index 33f4b08d74..60e14ecec7 100644
--- a/src/compiler/scala/reflect/runtime/JavaToScala.scala
+++ b/src/compiler/scala/reflect/runtime/JavaToScala.scala
@@ -1,15 +1,24 @@
 package scala.reflect
 package runtime
 
-import java.lang.{Class => jClass, Package => jPackage}
+import java.lang.{ Class => jClass, Package => jPackage }
 import java.lang.reflect.{
-  Method => jMethod, Constructor => jConstructor, Modifier => jModifier, Field => jField,
-  Member => jMember, Type => jType, TypeVariable => jTypeVariable,
-  GenericDeclaration, ParameterizedType, WildcardType, AnnotatedElement}
+  Method => jMethod,
+  Constructor => jConstructor,
+  Modifier => jModifier,
+  Field => jField,
+  Member => jMember,
+  Type => jType,
+  TypeVariable => jTypeVariable,
+  GenericDeclaration,
+  ParameterizedType,
+  WildcardType,
+  AnnotatedElement
+}
 import internal.pickling.ByteCodecs
 import internal.ClassfileConstants._
 import internal.pickling.UnPickler
-import collection.mutable.{HashMap, ListBuffer}
+import collection.mutable.{ HashMap, ListBuffer }
 import internal.Flags._
 
 trait JavaToScala extends ConversionUtil { self: Universe =>
@@ -20,7 +29,8 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
     val global: JavaToScala.this.type = self
   }
 
-  /** Generate types for top-level Scala root class and root companion object
+  /**
+   * Generate types for top-level Scala root class and root companion object
    *  from the pickled information stored in a corresponding Java class
    *  @param   clazz   The top-level Scala class for which info is unpickled
    *  @param   module  The top-level Scala companion object for which info is unpickled
@@ -28,7 +38,7 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
    *                   ScalaSignature or ScalaLongSignature annotation.
    */
   def unpickleClass(clazz: Symbol, module: Symbol, jclazz: jClass[_]): Unit = {
-    println("unpickling "+clazz+" "+module)
+    println("unpickling " + clazz + " " + module)
     val ssig = jclazz.getAnnotation(classOf[scala.reflect.ScalaSignature])
     if (ssig != null) {
       val bytes = ssig.bytes.getBytes
@@ -48,13 +58,14 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
         println("long sig")
         unpickler.unpickle(bytes, 0, clazz, module, jclazz.getName)
       } else { // class does not have a Scala signature; it's a Java class
-        println("no sig found for "+jclazz)
+        println("no sig found for " + jclazz)
         initClassModule(clazz, module, new FromJavaClassCompleter(clazz, module, jclazz))
       }
     }
   }
 
-  /** A fresh Scala type parameter that corresponds to a Java type variable.
+  /**
+   * A fresh Scala type parameter that corresponds to a Java type variable.
    *  The association between Scala type parameter and Java type variable is entered in the cache.
    *  @param   jtvar   The Java type variable
    */
@@ -65,7 +76,8 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
     tparam
   }
 
-  /** A completer that fills in the type of a Scala type parameter from the bounds of a Java type variable.
+  /**
+   * A completer that fills in the type of a Scala type parameter from the bounds of a Java type variable.
    *  @param   jtvar   The Java type variable
    */
   private class TypeParamCompleter(jtvar: jTypeVariable[_ <: GenericDeclaration]) extends LazyType {
@@ -74,7 +86,8 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
     }
   }
 
-  /** Copy all annotations of Java annotated element `jann` over to Scala symbol `sym`.
+  /**
+   * Copy all annotations of Java annotated element `jann` over to Scala symbol `sym`.
    *  Pre: `sym` is already initialized with a concrete type.
    *  Note: If `sym` is a method or constructor, its parameter annotations are copied as well.
    */
@@ -82,7 +95,8 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
     // to do: implement
   }
 
-  /** A completer that fills in the types of a Scala class and its companion object
+  /**
+   * A completer that fills in the types of a Scala class and its companion object
    *  by copying corresponding type info from a Java class. This completer is used
    *  to reflect classes in Scala that do not have a Scala pickle info, be it
    *  because they are local classes or have been compiled from Java sources.
@@ -92,7 +106,7 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
    */
   private class FromJavaClassCompleter(clazz: Symbol, module: Symbol, jclazz: jClass[_]) extends LazyType {
     override def complete(sym: Symbol) = {
-      println("completing from Java "+sym+"/"+clazz.fullName)
+      println("completing from Java " + sym + "/" + clazz.fullName)
       assert(sym == clazz || sym == module || sym == module.moduleClass, sym)
       val flags = toScalaFlags(jclazz.getModifiers, isClass = true)
       clazz setFlag (flags | JAVA)
@@ -125,44 +139,52 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
     }
   }
 
-  /** If Java modifiers `mods` contain STATIC, return the module class
+  /**
+   * If Java modifiers `mods` contain STATIC, return the module class
    *  of the companion module of `clazz`, otherwise the class `clazz` itself.
    */
   private def followStatic(clazz: Symbol, mods: Int) =
     if (jModifier.isStatic(mods)) clazz.companionModule.moduleClass else clazz
 
-  /** The Scala owner of the Scala class corresponding to the Java class `jclazz`
+  /**
+   * The Scala owner of the Scala class corresponding to the Java class `jclazz`
    */
   private def sOwner(jclazz: jClass[_]): Symbol = {
     if (jclazz.isMemberClass)
       followStatic(classToScala(jclazz.getEnclosingClass), jclazz.getModifiers)
     else if (jclazz.isLocalClass)
       methodToScala(jclazz.getEnclosingMethod) orElse constrToScala(jclazz.getEnclosingConstructor)
+    else if (jclazz.isPrimitive || jclazz.isArray)
+      ScalaPackageClass
     else {
       assert(jclazz.getPackage != null, jclazz)
       packageToScala(jclazz.getPackage)
     }
   }
 
-  /** The Scala owner of the Scala symbol corresponding to the Java member `jmember`
+  /**
+   * The Scala owner of the Scala symbol corresponding to the Java member `jmember`
    */
   private def sOwner(jmember: jMember): Symbol = {
     followStatic(classToScala(jmember.getDeclaringClass), jmember.getModifiers)
   }
 
-  /** The Scala owner of the Scala type parameter corresponding to the Java type variable `jtvar`
+  /**
+   * The Scala owner of the Scala type parameter corresponding to the Java type variable `jtvar`
    */
   private def sOwner(jtvar: jTypeVariable[_ <: GenericDeclaration]): Symbol =
     genericDeclarationToScala(jtvar.getGenericDeclaration)
 
-  /** Returns `true` if Scala name `name` equals Java name `jstr`, possibly after
+  /**
+   * Returns `true` if Scala name `name` equals Java name `jstr`, possibly after
    *  make-not-private expansion.
    */
   private def approximateMatch(sym: Symbol, jstr: String): Boolean =
     (sym.name.toString == jstr) ||
-    sym.isPrivate && nme.expandedName(sym.name, sym.owner).toString == jstr
+      sym.isPrivate && nme.expandedName(sym.name, sym.owner).toString == jstr
 
-  /** Find declarations or definition in class `clazz` that maps to a Java
+  /**
+   * Find declarations or definition in class `clazz` that maps to a Java
    *  entity with name `jname`. Because of name-mangling, this is more difficult
    *  than a simple name-based lookup via `decl`. If `decl` fails, members
    *  that start with the given name are searched instead.
@@ -170,13 +192,14 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
   private def lookup(clazz: Symbol, jname: String): Symbol =
     clazz.info.decl(newTermName(jname)) orElse {
       (clazz.info.decls.iterator filter (approximateMatch(_, jname))).toList match {
-        case List() => NoSymbol
+        case List()    => NoSymbol
         case List(sym) => sym
-        case alts => clazz.newOverloaded(alts.head.tpe.prefix, alts)
+        case alts      => clazz.newOverloaded(alts.head.tpe.prefix, alts)
       }
     }
 
-  /** The Scala method corresponding to given Java method.
+  /**
+   * The Scala method corresponding to given Java method.
    *  @param  jmeth  The Java method
    *  @return A Scala method object that corresponds to `jmeth`.
    */
@@ -185,7 +208,8 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
     lookup(owner, jmeth.getName) suchThat (erasesTo(_, jmeth)) orElse jmethodAsScala(jmeth)
   }
 
-  /** The Scala constructor corresponding to given Java constructor.
+  /**
+   * The Scala constructor corresponding to given Java constructor.
    *  @param  jconstr  The Java constructor
    *  @return A Scala method object that corresponds to `jconstr`.
    */
@@ -194,20 +218,23 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
     lookup(owner, "<init>") suchThat (erasesTo(_, jconstr)) orElse jconstrAsScala(jconstr)
   }
 
-  /** The Scala package corresponding to given Java package
+  /**
+   * The Scala package corresponding to given Java package
    */
   def packageToScala(jpkg: jPackage): Symbol = packageCache.toScala(jpkg) {
     makeScalaPackage(jpkg.getName)
   }
 
-  /** The Scala package with given fully qualified name.
+  /**
+   * The Scala package with given fully qualified name.
    */
   def packageNameToScala(fullname: String): Symbol = {
     val jpkg = jPackage.getPackage(fullname)
     if (jpkg != null) packageToScala(jpkg) else makeScalaPackage(fullname)
   }
 
-  /** The Scala package with given fully qualified name. Unlike `packageNameToScala`,
+  /**
+   * The Scala package with given fully qualified name. Unlike `packageNameToScala`,
    *  this one bypasses the cache.
    */
   private def makeScalaPackage(fullname: String): Symbol = {
@@ -219,7 +246,8 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
     pkg.moduleClass
   }
 
-  /** The Scala class that corresponds to a given Java class.
+  /**
+   * The Scala class that corresponds to a given Java class.
    *  @param jclazz  The Java class
    *  @return A Scala class symbol that reflects all elements of the Java class,
    *          in the form they appear in the Scala pickling info, or, if that is
@@ -230,14 +258,28 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
       sOwner(jclazz).info.decl(newTypeName(jclazz.getSimpleName)).asInstanceOf[ClassSymbol]
     } else if (jclazz.isLocalClass) { // local classes not preserved by unpickling - treat as Java
       jclassAsScala(jclazz)
-    } else { // jclazz is top-level - get signature
-      val (clazz, module) = createClassModule(
+    } else if (jclazz.isArray) {
+      ArrayClass
+    } else jclazz match {
+      case java.lang.Void.TYPE      => UnitClass
+      case java.lang.Byte.TYPE      => ByteClass
+      case java.lang.Character.TYPE => CharClass
+      case java.lang.Short.TYPE     => ShortClass
+      case java.lang.Integer.TYPE   => IntClass
+      case java.lang.Long.TYPE      => LongClass
+      case java.lang.Float.TYPE     => FloatClass
+      case java.lang.Double.TYPE    => DoubleClass
+      case java.lang.Boolean.TYPE   => BooleanClass
+      case _ =>
+        // jclazz is top-level - get signature
+        val (clazz, module) = createClassModule(
           sOwner(jclazz), newTypeName(jclazz.getSimpleName), new TopClassCompleter(_, _))
-      clazz
+        clazz
     }
   }
 
-  /** The Scala type parameter that corresponds to a given Java type parameter.
+  /**
+   * The Scala type parameter that corresponds to a given Java type parameter.
    *  @param jparam  The Java type parameter
    *  @return A Scala type parameter symbol that has the same owner and name as the Java type parameter
    */
@@ -248,25 +290,27 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
     }
   }
 
-  /** The Scala symbol that corresponds to a given Java generic declaration (class, method, or constructor)
+  /**
+   * The Scala symbol that corresponds to a given Java generic declaration (class, method, or constructor)
    */
   def genericDeclarationToScala(jdecl: GenericDeclaration) = jdecl match {
-    case jclazz: jClass[_] => classToScala(jclazz)
-    case jmeth: jMethod => methodToScala(jmeth)
+    case jclazz: jClass[_]        => classToScala(jclazz)
+    case jmeth: jMethod           => methodToScala(jmeth)
     case jconstr: jConstructor[_] => constrToScala(jconstr)
   }
 
-  /** Given some Java type arguments, a corresponding list of Scala types, plus potentially
+  /**
+   * Given some Java type arguments, a corresponding list of Scala types, plus potentially
    *  some existentially bound type variables that represent wildcard arguments.
    */
   private def targsToScala(owner: Symbol, args: List[jType]): (List[Type], List[Symbol]) = {
     val tparams = new ListBuffer[Symbol]
     def targToScala(arg: jType): Type = arg match {
       case jwild: WildcardType =>
-        val tparam = owner.newExistential(NoPosition, newTypeName("T$"+tparams.length))
+        val tparam = owner.newExistential(NoPosition, newTypeName("T$" + tparams.length))
           .setInfo(TypeBounds(
-              lub(jwild.getLowerBounds.toList map typeToScala),
-              glb(jwild.getUpperBounds.toList map typeToScala)))
+            lub(jwild.getLowerBounds.toList map typeToScala),
+            glb(jwild.getUpperBounds.toList map typeToScala)))
         tparams += tparam
         typeRef(NoPrefix, tparam, List())
       case _ =>
@@ -275,20 +319,13 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
     (args map targToScala, tparams.toList)
   }
 
-  /** The Scala type that corresponds to given Java type
+  /**
+   * The Scala type that corresponds to given Java type
    */
   def typeToScala(jtpe: jType): Type = jtpe match {
-    case java.lang.Void.TYPE => UnitClass.tpe
-    case java.lang.Byte.TYPE => ByteClass.tpe
-    case java.lang.Character.TYPE => CharClass.tpe
-    case java.lang.Short.TYPE => ShortClass.tpe
-    case java.lang.Integer.TYPE => IntClass.tpe
-    case java.lang.Long.TYPE => LongClass.tpe
-    case java.lang.Float.TYPE => FloatClass.tpe
-    case java.lang.Double.TYPE => DoubleClass.tpe
-    case java.lang.Boolean.TYPE => BooleanClass.tpe
     case jclazz: jClass[_] =>
-      if (jclazz.isArray) arrayType(typeToScala(jclazz.getComponentType))
+      if (jclazz.isArray)
+        arrayType(typeToScala(jclazz.getComponentType))
       else {
         val clazz = classToScala(jclazz)
         rawToExistential(typeRef(clazz.owner.thisType, clazz, List()))
@@ -296,7 +333,7 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
     case japplied: ParameterizedType =>
       val (pre, sym) = typeToScala(japplied.getRawType) match {
         case ExistentialType(tparams, TypeRef(pre, sym, _)) => (pre, sym)
-        case TypeRef(pre, sym, _) => (pre, sym)
+        case TypeRef(pre, sym, _)                           => (pre, sym)
       }
       val args0 = japplied.getActualTypeArguments
       val (args, bounds) = targsToScala(pre.typeSymbol, args0.toList)
@@ -306,18 +343,20 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
       typeRef(NoPrefix, tparam, List())
   }
 
-  /** The Scala class that corresponds to given Java class without taking
+  /**
+   * The Scala class that corresponds to given Java class without taking
    *  Scala pickling info into account.
    *  @param jclazz  The Java class
    *  @return A Scala class symbol that wraps all reflection info of `jclazz`
    */
   private def jclassAsScala(jclazz: jClass[_]): Symbol = {
     val (clazz, module) = createClassModule(
-        sOwner(jclazz), newTypeName(jclazz.getSimpleName), new FromJavaClassCompleter(_, _, jclazz))
+      sOwner(jclazz), newTypeName(jclazz.getSimpleName), new FromJavaClassCompleter(_, _, jclazz))
     clazz
   }
 
-  /** The Scala field that corresponds to given Java field without taking
+  /**
+   * The Scala field that corresponds to given Java field without taking
    *  Scala pickling info into account.
    *  @param jfield  The Java field
    *  @return A Scala value symbol that wraps all reflection info of `jfield`
@@ -330,7 +369,8 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
     field
   }
 
-  /** The Scala method that corresponds to given Java method without taking
+  /**
+   * The Scala method that corresponds to given Java method without taking
    *  Scala pickling info into account.
    *  @param jmeth  The Java method
    *  @return A Scala method symbol that wraps all reflection info of `jmethod`
@@ -347,7 +387,8 @@ trait JavaToScala extends ConversionUtil { self: Universe =>
     meth
   }
 
-  /** The Scala constructor that corresponds to given Java constructor without taking
+  /**
+   * The Scala constructor that corresponds to given Java constructor without taking
    *  Scala pickling info into account.
    *  @param jconstr  The Java constructor
    *  @return A Scala constructor symbol that wraps all reflection info of `jconstr`
diff --git a/src/compiler/scala/reflect/runtime/Loaders.scala b/src/compiler/scala/reflect/runtime/Loaders.scala
index bb2f628041..3cab02706a 100644
--- a/src/compiler/scala/reflect/runtime/Loaders.scala
+++ b/src/compiler/scala/reflect/runtime/Loaders.scala
@@ -1,6 +1,8 @@
 package scala.reflect
 package runtime
 
+import internal.Flags
+
 import java.lang.{Class => jClass, Package => jPackage}
 
 trait Loaders { self: Universe =>
@@ -21,9 +23,10 @@ trait Loaders { self: Universe =>
   class TopClassCompleter(clazz: Symbol, module: Symbol) extends LazyType {
     def makePackage() {
       val ptpe = new PackageType(module.moduleClass)
-      clazz setInfo ptpe
-      module setInfo ptpe
-      module.moduleClass setInfo ptpe
+      for (sym <- List(clazz, module, module.moduleClass)) {
+        sym setFlag Flags.PACKAGE
+        sym setInfo ptpe
+      }
     }
     override def complete(sym: Symbol) = {
       println("completing "+sym+"/"+clazz.fullName)
@@ -54,6 +57,7 @@ trait Loaders { self: Universe =>
    *  @param completer  The completer to be used to set the info of the class and the module
    */
   protected def createClassModule(owner: Symbol, name: TypeName, completer: (Symbol, Symbol) => LazyType) = {
+    assert(!(name.toString endsWith "[]"), name)
     val clazz = owner.newClass(NoPosition, name)
     val module = owner.newModule(NoPosition, name.toTermName)
     owner.info.decls enter clazz
diff --git a/src/compiler/scala/reflect/runtime/Mirror.scala b/src/compiler/scala/reflect/runtime/Mirror.scala
index 18283f3898..3d6d330cfe 100644
--- a/src/compiler/scala/reflect/runtime/Mirror.scala
+++ b/src/compiler/scala/reflect/runtime/Mirror.scala
@@ -2,27 +2,43 @@ package scala.reflect
 package runtime
 
 import internal.{SomePhase, NoPhase, Phase, TreeGen}
+import java.lang.reflect.Array
 
 /** The mirror for standard runtime reflection from Java.
  */
 class Mirror extends Universe with api.Mirror {
 
+  import definitions._
+
   def classWithName(name: String): Symbol = classToScala(java.lang.Class.forName(name))
   def getClass(obj: AnyRef): Symbol = classToScala(obj.getClass)
   def getType(obj: AnyRef): Type = typeToScala(obj.getClass)
   // to do add getClass/getType for instances of primitive types, probably like this:
   // def getClass[T <: AnyVal : Manifest](x: T): Symbol = manifest[T].getClass
 
-  def getValue(receiver: AnyRef, field: Symbol): Any = fieldToJava(field).get(receiver)
-  def setValue(receiver: AnyRef, field: Symbol, value: Any): Unit = fieldToJava(field).set(receiver, value)
-  def invoke(receiver: AnyRef, meth: Symbol, args: Any*): Any = methodToJava(meth).invoke(receiver, args)
+  def getValue(receiver: AnyRef, field: Symbol): Any = {
+    fieldToJava(field).get(receiver)
+  }
+  def setValue(receiver: AnyRef, field: Symbol, value: Any): Unit = {
+    fieldToJava(field).set(receiver, value)
+  }
+  def invoke(receiver: AnyRef, meth: Symbol, args: Any*): Any = {
+    if (meth.owner == ArrayClass) {
+      meth.name match {
+        case nme.length => return Array.getLength(receiver)
+        case nme.apply => return Array.get(receiver, args(0).asInstanceOf[Int])
+        case nme.update => return Array.set(receiver, args(0).asInstanceOf[Int], args(1))
+      }
+    }
+    methodToJava(meth).invoke(receiver, args.asInstanceOf[Seq[AnyRef]]: _*)
+  }
 
 }
 
 object Mirror extends Mirror
 
 /** test code; should go to tests once things settle down a bit
- */
+ *
 object Test extends Mirror with App {
   val sym = classToScala(classOf[scala.collection.Iterable[_]])
   println(sym)
@@ -30,4 +46,5 @@ object Test extends Mirror with App {
   println("decls = "+(sym.info.decls.toList map (_.defString)))
   val ms = sym.info.members.toList map (_.initialize)
   println("members = "+(ms map (_.defString) mkString ("\n  ")))
-}
\ No newline at end of file
+}
+*/
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/runtime/ScalaToJava.scala b/src/compiler/scala/reflect/runtime/ScalaToJava.scala
index b3f898e709..4155d7ee06 100644
--- a/src/compiler/scala/reflect/runtime/ScalaToJava.scala
+++ b/src/compiler/scala/reflect/runtime/ScalaToJava.scala
@@ -22,12 +22,27 @@ trait ScalaToJava extends ConversionUtil { self: Universe =>
    *   - top-level classes
    *   - Scala classes that were generated via jclassToScala
    *   - classes that have a class owner that has a corresponding Java class
-   *  @throws A `NoClassDefFoundError` for all Scala classes not in one of these categories.
+   *  @throws A `ClassNotFoundException` for all Scala classes not in one of these categories.
    */
+  @throws(classOf[ClassNotFoundException])
   def classToJava(clazz: Symbol): jClass[_] = classCache.toJava(clazz) {
-    def noClass = throw new NoClassDefFoundError("no Java class corresponding to "+clazz+" found")
+    def noClass = throw new ClassNotFoundException("no Java class corresponding to "+clazz+" found")
     println("classToJava "+clazz+" "+clazz.owner+" "+clazz.owner.isPackageClass)
-    if (clazz.owner.isPackageClass)
+    if (clazz.isValueClass)
+      clazz match {
+        case UnitClass => java.lang.Void.TYPE
+        case ByteClass => java.lang.Byte.TYPE
+        case CharClass => java.lang.Character.TYPE
+        case ShortClass => java.lang.Short.TYPE
+        case IntClass => java.lang.Integer.TYPE
+        case LongClass => java.lang.Long.TYPE
+        case FloatClass => java.lang.Float.TYPE
+        case DoubleClass => java.lang.Double.TYPE
+        case BooleanClass => java.lang.Boolean.TYPE
+      }
+    else if (clazz == ArrayClass)
+      noClass
+    else if (clazz.owner.isPackageClass)
       jClass.forName(clazz.fullName)
     else if (clazz.owner.isClass)
       classToJava(clazz.owner)
@@ -76,20 +91,7 @@ trait ScalaToJava extends ConversionUtil { self: Universe =>
   def typeToJavaClass(tpe: Type): jClass[_] = tpe match {
     case ExistentialType(_, rtpe) => typeToJavaClass(rtpe)
     case TypeRef(_, ArrayClass, List(elemtpe)) => jArrayClass(typeToJavaClass(elemtpe))
-    case TypeRef(_, sym, _) => typeSymToJavaClass(sym)
+    case TypeRef(_, sym, _) => classToJava(sym)
     case _ => throw new NoClassDefFoundError("no Java class corresponding to "+tpe+" found")
   }
-
-  private def typeSymToJavaClass(sym: Symbol): jClass[_] = sym match {
-    case UnitClass => java.lang.Void.TYPE
-    case ByteClass => java.lang.Byte.TYPE
-    case CharClass => java.lang.Character.TYPE
-    case ShortClass => java.lang.Short.TYPE
-    case IntClass => java.lang.Integer.TYPE
-    case LongClass => java.lang.Long.TYPE
-    case FloatClass => java.lang.Float.TYPE
-    case DoubleClass => java.lang.Double.TYPE
-    case BooleanClass => java.lang.Boolean.TYPE
-    case _ => jClass.forName(sym.fullName)
-  }
 }
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/api/AnnotationInfos.scala b/src/library/scala/reflect/api/AnnotationInfos.scala
index 96a65606e5..96a65606e5 100755
--- a/src/compiler/scala/reflect/api/AnnotationInfos.scala
+++ b/src/library/scala/reflect/api/AnnotationInfos.scala
diff --git a/src/compiler/scala/reflect/api/Constants.scala b/src/library/scala/reflect/api/Constants.scala
index 42a0fa8a27..42a0fa8a27 100755
--- a/src/compiler/scala/reflect/api/Constants.scala
+++ b/src/library/scala/reflect/api/Constants.scala
diff --git a/src/compiler/scala/reflect/api/Mirror.scala b/src/library/scala/reflect/api/Mirror.scala
index b6a9304617..b6a9304617 100644
--- a/src/compiler/scala/reflect/api/Mirror.scala
+++ b/src/library/scala/reflect/api/Mirror.scala
diff --git a/src/compiler/scala/reflect/api/Modifier.scala b/src/library/scala/reflect/api/Modifier.scala
index 5992e658c6..5992e658c6 100644
--- a/src/compiler/scala/reflect/api/Modifier.scala
+++ b/src/library/scala/reflect/api/Modifier.scala
diff --git a/src/compiler/scala/reflect/api/Names.scala b/src/library/scala/reflect/api/Names.scala
index 0ba5ad28f0..0ba5ad28f0 100755
--- a/src/compiler/scala/reflect/api/Names.scala
+++ b/src/library/scala/reflect/api/Names.scala
diff --git a/src/compiler/scala/reflect/api/Positions.scala b/src/library/scala/reflect/api/Positions.scala
index 181e7c1525..181e7c1525 100644
--- a/src/compiler/scala/reflect/api/Positions.scala
+++ b/src/library/scala/reflect/api/Positions.scala
diff --git a/src/compiler/scala/reflect/api/Scopes.scala b/src/library/scala/reflect/api/Scopes.scala
index d4e4e24f29..d4e4e24f29 100755
--- a/src/compiler/scala/reflect/api/Scopes.scala
+++ b/src/library/scala/reflect/api/Scopes.scala
diff --git a/src/compiler/scala/reflect/api/StandardDefinitions.scala b/src/library/scala/reflect/api/StandardDefinitions.scala
index 6b480ab83d..6b480ab83d 100755
--- a/src/compiler/scala/reflect/api/StandardDefinitions.scala
+++ b/src/library/scala/reflect/api/StandardDefinitions.scala
diff --git a/src/compiler/scala/reflect/api/Symbols.scala b/src/library/scala/reflect/api/Symbols.scala
index c841417209..c2fed361f0 100755
--- a/src/compiler/scala/reflect/api/Symbols.scala
+++ b/src/library/scala/reflect/api/Symbols.scala
@@ -80,20 +80,19 @@ trait Symbols { self: Universe =>
      */
     def info: Type
 
-    /** If this symbol is a class or trait, its self type, otherwise the type of the symbol itse;lf
+    /** If this symbol is a class or trait, its self type, otherwise the type of the symbol itself
      */
     def typeOfThis: Type
 
-    /** For a module class its linked class, for a plain class
-     *  the module class of its linked module.
-     *  For instance
-     *    object Foo
-     *    class Foo
-     *
-     *  Then object Foo has a `moduleClass` (invisible to the user, the backend calls it Foo$
-     *  linkedClassOfClass goes from class Foo$ to class Foo, and back.
+    /** For a class: the module or case class factory with the same name in the same package.
+     *  For all others: NoSymbol
+     */
+    def companionModule: Symbol
+
+    /** For a module: the class with the same name in the same package.
+     *  For all others: NoSymbol
      */
-    def linkedClassOfClass: Symbol
+    def companionClass: Symbol
 
     /** The module corresponding to this module class (note that this
      *  is not updated when a module is cloned), or NoSymbol if this is not a ModuleClass
@@ -108,11 +107,6 @@ trait Symbols { self: Universe =>
     /** The top-level class containing this symbol. */
     def toplevelClass: Symbol
 
-    /**
-     *  If symbol is a lazy val, it's lazy accessor
-     */
-    def lazyAccessor: Symbol
-
     /** The next enclosing class */
     def enclClass      : Symbol
 
@@ -124,34 +118,6 @@ trait Symbols { self: Universe =>
     def isClass        : Boolean
     def isAliasType    : Boolean
     def isAbstractType : Boolean
-
-    def isAbstractClass      : Boolean
-    def isBridge             : Boolean
-    def isConcreteClass      : Boolean
-    def isContravariant      : Boolean
-    def isCovariant          : Boolean
-    def isEarlyInitialized   : Boolean
-    def isExistentiallyBound : Boolean
-    def isImplClass          : Boolean
-    def isLazyAccessor       : Boolean
-    def isMethod             : Boolean
-    def isModule             : Boolean
-    def isModuleClass        : Boolean
-    def isNumericValueClass  : Boolean
-    def isOverloaded         : Boolean
-    def isRefinementClass    : Boolean
-    def isSourceMethod       : Boolean
-    def isTypeParameter      : Boolean
-    def isValueClass         : Boolean
-    def isVarargsMethod      : Boolean
-
-    /** Package tests */
-    def isPackage      : Boolean
-    def isPackageClass : Boolean
-    def isRootPackage  : Boolean
-    def isRoot         : Boolean
-    def isEmptyPackage : Boolean
-    def isEmptyPackageClass: Boolean
   }
 
   val NoSymbol: Symbol
diff --git a/src/compiler/scala/reflect/api/Trees.scala b/src/library/scala/reflect/api/Trees.scala
index 0dbc09c46e..0dbc09c46e 100644
--- a/src/compiler/scala/reflect/api/Trees.scala
+++ b/src/library/scala/reflect/api/Trees.scala
diff --git a/src/compiler/scala/reflect/api/Types.scala b/src/library/scala/reflect/api/Types.scala
index 646c93ad5f..646c93ad5f 100755
--- a/src/compiler/scala/reflect/api/Types.scala
+++ b/src/library/scala/reflect/api/Types.scala
diff --git a/src/compiler/scala/reflect/api/Universe.scala b/src/library/scala/reflect/api/Universe.scala
index ad145b12ac..ad145b12ac 100755
--- a/src/compiler/scala/reflect/api/Universe.scala
+++ b/src/library/scala/reflect/api/Universe.scala
diff --git a/src/library/scala/reflect/package.scala b/src/library/scala/reflect/package.scala
new file mode 100644
index 0000000000..3fe25316ca
--- /dev/null
+++ b/src/library/scala/reflect/package.scala
@@ -0,0 +1,18 @@
+package scala
+
+package object reflect {
+
+  val mirror: api.Mirror = try {
+    // we use (Java) reflection here so that we can keep reflect.runtime and reflect.internals in a seperate jar
+    (java.lang.Class forName "scala.reflect.runtime.Mirror$" getField "$MODULE" get null).asInstanceOf[api.Mirror]
+  } catch {
+    case ex: NoClassDefFoundError =>
+      throw new UnsupportedOperationException("Scala reflection not available on this platform")
+  }
+  /** Uncomment once we got rid of the old Symbols, Types, Trees
+  type Symbol = mirror.Symbol
+  type Type = mirror.Type
+  type Tree = mirror.Tree
+  */
+
+}
\ No newline at end of file