jdk-sandbox: comparison langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/file/JavacFileManager.java

equal deleted inserted replaced

-:9fffb959eb41
+:443efec4bf09
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.nio.CharBuffer;
 import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.InvalidPathException;
+import java.nio.file.LinkOption;
+import java.nio.file.NoSuchFileException;
 import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import java.util.zip.ZipFile;
 import javax.lang.model.SourceVersion;
 import javax.tools.FileObject;
 import javax.tools.JavaFileManager;
 EnumSet.of(JavaFileObject.Kind.SOURCE, JavaFileObject.Kind.CLASS);
 protected boolean mmappedIO;
 protected boolean symbolFileEnabled;
-protected enum SortFiles implements Comparator<File> {
+protected enum SortFiles implements Comparator<Path> {
 FORWARD {
 @Override
-public int compare(File f1, File f2) {
+public int compare(Path f1, Path f2) {
-return f1.getName().compareTo(f2.getName());
+return f1.getFileName().compareTo(f2.getFileName());
 }
 },
 REVERSE {
 @Override
-public int compare(File f1, File f2) {
+public int compare(Path f1, Path f2) {
-return -f1.getName().compareTo(f2.getName());
+return -f1.getFileName().compareTo(f2.getFileName());
 }
 }
 }
 protected SortFiles sortFiles;
 public boolean isSymbolFileEnabled() {
 return symbolFileEnabled;
 }
 public JavaFileObject getFileForInput(String name) {
-return getRegularFile(new File(name));
+return getRegularFile(Paths.get(name));
 }
-public JavaFileObject getRegularFile(File file) {
+public JavaFileObject getRegularFile(Path file) {
 return new RegularFileObject(this, file);
 }
 public JavaFileObject getFileForOutput(String classname,
 JavaFileObject.Kind kind,
 /**
 * Insert all files in subdirectory subdirectory of directory directory
 * which match fileKinds into resultList
 */
-private void listDirectory(File directory,
+private void listDirectory(Path directory,
 RelativeDirectory subdirectory,
 Set<JavaFileObject.Kind> fileKinds,
 boolean recurse,
 ListBuffer<JavaFileObject> resultList) {
-File d = subdirectory.getFile(directory);
+Path d;
-if (!caseMapCheck(d, subdirectory))
+try {
+d = subdirectory.getFile(directory);
+} catch (InvalidPathException ignore) {
 return;
+}
-File[] files = d.listFiles();
-if (files == null)
+if (!Files.exists(d)) {
+return;
+}
+if (!caseMapCheck(d, subdirectory)) {
 return;
+}
-if (sortFiles != null)
-Arrays.sort(files, sortFiles);
+java.util.List<Path> files;
+try (Stream<Path> s = Files.list(d)) {
-for (File f: files) {
+files = (sortFiles == null ? s : s.sorted(sortFiles)).collect(Collectors.toList());
-String fname = f.getName();
+} catch (IOException ignore) {
-if (f.isDirectory()) {
+return;
+}
+for (Path f: files) {
+String fname = f.getFileName().toString();
+if (Files.isDirectory(f)) {
 if (recurse && SourceVersion.isIdentifier(fname)) {
 listDirectory(directory,
 new RelativeDirectory(subdirectory, fname),
 fileKinds,
 recurse,
 resultList);
 }
 } else {
 if (isValidFile(fname, fileKinds)) {
 JavaFileObject fe =
-new RegularFileObject(this, fname, new File(d, fname));
+new RegularFileObject(this, fname, d.resolve(fname));
 resultList.append(fe);
 }
 }
 }
 }
 /**
 * container is a directory, a zip file, or a non-existant path.
 * Insert all files in subdirectory subdirectory of container which
 * match fileKinds into resultList
 */
-private void listContainer(File container,
+private void listContainer(Path container,
 RelativeDirectory subdirectory,
 Set<JavaFileObject.Kind> fileKinds,
 boolean recurse,
 ListBuffer<JavaFileObject> resultList) {
 Archive archive = archives.get(container);
 if (archive == null) {
 // Very temporary and obnoxious interim hack
-if (container.getName().equals("bootmodules.jimage")) {
+if (container.endsWith("bootmodules.jimage")) {
 System.err.println("Warning: reference to bootmodules.jimage replaced by jrt:");
 container = Locations.JRT_MARKER_FILE;
-} else if (container.getName().endsWith(".jimage")) {
+} else if (container.getFileName().toString().endsWith(".jimage")) {
 System.err.println("Warning: reference to " + container + " ignored");
 return;
 }
 // archives are not created for directories or jrt: images
 /** Hack to make Windows case sensitive. Test whether given path
 *  ends in a string of characters with the same case as given name.
 *  Ignore file separators in both path and name.
 */
-private boolean caseMapCheck(File f, RelativePath name) {
+private boolean caseMapCheck(Path f, RelativePath name) {
 if (fileSystemIsCaseSensitive) return true;
-// Note that getCanonicalPath() returns the case-sensitive
+// Note that toRealPath() returns the case-sensitive
 // spelled file name.
 String path;
+char sep;
 try {
-path = f.getCanonicalPath();
+path = f.toRealPath(LinkOption.NOFOLLOW_LINKS).toString();
+sep = f.getFileSystem().getSeparator().charAt(0);
 } catch (IOException ex) {
 return false;
 }
 char[] pcs = path.toCharArray();
 char[] ncs = name.path.toCharArray();
 int i = pcs.length - 1;
 int j = ncs.length - 1;
 while (i >= 0 && j >= 0) {
-while (i >= 0 && pcs[i] == File.separatorChar) i--;
+while (i >= 0 && pcs[i] == sep) i--;
 while (j >= 0 && ncs[j] == '/') j--;
 if (i >= 0 && j >= 0) {
 if (pcs[i] != ncs[j]) return false;
 i--;
 j--;
 Set<RelativeDirectory> getSubdirectories();
 }
 public class MissingArchive implements Archive {
-final File zipFileName;
+final Path zipFileName;
-public MissingArchive(File name) {
+public MissingArchive(Path name) {
 zipFileName = name;
 }
 @Override
 public boolean contains(RelativePath name) {
 return false;
 }
 }
 /** A directory of zip files already opened.
 */
-Map<File, Archive> archives = new HashMap<>();
+Map<Path, Archive> archives = new HashMap<>();
 /*
 * This method looks for a ZipFormatException and takes appropriate
 * evasive action. If there is a failure in the fast mode then we
 * fail over to the platform zip, and allow it to deal with a potentially
 * non compliant zip file.
 */
-protected Archive openArchive(File zipFilename) throws IOException {
+protected Archive openArchive(Path zipFilename) throws IOException {
 try {
 return openArchive(zipFilename, contextUseOptimizedZip);
 } catch (IOException ioe) {
 if (ioe instanceof ZipFileIndex.ZipFormatException) {
 return openArchive(zipFilename, false);
 }
 }
 /** Open a new zip file directory, and cache it.
 */
-private Archive openArchive(File zipFileName, boolean useOptimizedZip) throws IOException {
+private Archive openArchive(Path zipFileName, boolean useOptimizedZip) throws IOException {
 Archive archive;
 try {
 ZipFile zdir = null;
 boolean usePreindexedCache = false;
 String preindexCacheLocation = null;
 if (!useOptimizedZip) {
-zdir = new ZipFile(zipFileName);
+zdir = new ZipFile(zipFileName.toFile());
 } else {
 usePreindexedCache = options.isSet("usezipindex");
 preindexCacheLocation = options.get("java.io.tmpdir");
 String optCacheLoc = options.get("cachezipindexdir");
 null,
 usePreindexedCache,
 preindexCacheLocation,
 options.isSet("writezipindexfiles")));
 }
-} catch (FileNotFoundException ex) {
+} catch (FileNotFoundException | NoSuchFileException ex) {
 archive = new MissingArchive(zipFileName);
 } catch (ZipFileIndex.ZipFormatException zfe) {
 throw zfe;
 } catch (IOException ex) {
-if (zipFileName.exists())
+if (Files.exists(zipFileName))
 log.error("error.reading.file", zipFileName, getMessage(ex));
 archive = new MissingArchive(zipFileName);
 }
 archives.put(zipFileName, archive);
 {
 // validatePackageName(packageName);
 nullCheck(packageName);
 nullCheck(kinds);
-Iterable<? extends File> path = getLocation(location);
+Iterable<? extends Path> path = getLocationAsPaths(location);
 if (path == null)
 return List.nil();
 RelativeDirectory subdirectory = RelativeDirectory.forPackage(packageName);
 ListBuffer<JavaFileObject> results = new ListBuffer<>();
-for (File directory : path)
+for (Path directory : path)
 listContainer(directory, subdirectory, kinds, recurse, results);
 return results.toList();
 }
 @Override @DefinedBy(Api.COMPILER)
 public String inferBinaryName(Location location, JavaFileObject file) {
 file.getClass(); // null check
 location.getClass(); // null check
 // Need to match the path semantics of list(location, ...)
-Iterable<? extends File> path = getLocation(location);
+Iterable<? extends Path> path = getLocationAsPaths(location);
 if (path == null) {
 return null;
 }
 if (file instanceof BaseFileObject) {
 : new RelativeFile(RelativeDirectory.forPackage(packageName), relativeName);
 return getFileForInput(location, name);
 }
 private JavaFileObject getFileForInput(Location location, RelativeFile name) throws IOException {
-Iterable<? extends File> path = getLocation(location);
+Iterable<? extends Path> path = getLocationAsPaths(location);
 if (path == null)
 return null;
-for (File file: path) {
+for (Path file: path) {
 Archive a = archives.get(file);
 if (a == null) {
 // archives are not created for directories or jrt: images
 if (file == Locations.JRT_MARKER_FILE) {
 JRTIndex.Entry e = getJRTIndex().getEntry(name.dirname());
 Path p = e.files.get(name.basename());
 if (p != null)
 return PathFileObject.createJRTPathFileObject(this, p);
 continue;
 } else if (fsInfo.isDirectory(file)) {
-File f = name.getFile(file);
+try {
-if (f.exists())
+Path f = name.getFile(file);
-return new RegularFileObject(this, f);
+if (Files.exists(f))
+return new RegularFileObject(this, f);
+} catch (InvalidPathException ignore) {
+}
 continue;
 }
 // Not a directory, create the archive
 a = openArchive(file);
 }
 private JavaFileObject getFileForOutput(Location location,
 RelativeFile fileName,
 FileObject sibling)
 throws IOException
 {
-File dir;
+Path dir;
 if (location == CLASS_OUTPUT) {
 if (getClassOutDir() != null) {
 dir = getClassOutDir();
 } else {
-File siblingDir = null;
+Path siblingDir = null;
 if (sibling != null && sibling instanceof RegularFileObject) {
-siblingDir = ((RegularFileObject)sibling).file.getParentFile();
+siblingDir = ((RegularFileObject)sibling).file.getParent();
 }
-return new RegularFileObject(this, new File(siblingDir, fileName.basename()));
+if (siblingDir == null)
+return new RegularFileObject(this, Paths.get(fileName.basename()));
+else
+return new RegularFileObject(this, siblingDir.resolve(fileName.basename()));
 }
 } else if (location == SOURCE_OUTPUT) {
 dir = (getSourceOutDir() != null ? getSourceOutDir() : getClassOutDir());
 } else {
-Iterable<? extends File> path = locations.getLocation(location);
+Iterable<? extends Path> path = locations.getLocation(location);
 dir = null;
-for (File f: path) {
+for (Path f: path) {
 dir = f;
 break;
 }
 }
-File file = fileName.getFile(dir); // null-safe
+try {
-return new RegularFileObject(this, file);
+Path file = fileName.getFile(dir); // null-safe
+return new RegularFileObject(this, file);
+} catch (InvalidPathException e) {
+throw new IOException("bad filename " + fileName, e);
+}
 }
 @Override @DefinedBy(Api.COMPILER)
 public Iterable<? extends JavaFileObject> getJavaFileObjectsFromFiles(
 Iterable<? extends File> files)
 if (files instanceof Collection<?>)
 result = new ArrayList<>(((Collection<?>)files).size());
 else
 result = new ArrayList<>();
 for (File f: files)
-result.add(new RegularFileObject(this, nullCheck(f)));
+result.add(new RegularFileObject(this, nullCheck(f).toPath()));
 return result;
 }
 @Override @DefinedBy(Api.COMPILER)
 public Iterable<? extends JavaFileObject> getJavaFileObjects(File... files) {
 return getJavaFileObjectsFromFiles(Arrays.asList(nullCheck(files)));
 }
 @Override @DefinedBy(Api.COMPILER)
 public void setLocation(Location location,
-Iterable<? extends File> path)
+Iterable<? extends File> searchpath)
 throws IOException
 {
 nullCheck(location);
-locations.setLocation(location, path);
+locations.setLocation(location, asPaths(searchpath));
 }
 @Override @DefinedBy(Api.COMPILER)
 public Iterable<? extends File> getLocation(Location location) {
 nullCheck(location);
+return asFiles(locations.getLocation(location));
+}
+private Iterable<? extends Path> getLocationAsPaths(Location location) {
+nullCheck(location);
 return locations.getLocation(location);
 }
-private File getClassOutDir() {
+private Path getClassOutDir() {
 return locations.getOutputLocation(CLASS_OUTPUT);
 }
-private File getSourceOutDir() {
+private Path getSourceOutDir() {
 return locations.getOutputLocation(SOURCE_OUTPUT);
 }
 /**
 * Enforces the specification of a "relative" name as used in
 s = e.getMessage();
 if (s != null)
 return s;
 return e.toString();
 }
+/* Converters between files and paths.
+* These are temporary until we can update the StandardJavaFileManager API.
+*/
+private static Iterable<Path> asPaths(final Iterable<? extends File> files) {
+if (files == null)
+return null;
+return () -> new Iterator<Path>() {
+Iterator<? extends File> iter = files.iterator();
+@Override
+public boolean hasNext() {
+return iter.hasNext();
+}
+@Override
+public Path next() {
+return iter.next().toPath();
+}
+};
+}
+private static Iterable<File> asFiles(final Iterable<? extends Path> paths) {
+if (paths == null)
+return null;
+return () -> new Iterator<File>() {
+Iterator<? extends Path> iter = paths.iterator();
+@Override
+public boolean hasNext() {
+return iter.hasNext();
+}
+@Override
+public File next() {
+return iter.next().toFile();
+}
+};
+}
+private static File asFile(Path path) {
+return path == null ? null : path.toFile();
+}
 }

changeset 27858	443efec4bf09
parent 27579	d1a63c99cdd5
parent 27852	2e6ad0e4fe20
child 28332	cd3ea1087d2b