Commenting out unused members.

I want to get this commit into the history because
the tests pass here, which demonstrates that every commented
out method is not only unnecessary internally but has zero
test coverage. Since I know (based on the occasional source
code comment, or more often based on knowing something about
other source bases) that some of these can't be removed
without breaking other things, I want to at least record
a snapshot of the identities of all these unused and
untested methods.

This commit will be reverted; then there will be another
commit which removes the subset of these methods which I
believe to be removable. The remainder are in great need of
tests which exercise the interfaces upon which other
repositories depend.

9 files changed, 104 insertions, 104 deletions

diff --git a/src/reflect/scala/reflect/io/AbstractFile.scala b/src/reflect/scala/reflect/io/AbstractFile.scala
index 15befb67f1..de37176cd5 100644
--- a/src/reflect/scala/reflect/io/AbstractFile.scala
+++ b/src/reflect/scala/reflect/io/AbstractFile.scala
@@ -14,9 +14,9 @@ import scala.collection.mutable.ArrayBuffer
 
 /**
  * An abstraction over files for use in the reflection/compiler libraries.
- * 
+ *
  * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
- *  
+ *
  * @author Philippe Altherr
  * @version 1.0, 23/03/2004
  */
@@ -85,7 +85,7 @@ object AbstractFile {
  *   all other cases, the class <code>SourceFile</code> is used, which honors
  *   <code>global.settings.encoding.value</code>.
  * </p>
- * 
+ *
  * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 abstract class AbstractFile extends Iterable[AbstractFile] {
@@ -195,9 +195,9 @@ abstract class AbstractFile extends Iterable[AbstractFile] {
    *  @param directory ...
    *  @return          ...
    */
-  def lookupPath(path: String, directory: Boolean): AbstractFile = {
-    lookup((f, p, dir) => f.lookupName(p, dir), path, directory)
-  }
+  // def lookupPath(path: String, directory: Boolean): AbstractFile = {
+  //   lookup((f, p, dir) => f.lookupName(p, dir), path, directory)
+  // }
 
   /** Return an abstract file that does not check that `path` denotes
    *  an existing file.
diff --git a/src/reflect/scala/reflect/io/Directory.scala b/src/reflect/scala/reflect/io/Directory.scala
index c040d1eac5..3a21509457 100644
--- a/src/reflect/scala/reflect/io/Directory.scala
+++ b/src/reflect/scala/reflect/io/Directory.scala
@@ -14,12 +14,12 @@ import java.io.{ File => JFile }
  * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 object Directory {
-  import scala.util.Properties.{ tmpDir, userHome, userDir }
+  import scala.util.Properties.{ userHome, userDir }
 
   private def normalizePath(s: String) = Some(apply(Path(s).normalize))
   def Current: Option[Directory]  = if (userDir == "") None else normalizePath(userDir)
-  def Home: Option[Directory]     = if (userHome == "") None else normalizePath(userHome)
-  def TmpDir: Option[Directory]   = if (tmpDir == "") None else normalizePath(tmpDir)
+  // def Home: Option[Directory]     = if (userHome == "") None else normalizePath(userHome)
+  // def TmpDir: Option[Directory]   = if (tmpDir == "") None else normalizePath(tmpDir)
 
   def apply(path: Path): Directory = path.toDirectory
 
@@ -30,20 +30,19 @@ object Directory {
     path.createDirectory()
   }
 }
-import Path._
 
 /** An abstraction for directories.
  *
  *  @author  Paul Phillips
  *  @since   2.8
- *  
+ *
  *  ''Note:  This is library is considered experimental and should not be used unless you know what you are doing.''
  */
 class Directory(jfile: JFile) extends Path(jfile) {
   override def toAbsolute: Directory = if (isAbsolute) this else super.toAbsolute.toDirectory
   override def toDirectory: Directory = this
   override def toFile: File = new File(jfile)
-  override def isValid = jfile.isDirectory() || !jfile.exists()
+  // override def isValid = jfile.isDirectory() || !jfile.exists()
   override def normalize: Directory = super.normalize.toDirectory
 
   /** An iterator over the contents of this directory.
@@ -60,7 +59,7 @@ class Directory(jfile: JFile) extends Path(jfile) {
   override def walkFilter(cond: Path => Boolean): Iterator[Path] =
     list filter cond flatMap (_ walkFilter cond)
 
-  def deepDirs: Iterator[Directory] = Path.onlyDirs(deepList())
+  // def deepDirs: Iterator[Directory] = Path.onlyDirs(deepList())
   def deepFiles: Iterator[File] = Path.onlyFiles(deepList())
 
   /** If optional depth argument is not given, will recurse
@@ -74,6 +73,6 @@ class Directory(jfile: JFile) extends Path(jfile) {
   /** An iterator over the directories underneath this directory,
    *  to the (optionally) given depth.
    */
-  def subdirs(depth: Int = 1): Iterator[Directory] =
-    deepList(depth) collect { case x: Directory => x }
+  // def subdirs(depth: Int = 1): Iterator[Directory] =
+  //   deepList(depth) collect { case x: Directory => x }
 }
diff --git a/src/reflect/scala/reflect/io/File.scala b/src/reflect/scala/reflect/io/File.scala
index 736ba5d51e..04e122af67 100644
--- a/src/reflect/scala/reflect/io/File.scala
+++ b/src/reflect/scala/reflect/io/File.scala
@@ -35,12 +35,12 @@ object File {
 
   type HasClose = { def close(): Unit }
 
-  def closeQuietly(target: HasClose) {
-    try target.close() catch { case e: IOException => }
-  }
-  def closeQuietly(target: JCloseable) {
-    try target.close() catch { case e: IOException => }
-  }
+  // def closeQuietly(target: HasClose) {
+  //   try target.close() catch { case e: IOException => }
+  // }
+  // def closeQuietly(target: JCloseable) {
+  //   try target.close() catch { case e: IOException => }
+  // }
 
   // this is a workaround for http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6503430
   // we are using a static initializer to statically initialize a java class so we don't
@@ -65,8 +65,8 @@ object File {
   //   case _: IllegalArgumentException | _: IllegalStateException | _: IOException | _: SecurityException => ()
   // }
 }
-import File._
-import Path._
+// import File._
+// import Path._
 
 /** An abstraction for files.  For character data, a Codec
  *  can be supplied at either creation time or when a method
@@ -76,19 +76,19 @@ import Path._
  *
  *  @author  Paul Phillips
  *  @since   2.8
- *  
+ *
  *  ''Note:  This is library is considered experimental and should not be used unless you know what you are doing.''
  */
 class File(jfile: JFile)(implicit constructorCodec: Codec) extends Path(jfile) with Streamable.Chars {
   override val creationCodec = constructorCodec
-  def withCodec(codec: Codec): File = new File(jfile)(codec)
+  // def withCodec(codec: Codec): File = new File(jfile)(codec)
 
   override def addExtension(ext: String): File = super.addExtension(ext).toFile
   override def toAbsolute: File = if (isAbsolute) this else super.toAbsolute.toFile
   override def toDirectory: Directory = new Directory(jfile)
   override def toFile: File = this
   override def normalize: File = super.normalize.toFile
-  override def isValid = jfile.isFile() || !jfile.exists()
+  // override def isValid = jfile.isFile() || !jfile.exists()
   override def length = super[Path].length
   override def walkFilter(cond: Path => Boolean): Iterator[Path] =
     if (cond(this)) Iterator.single(this) else Iterator.empty
@@ -99,14 +99,14 @@ class File(jfile: JFile)(implicit constructorCodec: Codec) extends Path(jfile) w
   /** Obtains a OutputStream. */
   def outputStream(append: Boolean = false) = new FileOutputStream(jfile, append)
   def bufferedOutput(append: Boolean = false) = new BufferedOutputStream(outputStream(append))
-  def printStream(append: Boolean = false) = new PrintStream(outputStream(append), true)
+  // def printStream(append: Boolean = false) = new PrintStream(outputStream(append), true)
 
   /** Obtains an OutputStreamWriter wrapped around a FileOutputStream.
    *  This should behave like a less broken version of java.io.FileWriter,
    *  in that unlike the java version you can specify the encoding.
    */
-  def writer(): OutputStreamWriter = writer(false)
-  def writer(append: Boolean): OutputStreamWriter = writer(append, creationCodec)
+  // def writer(): OutputStreamWriter = writer(false)
+  // def writer(append: Boolean): OutputStreamWriter = writer(append, creationCodec)
   def writer(append: Boolean, codec: Codec): OutputStreamWriter =
     new OutputStreamWriter(outputStream(append), codec.charSet)
 
@@ -118,7 +118,7 @@ class File(jfile: JFile)(implicit constructorCodec: Codec) extends Path(jfile) w
     new BufferedWriter(writer(append, codec))
 
   def printWriter(): PrintWriter = new PrintWriter(bufferedWriter(), true)
-  def printWriter(append: Boolean): PrintWriter = new PrintWriter(bufferedWriter(append), true)
+  // def printWriter(append: Boolean): PrintWriter = new PrintWriter(bufferedWriter(append), true)
 
   /** Creates a new file and writes all the Strings to it. */
   def writeAll(strings: String*): Unit = {
@@ -127,11 +127,11 @@ class File(jfile: JFile)(implicit constructorCodec: Codec) extends Path(jfile) w
     finally out.close()
   }
 
-  def writeBytes(bytes: Array[Byte]): Unit = {
-    val out = bufferedOutput()
-    try out write bytes
-    finally out.close()
-  }
+  // def writeBytes(bytes: Array[Byte]): Unit = {
+  //   val out = bufferedOutput()
+  //   try out write bytes
+  //   finally out.close()
+  // }
 
   def appendAll(strings: String*): Unit = {
     val out = bufferedWriter(append = true)
@@ -150,38 +150,38 @@ class File(jfile: JFile)(implicit constructorCodec: Codec) extends Path(jfile) w
     try Some(slurp())
     catch { case _: IOException => None }
 
-  def copyTo(destPath: Path, preserveFileDate: Boolean = false): Boolean = {
-    val CHUNK = 1024 * 1024 * 16  // 16 MB
-    val dest = destPath.toFile
-    if (!isValid) fail("Source %s is not a valid file." format name)
-    if (this.normalize == dest.normalize) fail("Source and destination are the same.")
-    if (!dest.parent.exists) fail("Destination cannot be created.")
-    if (dest.exists && !dest.canWrite) fail("Destination exists but is not writable.")
-    if (dest.isDirectory) fail("Destination exists but is a directory.")
-
-    lazy val in_s = inputStream()
-    lazy val out_s = dest.outputStream()
-    lazy val in = in_s.getChannel()
-    lazy val out = out_s.getChannel()
-
-    try {
-      val size = in.size()
-      var pos, count = 0L
-      while (pos < size) {
-        count = (size - pos) min CHUNK
-        pos += out.transferFrom(in, pos, count)
-      }
-    }
-    finally List[HasClose](out, out_s, in, in_s) foreach closeQuietly
-
-    if (this.length != dest.length)
-      fail("Failed to completely copy %s to %s".format(name, dest.name))
-
-    if (preserveFileDate)
-      dest.lastModified = this.lastModified
-
-    true
-  }
+  // def copyTo(destPath: Path, preserveFileDate: Boolean = false): Boolean = {
+  //   val CHUNK = 1024 * 1024 * 16  // 16 MB
+  //   val dest = destPath.toFile
+  //   if (!isValid) fail("Source %s is not a valid file." format name)
+  //   if (this.normalize == dest.normalize) fail("Source and destination are the same.")
+  //   if (!dest.parent.exists) fail("Destination cannot be created.")
+  //   if (dest.exists && !dest.canWrite) fail("Destination exists but is not writable.")
+  //   if (dest.isDirectory) fail("Destination exists but is a directory.")
+
+  //   lazy val in_s = inputStream()
+  //   lazy val out_s = dest.outputStream()
+  //   lazy val in = in_s.getChannel()
+  //   lazy val out = out_s.getChannel()
+
+  //   try {
+  //     val size = in.size()
+  //     var pos, count = 0L
+  //     while (pos < size) {
+  //       count = (size - pos) min CHUNK
+  //       pos += out.transferFrom(in, pos, count)
+  //     }
+  //   }
+  //   finally List[HasClose](out, out_s, in, in_s) foreach closeQuietly
+
+  //   if (this.length != dest.length)
+  //     fail("Failed to completely copy %s to %s".format(name, dest.name))
+
+  //   if (preserveFileDate)
+  //     dest.lastModified = this.lastModified
+
+  //   true
+  // }
 
   /** Reflection since we're into the java 6+ API.
    */
diff --git a/src/reflect/scala/reflect/io/Path.scala b/src/reflect/scala/reflect/io/Path.scala
index 36fdc04db4..77b5065db1 100644
--- a/src/reflect/scala/reflect/io/Path.scala
+++ b/src/reflect/scala/reflect/io/Path.scala
@@ -27,7 +27,7 @@ import scala.language.implicitConversions
  *
  *  @author  Paul Phillips
  *  @since   2.8
- *  
+ *
  *  ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 object Path {
@@ -65,11 +65,11 @@ object Path {
   def onlyDirs(xs: Iterator[Path]): Iterator[Directory] = xs filter (_.isDirectory) map (_.toDirectory)
   def onlyDirs(xs: List[Path]): List[Directory] = xs filter (_.isDirectory) map (_.toDirectory)
   def onlyFiles(xs: Iterator[Path]): Iterator[File] = xs filter (_.isFile) map (_.toFile)
-  def onlyFiles(xs: List[Path]): List[File] = xs filter (_.isFile) map (_.toFile)
+  // def onlyFiles(xs: List[Path]): List[File] = xs filter (_.isFile) map (_.toFile)
 
   def roots: List[Path] = java.io.File.listRoots().toList map Path.apply
 
-  def apply(segments: Seq[String]): Path = apply(segments mkString java.io.File.separator)
+  // def apply(segments: Seq[String]): Path = apply(segments mkString java.io.File.separator)
   def apply(path: String): Path = apply(new JFile(path))
   def apply(jfile: JFile): Path =
     if (jfile.isFile) new File(jfile)
@@ -84,7 +84,7 @@ import Path._
 
 /** The Path constructor is private so we can enforce some
  *  semantics regarding how a Path might relate to the world.
- *  
+ *
  *  ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 class Path private[io] (val jfile: JFile) {
@@ -95,7 +95,7 @@ class Path private[io] (val jfile: JFile) {
   // contents of the filesystem are in agreement.  All objects are
   // valid except File objects whose path points to a directory and
   // Directory objects whose path points to a file.
-  def isValid: Boolean = true
+  // def isValid: Boolean = true
 
   // conversions
   def toFile: File = new File(jfile)
@@ -136,7 +136,7 @@ class Path private[io] (val jfile: JFile) {
   def name: String = jfile.getName()
   def path: String = jfile.getPath()
   def normalize: Path = Path(jfile.getAbsolutePath())
-  def isRootPath: Boolean = roots exists (_ isSame this)
+  // def isRootPath: Boolean = roots exists (_ isSame this)
 
   def resolve(other: Path) = if (other.isAbsolute || isEmpty) other else /(other)
   def relativize(other: Path) = {
@@ -153,7 +153,7 @@ class Path private[io] (val jfile: JFile) {
   }
 
   // derived from identity
-  def root: Option[Path] = roots find (this startsWith _)
+  // def root: Option[Path] = roots find (this startsWith _)
   def segments: List[String] = (path split separator).toList filterNot (_.length == 0)
   /**
    * @return The path of the parent directory, or root if path is already root
@@ -213,22 +213,22 @@ class Path private[io] (val jfile: JFile) {
   def canRead = jfile.canRead()
   def canWrite = jfile.canWrite()
   def exists = jfile.exists()
-  def notExists = try !jfile.exists() catch { case ex: SecurityException => false }
+  // def notExists = try !jfile.exists() catch { case ex: SecurityException => false }
 
   def isFile = jfile.isFile()
   def isDirectory = jfile.isDirectory()
   def isAbsolute = jfile.isAbsolute()
-  def isHidden = jfile.isHidden()
+  // def isHidden = jfile.isHidden()
   def isEmpty = path.length == 0
 
   // Information
   def lastModified = jfile.lastModified()
-  def lastModified_=(time: Long) = jfile setLastModified time // should use setXXX function?
+  // def lastModified_=(time: Long) = jfile setLastModified time // should use setXXX function?
   def length = jfile.length()
 
   // Boolean path comparisons
   def endsWith(other: Path) = segments endsWith other.segments
-  def startsWith(other: Path) = segments startsWith other.segments
+  // def startsWith(other: Path) = segments startsWith other.segments
   def isSame(other: Path) = toCanonical == other.toCanonical
   def isFresher(other: Path) = lastModified > other.lastModified
 
@@ -248,7 +248,7 @@ class Path private[io] (val jfile: JFile) {
 
   // deletions
   def delete() = jfile.delete()
-  def deleteIfExists() = if (jfile.exists()) delete() else false
+  // def deleteIfExists() = if (jfile.exists()) delete() else false
 
   /** Deletes the path recursively. Returns false on failure.
    *  Use with caution!
@@ -270,11 +270,11 @@ class Path private[io] (val jfile: JFile) {
       length == 0
     }
 
-  def touch(modTime: Long = System.currentTimeMillis) = {
-    createFile()
-    if (isFile)
-      lastModified = modTime
-  }
+  // def touch(modTime: Long = System.currentTimeMillis) = {
+  //   createFile()
+  //   if (isFile)
+  //     lastModified = modTime
+  // }
 
   // todo
   // def copyTo(target: Path, options ...): Boolean
diff --git a/src/reflect/scala/reflect/io/PlainFile.scala b/src/reflect/scala/reflect/io/PlainFile.scala
index 82b0568657..6ee51d3d37 100644
--- a/src/reflect/scala/reflect/io/PlainFile.scala
+++ b/src/reflect/scala/reflect/io/PlainFile.scala
@@ -8,17 +8,17 @@ package scala.reflect
 package io
 
 import java.io.{ FileInputStream, FileOutputStream, IOException }
-import PartialFunction._
+
 /** ''Note:  This library is considered experimental and should not be used unless you know what you are doing.'' */
 object PlainFile {
   /**
    * If the specified File exists, returns an abstract file backed
    * by it. Otherwise, returns null.
    */
-  def fromPath(file: Path): PlainFile =
-    if (file.isDirectory) new PlainDirectory(file.toDirectory)
-    else if (file.isFile) new PlainFile(file)
-    else null
+  // def fromPath(file: Path): PlainFile =
+  //   if (file.isDirectory) new PlainDirectory(file.toDirectory)
+  //   else if (file.isFile) new PlainFile(file)
+  //   else null
 }
 /** ''Note:  This library is considered experimental and should not be used unless you know what you are doing.'' */
 class PlainDirectory(givenPath: Directory) extends PlainFile(givenPath) {
@@ -28,7 +28,7 @@ class PlainDirectory(givenPath: Directory) extends PlainFile(givenPath) {
 }
 
 /** This class implements an abstract file backed by a File.
- * 
+ *
  * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 class PlainFile(val givenPath: Path) extends AbstractFile {
diff --git a/src/reflect/scala/reflect/io/Streamable.scala b/src/reflect/scala/reflect/io/Streamable.scala
index 61ec8a4c23..615f44acc5 100644
--- a/src/reflect/scala/reflect/io/Streamable.scala
+++ b/src/reflect/scala/reflect/io/Streamable.scala
@@ -17,14 +17,14 @@ import Path.fail
  *
  *  @author Paul Phillips
  *  @since  2.8
- *  
+ *
  *  ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 object Streamable {
   /** Traits which can be viewed as a sequence of bytes.  Source types
    *  which know their length should override def length: Long for more
    *  efficient method implementations.
-   *  
+   *
    *  ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
    */
   trait Bytes {
@@ -69,7 +69,7 @@ object Streamable {
   }
 
   /** For objects which can be viewed as Chars.
-   * 
+   *
    * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
    */
   trait Chars extends Bytes {
@@ -81,7 +81,7 @@ object Streamable {
      */
     def creationCodec: Codec = implicitly[Codec]
 
-    def chars(): BufferedSource = chars(creationCodec)
+    // def chars(): BufferedSource = chars(creationCodec)
     def chars(codec: Codec): BufferedSource = Source.fromInputStream(inputStream())(codec)
 
     def lines(): Iterator[String] = lines(creationCodec)
@@ -89,7 +89,7 @@ object Streamable {
 
     /** Obtains an InputStreamReader wrapped around a FileInputStream.
      */
-    def reader(): InputStreamReader = reader(creationCodec)
+    // def reader(): InputStreamReader = reader(creationCodec)
     def reader(codec: Codec): InputStreamReader = new InputStreamReader(inputStream, codec.charSet)
 
     /** Wraps a BufferedReader around the result of reader().
diff --git a/src/reflect/scala/reflect/io/VirtualDirectory.scala b/src/reflect/scala/reflect/io/VirtualDirectory.scala
index 78713c2ae0..72ffff2aa9 100644
--- a/src/reflect/scala/reflect/io/VirtualDirectory.scala
+++ b/src/reflect/scala/reflect/io/VirtualDirectory.scala
@@ -11,7 +11,7 @@ import scala.collection.mutable
  * An in-memory directory.
  *
  * @author Lex Spoon
- * 
+ *
  * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 class VirtualDirectory(val name: String, maybeContainer: Option[VirtualDirectory])
@@ -26,7 +26,8 @@ extends AbstractFile {
 
   def container = maybeContainer.get
   def isDirectory = true
-  var lastModified: Long = System.currentTimeMillis
+  val lastModified: Long = System.currentTimeMillis
+  // var lastModified: Long = System.currentTimeMillis
 
   override def file = null
   override def input = sys.error("directories cannot be read")
diff --git a/src/reflect/scala/reflect/io/VirtualFile.scala b/src/reflect/scala/reflect/io/VirtualFile.scala
index 95f4429fad..014e02c6cd 100644
--- a/src/reflect/scala/reflect/io/VirtualFile.scala
+++ b/src/reflect/scala/reflect/io/VirtualFile.scala
@@ -14,7 +14,7 @@ import java.io.{ File => JFile }
  *
  *  @author  Philippe Altherr
  *  @version 1.0, 23/03/2004
- *  
+ *
  *  ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 class VirtualFile(val name: String, override val path: String) extends AbstractFile {
@@ -65,7 +65,7 @@ class VirtualFile(val name: String, override val path: String) extends AbstractF
   /** Returns the time that this abstract file was last modified. */
   private var _lastModified: Long = 0
   def lastModified: Long = _lastModified
-  def lastModified_=(x: Long) = _lastModified = x
+  // def lastModified_=(x: Long) = _lastModified = x
 
   /** Returns all abstract subfiles of this abstract directory. */
   def iterator: Iterator[AbstractFile] = {
diff --git a/src/reflect/scala/reflect/io/ZipArchive.scala b/src/reflect/scala/reflect/io/ZipArchive.scala
index 3b57721e89..0e69834d26 100644
--- a/src/reflect/scala/reflect/io/ZipArchive.scala
+++ b/src/reflect/scala/reflect/io/ZipArchive.scala
@@ -20,12 +20,12 @@ import scala.annotation.tailrec
  *  @author  Philippe Altherr (original version)
  *  @author  Paul Phillips (this one)
  *  @version 2.0,
- *  
+ *
  *  ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 object ZipArchive {
-  def fromPath(path: String): FileZipArchive = fromFile(new JFile(path))
-  def fromPath(path: Path): FileZipArchive = fromFile(path.toFile)
+  // def fromPath(path: String): FileZipArchive = fromFile(new JFile(path))
+  // def fromPath(path: Path): FileZipArchive = fromFile(path.toFile)
 
   /**
    * @param   file  a File
@@ -41,7 +41,7 @@ object ZipArchive {
    * @return  A ZipArchive backed by the given url.
    */
   def fromURL(url: URL): URLZipArchive = new URLZipArchive(url)
-  def fromURL(url: String): URLZipArchive = fromURL(new URL(url))
+  // def fromURL(url: String): URLZipArchive = fromURL(new URL(url))
 
   private def dirName(path: String)  = splitPath(path, true)
   private def baseName(path: String) = splitPath(path, false)
@@ -79,7 +79,7 @@ abstract class ZipArchive(override val file: JFile) extends AbstractFile with Eq
       else Iterator(f)
     }
   }
-  def deepIterator = walkIterator(iterator)
+  // def deepIterator = walkIterator(iterator)
   /** ''Note:  This library is considered experimental and should not be used unless you know what you are doing.'' */
   sealed abstract class Entry(path: String) extends VirtualFile(baseName(path), path) {
     // have to keep this name for compat with sbt's compiler-interface