Reduce duplication in JavaMirrors.

Applying some of the abstractions from the prior commits,
though I would like to emphasize that such infrastructure was
not a prerequisite for de-duplicating this file.

1 files changed, 90 insertions, 95 deletions

diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
index f324f5145a..3211bb7919 100644
--- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala
+++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
@@ -6,12 +6,14 @@ import scala.collection.mutable.WeakHashMap
 
 import java.lang.{Class => jClass, Package => jPackage}
 import java.lang.reflect.{
-  Method => jMethod, Constructor => jConstructor, Modifier => jModifier, Field => jField,
+  Method => jMethod, Constructor => jConstructor, Field => jField,
   Member => jMember, Type => jType, TypeVariable => jTypeVariable, Array => jArray,
+  AccessibleObject => jAccessibleObject,
   GenericDeclaration, GenericArrayType, ParameterizedType, WildcardType, AnnotatedElement }
 import java.lang.annotation.{Annotation => jAnnotation}
 import java.io.IOException
-import internal.MissingRequirementError
+import scala.reflect.internal.{ MissingRequirementError, JavaAccFlags, JMethodOrConstructor }
+import JavaAccFlags._
 import internal.pickling.ByteCodecs
 import internal.ClassfileConstants._
 import internal.pickling.UnPickler
@@ -88,12 +90,12 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
 
 // ----------- Caching ------------------------------------------------------------------
 
-    private val classCache = new TwoWayCache[jClass[_], ClassSymbol]
-    private val packageCache = new TwoWayCache[Package, ModuleSymbol]
-    private val methodCache = new TwoWayCache[jMethod, MethodSymbol]
+    private val classCache       = new TwoWayCache[jClass[_], ClassSymbol]
+    private val packageCache     = new TwoWayCache[Package, ModuleSymbol]
+    private val methodCache      = new TwoWayCache[jMethod, MethodSymbol]
     private val constructorCache = new TwoWayCache[jConstructor[_], MethodSymbol]
-    private val fieldCache = new TwoWayCache[jField, TermSymbol]
-    private val tparamCache = new TwoWayCache[jTypeVariable[_ <: GenericDeclaration], TypeSymbol]
+    private val fieldCache       = new TwoWayCache[jField, TermSymbol]
+    private val tparamCache      = new TwoWayCache[jTypeVariable[_ <: GenericDeclaration], TypeSymbol]
 
     private[runtime] def toScala[J: HasJavaClass, S](cache: TwoWayCache[J, S], key: J)(body: (JavaMirror, J) => S): S =
       cache.toScala(key){
@@ -101,38 +103,36 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
         body(mirrorDefining(jclazz), key)
       }
 
-    private implicit val classHasJavaClass: HasJavaClass[jClass[_]] =
-      new HasJavaClass(identity)
-    private implicit val methHasJavaClass: HasJavaClass[jMethod]
-      = new HasJavaClass(_.getDeclaringClass)
-    private implicit val fieldHasJavaClass: HasJavaClass[jField] =
-      new HasJavaClass(_.getDeclaringClass)
-    private implicit val constrHasJavaClass: HasJavaClass[jConstructor[_]] =
-      new HasJavaClass(_.getDeclaringClass)
+    private implicit val classHasJavaClass: HasJavaClass[jClass[_]]        = new HasJavaClass(identity)
+    private implicit val methHasJavaClass: HasJavaClass[jMethod]           = new HasJavaClass(_.getDeclaringClass)
+    private implicit val fieldHasJavaClass: HasJavaClass[jField]           = new HasJavaClass(_.getDeclaringClass)
+    private implicit val constrHasJavaClass: HasJavaClass[jConstructor[_]] = new HasJavaClass(_.getDeclaringClass)
     private implicit val tparamHasJavaClass: HasJavaClass[jTypeVariable[_ <: GenericDeclaration]] =
       new HasJavaClass ( (tparam: jTypeVariable[_ <: GenericDeclaration]) => {
         tparam.getGenericDeclaration match {
-          case jclazz: jClass[_] => jclazz
-          case jmeth: jMethod => jmeth.getDeclaringClass
+          case jclazz: jClass[_]        => jclazz
+          case jmeth: jMethod           => jmeth.getDeclaringClass
           case jconstr: jConstructor[_] => jconstr.getDeclaringClass
         }
       })
 
 // ----------- Implementations of mirror operations and classes  -------------------
 
-    private def ErrorInnerClass(sym: Symbol) = throw new ScalaReflectionException(s"$sym is an inner class, use reflectClass on an InstanceMirror to obtain its ClassMirror")
-    private def ErrorInnerModule(sym: Symbol) = throw new ScalaReflectionException(s"$sym is an inner module, use reflectModule on an InstanceMirror to obtain its ModuleMirror")
-    private def ErrorStaticClass(sym: Symbol) = throw new ScalaReflectionException(s"$sym is a static class, use reflectClass on a RuntimeMirror to obtain its ClassMirror")
-    private def ErrorStaticModule(sym: Symbol) = throw new ScalaReflectionException(s"$sym is a static module, use reflectModule on a RuntimeMirror to obtain its ModuleMirror")
-    private def ErrorNotMember(sym: Symbol, owner: Symbol) = throw new ScalaReflectionException(s"expected a member of $owner, you provided ${sym.kindString} ${sym.fullName}")
-    private def ErrorNotField(sym: Symbol) = throw new ScalaReflectionException(s"expected a field or an accessor method symbol, you provided $sym")
-    private def ErrorNonExistentField(sym: Symbol) = throw new ScalaReflectionException(
+    private def abort(msg: String) = throw new ScalaReflectionException(msg)
+
+    private def ErrorInnerClass(sym: Symbol)                    = abort(s"$sym is an inner class, use reflectClass on an InstanceMirror to obtain its ClassMirror")
+    private def ErrorInnerModule(sym: Symbol)                   = abort(s"$sym is an inner module, use reflectModule on an InstanceMirror to obtain its ModuleMirror")
+    private def ErrorStaticClass(sym: Symbol)                   = abort(s"$sym is a static class, use reflectClass on a RuntimeMirror to obtain its ClassMirror")
+    private def ErrorStaticModule(sym: Symbol)                  = abort(s"$sym is a static module, use reflectModule on a RuntimeMirror to obtain its ModuleMirror")
+    private def ErrorNotMember(sym: Symbol, owner: Symbol)      = abort(s"expected a member of $owner, you provided ${sym.kindString} ${sym.fullName}")
+    private def ErrorNotField(sym: Symbol)                      = abort(s"expected a field or an accessor method symbol, you provided $sym")
+    private def ErrorSetImmutableField(sym: Symbol)             = abort(s"cannot set an immutable field ${sym.name}")
+    private def ErrorNotConstructor(sym: Symbol, owner: Symbol) = abort(s"expected a constructor of $owner, you provided $sym")
+    private def ErrorFree(member: Symbol, freeType: Symbol)     = abort(s"cannot reflect ${member.kindString} ${member.name}, because it's a member of a weak type ${freeType.name}")
+    private def ErrorNonExistentField(sym: Symbol)              = abort(
       sm"""Scala field ${sym.name} isn't represented as a Java field, neither it has a Java accessor method
           |note that private parameters of class constructors don't get mapped onto fields and/or accessors,
           |unless they are used outside of their declaring constructors.""")
-    private def ErrorSetImmutableField(sym: Symbol) = throw new ScalaReflectionException(s"cannot set an immutable field ${sym.name}")
-    private def ErrorNotConstructor(sym: Symbol, owner: Symbol) = throw new ScalaReflectionException(s"expected a constructor of $owner, you provided $sym")
-    private def ErrorFree(member: Symbol, freeType: Symbol) = throw new ScalaReflectionException(s"cannot reflect ${member.kindString} ${member.name}, because it's a member of a weak type ${freeType.name}")
 
     /** Helper functions for extracting typed values from a (Class[_], Any)
      *  representing an annotation argument.
@@ -210,7 +210,6 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
         case _ => body
       }
     }
-
     private def checkMemberOf(sym: Symbol, owner: ClassSymbol) {
       if (sym.owner == AnyClass || sym.owner == AnyRefClass || sym.owner == ObjectClass) {
         // do nothing
@@ -236,8 +235,7 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
       if (staticClazz.isPrimitive) staticClazz else dynamicClazz
     }
 
-    private class JavaInstanceMirror[T: ClassTag](val instance: T)
-            extends InstanceMirror {
+    private class JavaInstanceMirror[T: ClassTag](val instance: T) extends InstanceMirror {
       def symbol = thisMirror.classSymbol(preciseClass(instance))
       def reflectField(field: TermSymbol): FieldMirror = {
         checkMemberOf(field, symbol)
@@ -269,12 +267,8 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
 
     private class JavaFieldMirror(val receiver: Any, val symbol: TermSymbol)
             extends FieldMirror {
-      lazy val jfield = {
-        val jfield = fieldToJava(symbol)
-        if (!jfield.isAccessible) jfield.setAccessible(true)
-        jfield
-      }
-      def get = jfield.get(receiver)
+      lazy val jfield = ensureAccessible(fieldToJava(symbol))
+      def get = jfield get receiver
       def set(value: Any) = {
         if (!symbol.isMutable) ErrorSetImmutableField(symbol)
         jfield.set(receiver, value)
@@ -338,15 +332,8 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
         }
       }
     }
-
-    private abstract class JavaMethodMirror(val symbol: MethodSymbol)
-            extends MethodMirror {
-      lazy val jmeth = {
-        val jmeth = methodToJava(symbol)
-        if (!jmeth.isAccessible) jmeth.setAccessible(true)
-        jmeth
-      }
-
+    private abstract class JavaMethodMirror(val symbol: MethodSymbol) extends MethodMirror {
+      lazy val jmeth = ensureAccessible(methodToJava(symbol))
       def jinvokeraw(jmeth: jMethod, receiver: Any, args: Seq[Any]) = jmeth.invoke(receiver, args.asInstanceOf[Seq[AnyRef]]: _*)
 
       def jinvoke(jmeth: jMethod, receiver: Any, args: Seq[Any]): Any = {
@@ -418,13 +405,13 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
         if (!perfectMatch && !varargMatch) {
           val n_arguments = if (isVarArgsList(params)) s"${params.length - 1} or more" else s"${params.length}"
           val s_arguments = if (params.length == 1 && !isVarArgsList(params)) "argument" else "arguments"
-          throw new ScalaReflectionException(s"${showMethodSig(symbol)} takes $n_arguments $s_arguments")
+          abort(s"${showMethodSig(symbol)} takes $n_arguments $s_arguments")
         }
 
         def objReceiver       = receiver.asInstanceOf[AnyRef]
         def objArg0           = args(0).asInstanceOf[AnyRef]
         def objArgs           = args.asInstanceOf[Seq[AnyRef]]
-        def fail(msg: String) = throw new ScalaReflectionException(msg + ", it cannot be invoked with mirrors")
+        def fail(msg: String) = abort(msg + ", it cannot be invoked with mirrors")
 
         def invokePrimitiveMethod = {
           val jmeths = classOf[BoxesRunTime].getDeclaredMethods.filter(_.getName == nme.primitiveMethodName(symbol.name).toString)
@@ -464,14 +451,10 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
             extends MethodMirror {
       def bind(newReceiver: Any) = new JavaConstructorMirror(newReceiver.asInstanceOf[AnyRef], symbol)
       override val receiver = outer
-      lazy val jconstr = {
-        val jconstr = constructorToJava(symbol)
-        if (!jconstr.isAccessible) jconstr.setAccessible(true)
-        jconstr
-      }
+      lazy val jconstr = ensureAccessible(constructorToJava(symbol))
       def apply(args: Any*): Any = {
         if (symbol.owner == ArrayClass)
-          throw new ScalaReflectionException("Cannot instantiate arrays with mirrors. Consider using `scala.reflect.ClassTag(<class of element>).newArray(<length>)` instead")
+          abort("Cannot instantiate arrays with mirrors. Consider using `scala.reflect.ClassTag(<class of element>).newArray(<length>)` instead")
 
         val effectiveArgs =
           if (outer == null) args.asInstanceOf[Seq[AnyRef]]
@@ -532,7 +515,7 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
     }
 
     def javaClass(path: String): jClass[_] =
-      Class.forName(path, true, classLoader)
+      jClass.forName(path, true, classLoader)
 
     /** Does `path` correspond to a Java class with that fully qualified name in the current class loader? */
     def tryJavaClass(path: String): Option[jClass[_]] = (
@@ -655,13 +638,22 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
       sym setAnnotations (jann.getAnnotations map JavaAnnotationProxy).toList
       // SI-7065: we're not using getGenericExceptionTypes here to be consistent with ClassfileParser
       val jexTpes = jann match {
-        case jm: jMethod => jm.getExceptionTypes.toList
+        case jm: jMethod              => jm.getExceptionTypes.toList
         case jconstr: jConstructor[_] => jconstr.getExceptionTypes.toList
-        case _ => Nil
+        case _                        => Nil
       }
       jexTpes foreach (jexTpe => sym.addThrowsAnnotation(classSymbol(jexTpe)))
     }
 
+    private implicit class jClassOps(val clazz: jClass[_]) {
+      def javaFlags: JavaAccFlags = JavaAccFlags(clazz)
+      def scalaFlags: Long        = javaFlags.toScalaFlags
+    }
+    private implicit class jMemberOps(val member: jMember) {
+      def javaFlags: JavaAccFlags = JavaAccFlags(member)
+      def scalaFlags: Long        = javaFlags.toScalaFlags
+    }
+
     /**
      * 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
@@ -681,14 +673,14 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
       override def load(sym: Symbol): Unit = {
         debugInfo("completing from Java " + sym + "/" + clazz.fullName)//debug
         assert(sym == clazz || (module != NoSymbol && (sym == module || sym == module.moduleClass)), sym)
-        val flags = toScalaClassFlags(jclazz.getModifiers)
+        val flags = jclazz.scalaFlags
         clazz setFlag (flags | JAVA)
         if (module != NoSymbol) {
           module setFlag (flags & PRIVATE | JAVA)
           module.moduleClass setFlag (flags & PRIVATE | JAVA)
         }
 
-        relatedSymbols foreach (importPrivateWithinFromJavaFlags(_, jclazz.getModifiers))
+        propagatePackageBoundary(jclazz, relatedSymbols: _*)
         copyAnnotations(clazz, jclazz)
         // to do: annotations to set also for module?
 
@@ -720,28 +712,21 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
           module.moduleClass setInfo new ClassInfoType(List(), newScope, module.moduleClass)
         }
 
-        def enter(sym: Symbol, mods: Int) =
-          (if (jModifier.isStatic(mods)) module.moduleClass else clazz).info.decls enter sym
+        def enter(sym: Symbol, mods: JavaAccFlags) =
+          ( if (mods.isStatic) module.moduleClass else clazz ).info.decls enter sym
 
         for (jinner <- jclazz.getDeclaredClasses)
           jclassAsScala(jinner) // inner class is entered as a side-effect
                                 // no need to call enter explicitly
 
-        pendingLoadActions = { () =>
-
-          for (jfield <- jclazz.getDeclaredFields)
-            enter(jfieldAsScala(jfield), jfield.getModifiers)
-
-          for (jmeth <- jclazz.getDeclaredMethods)
-            enter(jmethodAsScala(jmeth), jmeth.getModifiers)
-
-          for (jconstr <- jclazz.getConstructors)
-            enter(jconstrAsScala(jconstr), jconstr.getModifiers)
-
-        } :: pendingLoadActions
+        pendingLoadActions ::= { () =>
+          jclazz.getDeclaredFields  foreach (f => enter(jfieldAsScala(f),  f.javaFlags))
+          jclazz.getDeclaredMethods foreach (m => enter(jmethodAsScala(m), m.javaFlags))
+          jclazz.getConstructors    foreach (c => enter(jconstrAsScala(c), c.javaFlags))
+        }
 
         if (parentsLevel == 0) {
-          while (!pendingLoadActions.isEmpty) {
+          while (pendingLoadActions.nonEmpty) {
             val item = pendingLoadActions.head
             pendingLoadActions = pendingLoadActions.tail
             item()
@@ -760,8 +745,8 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
      * 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
+    private def followStatic(clazz: Symbol, mods: JavaAccFlags) =
+      if (mods.isStatic) clazz.companionModule.moduleClass else clazz
 
   /** Methods which need to be treated with care
    *  because they either are getSimpleName or call getSimpleName:
@@ -797,7 +782,7 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
       if (jclazz.isMemberClass) {
         val jEnclosingClass = jclazz.getEnclosingClass
         val sEnclosingClass = classToScala(jEnclosingClass)
-        followStatic(sEnclosingClass, jclazz.getModifiers)
+        followStatic(sEnclosingClass, jclazz.javaFlags)
       } else if (jclazz.isLocalClass0) {
         val jEnclosingMethod = jclazz.getEnclosingMethod
         if (jEnclosingMethod != null) {
@@ -825,7 +810,7 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
      * 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)
+      followStatic(classToScala(jmember.getDeclaringClass), jmember.javaFlags)
     }
 
     /**
@@ -866,7 +851,7 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
     private def methodToScala1(jmeth: jMethod): MethodSymbol = {
       val jOwner = jmeth.getDeclaringClass
       val preOwner = classToScala(jOwner)
-      val owner = followStatic(preOwner, jmeth.getModifiers)
+      val owner = followStatic(preOwner, jmeth.javaFlags)
       (lookup(owner, jmeth.getName) suchThat (erasesTo(_, jmeth)) orElse jmethodAsScala(jmeth))
         .asMethod
     }
@@ -880,7 +865,7 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
       toScala(constructorCache, jconstr)(_ constructorToScala1 _)
 
     private def constructorToScala1(jconstr: jConstructor[_]): MethodSymbol = {
-      val owner = followStatic(classToScala(jconstr.getDeclaringClass), jconstr.getModifiers)
+      val owner = followStatic(classToScala(jconstr.getDeclaringClass), jconstr.javaFlags)
       (lookup(owner, jconstr.getName) suchThat (erasesTo(_, jconstr)) orElse jconstrAsScala(jconstr))
         .asMethod
     }
@@ -1018,6 +1003,10 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
       case jmeth: jMethod           => methodToScala(jmeth)
       case jconstr: jConstructor[_] => constructorToScala(jconstr)
     }
+    def reflectMemberToScala(m: jMember): Symbol = m match {
+      case x: GenericDeclaration => genericDeclarationToScala(x)
+      case x: jField             => jfieldAsScala(x)
+    }
 
     /**
      * Given some Java type arguments, a corresponding list of Scala types, plus potentially
@@ -1092,10 +1081,11 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
 
     private def jfieldAsScala1(jfield: jField): TermSymbol = {
       val field = sOwner(jfield)
-          .newValue(newTermName(jfield.getName), NoPosition, toScalaFieldFlags(jfield.getModifiers))
+          .newValue(newTermName(jfield.getName), NoPosition, jfield.scalaFlags)
           .setInfo(typeToScala(jfield.getGenericType))
-      fieldCache enter (jfield, field)
-      importPrivateWithinFromJavaFlags(field, jfield.getModifiers)
+
+      fieldCache.enter(jfield, field)
+      propagatePackageBoundary(jfield, field)
       copyAnnotations(field, jfield)
       field
     }
@@ -1115,16 +1105,19 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
 
     private def jmethodAsScala1(jmeth: jMethod): MethodSymbol = {
       val clazz = sOwner(jmeth)
-      val meth = clazz.newMethod(newTermName(jmeth.getName), NoPosition, toScalaMethodFlags(jmeth.getModifiers))
+      val meth = clazz.newMethod(newTermName(jmeth.getName), NoPosition, jmeth.scalaFlags)
       methodCache enter (jmeth, meth)
       val tparams = jmeth.getTypeParameters.toList map createTypeParameter
       val paramtpes = jmeth.getGenericParameterTypes.toList map typeToScala
       val resulttpe = typeToScala(jmeth.getGenericReturnType)
       setMethType(meth, tparams, paramtpes, resulttpe)
-      importPrivateWithinFromJavaFlags(meth, jmeth.getModifiers)
+      propagatePackageBoundary(jmeth.javaFlags, meth)
       copyAnnotations(meth, jmeth)
-      if ((jmeth.getModifiers & JAVA_ACC_VARARGS) != 0) meth.setInfo(arrayToRepeated(meth.info))
-      meth
+
+      if (jmeth.javaFlags.isVarargs)
+        meth modifyInfo arrayToRepeated
+      else
+        meth
     }
 
     /**
@@ -1139,13 +1132,13 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
     private def jconstrAsScala1(jconstr: jConstructor[_]): MethodSymbol = {
       // [Martin] Note: I know there's a lot of duplication wrt jmethodAsScala, but don't think it's worth it to factor this out.
       val clazz = sOwner(jconstr)
-      val constr = clazz.newConstructor(NoPosition, toScalaMethodFlags(jconstr.getModifiers))
+      val constr = clazz.newConstructor(NoPosition, jconstr.scalaFlags)
       constructorCache enter (jconstr, constr)
       val tparams = jconstr.getTypeParameters.toList map createTypeParameter
       val paramtpes = jconstr.getGenericParameterTypes.toList map typeToScala
       setMethType(constr, tparams, paramtpes, clazz.tpe_*)
       constr setInfo GenPolyType(tparams, MethodType(clazz.newSyntheticValueParams(paramtpes), clazz.tpe))
-      importPrivateWithinFromJavaFlags(constr, jconstr.getModifiers)
+      propagatePackageBoundary(jconstr.javaFlags, constr)
       copyAnnotations(constr, jconstr)
       constr
     }
@@ -1170,13 +1163,15 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
       else if (clazz.isTopLevel)
         javaClass(clazz.javaClassName)
       else if (clazz.owner.isClass) {
-        val childOfClass = !clazz.owner.isModuleClass
-        val childOfTopLevel = clazz.owner.isTopLevel
+        val childOfClass          = !clazz.owner.isModuleClass
+        val childOfTopLevel       = clazz.owner.isTopLevel
         val childOfTopLevelObject = clazz.owner.isModuleClass && childOfTopLevel
 
         // suggested in https://issues.scala-lang.org/browse/SI-4023?focusedCommentId=54759#comment-54759
         var ownerClazz = classToJava(clazz.owner.asClass)
-        if (childOfTopLevelObject) ownerClazz = Class.forName(ownerClazz.getName stripSuffix "$", true, ownerClazz.getClassLoader)
+        if (childOfTopLevelObject)
+          ownerClazz = jClass.forName(ownerClazz.getName stripSuffix "$", true, ownerClazz.getClassLoader)
+
         val ownerChildren = ownerClazz.getDeclaredClasses
 
         var fullNameOfJavaClass = ownerClazz.getName
@@ -1241,11 +1236,11 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
      *  Pre: Scala type is already transformed to Java level.
      */
     def typeToJavaClass(tpe: Type): jClass[_] = tpe match {
-      case ExistentialType(_, rtpe) => typeToJavaClass(rtpe)
-      case TypeRef(_, ArrayClass, List(elemtpe)) => jArrayClass(typeToJavaClass(elemtpe))
-      case TypeRef(_, sym: ClassSymbol, _) => classToJava(sym.asClass)
+      case ExistentialType(_, rtpe)                  => typeToJavaClass(rtpe)
+      case TypeRef(_, ArrayClass, List(elemtpe))     => jArrayClass(typeToJavaClass(elemtpe))
+      case TypeRef(_, sym: ClassSymbol, _)           => classToJava(sym.asClass)
       case tpe @ TypeRef(_, sym: AliasTypeSymbol, _) => typeToJavaClass(tpe.dealias)
-      case _ => throw new NoClassDefFoundError("no Java class corresponding to "+tpe+" found")
+      case _                                         => throw new NoClassDefFoundError("no Java class corresponding to "+tpe+" found")
     }
   }