Further improve dotty.io

allanrenucci · allanrenucci · commit 93b1214bc2f7 · 2017-11-15T15:35:12.000+01:00
diff --git a/compiler/src/dotty/tools/backend/jvm/GenBCode.scala b/compiler/src/dotty/tools/backend/jvm/GenBCode.scala
@@ -53,7 +53,7 @@ class GenBCode extends Phase {
 
   def outputDir(implicit ctx: Context): AbstractFile = {
     val path = ctx.settings.outputDir.value
-    if (path.isDirectory) new PlainDirectory(Directory(path))
+    if (path.isDirectory) new PlainDirectory(path.toDirectory)
     else {
       if (jarFS == null) {
         path.delete()
diff --git a/compiler/src/dotty/tools/dotc/Run.scala b/compiler/src/dotty/tools/dotc/Run.scala
@@ -60,7 +60,7 @@ class Run(comp: Compiler, ictx: Context) {
   assert(ctx.runId <= Periods.MaxPossibleRunId)
 
   def getSource(fileName: String): SourceFile = {
-    val f = new PlainFile(fileName)
+    val f = new PlainFile(io.Path(fileName))
     if (f.isDirectory) {
       ctx.error(s"expected file, received directory '$fileName'")
       NoSource
diff --git a/compiler/src/dotty/tools/dotc/classpath/ClassPathFactory.scala b/compiler/src/dotty/tools/dotc/classpath/ClassPathFactory.scala
@@ -4,7 +4,6 @@
 package dotty.tools.dotc.classpath
 
 import dotty.tools.io.{AbstractFile, VirtualDirectory}
-import dotty.tools.io.Path.string2path
 import dotty.tools.dotc.config.Settings
 import FileUtils.AbstractFileOps
 import dotty.tools.io.ClassPath
diff --git a/compiler/src/dotty/tools/dotc/config/OutputDirs.scala b/compiler/src/dotty/tools/dotc/config/OutputDirs.scala
@@ -31,7 +31,7 @@ class OutputDirs {
     if (dir != null && dir.isDirectory)
       dir
     // was:      else if (allowJar && dir == null && Path.isJarOrZip(name, false))
-    else if (allowJar && dir == null && Jar.isJarOrZip(name, false))
+    else if (allowJar && dir == null && Jar.isJarOrZip(File(name), false))
       new PlainFile(Path(name))
     else
       throw new FatalError(name + " does not exist or is not a directory"))
diff --git a/compiler/src/dotty/tools/dotc/config/PathResolver.scala b/compiler/src/dotty/tools/dotc/config/PathResolver.scala
@@ -80,11 +80,11 @@ object PathResolver {
     def scalaHome         = Environment.scalaHome
     def scalaHomeDir      = Directory(scalaHome)
     def scalaHomeExists   = scalaHomeDir.isDirectory
-    def scalaLibDir       = Directory(scalaHomeDir / "lib")
-    def scalaClassesDir   = Directory(scalaHomeDir / "classes")
+    def scalaLibDir       = (scalaHomeDir / "lib").toDirectory
+    def scalaClassesDir   = (scalaHomeDir / "classes").toDirectory
 
-    def scalaLibAsJar     = File(scalaLibDir / "scala-library.jar")
-    def scalaLibAsDir     = Directory(scalaClassesDir / "library")
+    def scalaLibAsJar     = (scalaLibDir / "scala-library.jar").toFile
+    def scalaLibAsDir     = (scalaClassesDir / "library").toDirectory
 
     def scalaLibDirFound: Option[Directory] =
       if (scalaLibAsJar.isFile) Some(scalaLibDir)
diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
@@ -18,7 +18,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val javaextdirs = PathSetting("-javaextdirs", "Override java extdirs classpath.", Defaults.javaExtDirs)
   val sourcepath = PathSetting("-sourcepath", "Specify location(s) of source files.", "") // Defaults.scalaSourcePath
   val classpath = PathSetting("-classpath", "Specify where to find user class files.", defaultClasspath) withAbbreviation "-cp"
-  val outputDir = DirectoryJarSetting("-d", "directory|jar", "destination for generated classfiles.", Directory(Path(".")))
+  val outputDir = DirectoryJarSetting("-d", "directory|jar", "destination for generated classfiles.", Directory("."))
   val priorityclasspath = PathSetting("-priorityclasspath", "class path that takes precedence over all other paths (or testing only)", "")
 
   /** Other settings */
diff --git a/compiler/src/dotty/tools/dotc/config/Settings.scala b/compiler/src/dotty/tools/dotc/config/Settings.scala
@@ -163,7 +163,7 @@ object Settings {
           }
         case (DirectoryJarTag, arg :: args) =>
           val path = Path(arg)
-          if (path.isDirectory) update(Directory(path), args)
+          if (path.isDirectory) update(path, args)
           else if (path.extension == "jar") update(path, args)
           else fail(s"'$arg' does not exist or is not a directory", args)
         case (_, Nil) =>
diff --git a/compiler/src/dotty/tools/io/AbstractFile.scala b/compiler/src/dotty/tools/io/AbstractFile.scala
@@ -10,7 +10,7 @@ import java.io.{
   ByteArrayOutputStream
 }
 import java.net.URL
-import java.nio.file.{FileAlreadyExistsException, Files}
+import java.nio.file.{FileAlreadyExistsException, Files, Paths}
 
 /**
  * An abstraction over files for use in the reflection/compiler libraries.
@@ -21,28 +21,26 @@ import java.nio.file.{FileAlreadyExistsException, Files}
  * @version 1.0, 23/03/2004
  */
 object AbstractFile {
-  /** Returns "getFile(new File(path))". */
   def getFile(path: String): AbstractFile = getFile(File(path))
-  def getFile(path: Path): AbstractFile = getFile(path.toFile)
+  def getDirectory(path: String): AbstractFile = getDirectory(Directory(path))
+  def getFile(path: JPath): AbstractFile = getFile(File(path))
+  def getDirectory(path: JPath): AbstractFile = getDirectory(Directory(path))
 
   /**
    * If the specified File exists and is a regular file, returns an
    * abstract regular file backed by it. Otherwise, returns `null`.
    */
-  def getFile(file: File): AbstractFile =
-    if (file.isFile) new PlainFile(file) else null
-
-  /** Returns "getDirectory(new File(path))". */
-  def getDirectory(path: Path): AbstractFile = getDirectory(path.toFile)
+  def getFile(path: Path): AbstractFile =
+    if (path.isFile) new PlainFile(path) else null
 
   /**
    * If the specified File exists and is either a directory or a
    * readable zip or jar archive, returns an abstract directory
    * backed by it. Otherwise, returns `null`.
    */
-  def getDirectory(file: File): AbstractFile =
-    if (file.isDirectory) new PlainFile(file)
-    else if (file.isFile && Path.isExtensionJarOrZip(file.jpath)) ZipArchive fromFile file
+  def getDirectory(path: Path): AbstractFile =
+    if (path.isDirectory) new PlainFile(path)
+    else if (path.isFile && Path.isExtensionJarOrZip(path.jpath)) ZipArchive fromFile path.toFile
     else null
 
   /**
@@ -51,11 +49,8 @@ object AbstractFile {
    * Otherwise, returns `null`.
    */
   def getURL(url: URL): AbstractFile =
-    if (url.getProtocol == "file") {
-      val f = new java.io.File(url.getPath)
-      if (f.isDirectory) getDirectory(f)
-      else getFile(f)
-    } else null
+    if (url.getProtocol != "file") null
+    else new PlainFile(new Path(Paths.get(url.toURI)))
 
   def getResources(url: URL): AbstractFile = ZipArchive fromManifestURL url
 }
diff --git a/compiler/src/dotty/tools/io/Directory.scala b/compiler/src/dotty/tools/io/Directory.scala
@@ -8,7 +8,7 @@
 
 package dotty.tools.io
 
-import java.nio.file.Files
+import java.nio.file.{Files, Paths}
 import java.util.stream.Collectors
 
 import scala.collection.JavaConverters._
@@ -19,18 +19,12 @@ import scala.collection.JavaConverters._
 object Directory {
   import scala.util.Properties.userDir
 
-  private def normalizePath(s: String) = Some(apply(Path(s).normalize))
-  def Current: Option[Directory]  = if (userDir == "") None else normalizePath(userDir)
+  def Current: Option[Directory] =
+    if (userDir == "") None
+    else Some(apply(userDir).normalize)
 
-  def apply(path: Path): Directory = path.toDirectory
-  def apply(jpath: JPath): Directory = new Directory(jpath)
-
-  // Like File.makeTemp but creates a directory instead
-  def makeTemp(prefix: String = Path.randomPrefix, suffix: String = null, dir: JFile = null): Directory = {
-    val path = File.makeTemp(prefix, suffix, dir)
-    path.delete()
-    path.createDirectory()
-  }
+  def apply(path: String): Directory = apply(Paths.get(path))
+  def apply(path: JPath): Directory = new Directory(path)
 }
 
 /** An abstraction for directories.
@@ -49,10 +43,13 @@ class Directory(jpath: JPath) extends Path(jpath) {
   /** An iterator over the contents of this directory.
    */
   def list: Iterator[Path] =
-    jpath.toFile.listFiles match {
-      case null => Iterator.empty
-      case xs => xs.iterator.map(x => Path(x.toPath))
+    if (isDirectory) {
+      val fileStream = Files.list(jpath)
+      val files = fileStream.toArray(size => new Array[JPath](size))
+      fileStream.close()
+      files.iterator.map(Path.apply)
     }
+    else Iterator.empty
 
   def dirs: Iterator[Directory] = list collect { case x: Directory => x }
   def files: Iterator[File] = list collect { case x: File => x }
diff --git a/compiler/src/dotty/tools/io/File.scala b/compiler/src/dotty/tools/io/File.scala
@@ -12,7 +12,7 @@ import java.io.{
   FileInputStream, FileOutputStream, BufferedWriter, OutputStreamWriter,
   BufferedOutputStream, IOException, PrintWriter
 }
-import java.nio.file.Files
+import java.nio.file.{Files, Paths}
 import java.nio.file.StandardOpenOption._
 
 import scala.io.Codec
@@ -22,14 +22,9 @@ import scala.io.Codec
 object File {
   def pathSeparator = java.io.File.pathSeparator
   def separator     = java.io.File.separator
-  def apply(path: Path)(implicit codec: Codec) = new File(path.jpath)(codec)
 
-  // Create a temporary file, which will be deleted upon jvm exit.
-  def makeTemp(prefix: String = Path.randomPrefix, suffix: String = null, dir: JFile = null) = {
-    val jfile = java.io.File.createTempFile(prefix, suffix, dir)
-    jfile.deleteOnExit()
-    apply(jfile)
-  }
+  def apply(path: String)(implicit codec: Codec): File = apply(Paths.get(path))
+  def apply(path: JPath)(implicit codec: Codec): File = new File(path)
 }
 
 /** An abstraction for files.  For character data, a Codec
@@ -59,9 +54,9 @@ class File(jpath: JPath)(implicit constructorCodec: Codec) extends Path(jpath) w
   def inputStream() = Files.newInputStream(jpath)
 
   /** Obtains a OutputStream. */
-  def outputStream(append: Boolean = false) = 
-    if (append) Files.newOutputStream(jpath, APPEND)
-    else Files.newOutputStream(jpath)
+  def outputStream(append: Boolean = false) =
+    if (append) Files.newOutputStream(jpath, CREATE, APPEND)
+    else Files.newOutputStream(jpath, CREATE, TRUNCATE_EXISTING)
   def bufferedOutput(append: Boolean = false) = new BufferedOutputStream(outputStream(append))
 
   /** Obtains an OutputStreamWriter wrapped around a FileOutputStream.
diff --git a/compiler/src/dotty/tools/io/Jar.scala b/compiler/src/dotty/tools/io/Jar.scala
@@ -35,7 +35,7 @@ import scala.annotation.tailrec
 // static Attributes.Name   SPECIFICATION_VERSION
 
 class Jar(file: File) extends Iterable[JarEntry] {
-  def this(jfile: JFile) = this(File(jfile))
+  def this(jfile: JFile) = this(File(jfile.toPath))
   def this(path: String) = this(File(path))
 
   protected def errorFn(msg: String): Unit = Console println msg
diff --git a/compiler/src/dotty/tools/io/JarFS.scala b/compiler/src/dotty/tools/io/JarFS.scala
@@ -12,7 +12,7 @@ class JarFS private (private[this] var jarFS: FileSystem) {
 
   def getRoot(): AbstractFile = {
     val root = jarFS.getRootDirectories.iterator().next()
-    new JarFS.JarDirectory(root)(jarFS)
+    new PlainDirectory(Directory(root))
   }
 
   def close() = {
@@ -22,30 +22,10 @@ class JarFS private (private[this] var jarFS: FileSystem) {
 }
 
 object JarFS {
-
   def create(path: Path): JarFS = {
     assert(path.extension == "jar")
     val env = Map("create" -> "true").asJava
     val jarUri = java.net.URI.create("jar:file:" + path.toAbsolute.path)
     new JarFS(FileSystems.newFileSystem(jarUri, env))
   }
-
-  private class JarDirectory(path: JPath)(jarFS: FileSystem) extends PlainDirectory(new Directory(path)) {
-    override def name = "<jar-dir>"
-    override def file = throw new UnsupportedOperationException
-    override def fileNamed(name: String): AbstractFile = new JarFile(pathTo(name))
-    override def subdirectoryNamed(name: String): AbstractFile = new JarDirectory(pathTo(name))(jarFS)
-    private def pathTo(name: String): JPath =
-      jarFS.getPath(if (path.toString == "/") name else path.resolve(name).toString)
-  }
-
-  private class JarFile(path: JPath) extends PlainFile(new File(path)) {
-    override def name = "<jar-file>"
-    override def file = throw new UnsupportedOperationException
-    override def output = {
-      if (path.getParent ne null)
-        Files.createDirectories(path.getParent)
-      Files.newOutputStream(path)
-    }
-  }
 }
diff --git a/compiler/src/dotty/tools/io/Path.scala b/compiler/src/dotty/tools/io/Path.scala
@@ -47,10 +47,6 @@ object Path {
     else name.substring(i + 1).toLowerCase
   }
 
-  // not certain these won't be problematic, but looks good so far
-  implicit def string2path(s: String): Path = apply(s)
-  implicit def jfile2path(jfile: JFile): Path = apply(jfile.toPath)
-
   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)
@@ -95,6 +91,7 @@ class Path private[io] (val jpath: JPath) {
   /** Creates a new Path with the specified path appended.  Assumes
    *  the type of the new component implies the type of the result.
    */
+  def /(child: String): Path = new Path(jpath.resolve(child))
   def /(child: Path): Path = resolve(child)
   def /(child: Directory): Directory = /(child: Path).toDirectory
   def /(child: File): File = /(child: Path).toFile
@@ -117,31 +114,24 @@ class Path private[io] (val jpath: JPath) {
   def walk: Iterator[Path] = walkFilter(_ => true)
 
   // identity
-  def name: String = jpath.getFileName().toString
+  def name: String = jpath.getFileName() match {
+    case null => ""
+    case name => name.toString
+  }
   def path: String = jpath.toString
-  def normalize: Path = Path(jpath.normalize)
+  def normalize: Path = new Path(jpath.normalize)
 
-  def resolve(other: Path) = Path(jpath.resolve(other.jpath))
-  def relativize(other: Path) = Path(jpath.relativize(other.jpath))
+  def resolve(other: Path) = new Path(jpath.resolve(other.jpath))
+  def relativize(other: Path) = new Path(jpath.relativize(other.jpath))
 
   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
    */
-  def parent: Directory = path match {
-    case "" | "." => Directory("..")
-    case _        =>
-      // the only solution <-- a comment which could have used elaboration
-      if (segments.nonEmpty && segments.last == "..")
-        (path / "..").toDirectory
-      else jpath.getParent match {
-        case null =>
-          if (isAbsolute) toDirectory // it should be a root. BTW, don't need to worry about relative pathed root
-          else Directory(".")         // a dir under pwd
-        case x    =>
-          Directory(x)
-      }
+  def parent: Directory = jpath.normalize.getParent match {
+    case null => Directory(jpath)
+    case parent => Directory(parent)
   }
   def parents: List[Directory] = {
     val p = parent
@@ -164,12 +154,12 @@ class Path private[io] (val jpath: JPath) {
   // returns the filename without the extension.
   def stripExtension: String = name stripSuffix ("." + extension)
   // returns the Path with the extension.
-  def addExtension(ext: String): Path = Path(path + "." + ext)
+  def addExtension(ext: String): Path = new Path(jpath.resolveSibling(name + ext))
   // changes the existing extension out for a new one, or adds it
   // if the current path has none.
   def changeExtension(ext: String): Path =
     if (extension == "") addExtension(ext)
-    else Path(path.stripSuffix(extension) + ext)
+    else new Path(jpath.resolveSibling(stripExtension + "." + ext))
 
   // conditionally execute
   def ifFile[T](f: File => T): Option[T] = if (isFile) Some(f(toFile)) else None
diff --git a/compiler/src/dotty/tools/io/PlainFile.scala b/compiler/src/dotty/tools/io/PlainFile.scala
@@ -22,7 +22,7 @@ class PlainDirectory(givenPath: Directory) extends PlainFile(givenPath) {
 class PlainFile(val givenPath: Path) extends AbstractFile {
   assert(path ne null)
 
-  val jpath = givenPath.jpath
+  def jpath = givenPath.jpath
   override def underlyingSource = Some(this)
 
   private val fpath = givenPath.toAbsolute
@@ -37,8 +37,8 @@ class PlainFile(val givenPath: Path) extends AbstractFile {
   def absolute = new PlainFile(givenPath.toAbsolute)
 
   override def container: AbstractFile = new PlainFile(givenPath.parent)
-  override def input = Files.newInputStream(jpath)
-  override def output = Files.newOutputStream(jpath)
+  override def input = givenPath.toFile.inputStream()
+  override def output = givenPath.toFile.outputStream()
   override def sizeOption = Some(givenPath.length.toInt)
 
   override def hashCode(): Int = fpath.hashCode()
@@ -58,11 +58,10 @@ class PlainFile(val givenPath: Path) extends AbstractFile {
     // Optimization: Assume that the file was not deleted and did not have permissions changed
     // between the call to `list` and the iteration. This saves a call to `exists`.
     def existsFast(path: Path) = path match {
-      case (_: Directory | _: io.File) => true
+      case (_: Directory | _: File) => true
       case _ => path.exists
     }
-    if (!isDirectory) Iterator.empty
-    else givenPath.toDirectory.list filter existsFast map (new PlainFile(_))
+    givenPath.toDirectory.list.filter(existsFast).map(new PlainFile(_))
   }
 
   /**
diff --git a/compiler/src/dotty/tools/repl/ReplDriver.scala b/compiler/src/dotty/tools/repl/ReplDriver.scala
@@ -111,7 +111,7 @@ class ReplDriver(settings: Array[String],
       else {
         val path = rootCtx.settings.outputDir.value(rootCtx)
         assert(path.isDirectory)
-        new PlainDirectory(Directory(path))
+        new PlainDirectory(path.toDirectory)
       }
     }
     compiler = new ReplCompiler(outDir)
diff --git a/compiler/test/dotty/tools/dotc/CompilerTest.scala b/compiler/test/dotty/tools/dotc/CompilerTest.scala
diff --git a/compiler/test/dotty/tools/dotc/JarOutputTests.scala b/compiler/test/dotty/tools/dotc/JarOutputTests.scala
diff --git a/compiler/test/dotty/tools/dotc/classpath/ZipAndJarFileLookupFactoryTest.scala b/compiler/test/dotty/tools/dotc/classpath/ZipAndJarFileLookupFactoryTest.scala
diff --git a/compiler/test/dotty/tools/dotc/parsing/ParserTest.scala b/compiler/test/dotty/tools/dotc/parsing/ParserTest.scala
diff --git a/compiler/test/dotty/tools/dotc/parsing/ScannerTest.scala b/compiler/test/dotty/tools/dotc/parsing/ScannerTest.scala

Original file line number	Diff line number	Diff line change
`@@ -163,7 +163,7 @@ object Settings {`
`163`	`163`	`}`
`164`	`164`	`case (DirectoryJarTag, arg :: args) =>`
`165`	`165`	`val path = Path(arg)`
`166`		`- if (path.isDirectory) update(Directory(path), args)`
	`166`	`+ if (path.isDirectory) update(path, args)`
`167`	`167`	`else if (path.extension == "jar") update(path, args)`
`168`	`168`	`else fail(s"'$arg' does not exist or is not a directory", args)`
`169`	`169`	`case (_, Nil) =>`