langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/file/PathFileObject.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2009, 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package com.sun.tools.javac.file;

 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 import java.io.Reader;
 import java.io.Writer;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
 import java.nio.charset.CharsetDecoder;
 import java.nio.file.FileSystem;
 import java.nio.file.FileSystems;
 import java.nio.file.Files;
 import java.nio.file.LinkOption;
 import java.nio.file.Path;
 import java.text.Normalizer;
 import java.util.Objects;

 import javax.lang.model.element.Modifier;
 import javax.lang.model.element.NestingKind;
 import javax.tools.FileObject;
 import javax.tools.JavaFileObject;

 import com.sun.tools.javac.file.RelativePath.RelativeFile;
 import com.sun.tools.javac.util.DefinedBy;
 import com.sun.tools.javac.util.DefinedBy.Api;


 /**
  *  Implementation of JavaFileObject using java.nio.file API.
  *
  *  <p>PathFileObjects are, for the most part, straightforward wrappers around
  *  immutable absolute Path objects. Different subtypes are used to provide
  *  specialized implementations of "inferBinaryName" and "getName" that capture
  *  additional information available at the time the object is created.
  *
  *  <p>In general, {@link JavaFileManager#isSameFile} should be used to
  *  determine whether two file objects refer to the same file on disk.
  *  PathFileObject also supports the standard {@code equals} and {@code hashCode}
  *  methods, primarily for convenience when working with collections.
  *  All of these operations delegate to the equivalent operations on the
  *  underlying Path object.
  *
  *  <p><b>This is NOT part of any supported API.
  *  If you write code that depends on this, you do so at your own risk.
  *  This code and its internal interfaces are subject to change or
  *  deletion without notice.</b>
  */
 public abstract class PathFileObject implements JavaFileObject {
     private static final FileSystem defaultFileSystem = FileSystems.getDefault();
     private static final boolean isMacOS = System.getProperty("os.name", "").contains("OS X");

     protected final BaseFileManager fileManager;
     protected final Path path;
     private boolean hasParents;

     /**
      * Create a PathFileObject for a file within a directory, such that the
      * binary name can be inferred from the relationship to an enclosing directory.
      *
      * The binary name is derived from {@code relativePath}.
      * The name is derived from the composition of {@code userPackageRootDir}
      * and {@code relativePath}.
      *
      * @param fileManager the file manager creating this file object
      * @param path the absolute path referred to by this file object
      * @param userPackageRootDir the path of the directory containing the
      *          root of the package hierarchy
      * @param relativePath the path of this file relative to {@code userPackageRootDir}
      */
     static PathFileObject forDirectoryPath(BaseFileManager fileManager, Path path,
             Path userPackageRootDir, RelativePath relativePath) {
         return new DirectoryFileObject(fileManager, path, userPackageRootDir, relativePath);
     }

     private static class DirectoryFileObject extends PathFileObject {
         private final Path userPackageRootDir;
         private final RelativePath relativePath;

         private DirectoryFileObject(BaseFileManager fileManager, Path path,
                 Path userPackageRootDir, RelativePath relativePath) {
             super(fileManager, path);
             this.userPackageRootDir = Objects.requireNonNull(userPackageRootDir);
             this.relativePath = relativePath;
         }

         @Override @DefinedBy(Api.COMPILER)
         public String getName() {
             return relativePath.resolveAgainst(userPackageRootDir).toString();
         }

         @Override
         public String inferBinaryName(Iterable<? extends Path> paths) {
             return toBinaryName(relativePath);
         }

         @Override
         public String toString() {
             return "DirectoryFileObject[" + userPackageRootDir + ":" + relativePath.path + "]";
         }

         @Override
         PathFileObject getSibling(String baseName) {
             return new DirectoryFileObject(fileManager,
                     path.resolveSibling(baseName),
                     userPackageRootDir,
                     new RelativeFile(relativePath.dirname(), baseName)
             );
         }
     }

     /**
      * Create a PathFileObject for a file in a file system such as a jar file,
      * such that the binary name can be inferred from its position within the
      * file system.
      *
      * The binary name is derived from {@code path}.
      * The name is derived from the composition of {@code userJarPath}
      * and {@code path}.
      *
      * @param fileManager the file manager creating this file object
      * @param path the path referred to by this file object
      * @param userJarPath the path of the jar file containing the file system.
      */
     public static PathFileObject forJarPath(BaseFileManager fileManager,
             Path path, Path userJarPath) {
         return new JarFileObject(fileManager, path, userJarPath);
     }

     private static class JarFileObject extends PathFileObject {
         private final Path userJarPath;

         private JarFileObject(BaseFileManager fileManager, Path path, Path userJarPath) {
             super(fileManager, path);
             this.userJarPath = userJarPath;
         }

         @Override @DefinedBy(Api.COMPILER)
         public String getName() {
             // The use of ( ) to delimit the entry name is not ideal
             // but it does match earlier behavior
             return userJarPath + "(" + path + ")";
         }

         @Override
         public String inferBinaryName(Iterable<? extends Path> paths) {
             Path root = path.getFileSystem().getRootDirectories().iterator().next();
             return toBinaryName(root.relativize(path));
         }

         @Override @DefinedBy(Api.COMPILER)
         public URI toUri() {
             // Work around bug JDK-8134451:
             // path.toUri() returns double-encoded URIs, that cannot be opened by URLConnection
             return createJarUri(userJarPath, path.toString());
         }

         @Override
         public String toString() {
             return "JarFileObject[" + userJarPath + ":" + path + "]";
         }

         @Override
         PathFileObject getSibling(String baseName) {
             return new JarFileObject(fileManager,
                     path.resolveSibling(baseName),
                     userJarPath
             );
         }

         private static URI createJarUri(Path jarFile, String entryName) {
             URI jarURI = jarFile.toUri().normalize();
             String separator = entryName.startsWith("/") ? "!" : "!/";
             try {
                 // The jar URI convention appears to be not to re-encode the jarURI
                 return new URI("jar:" + jarURI + separator + entryName);
             } catch (URISyntaxException e) {
                 throw new CannotCreateUriError(jarURI + separator + entryName, e);
             }
         }
     }

     /**
      * Create a PathFileObject for a file in a modular file system, such as jrt:,
      * such that the binary name can be inferred from its position within the
      * filesystem.
      *
      * The binary name is derived from {@code path}, ignoring the first two
      * elements of the name (which are "modules" and a module name).
      * The name is derived from {@code path}.
      *
      * @param fileManager the file manager creating this file object
      * @param path the path referred to by this file object
      */
     public static PathFileObject forJRTPath(BaseFileManager fileManager,
             final Path path) {
         return new JRTFileObject(fileManager, path);
     }

     private static class JRTFileObject extends PathFileObject {
         // private final Path javaHome;
         private JRTFileObject(BaseFileManager fileManager, Path path) {
             super(fileManager, path);
         }

         @Override @DefinedBy(Api.COMPILER)
         public String getName() {
             return path.toString();
         }

         @Override
         public String inferBinaryName(Iterable<? extends Path> paths) {
             // use subpath to ignore the leading /modules/MODULE-NAME
             return toBinaryName(path.subpath(2, path.getNameCount()));
         }

         @Override
         public String toString() {
             return "JRTFileObject[" + path + "]";
         }

         @Override
         PathFileObject getSibling(String baseName) {
             return new JRTFileObject(fileManager,
                     path.resolveSibling(baseName)
             );
         }
     }

     /**
      * Create a PathFileObject for a file whose binary name must be inferred
      * from its position on a search path.
      *
      * The binary name is inferred by finding an enclosing directory in
      * the sequence of paths associated with the location given to
      * {@link JavaFileManager#inferBinaryName).
      * The name is derived from {@code userPath}.
      *
      * @param fileManager the file manager creating this file object
      * @param path the path referred to by this file object
      * @param userPath the "user-friendly" name for this path.
      */
     static PathFileObject forSimplePath(BaseFileManager fileManager,
             Path path, Path userPath) {
         return new SimpleFileObject(fileManager, path, userPath);
     }

     private static class SimpleFileObject extends PathFileObject {
         private final Path userPath;
         private SimpleFileObject(BaseFileManager fileManager, Path path, Path userPath) {
             super(fileManager, path);
             this.userPath = userPath;
         }

         @Override @DefinedBy(Api.COMPILER)
         public String getName() {
             return userPath.toString();
         }

         @Override
         public String inferBinaryName(Iterable<? extends Path> paths) {
             Path absPath = path.toAbsolutePath();
             for (Path p: paths) {
                 Path ap = p.toAbsolutePath();
                 if (absPath.startsWith(ap)) {
                     try {
                         Path rp = ap.relativize(absPath);
                         if (rp != null) // maybe null if absPath same as ap
                             return toBinaryName(rp);
                     } catch (IllegalArgumentException e) {
                         // ignore this p if cannot relativize path to p
                     }
                 }
             }
             return null;
         }

         @Override
         PathFileObject getSibling(String baseName) {
             return new SimpleFileObject(fileManager,
                     path.resolveSibling(baseName),
                     userPath.resolveSibling(baseName)
             );
         }
     }

     /**
      * Create a PathFileObject, for a specified path, in the context of
      * a given file manager.
      *
      * In general, this path should be an
      * {@link Path#toAbsolutePath absolute path}, if not a
      * {@link Path#toRealPath} real path.
      * It will be used as the basis of {@code equals}, {@code hashCode}
      * and {@code isSameFile} methods on this file object.
      *
      * A PathFileObject should also have a "friendly name" per the
      * specification for {@link FileObject#getName}. The friendly name
      * is provided by the various subtypes of {@code PathFileObject}.
      *
      * @param fileManager the file manager creating this file object
      * @param path the path contained in this file object.
      */
     protected PathFileObject(BaseFileManager fileManager, Path path) {
         this.fileManager = Objects.requireNonNull(fileManager);
         if (Files.isDirectory(path)) {
             throw new IllegalArgumentException("directories not supported");
         }
         this.path = path;
     }

     /**
      * See {@link JavacFileManager#inferBinaryName}.
      */
     abstract String inferBinaryName(Iterable<? extends Path> paths);

     /**
      * Return the file object for a sibling file with a given file name.
      * See {@link JavacFileManager#getFileForOutput} and
      * {@link JavacFileManager#getJavaFileForOutput}.
      */
     abstract PathFileObject getSibling(String basename);

     /**
      * Return the Path for this object.
      * @return the Path for this object.
      * @see StandardJavaFileManager#asPath
      */
     public Path getPath() {
         return path;
     }

     /**
      * The short name is used when generating raw diagnostics.
      * @return the last component of the path
      */
     public String getShortName() {
         return path.getFileName().toString();
     }

     @Override @DefinedBy(Api.COMPILER)
     public Kind getKind() {
         return BaseFileManager.getKind(path.getFileName().toString());
     }

     @Override @DefinedBy(Api.COMPILER)
     public boolean isNameCompatible(String simpleName, Kind kind) {
         Objects.requireNonNull(simpleName);
         Objects.requireNonNull(kind);

         if (kind == Kind.OTHER && getKind() != kind) {
             return false;
         }

         String sn = simpleName + kind.extension;
         String pn = path.getFileName().toString();
         if (pn.equals(sn)) {
             return true;
         }

         if (path.getFileSystem() == defaultFileSystem) {
             if (isMacOS) {
                 String name = path.getFileName().toString();
                 if (Normalizer.isNormalized(name, Normalizer.Form.NFD)
                         && Normalizer.isNormalized(sn, Normalizer.Form.NFC)) {
                     // On Mac OS X it is quite possible to have the file name and the
                     // given simple name normalized in different ways.
                     // In that case we have to normalize file name to the
                     // Normal Form Composed (NFC).
                     String normName = Normalizer.normalize(name, Normalizer.Form.NFC);
                     if (normName.equals(sn)) {
                         return true;
                     }
                 }
             }

             if (pn.equalsIgnoreCase(sn)) {
                 try {
                     // allow for Windows
                     return path.toRealPath(LinkOption.NOFOLLOW_LINKS).getFileName().toString().equals(sn);
                 } catch (IOException e) {
                 }
             }
         }

         return false;
     }

     @Override @DefinedBy(Api.COMPILER)
     public NestingKind getNestingKind() {
         return null;
     }

     @Override @DefinedBy(Api.COMPILER)
     public Modifier getAccessLevel() {
         return null;
     }

     @Override @DefinedBy(Api.COMPILER)
     public URI toUri() {
         return path.toUri();
     }

     @Override @DefinedBy(Api.COMPILER)
     public InputStream openInputStream() throws IOException {
         fileManager.updateLastUsedTime();
         return Files.newInputStream(path);
     }

     @Override @DefinedBy(Api.COMPILER)
     public OutputStream openOutputStream() throws IOException {
         fileManager.updateLastUsedTime();
         fileManager.flushCache(this);
         ensureParentDirectoriesExist();
         return Files.newOutputStream(path);
     }

     @Override @DefinedBy(Api.COMPILER)
     public Reader openReader(boolean ignoreEncodingErrors) throws IOException {
         CharsetDecoder decoder = fileManager.getDecoder(fileManager.getEncodingName(), ignoreEncodingErrors);
         return new InputStreamReader(openInputStream(), decoder);
     }

     @Override @DefinedBy(Api.COMPILER)
     public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
         CharBuffer cb = fileManager.getCachedContent(this);
         if (cb == null) {
             try (InputStream in = openInputStream()) {
                 ByteBuffer bb = fileManager.makeByteBuffer(in);
                 JavaFileObject prev = fileManager.log.useSource(this);
                 try {
                     cb = fileManager.decode(bb, ignoreEncodingErrors);
                 } finally {
                     fileManager.log.useSource(prev);
                 }
                 fileManager.recycleByteBuffer(bb);
                 if (!ignoreEncodingErrors) {
                     fileManager.cache(this, cb);
                 }
             }
         }
         return cb;
     }

     @Override @DefinedBy(Api.COMPILER)
     public Writer openWriter() throws IOException {
         fileManager.updateLastUsedTime();
         fileManager.flushCache(this);
         ensureParentDirectoriesExist();
         return new OutputStreamWriter(Files.newOutputStream(path), fileManager.getEncodingName());
     }

     @Override @DefinedBy(Api.COMPILER)
     public long getLastModified() {
         try {
             return Files.getLastModifiedTime(path).toMillis();
         } catch (IOException e) {
             return 0;
         }
     }

     @Override @DefinedBy(Api.COMPILER)
     public boolean delete() {
         try {
             Files.delete(path);
             return true;
         } catch (IOException e) {
             return false;
         }
     }

     boolean isSameFile(PathFileObject other) {
         // By construction, the "path" field should be canonical in all likely, supported scenarios.
         // (Any exceptions would involve the use of symlinks within a package hierarchy.)
         // Therefore, it is sufficient to check that the paths are .equals.
         return path.equals(other.path);
     }

     @Override
     public boolean equals(Object other) {
         return (other instanceof PathFileObject && path.equals(((PathFileObject) other).path));
     }

     @Override
     public int hashCode() {
         return path.hashCode();
     }

     @Override
     public String toString() {
         return getClass().getSimpleName() + "[" + path + "]";
     }

     private void ensureParentDirectoriesExist() throws IOException {
         if (!hasParents) {
             Path parent = path.getParent();
             if (parent != null && !Files.isDirectory(parent)) {
                 try {
                     Files.createDirectories(parent);
                 } catch (IOException e) {
                     throw new IOException("could not create parent directories", e);
                 }
             }
             hasParents = true;
         }
     }

     protected static String toBinaryName(RelativePath relativePath) {
         return toBinaryName(relativePath.path, "/");
     }

     protected static String toBinaryName(Path relativePath) {
         return toBinaryName(relativePath.toString(),
                 relativePath.getFileSystem().getSeparator());
     }

     private static String toBinaryName(String relativePath, String sep) {
         return removeExtension(relativePath).replace(sep, ".");
     }

     private static String removeExtension(String fileName) {
         int lastDot = fileName.lastIndexOf(".");
         return (lastDot == -1 ? fileName : fileName.substring(0, lastDot));
     }

     /** Return the last component of a presumed hierarchical URI.
      *  From the scheme specific part of the URI, it returns the substring
      *  after the last "/" if any, or everything if no "/" is found.
      */
     public static String getSimpleName(FileObject fo) {
         URI uri = fo.toUri();
         String s = uri.getSchemeSpecificPart();
         return s.substring(s.lastIndexOf("/") + 1); // safe when / not found

     }

     /** Used when URLSyntaxException is thrown unexpectedly during
      *  implementations of FileObject.toURI(). */
     public static class CannotCreateUriError extends Error {
         private static final long serialVersionUID = 9101708840997613546L;
         public CannotCreateUriError(String value, Throwable cause) {
             super(value, cause);
         }
     }
 }
	/*
	* Copyright (c) 2009, 2016, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package com.sun.tools.javac.file;

	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.OutputStream;
	import java.io.OutputStreamWriter;
	import java.io.Reader;
	import java.io.Writer;
	import java.net.URI;
	import java.net.URISyntaxException;
	import java.nio.ByteBuffer;
	import java.nio.CharBuffer;
	import java.nio.charset.CharsetDecoder;
	import java.nio.file.FileSystem;
	import java.nio.file.FileSystems;
	import java.nio.file.Files;
	import java.nio.file.LinkOption;
	import java.nio.file.Path;
	import java.text.Normalizer;
	import java.util.Objects;

	import javax.lang.model.element.Modifier;
	import javax.lang.model.element.NestingKind;
	import javax.tools.FileObject;
	import javax.tools.JavaFileObject;

	import com.sun.tools.javac.file.RelativePath.RelativeFile;
	import com.sun.tools.javac.util.DefinedBy;
	import com.sun.tools.javac.util.DefinedBy.Api;


	/**
	* Implementation of JavaFileObject using java.nio.file API.
	*
	* <p>PathFileObjects are, for the most part, straightforward wrappers around
	* immutable absolute Path objects. Different subtypes are used to provide
	* specialized implementations of "inferBinaryName" and "getName" that capture
	* additional information available at the time the object is created.
	*
	* <p>In general, {@link JavaFileManager#isSameFile} should be used to
	* determine whether two file objects refer to the same file on disk.
	* PathFileObject also supports the standard {@code equals} and {@code hashCode}
	* methods, primarily for convenience when working with collections.
	* All of these operations delegate to the equivalent operations on the
	* underlying Path object.
	*
	* <p><b>This is NOT part of any supported API.
	* If you write code that depends on this, you do so at your own risk.
	* This code and its internal interfaces are subject to change or
	* deletion without notice.</b>
	*/
	public abstract class PathFileObject implements JavaFileObject {
	private static final FileSystem defaultFileSystem = FileSystems.getDefault();
	private static final boolean isMacOS = System.getProperty("os.name", "").contains("OS X");

	protected final BaseFileManager fileManager;
	protected final Path path;
	private boolean hasParents;

	/**
	* Create a PathFileObject for a file within a directory, such that the
	* binary name can be inferred from the relationship to an enclosing directory.
	*
	* The binary name is derived from {@code relativePath}.
	* The name is derived from the composition of {@code userPackageRootDir}
	* and {@code relativePath}.
	*
	* @param fileManager the file manager creating this file object
	* @param path the absolute path referred to by this file object
	* @param userPackageRootDir the path of the directory containing the
	* root of the package hierarchy
	* @param relativePath the path of this file relative to {@code userPackageRootDir}
	*/
	static PathFileObject forDirectoryPath(BaseFileManager fileManager, Path path,
	Path userPackageRootDir, RelativePath relativePath) {
	return new DirectoryFileObject(fileManager, path, userPackageRootDir, relativePath);
	}

	private static class DirectoryFileObject extends PathFileObject {
	private final Path userPackageRootDir;
	private final RelativePath relativePath;

	private DirectoryFileObject(BaseFileManager fileManager, Path path,
	Path userPackageRootDir, RelativePath relativePath) {
	super(fileManager, path);
	this.userPackageRootDir = Objects.requireNonNull(userPackageRootDir);
	this.relativePath = relativePath;
	}

	@Override @DefinedBy(Api.COMPILER)
	public String getName() {
	return relativePath.resolveAgainst(userPackageRootDir).toString();
	}

	@Override
	public String inferBinaryName(Iterable<? extends Path> paths) {
	return toBinaryName(relativePath);
	}

	@Override
	public String toString() {
	return "DirectoryFileObject[" + userPackageRootDir + ":" + relativePath.path + "]";
	}

	@Override
	PathFileObject getSibling(String baseName) {
	return new DirectoryFileObject(fileManager,
	path.resolveSibling(baseName),
	userPackageRootDir,
	new RelativeFile(relativePath.dirname(), baseName)
	);
	}
	}

	/**
	* Create a PathFileObject for a file in a file system such as a jar file,
	* such that the binary name can be inferred from its position within the
	* file system.
	*
	* The binary name is derived from {@code path}.
	* The name is derived from the composition of {@code userJarPath}
	* and {@code path}.
	*
	* @param fileManager the file manager creating this file object
	* @param path the path referred to by this file object
	* @param userJarPath the path of the jar file containing the file system.
	*/
	public static PathFileObject forJarPath(BaseFileManager fileManager,
	Path path, Path userJarPath) {
	return new JarFileObject(fileManager, path, userJarPath);
	}

	private static class JarFileObject extends PathFileObject {
	private final Path userJarPath;

	private JarFileObject(BaseFileManager fileManager, Path path, Path userJarPath) {
	super(fileManager, path);
	this.userJarPath = userJarPath;
	}

	@Override @DefinedBy(Api.COMPILER)
	public String getName() {
	// The use of ( ) to delimit the entry name is not ideal
	// but it does match earlier behavior
	return userJarPath + "(" + path + ")";
	}

	@Override
	public String inferBinaryName(Iterable<? extends Path> paths) {
	Path root = path.getFileSystem().getRootDirectories().iterator().next();
	return toBinaryName(root.relativize(path));
	}

	@Override @DefinedBy(Api.COMPILER)
	public URI toUri() {
	// Work around bug JDK-8134451:
	// path.toUri() returns double-encoded URIs, that cannot be opened by URLConnection
	return createJarUri(userJarPath, path.toString());
	}

	@Override
	public String toString() {
	return "JarFileObject[" + userJarPath + ":" + path + "]";
	}

	@Override
	PathFileObject getSibling(String baseName) {
	return new JarFileObject(fileManager,
	path.resolveSibling(baseName),
	userJarPath
	);
	}

	private static URI createJarUri(Path jarFile, String entryName) {
	URI jarURI = jarFile.toUri().normalize();
	String separator = entryName.startsWith("/") ? "!" : "!/";
	try {
	// The jar URI convention appears to be not to re-encode the jarURI
	return new URI("jar:" + jarURI + separator + entryName);
	} catch (URISyntaxException e) {
	throw new CannotCreateUriError(jarURI + separator + entryName, e);
	}
	}
	}

	/**
	* Create a PathFileObject for a file in a modular file system, such as jrt:,
	* such that the binary name can be inferred from its position within the
	* filesystem.
	*
	* The binary name is derived from {@code path}, ignoring the first two
	* elements of the name (which are "modules" and a module name).
	* The name is derived from {@code path}.
	*
	* @param fileManager the file manager creating this file object
	* @param path the path referred to by this file object
	*/
	public static PathFileObject forJRTPath(BaseFileManager fileManager,
	final Path path) {
	return new JRTFileObject(fileManager, path);
	}

	private static class JRTFileObject extends PathFileObject {
	// private final Path javaHome;
	private JRTFileObject(BaseFileManager fileManager, Path path) {
	super(fileManager, path);
	}

	@Override @DefinedBy(Api.COMPILER)
	public String getName() {
	return path.toString();
	}

	@Override
	public String inferBinaryName(Iterable<? extends Path> paths) {
	// use subpath to ignore the leading /modules/MODULE-NAME
	return toBinaryName(path.subpath(2, path.getNameCount()));
	}

	@Override
	public String toString() {
	return "JRTFileObject[" + path + "]";
	}

	@Override
	PathFileObject getSibling(String baseName) {
	return new JRTFileObject(fileManager,
	path.resolveSibling(baseName)
	);
	}
	}

	/**
	* Create a PathFileObject for a file whose binary name must be inferred
	* from its position on a search path.
	*
	* The binary name is inferred by finding an enclosing directory in
	* the sequence of paths associated with the location given to
	* {@link JavaFileManager#inferBinaryName).
	* The name is derived from {@code userPath}.
	*
	* @param fileManager the file manager creating this file object
	* @param path the path referred to by this file object
	* @param userPath the "user-friendly" name for this path.
	*/
	static PathFileObject forSimplePath(BaseFileManager fileManager,
	Path path, Path userPath) {
	return new SimpleFileObject(fileManager, path, userPath);
	}

	private static class SimpleFileObject extends PathFileObject {
	private final Path userPath;
	private SimpleFileObject(BaseFileManager fileManager, Path path, Path userPath) {
	super(fileManager, path);
	this.userPath = userPath;
	}

	@Override @DefinedBy(Api.COMPILER)
	public String getName() {
	return userPath.toString();
	}

	@Override
	public String inferBinaryName(Iterable<? extends Path> paths) {
	Path absPath = path.toAbsolutePath();
	for (Path p: paths) {
	Path ap = p.toAbsolutePath();
	if (absPath.startsWith(ap)) {
	try {
	Path rp = ap.relativize(absPath);
	if (rp != null) // maybe null if absPath same as ap
	return toBinaryName(rp);
	} catch (IllegalArgumentException e) {
	// ignore this p if cannot relativize path to p
	}
	}
	}
	return null;
	}

	@Override
	PathFileObject getSibling(String baseName) {
	return new SimpleFileObject(fileManager,
	path.resolveSibling(baseName),
	userPath.resolveSibling(baseName)
	);
	}
	}

	/**
	* Create a PathFileObject, for a specified path, in the context of
	* a given file manager.
	*
	* In general, this path should be an
	* {@link Path#toAbsolutePath absolute path}, if not a
	* {@link Path#toRealPath} real path.
	* It will be used as the basis of {@code equals}, {@code hashCode}
	* and {@code isSameFile} methods on this file object.
	*
	* A PathFileObject should also have a "friendly name" per the
	* specification for {@link FileObject#getName}. The friendly name
	* is provided by the various subtypes of {@code PathFileObject}.
	*
	* @param fileManager the file manager creating this file object
	* @param path the path contained in this file object.
	*/
	protected PathFileObject(BaseFileManager fileManager, Path path) {
	this.fileManager = Objects.requireNonNull(fileManager);
	if (Files.isDirectory(path)) {
	throw new IllegalArgumentException("directories not supported");
	}
	this.path = path;
	}

	/**
	* See {@link JavacFileManager#inferBinaryName}.
	*/
	abstract String inferBinaryName(Iterable<? extends Path> paths);

	/**
	* Return the file object for a sibling file with a given file name.
	* See {@link JavacFileManager#getFileForOutput} and
	* {@link JavacFileManager#getJavaFileForOutput}.
	*/
	abstract PathFileObject getSibling(String basename);

	/**
	* Return the Path for this object.
	* @return the Path for this object.
	* @see StandardJavaFileManager#asPath
	*/
	public Path getPath() {
	return path;
	}

	/**
	* The short name is used when generating raw diagnostics.
	* @return the last component of the path
	*/
	public String getShortName() {
	return path.getFileName().toString();
	}

	@Override @DefinedBy(Api.COMPILER)
	public Kind getKind() {
	return BaseFileManager.getKind(path.getFileName().toString());
	}

	@Override @DefinedBy(Api.COMPILER)
	public boolean isNameCompatible(String simpleName, Kind kind) {
	Objects.requireNonNull(simpleName);
	Objects.requireNonNull(kind);

	if (kind == Kind.OTHER && getKind() != kind) {
	return false;
	}

	String sn = simpleName + kind.extension;
	String pn = path.getFileName().toString();
	if (pn.equals(sn)) {
	return true;
	}

	if (path.getFileSystem() == defaultFileSystem) {
	if (isMacOS) {
	String name = path.getFileName().toString();
	if (Normalizer.isNormalized(name, Normalizer.Form.NFD)
	&& Normalizer.isNormalized(sn, Normalizer.Form.NFC)) {
	// On Mac OS X it is quite possible to have the file name and the
	// given simple name normalized in different ways.
	// In that case we have to normalize file name to the
	// Normal Form Composed (NFC).
	String normName = Normalizer.normalize(name, Normalizer.Form.NFC);
	if (normName.equals(sn)) {
	return true;
	}
	}
	}

	if (pn.equalsIgnoreCase(sn)) {
	try {
	// allow for Windows
	return path.toRealPath(LinkOption.NOFOLLOW_LINKS).getFileName().toString().equals(sn);
	} catch (IOException e) {
	}
	}
	}

	return false;
	}

	@Override @DefinedBy(Api.COMPILER)
	public NestingKind getNestingKind() {
	return null;
	}

	@Override @DefinedBy(Api.COMPILER)
	public Modifier getAccessLevel() {
	return null;
	}

	@Override @DefinedBy(Api.COMPILER)
	public URI toUri() {
	return path.toUri();
	}

	@Override @DefinedBy(Api.COMPILER)
	public InputStream openInputStream() throws IOException {
	fileManager.updateLastUsedTime();
	return Files.newInputStream(path);
	}

	@Override @DefinedBy(Api.COMPILER)
	public OutputStream openOutputStream() throws IOException {
	fileManager.updateLastUsedTime();
	fileManager.flushCache(this);
	ensureParentDirectoriesExist();
	return Files.newOutputStream(path);
	}

	@Override @DefinedBy(Api.COMPILER)
	public Reader openReader(boolean ignoreEncodingErrors) throws IOException {
	CharsetDecoder decoder = fileManager.getDecoder(fileManager.getEncodingName(), ignoreEncodingErrors);
	return new InputStreamReader(openInputStream(), decoder);
	}

	@Override @DefinedBy(Api.COMPILER)
	public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
	CharBuffer cb = fileManager.getCachedContent(this);
	if (cb == null) {
	try (InputStream in = openInputStream()) {
	ByteBuffer bb = fileManager.makeByteBuffer(in);
	JavaFileObject prev = fileManager.log.useSource(this);
	try {
	cb = fileManager.decode(bb, ignoreEncodingErrors);
	} finally {
	fileManager.log.useSource(prev);
	}
	fileManager.recycleByteBuffer(bb);
	if (!ignoreEncodingErrors) {
	fileManager.cache(this, cb);
	}
	}
	}
	return cb;
	}

	@Override @DefinedBy(Api.COMPILER)
	public Writer openWriter() throws IOException {
	fileManager.updateLastUsedTime();
	fileManager.flushCache(this);
	ensureParentDirectoriesExist();
	return new OutputStreamWriter(Files.newOutputStream(path), fileManager.getEncodingName());
	}

	@Override @DefinedBy(Api.COMPILER)
	public long getLastModified() {
	try {
	return Files.getLastModifiedTime(path).toMillis();
	} catch (IOException e) {
	return 0;
	}
	}

	@Override @DefinedBy(Api.COMPILER)
	public boolean delete() {
	try {
	Files.delete(path);
	return true;
	} catch (IOException e) {
	return false;
	}
	}

	boolean isSameFile(PathFileObject other) {
	// By construction, the "path" field should be canonical in all likely, supported scenarios.
	// (Any exceptions would involve the use of symlinks within a package hierarchy.)
	// Therefore, it is sufficient to check that the paths are .equals.
	return path.equals(other.path);
	}

	@Override
	public boolean equals(Object other) {
	return (other instanceof PathFileObject && path.equals(((PathFileObject) other).path));
	}

	@Override
	public int hashCode() {
	return path.hashCode();
	}

	@Override
	public String toString() {
	return getClass().getSimpleName() + "[" + path + "]";
	}

	private void ensureParentDirectoriesExist() throws IOException {
	if (!hasParents) {
	Path parent = path.getParent();
	if (parent != null && !Files.isDirectory(parent)) {
	try {
	Files.createDirectories(parent);
	} catch (IOException e) {
	throw new IOException("could not create parent directories", e);
	}
	}
	hasParents = true;
	}
	}

	protected static String toBinaryName(RelativePath relativePath) {
	return toBinaryName(relativePath.path, "/");
	}

	protected static String toBinaryName(Path relativePath) {
	return toBinaryName(relativePath.toString(),
	relativePath.getFileSystem().getSeparator());
	}

	private static String toBinaryName(String relativePath, String sep) {
	return removeExtension(relativePath).replace(sep, ".");
	}

	private static String removeExtension(String fileName) {
	int lastDot = fileName.lastIndexOf(".");
	return (lastDot == -1 ? fileName : fileName.substring(0, lastDot));
	}

	/** Return the last component of a presumed hierarchical URI.
	* From the scheme specific part of the URI, it returns the substring
	* after the last "/" if any, or everything if no "/" is found.
	*/
	public static String getSimpleName(FileObject fo) {
	URI uri = fo.toUri();
	String s = uri.getSchemeSpecificPart();
	return s.substring(s.lastIndexOf("/") + 1); // safe when / not found

	}

	/** Used when URLSyntaxException is thrown unexpectedly during
	* implementations of FileObject.toURI(). */
	public static class CannotCreateUriError extends Error {
	private static final long serialVersionUID = 9101708840997613546L;
	public CannotCreateUriError(String value, Throwable cause) {
	super(value, cause);
	}
	}
	}