1 files changed, 38 insertions, 5 deletions
diff --git a/src/reflect/scala/reflect/runtime/JavaUniverse.scala b/src/reflect/scala/reflect/runtime/JavaUniverse.scala
index f6556a442d..b5446694ed 100644
--- a/src/reflect/scala/reflect/runtime/JavaUniverse.scala
+++ b/src/reflect/scala/reflect/runtime/JavaUniverse.scala
@@ -2,33 +2,66 @@ package scala
 package reflect
 package runtime
 
+import scala.reflect.internal.{TreeInfo, SomePhase}
+import scala.reflect.internal.{SymbolTable => InternalSymbolTable}
+import scala.reflect.runtime.{SymbolTable => RuntimeSymbolTable}
+import scala.reflect.api.{TreeCreator, TypeCreator, Universe}
+
 /** An implementation of [[scala.reflect.api.Universe]] for runtime reflection using JVM classloaders.
  *
  *  Should not be instantiated directly, use [[scala.reflect.runtime.universe]] instead.
  *
  *  @contentDiagram hideNodes "*Api" "*Extractor"
  */
-class JavaUniverse extends internal.SymbolTable with JavaUniverseForce with ReflectSetup with runtime.SymbolTable { self =>
+class JavaUniverse extends InternalSymbolTable with JavaUniverseForce with ReflectSetup with RuntimeSymbolTable { self =>
 
   override def inform(msg: String): Unit = log(msg)
-  def picklerPhase = internal.SomePhase
-  def erasurePhase = internal.SomePhase
-
+  def picklerPhase = SomePhase
+  def erasurePhase = SomePhase
   lazy val settings = new Settings
   private val isLogging = sys.props contains "scala.debug.reflect"
 
   def log(msg: => AnyRef): Unit = if (isLogging) Console.err.println("[reflect] " + msg)
 
   type TreeCopier = InternalTreeCopierOps
+  implicit val TreeCopierTag: ClassTag[TreeCopier] = ClassTag[TreeCopier](classOf[TreeCopier])
   def newStrictTreeCopier: TreeCopier = new StrictTreeCopier
   def newLazyTreeCopier: TreeCopier = new LazyTreeCopier
 
   def currentFreshNameCreator = globalFreshNameCreator
 
+  override lazy val internal: Internal = new SymbolTableInternal {
+    override def typeTagToManifest[T: ClassTag](mirror0: Any, tag: Universe # TypeTag[T]): Manifest[T] = {
+      // SI-6239: make this conversion more precise
+      val mirror = mirror0.asInstanceOf[Mirror]
+      val runtimeClass = mirror.runtimeClass(tag.in(mirror).tpe)
+      Manifest.classType(runtimeClass).asInstanceOf[Manifest[T]]
+    }
+    override def manifestToTypeTag[T](mirror0: Any, manifest: Manifest[T]): Universe # TypeTag[T] =
+      TypeTag(mirror0.asInstanceOf[Mirror], new TypeCreator {
+        def apply[U <: Universe with Singleton](mirror: scala.reflect.api.Mirror[U]): U # Type = {
+          mirror.universe match {
+            case ju: JavaUniverse =>
+              val jm = mirror.asInstanceOf[ju.Mirror]
+              val sym = jm.classSymbol(manifest.runtimeClass)
+              val tpe =
+                if (manifest.typeArguments.isEmpty) sym.toType
+                else {
+                  val tags = manifest.typeArguments map (targ => ju.internal.manifestToTypeTag(jm, targ))
+                  ju.appliedType(sym.toTypeConstructor, tags map (_.in(jm).tpe))
+                }
+              tpe.asInstanceOf[U # Type]
+            case u =>
+              u.internal.manifestToTypeTag(mirror.asInstanceOf[u.Mirror], manifest).in(mirror).tpe
+          }
+        }
+      })
+  }
+
   // can't put this in runtime.Trees since that's mixed with Global in ReflectGlobal, which has the definition from internal.Trees
   object treeInfo extends {
     val global: JavaUniverse.this.type = JavaUniverse.this
-  } with internal.TreeInfo
+  } with TreeInfo
 
   init()