--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/processing/JavacFiler.java Sun Aug 17 15:52:32 2014 +0100
@@ -0,0 +1,640 @@
+/*
+ * Copyright (c) 2005, 2014, 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.processing;
+
+import java.io.Closeable;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.FilterOutputStream;
+import java.io.Reader;
+import java.io.Writer;
+import java.io.FilterWriter;
+import java.io.PrintWriter;
+import java.io.IOException;
+import java.util.*;
+
+import static java.util.Collections.*;
+
+import javax.annotation.processing.*;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.NestingKind;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.Element;
+import javax.tools.*;
+import javax.tools.JavaFileManager.Location;
+
+import static javax.tools.StandardLocation.SOURCE_OUTPUT;
+import static javax.tools.StandardLocation.CLASS_OUTPUT;
+
+import com.sun.tools.javac.code.Lint;
+import com.sun.tools.javac.util.*;
+
+import static com.sun.tools.javac.code.Lint.LintCategory.PROCESSING;
+
+/**
+ * The FilerImplementation class must maintain a number of
+ * constraints. First, multiple attempts to open the same path within
+ * the same invocation of the tool results in an IOException being
+ * thrown. For example, trying to open the same source file twice:
+ *
+ * <pre>
+ * createSourceFile("foo.Bar")
+ * ...
+ * createSourceFile("foo.Bar")
+ * </pre>
+ *
+ * is disallowed as is opening a text file that happens to have
+ * the same name as a source file:
+ *
+ * <pre>
+ * createSourceFile("foo.Bar")
+ * ...
+ * createTextFile(SOURCE_TREE, "foo", new File("Bar"), null)
+ * </pre>
+ *
+ * <p>Additionally, creating a source file that corresponds to an
+ * already created class file (or vice versa) also results in an
+ * IOException since each type can only be created once. However, if
+ * the Filer is used to create a text file named *.java that happens
+ * to correspond to an existing class file, a warning is *not*
+ * generated. Similarly, a warning is not generated for a binary file
+ * named *.class and an existing source file.
+ *
+ * <p>The reason for this difference is that source files and class
+ * files are registered with the tool and can get passed on as
+ * declarations to the next round of processing. Files that are just
+ * named *.java and *.class are not processed in that manner; although
+ * having extra source files and class files on the source path and
+ * class path can alter the behavior of the tool and any final
+ * compile.
+ *
+ * <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 class JavacFiler implements Filer, Closeable {
+ // TODO: Implement different transaction model for updating the
+ // Filer's record keeping on file close.
+
+ private static final String ALREADY_OPENED =
+ "Output stream or writer has already been opened.";
+ private static final String NOT_FOR_READING =
+ "FileObject was not opened for reading.";
+ private static final String NOT_FOR_WRITING =
+ "FileObject was not opened for writing.";
+
+ /**
+ * Wrap a JavaFileObject to manage writing by the Filer.
+ */
+ private class FilerOutputFileObject extends ForwardingFileObject<FileObject> {
+ private boolean opened = false;
+ private String name;
+
+ FilerOutputFileObject(String name, FileObject fileObject) {
+ super(fileObject);
+ this.name = name;
+ }
+
+ @Override
+ public synchronized OutputStream openOutputStream() throws IOException {
+ if (opened)
+ throw new IOException(ALREADY_OPENED);
+ opened = true;
+ return new FilerOutputStream(name, fileObject);
+ }
+
+ @Override
+ public synchronized Writer openWriter() throws IOException {
+ if (opened)
+ throw new IOException(ALREADY_OPENED);
+ opened = true;
+ return new FilerWriter(name, fileObject);
+ }
+
+ // Three anti-literacy methods
+ @Override
+ public InputStream openInputStream() throws IOException {
+ throw new IllegalStateException(NOT_FOR_READING);
+ }
+
+ @Override
+ public Reader openReader(boolean ignoreEncodingErrors) throws IOException {
+ throw new IllegalStateException(NOT_FOR_READING);
+ }
+
+ @Override
+ public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
+ throw new IllegalStateException(NOT_FOR_READING);
+ }
+
+ @Override
+ public boolean delete() {
+ return false;
+ }
+ }
+
+ private class FilerOutputJavaFileObject extends FilerOutputFileObject implements JavaFileObject {
+ private final JavaFileObject javaFileObject;
+ FilerOutputJavaFileObject(String name, JavaFileObject javaFileObject) {
+ super(name, javaFileObject);
+ this.javaFileObject = javaFileObject;
+ }
+
+ public JavaFileObject.Kind getKind() {
+ return javaFileObject.getKind();
+ }
+
+ public boolean isNameCompatible(String simpleName,
+ JavaFileObject.Kind kind) {
+ return javaFileObject.isNameCompatible(simpleName, kind);
+ }
+
+ public NestingKind getNestingKind() {
+ return javaFileObject.getNestingKind();
+ }
+
+ public Modifier getAccessLevel() {
+ return javaFileObject.getAccessLevel();
+ }
+ }
+
+ /**
+ * Wrap a JavaFileObject to manage reading by the Filer.
+ */
+ private class FilerInputFileObject extends ForwardingFileObject<FileObject> {
+ FilerInputFileObject(FileObject fileObject) {
+ super(fileObject);
+ }
+
+ @Override
+ public OutputStream openOutputStream() throws IOException {
+ throw new IllegalStateException(NOT_FOR_WRITING);
+ }
+
+ @Override
+ public Writer openWriter() throws IOException {
+ throw new IllegalStateException(NOT_FOR_WRITING);
+ }
+
+ @Override
+ public boolean delete() {
+ return false;
+ }
+ }
+
+ private class FilerInputJavaFileObject extends FilerInputFileObject implements JavaFileObject {
+ private final JavaFileObject javaFileObject;
+ FilerInputJavaFileObject(JavaFileObject javaFileObject) {
+ super(javaFileObject);
+ this.javaFileObject = javaFileObject;
+ }
+
+ public JavaFileObject.Kind getKind() {
+ return javaFileObject.getKind();
+ }
+
+ public boolean isNameCompatible(String simpleName,
+ JavaFileObject.Kind kind) {
+ return javaFileObject.isNameCompatible(simpleName, kind);
+ }
+
+ public NestingKind getNestingKind() {
+ return javaFileObject.getNestingKind();
+ }
+
+ public Modifier getAccessLevel() {
+ return javaFileObject.getAccessLevel();
+ }
+ }
+
+
+ /**
+ * Wrap a {@code OutputStream} returned from the {@code
+ * JavaFileManager} to properly register source or class files
+ * when they are closed.
+ */
+ private class FilerOutputStream extends FilterOutputStream {
+ String typeName;
+ FileObject fileObject;
+ boolean closed = false;
+
+ /**
+ * @param typeName name of class or {@code null} if just a
+ * binary file
+ */
+ FilerOutputStream(String typeName, FileObject fileObject) throws IOException {
+ super(fileObject.openOutputStream());
+ this.typeName = typeName;
+ this.fileObject = fileObject;
+ }
+
+ public synchronized void close() throws IOException {
+ if (!closed) {
+ closed = true;
+ /*
+ * If an IOException occurs when closing the underlying
+ * stream, still try to process the file.
+ */
+
+ closeFileObject(typeName, fileObject);
+ out.close();
+ }
+ }
+ }
+
+ /**
+ * Wrap a {@code Writer} returned from the {@code JavaFileManager}
+ * to properly register source or class files when they are
+ * closed.
+ */
+ private class FilerWriter extends FilterWriter {
+ String typeName;
+ FileObject fileObject;
+ boolean closed = false;
+
+ /**
+ * @param fileObject the fileObject to be written to
+ * @param typeName name of source file or {@code null} if just a
+ * text file
+ */
+ FilerWriter(String typeName, FileObject fileObject) throws IOException {
+ super(fileObject.openWriter());
+ this.typeName = typeName;
+ this.fileObject = fileObject;
+ }
+
+ public synchronized void close() throws IOException {
+ if (!closed) {
+ closed = true;
+ /*
+ * If an IOException occurs when closing the underlying
+ * Writer, still try to process the file.
+ */
+
+ closeFileObject(typeName, fileObject);
+ out.close();
+ }
+ }
+ }
+
+ JavaFileManager fileManager;
+ Log log;
+ Context context;
+ boolean lastRound;
+
+ private final boolean lint;
+
+ /**
+ * Logical names of all created files. This set must be
+ * synchronized.
+ */
+ private final Set<FileObject> fileObjectHistory;
+
+ /**
+ * Names of types that have had files created but not closed.
+ */
+ private final Set<String> openTypeNames;
+
+ /**
+ * Names of source files closed in this round. This set must be
+ * synchronized. Its iterators should preserve insertion order.
+ */
+ private Set<String> generatedSourceNames;
+
+ /**
+ * Names and class files of the class files closed in this round.
+ * This set must be synchronized. Its iterators should preserve
+ * insertion order.
+ */
+ private final Map<String, JavaFileObject> generatedClasses;
+
+ /**
+ * JavaFileObjects for source files closed in this round. This
+ * set must be synchronized. Its iterators should preserve
+ * insertion order.
+ */
+ private Set<JavaFileObject> generatedSourceFileObjects;
+
+ /**
+ * Names of all created source files. Its iterators should
+ * preserve insertion order.
+ */
+ private final Set<String> aggregateGeneratedSourceNames;
+
+ /**
+ * Names of all created class files. Its iterators should
+ * preserve insertion order.
+ */
+ private final Set<String> aggregateGeneratedClassNames;
+
+
+ JavacFiler(Context context) {
+ this.context = context;
+ fileManager = context.get(JavaFileManager.class);
+
+ log = Log.instance(context);
+
+ fileObjectHistory = synchronizedSet(new LinkedHashSet<FileObject>());
+ generatedSourceNames = synchronizedSet(new LinkedHashSet<String>());
+ generatedSourceFileObjects = synchronizedSet(new LinkedHashSet<JavaFileObject>());
+
+ generatedClasses = synchronizedMap(new LinkedHashMap<String, JavaFileObject>());
+
+ openTypeNames = synchronizedSet(new LinkedHashSet<String>());
+
+ aggregateGeneratedSourceNames = new LinkedHashSet<>();
+ aggregateGeneratedClassNames = new LinkedHashSet<>();
+
+ lint = (Lint.instance(context)).isEnabled(PROCESSING);
+ }
+
+ public JavaFileObject createSourceFile(CharSequence name,
+ Element... originatingElements) throws IOException {
+ return createSourceOrClassFile(true, name.toString());
+ }
+
+ public JavaFileObject createClassFile(CharSequence name,
+ Element... originatingElements) throws IOException {
+ return createSourceOrClassFile(false, name.toString());
+ }
+
+ private JavaFileObject createSourceOrClassFile(boolean isSourceFile, String name) throws IOException {
+ if (lint) {
+ int periodIndex = name.lastIndexOf(".");
+ if (periodIndex != -1) {
+ String base = name.substring(periodIndex);
+ String extn = (isSourceFile ? ".java" : ".class");
+ if (base.equals(extn))
+ log.warning("proc.suspicious.class.name", name, extn);
+ }
+ }
+ checkNameAndExistence(name, isSourceFile);
+ Location loc = (isSourceFile ? SOURCE_OUTPUT : CLASS_OUTPUT);
+ JavaFileObject.Kind kind = (isSourceFile ?
+ JavaFileObject.Kind.SOURCE :
+ JavaFileObject.Kind.CLASS);
+
+ JavaFileObject fileObject =
+ fileManager.getJavaFileForOutput(loc, name, kind, null);
+ checkFileReopening(fileObject, true);
+
+ if (lastRound)
+ log.warning("proc.file.create.last.round", name);
+
+ if (isSourceFile)
+ aggregateGeneratedSourceNames.add(name);
+ else
+ aggregateGeneratedClassNames.add(name);
+ openTypeNames.add(name);
+
+ return new FilerOutputJavaFileObject(name, fileObject);
+ }
+
+ public FileObject createResource(JavaFileManager.Location location,
+ CharSequence pkg,
+ CharSequence relativeName,
+ Element... originatingElements) throws IOException {
+ locationCheck(location);
+
+ String strPkg = pkg.toString();
+ if (strPkg.length() > 0)
+ checkName(strPkg);
+
+ FileObject fileObject =
+ fileManager.getFileForOutput(location, strPkg,
+ relativeName.toString(), null);
+ checkFileReopening(fileObject, true);
+
+ if (fileObject instanceof JavaFileObject)
+ return new FilerOutputJavaFileObject(null, (JavaFileObject)fileObject);
+ else
+ return new FilerOutputFileObject(null, fileObject);
+ }
+
+ private void locationCheck(JavaFileManager.Location location) {
+ if (location instanceof StandardLocation) {
+ StandardLocation stdLoc = (StandardLocation) location;
+ if (!stdLoc.isOutputLocation())
+ throw new IllegalArgumentException("Resource creation not supported in location " +
+ stdLoc);
+ }
+ }
+
+ public FileObject getResource(JavaFileManager.Location location,
+ CharSequence pkg,
+ CharSequence relativeName) throws IOException {
+ String strPkg = pkg.toString();
+ if (strPkg.length() > 0)
+ checkName(strPkg);
+
+ // TODO: Only support reading resources in selected output
+ // locations? Only allow reading of non-source, non-class
+ // files from the supported input locations?
+
+ // In the following, getFileForInput is the "obvious" method
+ // to use, but it does not have the "obvious" semantics for
+ // SOURCE_OUTPUT and CLASS_OUTPUT. Conversely, getFileForOutput
+ // does not have the correct semantics for any "path" location
+ // with more than one component. So, for now, we use a hybrid
+ // invocation.
+ FileObject fileObject;
+ if (location.isOutputLocation()) {
+ fileObject = fileManager.getFileForOutput(location,
+ pkg.toString(),
+ relativeName.toString(),
+ null);
+ } else {
+ fileObject = fileManager.getFileForInput(location,
+ pkg.toString(),
+ relativeName.toString());
+ }
+ if (fileObject == null) {
+ String name = (pkg.length() == 0)
+ ? relativeName.toString() : (pkg + "/" + relativeName);
+ throw new FileNotFoundException(name);
+ }
+
+ // If the path was already opened for writing, throw an exception.
+ checkFileReopening(fileObject, false);
+ return new FilerInputFileObject(fileObject);
+ }
+
+ private void checkName(String name) throws FilerException {
+ checkName(name, false);
+ }
+
+ private void checkName(String name, boolean allowUnnamedPackageInfo) throws FilerException {
+ if (!SourceVersion.isName(name) && !isPackageInfo(name, allowUnnamedPackageInfo)) {
+ if (lint)
+ log.warning("proc.illegal.file.name", name);
+ throw new FilerException("Illegal name " + name);
+ }
+ }
+
+ private boolean isPackageInfo(String name, boolean allowUnnamedPackageInfo) {
+ // Is the name of the form "package-info" or
+ // "foo.bar.package-info"?
+ final String PKG_INFO = "package-info";
+ int periodIndex = name.lastIndexOf(".");
+ if (periodIndex == -1) {
+ return allowUnnamedPackageInfo ? name.equals(PKG_INFO) : false;
+ } else {
+ // "foo.bar.package-info." illegal
+ String prefix = name.substring(0, periodIndex);
+ String simple = name.substring(periodIndex+1);
+ return SourceVersion.isName(prefix) && simple.equals(PKG_INFO);
+ }
+ }
+
+ private void checkNameAndExistence(String typename, boolean allowUnnamedPackageInfo) throws FilerException {
+ // TODO: Check if type already exists on source or class path?
+ // If so, use warning message key proc.type.already.exists
+ checkName(typename, allowUnnamedPackageInfo);
+ if (aggregateGeneratedSourceNames.contains(typename) ||
+ aggregateGeneratedClassNames.contains(typename)) {
+ if (lint)
+ log.warning("proc.type.recreate", typename);
+ throw new FilerException("Attempt to recreate a file for type " + typename);
+ }
+ }
+
+ /**
+ * Check to see if the file has already been opened; if so, throw
+ * an exception, otherwise add it to the set of files.
+ */
+ private void checkFileReopening(FileObject fileObject, boolean addToHistory) throws FilerException {
+ for(FileObject veteran : fileObjectHistory) {
+ if (fileManager.isSameFile(veteran, fileObject)) {
+ if (lint)
+ log.warning("proc.file.reopening", fileObject.getName());
+ throw new FilerException("Attempt to reopen a file for path " + fileObject.getName());
+ }
+ }
+ if (addToHistory)
+ fileObjectHistory.add(fileObject);
+ }
+
+ public boolean newFiles() {
+ return (!generatedSourceNames.isEmpty())
+ || (!generatedClasses.isEmpty());
+ }
+
+ public Set<String> getGeneratedSourceNames() {
+ return generatedSourceNames;
+ }
+
+ public Set<JavaFileObject> getGeneratedSourceFileObjects() {
+ return generatedSourceFileObjects;
+ }
+
+ public Map<String, JavaFileObject> getGeneratedClasses() {
+ return generatedClasses;
+ }
+
+ public void warnIfUnclosedFiles() {
+ if (!openTypeNames.isEmpty())
+ log.warning("proc.unclosed.type.files", openTypeNames.toString());
+ }
+
+ /**
+ * Update internal state for a new round.
+ */
+ public void newRound() {
+ clearRoundState();
+ }
+
+ void setLastRound(boolean lastRound) {
+ this.lastRound = lastRound;
+ }
+
+ public void close() {
+ clearRoundState();
+ // Cross-round state
+ fileObjectHistory.clear();
+ openTypeNames.clear();
+ aggregateGeneratedSourceNames.clear();
+ aggregateGeneratedClassNames.clear();
+ }
+
+ private void clearRoundState() {
+ generatedSourceNames.clear();
+ generatedSourceFileObjects.clear();
+ generatedClasses.clear();
+ }
+
+ /**
+ * Debugging function to display internal state.
+ */
+ public void displayState() {
+ PrintWriter xout = context.get(Log.outKey);
+ xout.println("File Object History : " + fileObjectHistory);
+ xout.println("Open Type Names : " + openTypeNames);
+ xout.println("Gen. Src Names : " + generatedSourceNames);
+ xout.println("Gen. Cls Names : " + generatedClasses.keySet());
+ xout.println("Agg. Gen. Src Names : " + aggregateGeneratedSourceNames);
+ xout.println("Agg. Gen. Cls Names : " + aggregateGeneratedClassNames);
+ }
+
+ public String toString() {
+ return "javac Filer";
+ }
+
+ /**
+ * Upon close, register files opened by create{Source, Class}File
+ * for annotation processing.
+ */
+ private void closeFileObject(String typeName, FileObject fileObject) {
+ /*
+ * If typeName is non-null, the file object was opened as a
+ * source or class file by the user. If a file was opened as
+ * a resource, typeName will be null and the file is *not*
+ * subject to annotation processing.
+ */
+ if ((typeName != null)) {
+ if (!(fileObject instanceof JavaFileObject))
+ throw new AssertionError("JavaFileOject not found for " + fileObject);
+ JavaFileObject javaFileObject = (JavaFileObject)fileObject;
+ switch(javaFileObject.getKind()) {
+ case SOURCE:
+ generatedSourceNames.add(typeName);
+ generatedSourceFileObjects.add(javaFileObject);
+ openTypeNames.remove(typeName);
+ break;
+
+ case CLASS:
+ generatedClasses.put(typeName, javaFileObject);
+ openTypeNames.remove(typeName);
+ break;
+
+ default:
+ break;
+ }
+ }
+ }
+
+}