Add :javap to the REPL

Adapted from the Scala 2 implementation, which was written by
Paul Phillips and Som Snytt / A. P. Marki

Author: griggt

compiler/src/dotty/tools/dotc/config/PathResolver.scala

@@ -128,6 +128,47 @@ object PathResolver {
       )
   }
 
+  /** Locations discovered by supplemental heuristics.
+   */
+  object SupplementalLocations {
+
+    /** The platform-specific support jar.
+     *
+     *  Usually this is `tools.jar` in the jdk/lib directory of the platform distribution.
+     *
+     *  The file location is determined by probing the lib directory under JDK_HOME or JAVA_HOME,
+     *  if one of those environment variables is set, then the lib directory under java.home,
+     *  and finally the lib directory under the parent of java.home. Or, as a last resort,
+     *  search deeply under those locations (except for the parent of java.home, on the notion
+     *  that if this is not a canonical installation, then that search would have little
+     *  chance of succeeding).
+     */
+    def platformTools: Option[File] = {
+      val jarName = "tools.jar"
+      def jarPath(path: Path) = (path / "lib" / jarName).toFile
+      def jarAt(path: Path) = {
+        val f = jarPath(path)
+        if (f.isFile) Some(f) else None
+      }
+      val jdkDir = {
+        val d = Directory(jdkHome)
+        if (d.isDirectory) Some(d) else None
+      }
+      def deeply(dir: Directory) = dir.deepFiles find (_.name == jarName)
+
+      val home    = envOrSome("JDK_HOME", envOrNone("JAVA_HOME")) map (p => Path(p))
+      val install = Some(Path(javaHome))
+
+      (home flatMap jarAt) orElse (install flatMap jarAt) orElse (install map (_.parent) flatMap jarAt) orElse
+        (jdkDir flatMap deeply)
+    }
+
+    override def toString = s"""
+      |object SupplementalLocations {
+      |  platformTools        = $platformTools
+      |}""" //.asLines // TODO implement asLines or equivalent
+  }
+
   def fromPathString(path: String)(using Context): ClassPath = {
     val settings = ctx.settings.classpath.update(path)
     new PathResolver()(using ctx.fresh.setSettings(settings)).result

compiler/src/dotty/tools/dotc/config/Properties.scala

@@ -53,6 +53,7 @@ trait PropertiesTrait {
 
   def envOrElse(name: String, alt: String): String      = Option(System getenv name) getOrElse alt
   def envOrNone(name: String): Option[String]           = Option(System getenv name)
+  def envOrSome(name: String, alt: => Option[String])   = envOrNone(name) orElse alt
 
   // for values based on propFilename
   def scalaPropOrElse(name: String, alt: String): String = scalaProps.getProperty(name, alt)

compiler/src/dotty/tools/repl/ClassLoaderOps.scala

@@ -0,0 +1,55 @@
+package dotty.tools.repl
+
+import scala.reflect.{ ClassTag, classTag }
+import scala.util.control.Exception.catching
+
+object ClassLoaderOps:
+  extension (cl: ClassLoader)
+    /** Create an instance with ctor args, or invoke errorFn before throwing. */
+    def createInstance[T <: AnyRef : ClassTag](path: String, errorFn: String => Unit)(args: AnyRef*): T =
+      def fail(msg: String) = error(msg, new IllegalArgumentException(msg))
+      def error(msg: String, e: Throwable) = { errorFn(msg) ; throw e }
+      try
+        val clazz = Class.forName(path, /*initialize =*/ true, /*loader =*/ cl)
+        if classTag[T].runtimeClass.isAssignableFrom(clazz) then
+          val ctor =
+            val maybes = clazz.getConstructors.filter(c =>
+              c.getParameterCount == args.size
+              && (c.getParameterTypes zip args).forall { case (k, a) => k.isAssignableFrom(a.getClass) })
+            if maybes.size == 1 then maybes.head
+            else fail(s"Constructor must accept arg list (${args.map(_.getClass.getName).mkString(", ")}): ${path}")
+          (ctor.newInstance(args*)).asInstanceOf[T]
+        else
+          // TODO show is undefined; in the original code, it is imported from
+          //  import scala.reflect.runtime.ReflectionUtils.show
+          //errorFn(s"""Loader for ${classTag[T]}:   [${show(classTag[T].runtimeClass.getClassLoader)}]
+          //           |Loader for ${clazz.getName}: [${show(clazz.getClassLoader)}]""".stripMargin)
+          fail(s"Not a ${classTag[T]}: ${path}")
+      catch
+        case e: ClassNotFoundException =>
+          error(s"Class not found: ${path}", e)
+        case e @ (_: LinkageError | _: ReflectiveOperationException) =>
+          error(s"Unable to create instance: ${path}: ${e.toString}", e)
+
+    /** Load and link a class with this classloader */
+    def tryToLoadClass[T <: AnyRef](path: String): Option[Class[T]] =
+      tryClass(path, initialize = false)
+
+    /** Load, link and initialize a class with this classloader */
+    def tryToInitializeClass[T <: AnyRef](path: String): Option[Class[T]] =
+      tryClass(path, initialize = true)
+
+    private def tryClass[T <: AnyRef](path: String, initialize: Boolean): Option[Class[T]] =
+      catching(classOf[ClassNotFoundException], classOf[SecurityException]) opt
+        Class.forName(path, initialize, cl).asInstanceOf[Class[T]]
+
+    /** The actual bytes for a class file, or an empty array if it can't be found. */
+    def classBytes(className: String): Array[Byte] = classAsStream(className) match
+      case null   => Array()
+      case stream => dotty.tools.io.Streamable.bytes(stream)
+
+    private inline def classAsStream(className: String) = cl.getResourceAsStream {
+      if className.endsWith(".class") then className
+      else s"${className.replace('.', '/')}.class"  // classNameToPath
+    }
+end ClassLoaderOps