Fixes and more translations

Author: nicolasstucki

.drone.yml

@@ -13,7 +13,6 @@ pipeline:
     image: lampepfl/dotty:2017-10-20
     commands:
       - cp -R . /tmp/1/ && cd /tmp/1/
-      - ./project/scripts/sbt compile # to ensure that side projects (such as dotty doc) compile
       - ./project/scripts/sbt testAll
       - ./project/scripts/sbt ";dotty-bench/jmh:run 1 1 tests/run/arrays.scala"
 

compiler/src/dotty/tools/dotc/classpath/ZipArchiveFileLookup.scala

@@ -23,7 +23,7 @@ trait ZipArchiveFileLookup[FileEntryType <: ClassRepresentation] extends ClassPa
   override def asURLs: Seq[URL] = Seq(zipFile.toURI.toURL)
   override def asClassPathStrings: Seq[String] = Seq(zipFile.getPath)
 
-  private val archive = new FileZipArchive(zipFile)
+  private val archive = new FileZipArchive(zipFile.toPath)
 
   override private[dotty] def packages(inPackage: String): Seq[PackageEntry] = {
     val prefix = PackageNameUtils.packagePrefix(inPackage)

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -45,21 +45,21 @@ class ExtractAPI extends Phase {
     val dumpInc = ctx.settings.YdumpSbtInc.value
     val forceRun = dumpInc || ctx.settings.YforceSbtPhases.value
     if ((ctx.sbtCallback != null || forceRun) && !unit.isJava) {
-      val sourceFile = unit.source.file.file
+      val sourceFile = unit.source.file
       val apiTraverser = new ExtractAPICollector
       val source = apiTraverser.apiSource(unit.tpdTree)
 
       if (dumpInc) {
         // Append to existing file that should have been created by ExtractDependencies
-        val pw = new PrintWriter(Path(sourceFile).changeExtension("inc").toFile
+        val pw = new PrintWriter(Path(sourceFile.jpath).changeExtension("inc").toFile
           .bufferedWriter(append = true), true)
         try {
           pw.println(DefaultShowAPI(source))
         } finally pw.close()
       }
 
       if (ctx.sbtCallback != null)
-        ctx.sbtCallback.api(sourceFile, source)
+        ctx.sbtCallback.api(sourceFile.file, source)
     }
   }
 }

compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala

@@ -47,7 +47,7 @@ class ExtractDependencies extends Phase {
     val dumpInc = ctx.settings.YdumpSbtInc.value
     val forceRun = dumpInc || ctx.settings.YforceSbtPhases.value
     if ((ctx.sbtCallback != null || forceRun) && !unit.isJava) {
-      val sourceFile = unit.source.file.file
+      val sourceFile = unit.source.file
       val extractDeps = new ExtractDependenciesCollector
       extractDeps.traverse(unit.tpdTree)
 
@@ -59,7 +59,7 @@ class ExtractDependencies extends Phase {
         Arrays.sort(deps)
         Arrays.sort(inhDeps)
 
-        val pw = Path(sourceFile).changeExtension("inc").toFile.printWriter()
+        val pw = Path(sourceFile.jpath).changeExtension("inc").toFile.printWriter()
         try {
           pw.println(s"// usedNames: ${names.mkString(",")}")
           pw.println(s"// topLevelDependencies: ${deps.mkString(",")}")
@@ -69,11 +69,11 @@ class ExtractDependencies extends Phase {
 
       if (ctx.sbtCallback != null) {
         extractDeps.usedNames.foreach(name =>
-          ctx.sbtCallback.usedName(sourceFile, name.toString))
+          ctx.sbtCallback.usedName(sourceFile.file, name.toString))
         extractDeps.topLevelDependencies.foreach(dep =>
-          recordDependency(sourceFile, dep, DependencyContext.DependencyByMemberRef))
+          recordDependency(sourceFile.file, dep, DependencyContext.DependencyByMemberRef))
         extractDeps.topLevelInheritanceDependencies.foreach(dep =>
-          recordDependency(sourceFile, dep, DependencyContext.DependencyByInheritance))
+          recordDependency(sourceFile.file, dep, DependencyContext.DependencyByInheritance))
       }
     }
   }

compiler/src/dotty/tools/io/AbstractFile.scala

@@ -95,7 +95,7 @@ abstract class AbstractFile extends Iterable[AbstractFile] {
   def path: String
 
   /** Returns the path of this abstract file in a canonical form. */
-  def canonicalPath: String = if (jpath == null) path else jpath.toFile.getCanonicalPath
+  def canonicalPath: String = if (jpath == null) path else jpath.normalize.toString
 
   /** Checks extension case insensitively. */
   def hasExtension(other: String) = extension == other.toLowerCase
@@ -241,13 +241,10 @@ abstract class AbstractFile extends Iterable[AbstractFile] {
     val lookup = lookupName(name, isDir)
     if (lookup != null) lookup
     else {
+      Files.createDirectories(jpath)
       val path = jpath.resolve(name)
-      try {
-        if (isDir) Files.createDirectories(path)
-        else Files.createFile(path)
-      } catch {
-        case _: FileAlreadyExistsException =>
-      }
+      if (isDir) Files.createDirectory(path)
+      else Files.createFile(path)
       new PlainNioFile(path)
     }
   }

compiler/src/dotty/tools/io/Directory.scala

@@ -8,6 +8,11 @@
 
 package dotty.tools.io
 
+import java.nio.file.Files
+import java.util.stream.Collectors
+
+import scala.collection.JavaConverters._
+
 /**
  * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
@@ -18,6 +23,7 @@ object Directory {
   def Current: Option[Directory]  = if (userDir == "") None else normalizePath(userDir)
 
   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 = {
@@ -43,10 +49,7 @@ class Directory(jpath: JPath) extends Path(jpath) {
   /** An iterator over the contents of this directory.
    */
   def list: Iterator[Path] =
-    jfile.listFiles match {
-      case null   => Iterator.empty
-      case xs     => xs.iterator map Path.apply
-    }
+    Files.list(jpath).toArray[JPath](n => new Array(n)).iterator.map(Path.apply)
 
   def dirs: Iterator[Directory] = list collect { case x: Directory => x }
   def files: Iterator[File] = list collect { case x: File => x }

compiler/src/dotty/tools/io/File.scala

@@ -46,7 +46,7 @@ class File(jpath: JPath)(implicit constructorCodec: Codec) extends Path(jpath) w
 
   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.toPath)
+  override def toDirectory: Directory = new Directory(jpath)
   override def toFile: File = this
   override def normalize: File = super.normalize.toFile
   override def length = super[Path].length

compiler/src/dotty/tools/io/Path.scala

@@ -7,7 +7,7 @@ package dotty.tools.io
 
 import scala.language.implicitConversions
 import java.io.RandomAccessFile
-import java.nio.file.{DirectoryNotEmptyException, FileAlreadyExistsException, Files, NoSuchFileException}
+import java.nio.file.{DirectoryNotEmptyException, FileAlreadyExistsException, Files, NoSuchFileException, Paths}
 import java.net.{URI, URL}
 
 import scala.util.Random.alphanumeric
@@ -45,20 +45,20 @@ object Path {
 
   // 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)
+  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)
 
-  def roots: List[Path] = java.io.File.listRoots().toList map Path.apply
+  def roots: List[Path] = java.io.File.listRoots().toList.map(r => Path.apply(r.toPath))
 
-  def apply(path: String): Path = apply(new JFile(path))
-  def apply(jfile: JFile): Path = try {
-    if (jfile.isFile) new File(jfile.toPath)
-    else if (jfile.isDirectory) new Directory(jfile.toPath)
-    else new Path(jfile.toPath)
-  } catch { case ex: SecurityException => new Path(jfile.toPath) }
+  def apply(path: String): Path = apply(Paths.get(path))
+  def apply(jpath: JPath): Path = try {
+    if (Files.isRegularFile(jpath)) new File(jpath)
+    else if (Files.isDirectory(jpath)) new Directory(jpath)
+    else new Path(jpath)
+  } catch { case ex: SecurityException => new Path(jpath) }
 
   /** Avoiding any shell/path issues by only using alphanumerics. */
   private[io] def randomPrefix = alphanumeric take 6 mkString ""
@@ -149,7 +149,7 @@ class Path private[io] (val jpath: JPath) {
           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.toFile)
+          Directory(x)
       }
   }
   def parents: List[Directory] = {
@@ -213,6 +213,7 @@ class Path private[io] (val jpath: JPath) {
   }
   def createFile(failIfExists: Boolean = false): File = {
     val res = tryCreate(Files.createFile(jpath))
+    jfile.createNewFile()
     if (!res && failIfExists && exists) fail("File '%s' already exists." format name)
     else if (isFile) toFile
     else new File(jpath)
@@ -236,7 +237,7 @@ class Path private[io] (val jpath: JPath) {
   }
 
   private def delete(path: JPath): Boolean =
-    try { Files.delete(path); true } catch { case _: DirectoryNotEmptyException | _: NoSuchFileException => false }
+    try { Files.deleteIfExists(path); true } catch { case _: DirectoryNotEmptyException => false }
 
   def truncate() =
     isFile && {

compiler/src/dotty/tools/io/PlainFile.scala

@@ -6,6 +6,8 @@
 package dotty.tools
 package io
 
+import java.nio.file.{Files, NotDirectoryException}
+
 /** ''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) {
   override def isDirectory = true
@@ -35,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 = givenPath.toFile.inputStream()
-  override def output = givenPath.toFile.outputStream()
+  override def input = Files.newInputStream(jpath)
+  override def output = Files.newOutputStream(jpath)
   override def sizeOption = Some(givenPath.length.toInt)
 
   override def hashCode(): Int = fpath.hashCode()
@@ -53,14 +55,13 @@ class PlainFile(val givenPath: Path) extends AbstractFile {
 
   /** Returns all abstract subfiles of this abstract directory. */
   def iterator: Iterator[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 _                           => path.exists
+    try {
+      import scala.collection.JavaConverters._
+      val it = Files.newDirectoryStream(jpath).iterator()
+      it.asScala.map(new PlainNioFile(_))
+    } catch {
+      case _: NotDirectoryException => Iterator.empty
     }
-    if (!isDirectory) Iterator.empty
-    else givenPath.toDirectory.list filter existsFast map (new PlainFile(_))
   }
 
   /**
@@ -91,7 +92,6 @@ class PlainFile(val givenPath: Path) extends AbstractFile {
 }
 
 private[dotty] class PlainNioFile(nioPath: java.nio.file.Path) extends AbstractFile {
-  import java.nio.file._
 
   assert(nioPath ne null)
 

compiler/src/dotty/tools/io/ZipArchive.scala

@@ -7,6 +7,7 @@ package dotty.tools.io
 
 import java.net.URL
 import java.io.{ IOException, InputStream, ByteArrayInputStream, FilterInputStream }
+import java.nio.file.Files
 import java.util.zip.{ ZipEntry, ZipFile, ZipInputStream }
 import java.util.jar.Manifest
 import scala.collection.mutable
@@ -32,7 +33,7 @@ object ZipArchive {
    */
   def fromFile(file: File): FileZipArchive = fromFile(file.jfile)
   def fromFile(file: JFile): FileZipArchive =
-    try   { new FileZipArchive(file) }
+    try   { new FileZipArchive(file.toPath) }
     catch { case _: IOException => null }
 
   def fromManifestURL(url: URL): AbstractFile = new ManifestResources(url)
@@ -112,7 +113,7 @@ abstract class ZipArchive(override val jpath: JPath) extends AbstractFile with E
   }
 }
 /** ''Note:  This library is considered experimental and should not be used unless you know what you are doing.'' */
-final class FileZipArchive(file: JFile) extends ZipArchive(file.toPath) {
+final class FileZipArchive(jpath: JPath) extends ZipArchive(jpath) {
   private[this] def openZipFile(): ZipFile = try {
     new ZipFile(file)
   } catch {
@@ -182,16 +183,16 @@ final class FileZipArchive(file: JFile) extends ZipArchive(file.toPath) {
 
   def iterator: Iterator[Entry] = root.iterator
 
-  def name         = file.getName
-  def path         = file.getPath
-  def input        = File(file).inputStream()
-  def lastModified = file.lastModified
+  def name         = jpath.getFileName.toString
+  def path         = jpath.toString
+  def input        = Files.newInputStream(jpath)
+  def lastModified = Files.getLastModifiedTime(jpath).toMillis
 
-  override def sizeOption = Some(file.length.toInt)
+  override def sizeOption = Some(Files.size(jpath).toInt)
   override def canEqual(other: Any) = other.isInstanceOf[FileZipArchive]
-  override def hashCode() = file.hashCode
+  override def hashCode() = jpath.hashCode
   override def equals(that: Any) = that match {
-    case x: FileZipArchive => file.getAbsoluteFile == x.file.getAbsoluteFile
+    case x: FileZipArchive => jpath.toAbsolutePath == x.jpath.toAbsolutePath
     case _                 => false
   }
 }