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

equal deleted inserted replaced

-:4caf88912b7f
+:3b41f1c69604
 package com.sun.tools.javac.processing;
 import java.io.Closeable;
 import java.io.File;
+import java.io.IOException;
 import java.io.PrintWriter;
 import java.io.StringWriter;
+import java.lang.reflect.Method;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.nio.file.Path;
 import java.util.*;
 import java.util.regex.*;
 import javax.lang.model.SourceVersion;
 import javax.lang.model.element.*;
 import javax.lang.model.util.*;
 import javax.tools.JavaFileManager;
 import javax.tools.JavaFileObject;
+import javax.tools.JavaFileObject.Kind;
 import javax.tools.StandardJavaFileManager;
 import static javax.tools.StandardLocation.*;
 import com.sun.source.util.TaskEvent;
 import com.sun.tools.javac.api.MultiTaskListener;
 import com.sun.tools.javac.code.*;
+import com.sun.tools.javac.code.Scope.WriteableScope;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.code.Type.ClassType;
 import com.sun.tools.javac.code.Types;
 import com.sun.tools.javac.comp.AttrContext;
 import com.sun.tools.javac.comp.Check;
 import com.sun.tools.javac.comp.Enter;
 import com.sun.tools.javac.comp.Env;
+import com.sun.tools.javac.comp.Modules;
 import com.sun.tools.javac.file.JavacFileManager;
 import com.sun.tools.javac.main.JavaCompiler;
 import com.sun.tools.javac.model.JavacElements;
 import com.sun.tools.javac.model.JavacTypes;
 import com.sun.tools.javac.platform.PlatformDescription;
 import com.sun.tools.javac.platform.PlatformDescription.PluginInfo;
+import com.sun.tools.javac.resources.CompilerProperties.Errors;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.tree.JCTree.*;
 import com.sun.tools.javac.util.Abort;
 import com.sun.tools.javac.util.Assert;
 import com.sun.tools.javac.util.ClientCodeException;
 import com.sun.tools.javac.util.JCDiagnostic;
 import com.sun.tools.javac.util.JavacMessages;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.Log;
 import com.sun.tools.javac.util.MatchingUtils;
+import com.sun.tools.javac.util.ModuleHelper;
 import com.sun.tools.javac.util.Name;
 import com.sun.tools.javac.util.Names;
 import com.sun.tools.javac.util.Options;
-import com.sun.tools.javac.util.ServiceLoader;
 import static com.sun.tools.javac.code.Lint.LintCategory.PROCESSING;
 import static com.sun.tools.javac.code.Kinds.Kind.*;
 import static com.sun.tools.javac.main.Option.*;
 import static com.sun.tools.javac.comp.CompileStates.CompileState;
 private final JavacFiler filer;
 private final JavacMessager messager;
 private final JavacElements elementUtils;
 private final JavacTypes typeUtils;
+private final JavaCompiler compiler;
+private final Modules modules;
+private final ModuleHelper moduleHelper;
 private final Types types;
-private final JavaCompiler compiler;
 /**
 * Holds relevant state history of which processors have been
 * used.
 */
 * Source level of the compile.
 */
 Source source;
 private ClassLoader processorClassLoader;
-private SecurityException processorClassLoaderException;
+private ServiceLoader<Processor> serviceLoader;
+private SecurityException processorLoaderException;
+private final JavaFileManager fileManager;
 /**
 * JavacMessages object used for localization
 */
 private JavacMessages messages;
 private final Symtab symtab;
 private final Names names;
 private final Enter enter;
 private final Completer initialCompleter;
 private final Check chk;
+private final ModuleSymbol defaultModule;
 private final Context context;
 /** Get the JavacProcessingEnvironment instance for this context. */
 public static JavacProcessingEnvironment instance(Context context) {
 compiler.shouldStopPolicyIfNoError = CompileState.PROCESS;
 }
 fatalErrors = options.isSet("fatalEnterError");
 showResolveErrors = options.isSet("showResolveErrors");
 werror = options.isSet(WERROR);
+fileManager = context.get(JavaFileManager.class);
 platformAnnotations = initPlatformAnnotations();
 // Initialize services before any processors are initialized
 // in case processors use them.
 filer = new JavacFiler(context);
 messager = new JavacMessager(context, this);
 elementUtils = JavacElements.instance(context);
 typeUtils = JavacTypes.instance(context);
+modules = Modules.instance(context);
 types = Types.instance(context);
 processorOptions = initProcessorOptions();
 unmatchedProcessorOptions = initUnmatchedProcessorOptions();
 messages = JavacMessages.instance(context);
 taskListener = MultiTaskListener.instance(context);
 symtab = Symtab.instance(context);
 names = Names.instance(context);
 enter = Enter.instance(context);
 initialCompleter = ClassFinder.instance(context).getCompleter();
 chk = Check.instance(context);
-initProcessorClassLoader();
+moduleHelper = ModuleHelper.instance(context);
+initProcessorLoader();
+defaultModule = source.allowModules() && options.isUnset("noModules")
+? symtab.unnamedModule : symtab.noModule;
 }
 public void setProcessors(Iterable<? extends Processor> processors) {
 Assert.checkNull(discoveredProcs);
 initProcessorIterator(processors);
 platformAnnotations.add("java.lang.annotation.Retention");
 platformAnnotations.add("java.lang.annotation.Target");
 return Collections.unmodifiableSet(platformAnnotations);
 }
-private void initProcessorClassLoader() {
+private void initProcessorLoader() {
-JavaFileManager fileManager = context.get(JavaFileManager.class);
 try {
-// If processorpath is not explicitly set, use the classpath.
+if (fileManager.hasLocation(ANNOTATION_PROCESSOR_MODULE_PATH)) {
-processorClassLoader = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
+try {
-? fileManager.getClassLoader(ANNOTATION_PROCESSOR_PATH)
+serviceLoader = fileManager.getServiceLoader(ANNOTATION_PROCESSOR_MODULE_PATH, Processor.class);
-: fileManager.getClassLoader(CLASS_PATH);
+} catch (IOException e) {
+throw new Abort(e);
-if (processorClassLoader != null && processorClassLoader instanceof Closeable) {
+}
-compiler.closeables = compiler.closeables.prepend((Closeable) processorClassLoader);
+} else {
+// If processorpath is not explicitly set, use the classpath.
+processorClassLoader = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
+? fileManager.getClassLoader(ANNOTATION_PROCESSOR_PATH)
+: fileManager.getClassLoader(CLASS_PATH);
+moduleHelper.addExports(processorClassLoader);
+if (processorClassLoader != null && processorClassLoader instanceof Closeable) {
+compiler.closeables = compiler.closeables.prepend((Closeable) processorClassLoader);
+}
 }
 } catch (SecurityException e) {
-processorClassLoaderException = e;
+processorLoaderException = e;
 }
 }
 private void initProcessorIterator(Iterable<? extends Processor> processors) {
 Iterator<? extends Processor> processorIterator;
 throw assertError;
 }
 } else if (processors != null) {
 processorIterator = processors.iterator();
 } else {
-String processorNames = options.get(PROCESSOR);
+if (processorLoaderException == null) {
-if (processorClassLoaderException == null) {
 /*
 * If the "-processor" option is used, search the appropriate
 * path for the named class.  Otherwise, use a service
 * provider mechanism to create the processor iterator.
 */
-if (processorNames != null) {
+String processorNames = options.get(PROCESSOR);
+if (fileManager.hasLocation(ANNOTATION_PROCESSOR_MODULE_PATH)) {
+processorIterator = (processorNames == null) ?
+new ServiceIterator(serviceLoader, log) :
+new NameServiceIterator(serviceLoader, log, processorNames);
+} else if (processorNames != null) {
 processorIterator = new NameProcessIterator(processorNames, processorClassLoader, log);
 } else {
 processorIterator = new ServiceIterator(processorClassLoader, log);
 }
 } else {
 * Ignore the exception if, with hindsight, we didn't need it anyway
 * (i.e. no processor was specified either explicitly, or implicitly,
 * in service configuration file.) Otherwise, we cannot continue.
 */
 processorIterator = handleServiceLoaderUnavailability("proc.cant.create.loader",
-processorClassLoaderException);
+processorLoaderException);
 }
 }
 PlatformDescription platformProvider = context.get(PlatformDescription.class);
 java.util.List<Processor> platformProcessors = Collections.emptyList();
 if (platformProvider != null) {
 List<Iterator<? extends Processor>> iterators = List.of(processorIterator,
 platformProcessors.iterator());
 Iterator<? extends Processor> compoundIterator =
 Iterators.createCompoundIterator(iterators, i -> i);
 discoveredProcs = new DiscoveredProcessors(compoundIterator);
+}
+public <S> ServiceLoader<S> getServiceLoader(Class<S> service) {
+if (fileManager.hasLocation(ANNOTATION_PROCESSOR_MODULE_PATH)) {
+try {
+return fileManager.getServiceLoader(ANNOTATION_PROCESSOR_MODULE_PATH, service);
+} catch (IOException e) {
+throw new Abort(e);
+}
+} else {
+return ServiceLoader.load(service, getProcessorClassLoader());
+}
 }
 /**
 * Returns an empty processor iterator if no processors are on the
 * relevant path, otherwise if processors are present, logs an
 *
 * @param key The resource key to use to log an error message
 * @param e   If non-null, pass this exception to Abort
 */
 private Iterator<Processor> handleServiceLoaderUnavailability(String key, Exception e) {
-JavaFileManager fileManager = context.get(JavaFileManager.class);
 if (fileManager instanceof JavacFileManager) {
 StandardJavaFileManager standardFileManager = (JavacFileManager) fileManager;
 Iterable<? extends Path> workingPath = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
 ? standardFileManager.getLocationAsPaths(ANNOTATION_PROCESSOR_PATH)
 : standardFileManager.getLocationAsPaths(CLASS_PATH);
 * Use a service loader appropriate for the platform to provide an
 * iterator over annotations processors; fails if a loader is
 * needed but unavailable.
 */
 private class ServiceIterator implements Iterator<Processor> {
-private Iterator<Processor> iterator;
+Iterator<Processor> iterator;
-private Log log;
+Log log;
-private ServiceLoader<Processor> loader;
+ServiceLoader<Processor> loader;
 ServiceIterator(ClassLoader classLoader, Log log) {
 this.log = log;
 try {
 try {
 log.error("proc.service.problem");
 throw new Abort(t);
 }
 }
+ServiceIterator(ServiceLoader<Processor> loader, Log log) {
+this.log = log;
+this.loader = loader;
+this.iterator = loader.iterator();
+}
+@Override
 public boolean hasNext() {
 try {
-return iterator.hasNext();
+return internalHasNext();
 } catch(ServiceConfigurationError sce) {
 log.error("proc.bad.config.file", sce.getLocalizedMessage());
 throw new Abort(sce);
 } catch (Throwable t) {
 throw new Abort(t);
 }
 }
+boolean internalHasNext() {
+return iterator.hasNext();
+}
+@Override
 public Processor next() {
 try {
-return iterator.next();
+return internalNext();
 } catch (ServiceConfigurationError sce) {
 log.error("proc.bad.config.file", sce.getLocalizedMessage());
 throw new Abort(sce);
 } catch (Throwable t) {
 throw new Abort(t);
 }
 }
+Processor internalNext() {
+return iterator.next();
+}
+@Override
 public void remove() {
 throw new UnsupportedOperationException();
 }
 public void close() {
 }
 }
 }
 }
+private class NameServiceIterator extends ServiceIterator {
+private Map<String, Processor> namedProcessorsMap = new HashMap<>();;
+private Iterator<String> processorNames = null;
+private Processor nextProc = null;
+public NameServiceIterator(ServiceLoader<Processor> loader, Log log, String theNames) {
+super(loader, log);
+this.processorNames = Arrays.asList(theNames.split(",")).iterator();
+}
+@Override
+boolean internalHasNext() {
+if (nextProc != null) {
+return true;
+}
+if (!processorNames.hasNext()) {
+namedProcessorsMap = null;
+return false;
+}
+String processorName = processorNames.next();
+Processor theProcessor = namedProcessorsMap.get(processorName);
+if (theProcessor != null) {
+namedProcessorsMap.remove(processorName);
+nextProc = theProcessor;
+return true;
+} else {
+while (iterator.hasNext()) {
+theProcessor = iterator.next();
+String name = theProcessor.getClass().getName();
+if (name.equals(processorName)) {
+nextProc = theProcessor;
+return true;
+} else {
+namedProcessorsMap.put(name, theProcessor);
+}
+}
+log.error(Errors.ProcProcessorNotFound(processorName));
+return false;
+}
+}
+@Override
+Processor internalNext() {
+if (hasNext()) {
+Processor p = nextProc;
+nextProc = null;
+return p;
+} else {
+throw new NoSuchElementException();
+}
+}
+}
 private static class NameProcessIterator implements Iterator<Processor> {
 Processor nextProc = null;
 Iterator<String> names;
 ClassLoader processorCL;
 String processorName = names.next();
 Processor processor;
 try {
 try {
+Class<?> processorClass = processorCL.loadClass(processorName);
+ensureReadable(processorClass);
 processor =
-(Processor) (processorCL.loadClass(processorName).newInstance());
+(Processor) (processorClass.newInstance());
 } catch (ClassNotFoundException cnfe) {
 log.error("proc.processor.not.found", processorName);
 return false;
 } catch (ClassCastException cce) {
 log.error("proc.processor.wrong.type", processorName);
 }
 public void remove () {
 throw new UnsupportedOperationException();
 }
+/**
+* Ensures that the module of the given class is readable to this
+* module.
+*/
+private void ensureReadable(Class<?> targetClass) {
+try {
+Method getModuleMethod = Class.class.getMethod("getModule");
+Object thisModule = getModuleMethod.invoke(this.getClass());
+Object targetModule = getModuleMethod.invoke(targetClass);
+Class<?> moduleClass = getModuleMethod.getReturnType();
+Method addReadsMethod = moduleClass.getMethod("addReads", moduleClass);
+addReadsMethod.invoke(thisModule, targetModule);
+} catch (NoSuchMethodException e) {
+// ignore
+} catch (Exception e) {
+throw new InternalError(e);
+}
+}
 }
 public boolean atLeastOneProcessor() {
 return discoveredProcs.iterator().hasNext();
 }
 }
 // TODO: These two classes can probably be rewritten better...
 /**
 * This class holds information about the processors that have
-* been discoverd so far as well as the means to discover more, if
+* been discovered so far as well as the means to discover more, if
 * necessary.  A single iterator should be used per round of
 * annotation processing.  The iterator first visits already
 * discovered processors then fails over to the service provider
 * mechanism if additional queries are made.
 */
 Name name = names.fromString(entry.getKey());
 JavaFileObject file = entry.getValue();
 if (file.getKind() != JavaFileObject.Kind.CLASS)
 throw new AssertionError(file);
 ClassSymbol cs;
+// TODO: for now, we assume that generated code is in a default module;
+// in time, we need a way to be able to specify the module for generated code
 if (isPkgInfo(file, JavaFileObject.Kind.CLASS)) {
 Name packageName = Convert.packagePart(name);
-PackageSymbol p = symtab.enterPackage(packageName);
+PackageSymbol p = symtab.enterPackage(defaultModule, packageName);
 if (p.package_info == null)
-p.package_info = symtab.enterClass(Convert.shortName(name), p);
+p.package_info = symtab.enterClass(defaultModule, Convert.shortName(name), p);
 cs = p.package_info;
 cs.reset();
 if (cs.classfile == null)
 cs.classfile = file;
 cs.completer = initialCompleter;
 } else {
-cs = symtab.enterClass(name);
+cs = symtab.enterClass(defaultModule, name);
 cs.reset();
 cs.classfile = file;
 cs.completer = initialCompleter;
+cs.owner.members().enter(cs); //XXX - OverwriteBetweenCompilations; syms.getClass is not sufficient anymore
 }
 list = list.prepend(cs);
 }
 return list.reverse();
 }
 /** Enter a set of syntax trees. */
 private void enterTrees(List<JCCompilationUnit> roots) {
-compiler.enterTrees(roots);
+compiler.enterTrees(compiler.initModules(roots));
 }
 /** Run a processing round. */
 void run(boolean lastRound, boolean errorStatus) {
 printRoundInfo(lastRound);
 chk.newRound();
 enter.newRound();
 filer.newRound();
 messager.newRound();
 compiler.newRound();
+modules.newRound();
 types.newRound();
 boolean foundError = false;
-for (ClassSymbol cs : symtab.classes.values()) {
+for (ClassSymbol cs : symtab.getAllClasses()) {
 if (cs.kind == ERR) {
 foundError = true;
 break;
 }
 }
 if (foundError) {
-for (ClassSymbol cs : symtab.classes.values()) {
+for (ClassSymbol cs : symtab.getAllClasses()) {
 if (cs.classfile != null || cs.kind == ERR) {
 cs.reset();
 cs.type = new ClassType(cs.type.getEnclosingType(), null, cs);
 if (cs.isCompleted()) {
 cs.completer = initialCompleter;
 if (node.packge.package_info != null) {
 node.packge.package_info.reset();
 }
 node.packge.reset();
 }
+boolean isModuleInfo = node.sourcefile.isNameCompatible("module-info", Kind.SOURCE);
+if (isModuleInfo) {
+node.modle.reset();
+node.modle.completer = sym -> modules.enter(List.of(node), node.modle.module_info);
+node.modle.module_info.reset();
+node.modle.module_info.members_field = WriteableScope.create(node.modle.module_info);
+}
 node.packge = null;
 topLevel = node;
 try {
 super.visitTopLevel(node);
 } finally {

changeset 36526	3b41f1c69604
parent 36492	12abe038f3d9
child 37759	f0b5daef41b6