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

equal deleted inserted replaced

-:058fc03646d9
+:050370edaade
 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.code.Symbol.ModuleSymbol;
+import com.sun.tools.javac.code.Symtab;
+import com.sun.tools.javac.comp.Modules;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.DefinedBy.Api;
 import static com.sun.tools.javac.code.Lint.LintCategory.PROCESSING;
 /**
 * Wrap a JavaFileObject to manage writing by the Filer.
 */
 private class FilerOutputFileObject extends ForwardingFileObject<FileObject> {
 private boolean opened = false;
+private ModuleSymbol mod;
 private String name;
-FilerOutputFileObject(String name, FileObject fileObject) {
+FilerOutputFileObject(ModuleSymbol mod, String name, FileObject fileObject) {
 super(fileObject);
+this.mod = mod;
 this.name = name;
 }
 @Override @DefinedBy(Api.COMPILER)
 public synchronized OutputStream openOutputStream() throws IOException {
 if (opened)
 throw new IOException(ALREADY_OPENED);
 opened = true;
-return new FilerOutputStream(name, fileObject);
+return new FilerOutputStream(mod, name, fileObject);
 }
 @Override @DefinedBy(Api.COMPILER)
 public synchronized Writer openWriter() throws IOException {
 if (opened)
 throw new IOException(ALREADY_OPENED);
 opened = true;
-return new FilerWriter(name, fileObject);
+return new FilerWriter(mod, name, fileObject);
 }
 // Three anti-literacy methods
 @Override @DefinedBy(Api.COMPILER)
 public InputStream openInputStream() throws IOException {
 }
 }
 private class FilerOutputJavaFileObject extends FilerOutputFileObject implements JavaFileObject {
 private final JavaFileObject javaFileObject;
-FilerOutputJavaFileObject(String name, JavaFileObject javaFileObject) {
+FilerOutputJavaFileObject(ModuleSymbol mod, String name, JavaFileObject javaFileObject) {
-super(name, javaFileObject);
+super(mod, name, javaFileObject);
 this.javaFileObject = javaFileObject;
 }
 @DefinedBy(Api.COMPILER)
 public JavaFileObject.Kind getKind() {
 * 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 {
+ModuleSymbol mod;
 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 {
+FilerOutputStream(ModuleSymbol mod, String typeName, FileObject fileObject) throws IOException {
 super(fileObject.openOutputStream());
+this.mod = mod;
 this.typeName = typeName;
 this.fileObject = fileObject;
 }
 public synchronized void close() throws IOException {
 /*
 * If an IOException occurs when closing the underlying
 * stream, still try to process the file.
 */
-closeFileObject(typeName, fileObject);
+closeFileObject(mod, 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 {
+ModuleSymbol mod;
 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 {
+FilerWriter(ModuleSymbol mod, String typeName, FileObject fileObject) throws IOException {
 super(fileObject.openWriter());
+this.mod = mod;
 this.typeName = typeName;
 this.fileObject = fileObject;
 }
 public synchronized void close() throws IOException {
 /*
 * If an IOException occurs when closing the underlying
 * Writer, still try to process the file.
 */
-closeFileObject(typeName, fileObject);
+closeFileObject(mod, typeName, fileObject);
 out.close();
 }
 }
 }
 JavaFileManager fileManager;
 Log log;
+Modules modules;
+Names names;
+Symtab syms;
 Context context;
 boolean lastRound;
 private final boolean lint;
 /**
 * 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;
+private final Map<ModuleSymbol, Map<String, JavaFileObject>> generatedClasses;
 /**
 * JavaFileObjects for source files closed in this round.  This
 * set must be synchronized.  Its iterators should preserve
 * insertion order.
 /**
 * Names of all created source files.  Its iterators should
 * preserve insertion order.
 */
-private final Set<String> aggregateGeneratedSourceNames;
+private final Set<Pair<ModuleSymbol, String>> aggregateGeneratedSourceNames;
 /**
 * Names of all created class files.  Its iterators should
 * preserve insertion order.
 */
-private final Set<String> aggregateGeneratedClassNames;
+private final Set<Pair<ModuleSymbol, String>> aggregateGeneratedClassNames;
 JavacFiler(Context context) {
 this.context = context;
 fileManager = context.get(JavaFileManager.class);
 log = Log.instance(context);
+modules = Modules.instance(context);
+names = Names.instance(context);
+syms = Symtab.instance(context);
 fileObjectHistory = synchronizedSet(new LinkedHashSet<FileObject>());
 generatedSourceNames = synchronizedSet(new LinkedHashSet<String>());
 generatedSourceFileObjects = synchronizedSet(new LinkedHashSet<JavaFileObject>());
-generatedClasses = synchronizedMap(new LinkedHashMap<String, JavaFileObject>());
+generatedClasses = synchronizedMap(new LinkedHashMap<>());
 openTypeNames  = synchronizedSet(new LinkedHashSet<String>());
 aggregateGeneratedSourceNames = new LinkedHashSet<>();
 aggregateGeneratedClassNames  = new LinkedHashSet<>();
 lint = (Lint.instance(context)).isEnabled(PROCESSING);
 }
-@DefinedBy(Api.ANNOTATION_PROCESSING)
+@Override @DefinedBy(Api.ANNOTATION_PROCESSING)
-public JavaFileObject createSourceFile(CharSequence name,
+public JavaFileObject createSourceFile(CharSequence nameAndModule,
 Element... originatingElements) throws IOException {
-return createSourceOrClassFile(true, name.toString());
+Pair<ModuleSymbol, String> moduleAndClass = checkOrInferModule(nameAndModule);
-}
+return createSourceOrClassFile(moduleAndClass.fst, true, moduleAndClass.snd);
+}
-@DefinedBy(Api.ANNOTATION_PROCESSING)
-public JavaFileObject createClassFile(CharSequence name,
+@Override @DefinedBy(Api.ANNOTATION_PROCESSING)
-Element... originatingElements) throws IOException {
+public JavaFileObject createClassFile(CharSequence nameAndModule,
-return createSourceOrClassFile(false, name.toString());
+Element... originatingElements) throws IOException {
-}
+Pair<ModuleSymbol, String> moduleAndClass = checkOrInferModule(nameAndModule);
+return createSourceOrClassFile(moduleAndClass.fst, false, moduleAndClass.snd);
-private JavaFileObject createSourceOrClassFile(boolean isSourceFile, String name) throws IOException {
+}
+private Pair<ModuleSymbol, String> checkOrInferModule(CharSequence moduleAndPkg) throws FilerException {
+String moduleAndPkgString = moduleAndPkg.toString();
+int slash = moduleAndPkgString.indexOf('/');
+if (slash != (-1)) {
+//module name specified:
+String module = moduleAndPkgString.substring(0, slash);
+ModuleSymbol explicitModule = syms.getModule(names.fromString(module));
+if (explicitModule == null) {
+throw new FilerException("Module: " + module + " does not exist.");
+}
+if (!modules.isRootModule(explicitModule)) {
+throw new FilerException("Cannot write to the given module!");
+}
+return Pair.of(explicitModule, moduleAndPkgString.substring(slash + 1));
+} else {
+if (modules.multiModuleMode) {
+throw new FilerException("No module to write to specified!");
+}
+return Pair.of(modules.getDefaultModule(), moduleAndPkgString);
+}
+}
+private JavaFileObject createSourceOrClassFile(ModuleSymbol mod, boolean isSourceFile, String name) throws IOException {
+Assert.checkNonNull(mod);
 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);
+checkNameAndExistence(mod, name, isSourceFile);
 Location loc = (isSourceFile ? SOURCE_OUTPUT : CLASS_OUTPUT);
+if (modules.multiModuleMode) {
+loc = this.fileManager.getLocationForModule(loc, mod.name.toString());
+}
 JavaFileObject.Kind kind = (isSourceFile ?
 JavaFileObject.Kind.SOURCE :
 JavaFileObject.Kind.CLASS);
 JavaFileObject fileObject =
 if (lastRound)
 log.warning("proc.file.create.last.round", name);
 if (isSourceFile)
-aggregateGeneratedSourceNames.add(name);
+aggregateGeneratedSourceNames.add(Pair.of(mod, name));
 else
-aggregateGeneratedClassNames.add(name);
+aggregateGeneratedClassNames.add(Pair.of(mod, name));
 openTypeNames.add(name);
-return new FilerOutputJavaFileObject(name, fileObject);
+return new FilerOutputJavaFileObject(mod, name, fileObject);
 }
-@DefinedBy(Api.ANNOTATION_PROCESSING)
+@Override @DefinedBy(Api.ANNOTATION_PROCESSING)
 public FileObject createResource(JavaFileManager.Location location,
-CharSequence pkg,
+CharSequence moduleAndPkg,
 CharSequence relativeName,
 Element... originatingElements) throws IOException {
+Pair<ModuleSymbol, String> moduleAndPackage = checkOrInferModule(moduleAndPkg);
+ModuleSymbol msym = moduleAndPackage.fst;
+String pkg = moduleAndPackage.snd;
 locationCheck(location);
+if (modules.multiModuleMode) {
+Assert.checkNonNull(msym);
+location = this.fileManager.getLocationForModule(location, msym.name.toString());
+}
 String strPkg = pkg.toString();
 if (strPkg.length() > 0)
 checkName(strPkg);
 fileManager.getFileForOutput(location, strPkg,
 relativeName.toString(), null);
 checkFileReopening(fileObject, true);
 if (fileObject instanceof JavaFileObject)
-return new FilerOutputJavaFileObject(null, (JavaFileObject)fileObject);
+return new FilerOutputJavaFileObject(msym, null, (JavaFileObject)fileObject);
 else
-return new FilerOutputFileObject(null, fileObject);
+return new FilerOutputFileObject(msym, null, fileObject);
 }
 private void locationCheck(JavaFileManager.Location location) {
 if (location instanceof StandardLocation) {
 StandardLocation stdLoc = (StandardLocation) location;
 throw new IllegalArgumentException("Resource creation not supported in location " +
 stdLoc);
 }
 }
-@DefinedBy(Api.ANNOTATION_PROCESSING)
+@Override @DefinedBy(Api.ANNOTATION_PROCESSING)
 public FileObject getResource(JavaFileManager.Location location,
-CharSequence pkg,
+CharSequence moduleAndPkg,
 CharSequence relativeName) throws IOException {
-String strPkg = pkg.toString();
+Pair<ModuleSymbol, String> moduleAndPackage = checkOrInferModule(moduleAndPkg);
-if (strPkg.length() > 0)
+ModuleSymbol msym = moduleAndPackage.fst;
-checkName(strPkg);
+String pkg = moduleAndPackage.snd;
+if (modules.multiModuleMode) {
+Assert.checkNonNull(msym);
+location = this.fileManager.getLocationForModule(location, msym.name.toString());
+}
+if (pkg.length() > 0)
+checkName(pkg);
 // TODO: Only support reading resources in selected output
 // locations?  Only allow reading of non-source, non-class
 // files from the supported input locations?
 // with more than one component. So, for now, we use a hybrid
 // invocation.
 FileObject fileObject;
 if (location.isOutputLocation()) {
 fileObject = fileManager.getFileForOutput(location,
-pkg.toString(),
+pkg,
 relativeName.toString(),
 null);
 } else {
 fileObject = fileManager.getFileForInput(location,
-pkg.toString(),
+pkg,
 relativeName.toString());
 }
 if (fileObject == null) {
 String name = (pkg.length() == 0)
 ? relativeName.toString() : (pkg + "/" + relativeName);
 String simple = name.substring(periodIndex+1);
 return SourceVersion.isName(prefix) && simple.equals(PKG_INFO);
 }
 }
-private void checkNameAndExistence(String typename, boolean allowUnnamedPackageInfo) throws FilerException {
+private void checkNameAndExistence(ModuleSymbol mod, 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) ||
+if (aggregateGeneratedSourceNames.contains(Pair.of(mod, typename)) ||
-aggregateGeneratedClassNames.contains(typename)) {
+aggregateGeneratedClassNames.contains(Pair.of(mod, typename))) {
 if (lint)
 log.warning("proc.type.recreate", typename);
 throw new FilerException("Attempt to recreate a file for type " + typename);
+}
+if (!mod.isUnnamed() && !typename.contains(".")) {
+throw new FilerException("Attempt to create a type in unnamed package of a named module: " + typename);
 }
 }
 /**
 * Check to see if the file has already been opened; if so, throw
 public Set<JavaFileObject> getGeneratedSourceFileObjects() {
 return generatedSourceFileObjects;
 }
-public Map<String, JavaFileObject> getGeneratedClasses() {
+public Map<ModuleSymbol, Map<String, JavaFileObject>> getGeneratedClasses() {
 return generatedClasses;
 }
 public void warnIfUnclosedFiles() {
 if (!openTypeNames.isEmpty())
 /**
 * Upon close, register files opened by create{Source, Class}File
 * for annotation processing.
 */
-private void closeFileObject(String typeName, FileObject fileObject) {
+private void closeFileObject(ModuleSymbol mod, 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.
 generatedSourceFileObjects.add(javaFileObject);
 openTypeNames.remove(typeName);
 break;
 case CLASS:
-generatedClasses.put(typeName, javaFileObject);
+generatedClasses.computeIfAbsent(mod, m -> Collections.synchronizedMap(new LinkedHashMap<>())).put(typeName, javaFileObject);
 openTypeNames.remove(typeName);
 break;
 default:
 break;

changeset 42815	050370edaade
parent 40232	4995ab1a4558
child 43368	cabe410a7a5c