Resurrected the former contents of scala.io in ...

Resurrected the former contents of scala.io in their new home,
scala.tools.nsc.io, and equipped them with fake beards and handlebar
moustaches. Also restored the reverted bits of the compiler which had
been taking advantage of them.

1 files changed, 43 insertions, 48 deletions

diff --git a/src/compiler/scala/tools/nsc/plugins/Plugin.scala b/src/compiler/scala/tools/nsc/plugins/Plugin.scala
index 3013199c36..2b61724c49 100644
--- a/src/compiler/scala/tools/nsc/plugins/Plugin.scala
+++ b/src/compiler/scala/tools/nsc/plugins/Plugin.scala
@@ -7,7 +7,7 @@
 package scala.tools.nsc
 package plugins
 
-import java.io.File
+import io.{ File, Path }
 import java.net.URLClassLoader
 import java.util.jar.JarFile
 import java.util.zip.ZipException
@@ -63,39 +63,44 @@ abstract class Plugin {
  *  @author Lex Spoon
  *  @version 1.0, 2007-5-21
  */
-object Plugin {
+object Plugin
+{
+  private val PluginXML = "scalac-plugin.xml"
+
   /** Create a class loader with the specified file plus
    *  the loader that loaded the Scala compiler.
    */
-  private def loaderFor(jarfiles: Seq[File]): ClassLoader = {
+  private def loaderFor(jarfiles: Seq[Path]): ClassLoader = {
     val compilerLoader = classOf[Plugin].getClassLoader
-    val jarurls = jarfiles.map(_.toURL).toArray
-    new URLClassLoader(jarurls, compilerLoader)
+    val jarurls = jarfiles map (_.toURL)
+
+    new URLClassLoader(jarurls.toArray, compilerLoader)
   }
 
   /** Try to load a plugin description from the specified
    *  file, returning None if it does not work. */
-  private def loadDescription(jarfile: File): Option[PluginDescription] = {
-    if (!jarfile.exists) return None
+  private def loadDescription(jarfile: Path): Option[PluginDescription] =
+    // XXX Return to this once we have some ARM support
+    if (!jarfile.exists) None
+    else try {
+      val jar = new JarFile(jarfile.jfile)
 
-    try {
-      val jar = new JarFile(jarfile)
       try {
-	val ent = jar.getEntry("scalac-plugin.xml")
-	if (ent == null) return None
-
-	val inBytes = jar.getInputStream(ent)
-	val packXML = XML.load(inBytes)
-	inBytes.close()
-
-	PluginDescription.fromXML(packXML)
-      } finally {
-	jar.close()
+        (jar getEntry PluginXML) match {
+          case null   => None
+          case entry  =>
+            val in = jar getInputStream entry
+            val packXML = XML load in
+            in.close()
+
+            PluginDescription fromXML packXML
+        }
       }
-    } catch {
+      finally jar.close()
+    }
+    catch {
       case _: ZipException => None
     }
-  }
 
   type AnyClass = Class[_]
 
@@ -103,16 +108,13 @@ object Plugin {
    *  if the jar file has no plugin in it or if the plugin
    *  is badly formed.
    */
-  def loadFrom(jarfile: File, loader: ClassLoader): Option[AnyClass] = {
+  def loadFrom(jarfile: Path, loader: ClassLoader): Option[AnyClass] = {
     val pluginInfo = loadDescription(jarfile).get
 
-    try {
-      Some(loader.loadClass(pluginInfo.classname))
-    } catch {
-      case _:ClassNotFoundException =>
-	println("Warning: class not found for plugin in " + jarfile +
-                " (" + pluginInfo.classname + ")")
-      None
+    try Some(loader loadClass pluginInfo.classname) catch {
+      case _: ClassNotFoundException =>
+        println("Warning: class not found for plugin in %s (%s)".format(jarfile, pluginInfo.classname))
+        None
     }
   }
 
@@ -121,35 +123,28 @@ object Plugin {
    *  directories specified. Skips all plugins in <code>ignoring</code>.
    *  A single classloader is created and used to load all of them.
    */
-  def loadAllFrom(jars: List[File],
-		  dirs: List[File],
-		  ignoring: List[String]): List[AnyClass] =
+  def loadAllFrom(
+    jars: List[Path],
+    dirs: List[Path],
+    ignoring: List[String]): List[AnyClass] =
   {
-    val alljars = new ListBuffer[File]
-
-    alljars ++= jars
-
-    for {
+    val alljars = jars ::: (for {
       dir <- dirs if dir.isDirectory
-      entries = dir.listFiles
-      if entries ne null
-      entry <- entries.toList.sort(_.getName <= _.getName)
-      if entry.toString.toLowerCase endsWith ".jar"
+      entry <- dir.toDirectory.files.toList sortWith (_.name <= _.name)
+      if entry.name.toLowerCase endsWith ".jar"
       pdesc <- loadDescription(entry)
       if !(ignoring contains pdesc.name)
-    } alljars += entry
+    } yield entry)
 
-    val loader = loaderFor(alljars.toList)
-    alljars.toList.map(f => loadFrom(f,loader)).flatMap(x => x)
+    val loader = loaderFor(alljars)
+    alljars map (loadFrom(_, loader)) flatten
   }
 
   /** Instantiate a plugin class, given the class and
    *  the compiler it is to be used in.
    */
   def instantiate(clazz: AnyClass, global: Global): Plugin = {
-    //println("instantiating "+clazz)
-    //println(clazz.getDeclaredConstructors)
-    val constructor = clazz.getConstructor(classOf[Global])
-    constructor.newInstance(global).asInstanceOf[Plugin]
+    val constructor = clazz getConstructor classOf[Global]
+    (constructor newInstance global).asInstanceOf[Plugin]
   }
 }