Fix #2186: Synchronize classpath handling with Scala 2.12

This commit is a very crude port of the classpath handling as it exists
in the 2.12.x branch of scalac (hash: 232d95a198c94da0c6c8393624e83e9b9ac84e81),
this replaces the existing Classpath code that was adapted from scalac
years ago.

This code was written by Grzegorz Kossakowski, Michał Pociecha, Lukas
Rytz, Jason Zaugg and other scalac contributors, many thanks to them!

For more information on this implementation, see the description of the
PR that originally added it to scalac: https://github.com/scala/scala/pull/4060

Changes made to the copied code to get it to compile with dotty:
- Rename scala.tools.nsc.util.ClassPath to dotty.tools.io.ClassPath
- Rename scala.tools.nsc.classpath.* to dotty.tools.dotc.classpath.*
- Replace "private[nsc]" by "private[dotty]"
- Changed `isClass` methods in FileUtils to skip Scala 2.11
  implementation classes (needed until we stop being retro-compatible with
  Scala 2.11)

I also copied PlainFile.scala from scalac to get access to
`PlainNioFile`.

3 files changed, 250 insertions, 347 deletions

diff --git a/compiler/src/dotty/tools/io/ClassPath.scala b/compiler/src/dotty/tools/io/ClassPath.scala
index 5e77c1b61..b4cc426cf 100644
--- a/compiler/src/dotty/tools/io/ClassPath.scala
+++ b/compiler/src/dotty/tools/io/ClassPath.scala
@@ -1,56 +1,89 @@
 /* NSC -- new Scala compiler
- * Copyright 2006-2012 LAMP/EPFL
+ * Copyright 2006-2013 LAMP/EPFL
  * @author  Martin Odersky
  */
 
+
 package dotty.tools
 package io
 
+import java.net.MalformedURLException
 import java.net.URL
-import scala.collection.{ mutable, immutable }
-import dotc.core.Decorators.StringDecorator
+import java.util.regex.PatternSyntaxException
+
 import File.pathSeparator
-import java.net.MalformedURLException
 import Jar.isJarOrZip
-import ClassPath._
-import scala.Option.option2Iterable
-import scala.reflect.io.Path.string2path
-import language.postfixOps
-
-/** <p>
- *    This module provides star expansion of '-classpath' option arguments, behaves the same as
- *    java, see [http://java.sun.com/javase/6/docs/technotes/tools/windows/classpath.html]
- *  </p>
- *
- *  @author Stepan Koltsov
- */
+
+/**
+  * A representation of the compiler's class- or sourcepath.
+  */
+trait ClassPath {
+  import dotty.tools.dotc.classpath._
+  def asURLs: Seq[URL]
+
+  /** Empty string represents root package */
+  private[dotty] def packages(inPackage: String): Seq[PackageEntry]
+  private[dotty] def classes(inPackage: String): Seq[ClassFileEntry]
+  private[dotty] def sources(inPackage: String): Seq[SourceFileEntry]
+
+  /** Allows to get entries for packages and classes merged with sources possibly in one pass. */
+  private[dotty] def list(inPackage: String): ClassPathEntries
+
+  /**
+    * It returns both classes from class file and source files (as our base ClassRepresentation).
+    * So note that it's not so strictly related to findClassFile.
+    */
+  def findClass(className: String): Option[ClassRepresentation] = {
+    // A default implementation which should be overridden, if we can create the more efficient
+    // solution for a given type of ClassPath
+    val (pkg, simpleClassName) = PackageNameUtils.separatePkgAndClassNames(className)
+
+    val foundClassFromClassFiles = classes(pkg).find(_.name == simpleClassName)
+    def findClassInSources = sources(pkg).find(_.name == simpleClassName)
+
+    foundClassFromClassFiles orElse findClassInSources
+  }
+  def findClassFile(className: String): Option[AbstractFile]
+
+  def asClassPathStrings: Seq[String]
+
+  /** The whole classpath in the form of one String.
+    */
+  def asClassPathString: String = ClassPath.join(asClassPathStrings: _*)
+  // for compatibility purposes
+  @deprecated("use asClassPathString instead of this one", "2.11.5")
+  def asClasspathString: String = asClassPathString
+
+  /** The whole sourcepath in the form of one String.
+    */
+  def asSourcePathString: String
+}
+
 object ClassPath {
+  val RootPackage = ""
 
   /** Expand single path entry */
   private def expandS(pattern: String): List[String] = {
     val wildSuffix = File.separator + "*"
 
-    /** Get all subdirectories, jars, zips out of a directory. */
-    def lsDir(dir: Directory, filt: String => Boolean = _ => true) = {
-      val files = synchronized(dir.list)
-      files filter (x => filt(x.name) && (x.isDirectory || isJarOrZip(x))) map (_.path) toList
-    }
-
-    def basedir(s: String) =
-      if (s contains File.separator) s.substring(0, s.lastIndexOf(File.separator))
-      else "."
+    /* Get all subdirectories, jars, zips out of a directory. */
+    def lsDir(dir: Directory, filt: String => Boolean = _ => true) =
+      dir.list.filter(x => filt(x.name) && (x.isDirectory || isJarOrZip(x))).map(_.path).toList
 
     if (pattern == "*") lsDir(Directory("."))
     else if (pattern endsWith wildSuffix) lsDir(Directory(pattern dropRight 2))
     else if (pattern contains '*') {
-      val regexp = ("^%s$" format pattern.replaceAll("""\*""", """.*""")).r
-      lsDir(Directory(pattern).parent, regexp findFirstIn _ isDefined)
+      try {
+        val regexp = ("^" + pattern.replaceAllLiterally("""\*""", """.*""") + "$").r
+        lsDir(Directory(pattern).parent, regexp.findFirstIn(_).isDefined)
+      }
+      catch { case _: PatternSyntaxException => List(pattern) }
     }
     else List(pattern)
   }
 
   /** Split classpath using platform-dependent path separator */
-  def split(path: String): List[String] = (path split pathSeparator).toList filterNot (_ == "") distinct
+  def split(path: String): List[String] = (path split pathSeparator).toList.filterNot(_ == "").distinct
 
   /** Join classpath using platform-dependent path separator */
   def join(paths: String*): String  = paths filterNot (_ == "") mkString pathSeparator
@@ -58,22 +91,6 @@ object ClassPath {
   /** Split the classpath, apply a transformation function, and reassemble it. */
   def map(cp: String, f: String => String): String = join(split(cp) map f: _*)
 
-  /** Split the classpath, filter according to predicate, and reassemble. */
-  def filter(cp: String, p: String => Boolean): String = join(split(cp) filter p: _*)
-
-  /** Split the classpath and map them into Paths */
-  def toPaths(cp: String): List[Path] = split(cp) map (x => Path(x).toAbsolute)
-
-  /** Make all classpath components absolute. */
-  def makeAbsolute(cp: String): String = fromPaths(toPaths(cp): _*)
-
-  /** Join the paths as a classpath */
-  def fromPaths(paths: Path*): String = join(paths map (_.path): _*)
-  def fromURLs(urls: URL*): String = fromPaths(urls map (x => Path(x.getPath)) : _*)
-
-  /** Split the classpath and map them into URLs */
-  def toURLs(cp: String): List[URL] = toPaths(cp) map (_.toURL)
-
   /** Expand path and possibly expanding stars */
   def expandPath(path: String, expandStar: Boolean = true): List[String] =
     if (expandStar) split(path) flatMap expandS
@@ -83,9 +100,10 @@ object ClassPath {
   def expandDir(extdir: String): List[String] = {
     AbstractFile getDirectory extdir match {
       case null => Nil
-      case dir  => dir filter (_.isClassContainer) map (x => new java.io.File(dir.file, x.name) getPath) toList
+      case dir  => dir.filter(_.isClassContainer).map(x => new java.io.File(dir.file, x.name).getPath).toList
     }
   }
+
   /** Expand manifest jar classpath entries: these are either urls, or paths
    *  relative to the location of the jar.
    */
@@ -99,317 +117,34 @@ object ClassPath {
     )
   }
 
-  /** A useful name filter. */
-  def isTraitImplementation(name: String) = name endsWith "$class.class"
-
   def specToURL(spec: String): Option[URL] =
     try Some(new URL(spec))
     catch { case _: MalformedURLException => None }
 
-  /** A class modeling aspects of a ClassPath which should be
-   *  propagated to any classpaths it creates.
-   */
-  abstract class ClassPathContext {
-    /** A filter which can be used to exclude entities from the classpath
-     *  based on their name.
-     */
-    def isValidName(name: String): Boolean = true
-
-    /** From the representation to its identifier.
-     */
-    def toBinaryName(rep: AbstractFile): String
-
-    /** Create a new classpath based on the abstract file.
-     */
-    def newClassPath(file: AbstractFile): ClassPath
-
-    /** Creators for sub classpaths which preserve this context.
-     */
-    def sourcesInPath(path: String): List[ClassPath] =
-      for (file <- expandPath(path, false) ; dir <- Option(AbstractFile getDirectory file)) yield
-        new SourcePath(dir, this)
-
-    def contentsOfDirsInPath(path: String): List[ClassPath] =
-      for (dir <- expandPath(path, false) ; name <- expandDir(dir) ; entry <- Option(AbstractFile getDirectory name)) yield
-        newClassPath(entry)
-
-    def classesAtAllURLS(path: String): List[ClassPath] =
-      (path split " ").toList flatMap classesAtURL
-
-    def classesAtURL(spec: String) =
-      for (url <- specToURL(spec).toList ; location <- Option(AbstractFile getURL url)) yield
-        newClassPath(location)
-
-    def classesInExpandedPath(path: String): IndexedSeq[ClassPath] =
-      classesInPathImpl(path, true).toIndexedSeq
-
-    def classesInPath(path: String) = classesInPathImpl(path, false)
-
-    // Internal
-    private def classesInPathImpl(path: String, expand: Boolean) =
-      for (file <- expandPath(path, expand) ; dir <- Option(AbstractFile getDirectory file)) yield
-        newClassPath(dir)
-  }
-
-  class JavaContext extends ClassPathContext {
-    def toBinaryName(rep: AbstractFile) = {
-      val name = rep.name
-      assert(endsClass(name), name)
-      name.substring(0, name.length - 6)
-    }
-    def newClassPath(dir: AbstractFile) = new DirectoryClassPath(dir, this)
-  }
-
-  object DefaultJavaContext extends JavaContext {
-    override def isValidName(name: String) = !isTraitImplementation(name)
+  def manifests: List[java.net.URL] = {
+    import scala.collection.JavaConverters._
+    val resources = Thread.currentThread().getContextClassLoader().getResources("META-INF/MANIFEST.MF")
+    resources.asScala.filter(_.getProtocol == "jar").toList
   }
 
-  private def endsClass(s: String) = s.length > 6 && s.substring(s.length - 6) == ".class"
-  private def endsScala(s: String) = s.length > 6 && s.substring(s.length - 6) == ".scala"
-  private def endsJava(s: String)  = s.length > 5 && s.substring(s.length - 5) == ".java"
-
-  /** From the source file to its identifier.
-   */
-  def toSourceName(f: AbstractFile): String = {
-    val name = f.name
+  @deprecated("shim for sbt's compiler interface", since = "2.12.0")
+  sealed abstract class ClassPathContext
 
-    if (endsScala(name)) name.substring(0, name.length - 6)
-    else if (endsJava(name)) name.substring(0, name.length - 5)
-    else throw new FatalError("Unexpected source file ending: " + name)
-  }
+  @deprecated("shim for sbt's compiler interface", since = "2.12.0")
+  sealed abstract class JavaContext
 }
 
-/**
- * Represents a package which contains classes and other packages
- */
-abstract class ClassPath {
-  type AnyClassRep = ClassPath#ClassRep
-
-  /**
-   * The short name of the package (without prefix)
-   */
+trait ClassRepresentation {
   def name: String
-
-  /**
-   * A String representing the origin of this classpath element, if known.
-   * For example, the path of the directory or jar.
-   */
-  def origin: Option[String] = None
-
-  /** A list of URLs representing this classpath.
-   */
-  def asURLs: List[URL]
-
-  /** The whole classpath in the form of one String.
-   */
-  def asClasspathString: String
-
-  /** Info which should be propagated to any sub-classpaths.
-   */
-  def context: ClassPathContext
-
-  /** Lists of entities.
-   */
-  def classes: IndexedSeq[AnyClassRep]
-  def packages: IndexedSeq[ClassPath]
-  def sourcepaths: IndexedSeq[AbstractFile]
-
-  /**
-   * Represents classes which can be loaded with a ClassfileLoader
-   * and / or a SourcefileLoader.
-   */
-  case class ClassRep(binary: Option[AbstractFile], source: Option[AbstractFile]) {
-    def name: String = binary match {
-      case Some(x)  => context.toBinaryName(x)
-      case _        =>
-        assert(source.isDefined)
-        toSourceName(source.get)
-    }
-  }
-
-  /** Filters for assessing validity of various entities.
-   */
-  def validClassFile(name: String)  = endsClass(name) && context.isValidName(name)
-  def validPackage(name: String)    = (name != "META-INF") && (name != "") && (name.charAt(0) != '.')
-  def validSourceFile(name: String) = endsScala(name) || endsJava(name)
-
-  /**
-   * Find a ClassRep given a class name of the form "package.subpackage.ClassName".
-   * Does not support nested classes on .NET
-   */
-  def findClass(name: String): Option[AnyClassRep] =
-    name.splitWhere(_ == '.', doDropIndex = true) match {
-      case Some((pkg, rest)) =>
-        packages find (_.name == pkg) flatMap (_ findClass rest)
-      case _ =>
-        classes find (_.name == name)
-    }
-
-  def findBinaryFile(name: String): Option[AbstractFile] =
-    findClass(name).flatMap(_.binary)
-
-  def sortString = join(split(asClasspathString).sorted: _*)
-
-  override def equals(that: Any) = that match {
-    case x: ClassPath => this.sortString == x.sortString
-    case _            => false
-  }
-  override def hashCode = sortString.hashCode()
+  def binary: Option[AbstractFile]
+  def source: Option[AbstractFile]
 }
 
-/**
- * A Classpath containing source files
- */
-class SourcePath(dir: AbstractFile, val context: ClassPathContext) extends ClassPath {
-  def name = dir.name
-  override def origin = dir.underlyingSource map (_.path)
-  def asURLs = if (dir.file == null) Nil else List(dir.toURL)
-  def asClasspathString = dir.path
-  val sourcepaths: IndexedSeq[AbstractFile] = IndexedSeq(dir)
-
-  private def traverse() = {
-    val classBuf   = immutable.Vector.newBuilder[ClassRep]
-    val packageBuf = immutable.Vector.newBuilder[SourcePath]
-    dir foreach { f =>
-      if (!f.isDirectory && validSourceFile(f.name))
-        classBuf += ClassRep(None, Some(f))
-      else if (f.isDirectory && validPackage(f.name))
-        packageBuf += new SourcePath(f, context)
-    }
-    (packageBuf.result, classBuf.result)
-  }
+@deprecated("shim for sbt's compiler interface", since = "2.12.0")
+sealed abstract class DirectoryClassPath
 
-  lazy val (packages, classes) = traverse()
-  override def toString() = "sourcepath: " + dir.toString()
-}
+@deprecated("shim for sbt's compiler interface", since = "2.12.0")
+sealed abstract class MergedClassPath
 
-/**
- * A directory (or a .jar file) containing classfiles and packages
- */
-class DirectoryClassPath(val dir: AbstractFile, val context: ClassPathContext) extends ClassPath {
-  def name = dir.name
-  override def origin = dir.underlyingSource map (_.path)
-  def asURLs = if (dir.file == null) Nil else List(dir.toURL)
-  def asClasspathString = dir.path
-  val sourcepaths: IndexedSeq[AbstractFile] = IndexedSeq()
-
-  // calculates (packages, classes) in one traversal.
-  private def traverse() = {
-    val classBuf   = immutable.Vector.newBuilder[ClassRep]
-    val packageBuf = immutable.Vector.newBuilder[DirectoryClassPath]
-    dir foreach { f =>
-      if (!f.isDirectory && validClassFile(f.name))
-        classBuf += ClassRep(Some(f), None)
-      else if (f.isDirectory && validPackage(f.name))
-        packageBuf += new DirectoryClassPath(f, context)
-    }
-    (packageBuf.result, classBuf.result)
-  }
-
-  lazy val (packages, classes) = traverse()
-  override def toString() = "directory classpath: " + origin.getOrElse("?")
-}
-
-class DeltaClassPath(original: MergedClassPath, subst: Map[ClassPath, ClassPath])
-extends MergedClassPath(original.entries map (e => subst getOrElse (e, e)), original.context) {
-  // not sure we should require that here. Commented out for now.
-  // require(subst.keySet subsetOf original.entries.toSet)
-  // We might add specialized operations for computing classes packages here. Not sure it's worth it.
-}
-
-/**
- * A classpath unifying multiple class- and sourcepath entries.
- */
-class MergedClassPath(
-  val entries: IndexedSeq[ClassPath],
-  val context: ClassPathContext)
-extends ClassPath {
-  def this(entries: TraversableOnce[ClassPath], context: ClassPathContext) =
-    this(entries.toIndexedSeq, context)
-
-  def name = entries.head.name
-  def asURLs = (entries flatMap (_.asURLs)).toList
-  lazy val sourcepaths: IndexedSeq[AbstractFile] = entries flatMap (_.sourcepaths)
-
-  override def origin = Some(entries map (x => x.origin getOrElse x.name) mkString ("Merged(", ", ", ")"))
-  override def asClasspathString: String = join(entries map (_.asClasspathString) : _*)
-
-  lazy val classes: IndexedSeq[AnyClassRep] = {
-    var count   = 0
-    val indices = mutable.AnyRefMap[String, Int]()
-    val cls     = new mutable.ArrayBuffer[AnyClassRep](1024)
-
-    for (e <- entries; c <- e.classes) {
-      val name = c.name
-      if (indices contains name) {
-        val idx      = indices(name)
-        val existing = cls(idx)
-
-        if (existing.binary.isEmpty && c.binary.isDefined)
-          cls(idx) = existing.copy(binary = c.binary)
-        if (existing.source.isEmpty && c.source.isDefined)
-          cls(idx) = existing.copy(source = c.source)
-      }
-      else {
-        indices(name) = count
-        cls += c
-        count += 1
-      }
-    }
-    cls.toIndexedSeq
-  }
-
-  lazy val packages: IndexedSeq[ClassPath] = {
-    var count   = 0
-    val indices = mutable.AnyRefMap[String, Int]()
-    val pkg     = new mutable.ArrayBuffer[ClassPath](256)
-
-    for (e <- entries; p <- e.packages) {
-      val name = p.name
-      if (indices contains name) {
-        val idx  = indices(name)
-        pkg(idx) = addPackage(pkg(idx), p)
-      }
-      else {
-        indices(name) = count
-        pkg += p
-        count += 1
-      }
-    }
-    pkg.toIndexedSeq
-  }
-
-  private def addPackage(to: ClassPath, pkg: ClassPath) = {
-    val newEntries: IndexedSeq[ClassPath] = to match {
-      case cp: MergedClassPath => cp.entries :+ pkg
-      case _                   => IndexedSeq(to, pkg)
-    }
-    new MergedClassPath(newEntries, context)
-  }
-  def show(): Unit = {
-    println("ClassPath %s has %d entries and results in:\n".format(name, entries.size))
-    asClasspathString split ':' foreach (x => println("  " + x))
-  }
-  override def toString() = "merged classpath " + entries.mkString("(", "\n", ")")
-}
-
-/**
- * The classpath when compiling with target:jvm. Binary files (classfiles) are represented
- * as AbstractFile. nsc.io.ZipArchive is used to view zip/jar archives as directories.
- */
-class JavaClassPath(
-  containers: IndexedSeq[ClassPath],
-  context: JavaContext)
-extends MergedClassPath(containers, context) { }
-
-object JavaClassPath {
-  def fromURLs(urls: Seq[URL], context: JavaContext): JavaClassPath = {
-    val containers = {
-      for (url <- urls ; f = AbstractFile getURL url ; if f != null) yield
-        new DirectoryClassPath(f, context)
-    }
-    new JavaClassPath(containers.toIndexedSeq, context)
-  }
-  def fromURLs(urls: Seq[URL]): JavaClassPath =
-    fromURLs(urls, ClassPath.DefaultJavaContext)
-}
+@deprecated("shim for sbt's compiler interface", since = "2.12.0")
+sealed abstract class JavaClassPath
diff --git a/compiler/src/dotty/tools/io/PlainFile.scala b/compiler/src/dotty/tools/io/PlainFile.scala
new file mode 100644
index 000000000..53474e778
--- /dev/null
+++ b/compiler/src/dotty/tools/io/PlainFile.scala
@@ -0,0 +1,170 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2013 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+
+package dotty.tools
+package io
+
+/** ''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
+  override def iterator = givenPath.list filter (_.exists) map (x => new PlainFile(x))
+  override def delete(): Unit = givenPath.deleteRecursively()
+}
+
+/** 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 {
+  assert(path ne null)
+
+  val file = givenPath.jfile
+  override def underlyingSource = Some(this)
+
+  private val fpath = givenPath.toAbsolute
+
+  /** Returns the name of this abstract file. */
+  def name = givenPath.name
+
+  /** Returns the path of this abstract file. */
+  def path = givenPath.path
+
+  /** The absolute file. */
+  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 sizeOption = Some(givenPath.length.toInt)
+
+  override def hashCode(): Int = fpath.hashCode()
+  override def equals(that: Any): Boolean = that match {
+    case x: PlainFile => fpath == x.fpath
+    case _            => false
+  }
+
+  /** Is this abstract file a directory? */
+  def isDirectory: Boolean = givenPath.isDirectory
+
+  /** Returns the time that this abstract file was last modified. */
+  def lastModified: Long = givenPath.lastModified
+
+  /** 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
+    }
+    if (!isDirectory) Iterator.empty
+    else givenPath.toDirectory.list filter existsFast map (new PlainFile(_))
+  }
+
+  /**
+   * Returns the abstract file in this abstract directory with the
+   * specified name. If there is no such file, returns null. The
+   * argument "directory" tells whether to look for a directory or
+   * or a regular file.
+   */
+  def lookupName(name: String, directory: Boolean): AbstractFile = {
+    val child = givenPath / name
+    if ((child.isDirectory && directory) || (child.isFile && !directory)) new PlainFile(child)
+    else null
+  }
+
+  /** Does this abstract file denote an existing file? */
+  def create(): Unit = if (!exists) givenPath.createFile()
+
+  /** Delete the underlying file or directory (recursively). */
+  def delete(): Unit =
+    if (givenPath.isFile) givenPath.delete()
+    else if (givenPath.isDirectory) givenPath.toDirectory.deleteRecursively()
+
+  /** Returns a plain file with the given name. It does not
+   *  check that it exists.
+   */
+  def lookupNameUnchecked(name: String, directory: Boolean): AbstractFile =
+    new PlainFile(givenPath / name)
+}
+
+private[dotty] class PlainNioFile(nioPath: java.nio.file.Path) extends AbstractFile {
+  import java.nio.file._
+
+  assert(nioPath ne null)
+
+  /** Returns the underlying File if any and null otherwise. */
+  override def file: java.io.File = try {
+    nioPath.toFile
+  } catch {
+    case _: UnsupportedOperationException => null
+  }
+
+  override def underlyingSource  = Some(this)
+
+  private val fpath = nioPath.toAbsolutePath.toString
+
+  /** Returns the name of this abstract file. */
+  def name = nioPath.getFileName.toString
+
+  /** Returns the path of this abstract file. */
+  def path = nioPath.toString
+
+  /** The absolute file. */
+  def absolute = new PlainNioFile(nioPath.toAbsolutePath)
+
+  override def container: AbstractFile = new PlainNioFile(nioPath.getParent)
+  override def input = Files.newInputStream(nioPath)
+  override def output = Files.newOutputStream(nioPath)
+  override def sizeOption = Some(Files.size(nioPath).toInt)
+  override def hashCode(): Int = fpath.hashCode()
+  override def equals(that: Any): Boolean = that match {
+    case x: PlainNioFile => fpath == x.fpath
+    case _               => false
+  }
+
+  /** Is this abstract file a directory? */
+  def isDirectory: Boolean = Files.isDirectory(nioPath)
+
+  /** Returns the time that this abstract file was last modified. */
+  def lastModified: Long = Files.getLastModifiedTime(nioPath).toMillis
+
+  /** Returns all abstract subfiles of this abstract directory. */
+  def iterator: Iterator[AbstractFile] = {
+    try {
+      import scala.collection.JavaConverters._
+      val it = Files.newDirectoryStream(nioPath).iterator()
+      it.asScala.map(new PlainNioFile(_))
+    } catch {
+      case _: NotDirectoryException => Iterator.empty
+    }
+  }
+
+  /**
+    * Returns the abstract file in this abstract directory with the
+    * specified name. If there is no such file, returns null. The
+    * argument "directory" tells whether to look for a directory or
+    * or a regular file.
+    */
+  def lookupName(name: String, directory: Boolean): AbstractFile = {
+    val child = nioPath.resolve(name)
+    if ((Files.isDirectory(child) && directory) || (Files.isRegularFile(child) && !directory)) new PlainNioFile(child)
+    else null
+  }
+
+  /** Does this abstract file denote an existing file? */
+  def create(): Unit = if (!exists)  Files.createFile(nioPath)
+
+  /** Delete the underlying file or directory (recursively). */
+  def delete(): Unit =
+    if (Files.isRegularFile(nioPath)) Files.deleteIfExists(nioPath)
+    else if (Files.isDirectory(nioPath)) new Directory(nioPath.toFile).deleteRecursively()
+
+  /** Returns a plain file with the given name. It does not
+    *  check that it exists.
+    */
+  def lookupNameUnchecked(name: String, directory: Boolean): AbstractFile =
+    new PlainNioFile(nioPath.resolve(name))
+}
diff --git a/compiler/src/dotty/tools/io/package.scala b/compiler/src/dotty/tools/io/package.scala
index 1c0e0b5c4..7acb827c9 100644
--- a/compiler/src/dotty/tools/io/package.scala
+++ b/compiler/src/dotty/tools/io/package.scala
@@ -20,8 +20,6 @@ package object io {
   val File = scala.reflect.io.File
   type Path = scala.reflect.io.Path
   val Path = scala.reflect.io.Path
-  type PlainFile = scala.reflect.io.PlainFile
-  //val PlainFile = scala.reflect.io.PlainFile
   val Streamable = scala.reflect.io.Streamable
   type VirtualDirectory = scala.reflect.io.VirtualDirectory
   type VirtualFile = scala.reflect.io.VirtualFile