duke@1: /*
xdono@323: * Copyright 2005-2009 Sun Microsystems, Inc. All Rights Reserved.
duke@1: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@1: *
duke@1: * This code is free software; you can redistribute it and/or modify it
duke@1: * under the terms of the GNU General Public License version 2 only, as
duke@1: * published by the Free Software Foundation. Sun designates this
duke@1: * particular file as subject to the "Classpath" exception as provided
duke@1: * by Sun in the LICENSE file that accompanied this code.
duke@1: *
duke@1: * This code is distributed in the hope that it will be useful, but WITHOUT
duke@1: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@1: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@1: * version 2 for more details (a copy is included in the LICENSE file that
duke@1: * accompanied this code).
duke@1: *
duke@1: * You should have received a copy of the GNU General Public License version
duke@1: * 2 along with this work; if not, write to the Free Software Foundation,
duke@1: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@1: *
duke@1: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@1: * CA 95054 USA or visit www.sun.com if you need additional information or
duke@1: * have any questions.
duke@1: */
duke@1:
duke@1: package com.sun.tools.javac.processing;
duke@1:
jjg@50:
jjg@50: import java.lang.reflect.*;
jjg@50: import java.util.*;
jjg@50: import java.util.regex.*;
jjg@50:
jjg@50: import java.net.URL;
jjg@50: import java.io.Closeable;
jjg@50: import java.io.File;
jjg@50: import java.io.PrintWriter;
jjg@50: import java.io.IOException;
jjg@50: import java.net.MalformedURLException;
duke@1: import java.io.StringWriter;
duke@1:
duke@1: import javax.annotation.processing.*;
duke@1: import javax.lang.model.SourceVersion;
duke@1: import javax.lang.model.element.AnnotationMirror;
duke@1: import javax.lang.model.element.Element;
duke@1: import javax.lang.model.element.TypeElement;
duke@1: import javax.lang.model.element.PackageElement;
duke@1: import javax.lang.model.util.*;
duke@1: import javax.tools.JavaFileManager;
duke@1: import javax.tools.StandardJavaFileManager;
duke@1: import javax.tools.JavaFileObject;
duke@1: import javax.tools.DiagnosticListener;
jjg@50:
jjg@310: import com.sun.source.util.AbstractTypeProcessor;
jjg@50: import com.sun.source.util.TaskEvent;
jjg@50: import com.sun.source.util.TaskListener;
jjg@50: import com.sun.tools.javac.api.JavacTaskImpl;
jjg@50: import com.sun.tools.javac.code.*;
jjg@50: import com.sun.tools.javac.code.Symbol.*;
jjg@50: import com.sun.tools.javac.file.JavacFileManager;
jjg@50: import com.sun.tools.javac.jvm.*;
jjg@50: import com.sun.tools.javac.main.JavaCompiler;
jjg@310: import com.sun.tools.javac.main.JavaCompiler.CompileState;
jjg@50: import com.sun.tools.javac.model.JavacElements;
jjg@50: import com.sun.tools.javac.model.JavacTypes;
jjg@50: import com.sun.tools.javac.parser.*;
jjg@50: import com.sun.tools.javac.tree.*;
jjg@50: import com.sun.tools.javac.tree.JCTree.*;
jjg@50: import com.sun.tools.javac.util.Abort;
jjg@50: import com.sun.tools.javac.util.Context;
jjg@50: import com.sun.tools.javac.util.List;
jjg@50: import com.sun.tools.javac.util.ListBuffer;
jjg@50: import com.sun.tools.javac.util.Log;
mcimadamore@136: import com.sun.tools.javac.util.JavacMessages;
jjg@50: import com.sun.tools.javac.util.Name;
jjg@113: import com.sun.tools.javac.util.Names;
jjg@50: import com.sun.tools.javac.util.Options;
jjg@50:
duke@1: import static javax.tools.StandardLocation.*;
duke@1:
duke@1: /**
duke@1: * Objects of this class hold and manage the state needed to support
duke@1: * annotation processing.
duke@1: *
duke@1: *
This is NOT part of any API supported by Sun Microsystems.
duke@1: * If you write code that depends on this, you do so at your own risk.
duke@1: * This code and its internal interfaces are subject to change or
duke@1: * deletion without notice.
duke@1: */
duke@1: public class JavacProcessingEnvironment implements ProcessingEnvironment, Closeable {
duke@1: Options options;
duke@1:
duke@1: private final boolean printProcessorInfo;
duke@1: private final boolean printRounds;
duke@1: private final boolean verbose;
duke@1: private final boolean lint;
duke@1: private final boolean procOnly;
duke@1: private final boolean fatalErrors;
jjg@310: private boolean foundTypeProcessors;
duke@1:
duke@1: private final JavacFiler filer;
duke@1: private final JavacMessager messager;
duke@1: private final JavacElements elementUtils;
duke@1: private final JavacTypes typeUtils;
duke@1:
duke@1: /**
duke@1: * Holds relevant state history of which processors have been
duke@1: * used.
duke@1: */
duke@1: private DiscoveredProcessors discoveredProcs;
duke@1:
duke@1: /**
duke@1: * Map of processor-specific options.
duke@1: */
duke@1: private final Map processorOptions;
duke@1:
duke@1: /**
duke@1: */
duke@1: private final Set unmatchedProcessorOptions;
duke@1:
duke@1: /**
duke@1: * Annotations implicitly processed and claimed by javac.
duke@1: */
duke@1: private final Set platformAnnotations;
duke@1:
duke@1: /**
duke@1: * Set of packages given on command line.
duke@1: */
duke@1: private Set specifiedPackages = Collections.emptySet();
duke@1:
duke@1: /** The log to be used for error reporting.
duke@1: */
duke@1: Log log;
duke@1:
duke@1: /**
duke@1: * Source level of the compile.
duke@1: */
duke@1: Source source;
duke@1:
mcimadamore@136: /**
mcimadamore@136: * JavacMessages object used for localization
mcimadamore@136: */
mcimadamore@136: private JavacMessages messages;
mcimadamore@136:
duke@1: private Context context;
duke@1:
mcimadamore@136: public JavacProcessingEnvironment(Context context, Iterable extends Processor> processors) {
duke@1: options = Options.instance(context);
duke@1: this.context = context;
duke@1: log = Log.instance(context);
duke@1: source = Source.instance(context);
duke@1: printProcessorInfo = options.get("-XprintProcessorInfo") != null;
duke@1: printRounds = options.get("-XprintRounds") != null;
duke@1: verbose = options.get("-verbose") != null;
duke@1: lint = options.lint("processing");
duke@1: procOnly = options.get("-proc:only") != null ||
duke@1: options.get("-Xprint") != null;
duke@1: fatalErrors = options.get("fatalEnterError") != null;
duke@1: platformAnnotations = initPlatformAnnotations();
jjg@310: foundTypeProcessors = false;
duke@1:
duke@1: // Initialize services before any processors are initialzied
duke@1: // in case processors use them.
duke@1: filer = new JavacFiler(context);
duke@1: messager = new JavacMessager(context, this);
duke@1: elementUtils = new JavacElements(context);
duke@1: typeUtils = new JavacTypes(context);
duke@1: processorOptions = initProcessorOptions(context);
duke@1: unmatchedProcessorOptions = initUnmatchedProcessorOptions();
mcimadamore@136: messages = JavacMessages.instance(context);
duke@1: initProcessorIterator(context, processors);
duke@1: }
duke@1:
duke@1: private Set initPlatformAnnotations() {
duke@1: Set platformAnnotations = new HashSet();
duke@1: platformAnnotations.add("java.lang.Deprecated");
duke@1: platformAnnotations.add("java.lang.Override");
duke@1: platformAnnotations.add("java.lang.SuppressWarnings");
duke@1: platformAnnotations.add("java.lang.annotation.Documented");
duke@1: platformAnnotations.add("java.lang.annotation.Inherited");
duke@1: platformAnnotations.add("java.lang.annotation.Retention");
duke@1: platformAnnotations.add("java.lang.annotation.Target");
duke@1: return Collections.unmodifiableSet(platformAnnotations);
duke@1: }
duke@1:
duke@1: private void initProcessorIterator(Context context, Iterable extends Processor> processors) {
duke@1: Log log = Log.instance(context);
duke@1: Iterator extends Processor> processorIterator;
duke@1:
duke@1: if (options.get("-Xprint") != null) {
duke@1: try {
duke@1: Processor processor = PrintingProcessor.class.newInstance();
duke@1: processorIterator = List.of(processor).iterator();
duke@1: } catch (Throwable t) {
duke@1: AssertionError assertError =
duke@1: new AssertionError("Problem instantiating PrintingProcessor.");
duke@1: assertError.initCause(t);
duke@1: throw assertError;
duke@1: }
duke@1: } else if (processors != null) {
duke@1: processorIterator = processors.iterator();
duke@1: } else {
duke@1: String processorNames = options.get("-processor");
duke@1: JavaFileManager fileManager = context.get(JavaFileManager.class);
duke@1: try {
duke@1: // If processorpath is not explicitly set, use the classpath.
duke@1: ClassLoader processorCL = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
duke@1: ? fileManager.getClassLoader(ANNOTATION_PROCESSOR_PATH)
duke@1: : fileManager.getClassLoader(CLASS_PATH);
duke@1:
duke@1: /*
duke@1: * If the "-processor" option is used, search the appropriate
duke@1: * path for the named class. Otherwise, use a service
duke@1: * provider mechanism to create the processor iterator.
duke@1: */
duke@1: if (processorNames != null) {
duke@1: processorIterator = new NameProcessIterator(processorNames, processorCL, log);
duke@1: } else {
duke@1: processorIterator = new ServiceIterator(processorCL, log);
duke@1: }
duke@1: } catch (SecurityException e) {
duke@1: /*
duke@1: * A security exception will occur if we can't create a classloader.
duke@1: * Ignore the exception if, with hindsight, we didn't need it anyway
duke@1: * (i.e. no processor was specified either explicitly, or implicitly,
duke@1: * in service configuration file.) Otherwise, we cannot continue.
duke@1: */
duke@1: processorIterator = handleServiceLoaderUnavailability("proc.cant.create.loader", e);
duke@1: }
duke@1: }
duke@1: discoveredProcs = new DiscoveredProcessors(processorIterator);
duke@1: }
duke@1:
duke@1: /**
duke@1: * Returns an empty processor iterator if no processors are on the
duke@1: * relevant path, otherwise if processors are present, logs an
duke@1: * error. Called when a service loader is unavailable for some
duke@1: * reason, either because a service loader class cannot be found
duke@1: * or because a security policy prevents class loaders from being
duke@1: * created.
duke@1: *
duke@1: * @param key The resource key to use to log an error message
duke@1: * @param e If non-null, pass this exception to Abort
duke@1: */
duke@1: private Iterator handleServiceLoaderUnavailability(String key, Exception e) {
duke@1: JavaFileManager fileManager = context.get(JavaFileManager.class);
duke@1:
duke@1: if (fileManager instanceof JavacFileManager) {
duke@1: StandardJavaFileManager standardFileManager = (JavacFileManager) fileManager;
duke@1: Iterable extends File> workingPath = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
duke@1: ? standardFileManager.getLocation(ANNOTATION_PROCESSOR_PATH)
duke@1: : standardFileManager.getLocation(CLASS_PATH);
duke@1:
duke@1: if (needClassLoader(options.get("-processor"), workingPath) )
duke@1: handleException(key, e);
duke@1:
duke@1: } else {
duke@1: handleException(key, e);
duke@1: }
duke@1:
duke@1: java.util.List pl = Collections.emptyList();
duke@1: return pl.iterator();
duke@1: }
duke@1:
duke@1: /**
duke@1: * Handle a security exception thrown during initializing the
duke@1: * Processor iterator.
duke@1: */
duke@1: private void handleException(String key, Exception e) {
duke@1: if (e != null) {
duke@1: log.error(key, e.getLocalizedMessage());
duke@1: throw new Abort(e);
duke@1: } else {
duke@1: log.error(key);
duke@1: throw new Abort();
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * Use a service loader appropriate for the platform to provide an
duke@1: * iterator over annotations processors. If
duke@1: * java.util.ServiceLoader is present use it, otherwise, use
duke@1: * sun.misc.Service, otherwise fail if a loader is needed.
duke@1: */
duke@1: private class ServiceIterator implements Iterator {
duke@1: // The to-be-wrapped iterator.
duke@1: private Iterator> iterator;
duke@1: private Log log;
duke@1:
duke@1: ServiceIterator(ClassLoader classLoader, Log log) {
duke@1: Class> loaderClass;
duke@1: String loadMethodName;
duke@1: boolean jusl;
duke@1:
duke@1: this.log = log;
duke@1: try {
duke@1: try {
duke@1: loaderClass = Class.forName("java.util.ServiceLoader");
duke@1: loadMethodName = "load";
duke@1: jusl = true;
duke@1: } catch (ClassNotFoundException cnfe) {
duke@1: try {
duke@1: loaderClass = Class.forName("sun.misc.Service");
duke@1: loadMethodName = "providers";
duke@1: jusl = false;
duke@1: } catch (ClassNotFoundException cnfe2) {
duke@1: // Fail softly if a loader is not actually needed.
duke@1: this.iterator = handleServiceLoaderUnavailability("proc.no.service",
duke@1: null);
duke@1: return;
duke@1: }
duke@1: }
duke@1:
duke@1: // java.util.ServiceLoader.load or sun.misc.Service.providers
duke@1: Method loadMethod = loaderClass.getMethod(loadMethodName,
duke@1: Class.class,
duke@1: ClassLoader.class);
duke@1:
duke@1: Object result = loadMethod.invoke(null,
duke@1: Processor.class,
duke@1: classLoader);
duke@1:
duke@1: // For java.util.ServiceLoader, we have to call another
duke@1: // method to get the iterator.
duke@1: if (jusl) {
duke@1: Method m = loaderClass.getMethod("iterator");
duke@1: result = m.invoke(result); // serviceLoader.iterator();
duke@1: }
duke@1:
duke@1: // The result should now be an iterator.
duke@1: this.iterator = (Iterator>) result;
duke@1: } catch (Throwable t) {
duke@1: log.error("proc.service.problem");
duke@1: throw new Abort(t);
duke@1: }
duke@1: }
duke@1:
duke@1: public boolean hasNext() {
duke@1: try {
duke@1: return iterator.hasNext();
duke@1: } catch (Throwable t) {
duke@1: if ("ServiceConfigurationError".
duke@1: equals(t.getClass().getSimpleName())) {
duke@1: log.error("proc.bad.config.file", t.getLocalizedMessage());
duke@1: }
duke@1: throw new Abort(t);
duke@1: }
duke@1: }
duke@1:
duke@1: public Processor next() {
duke@1: try {
duke@1: return (Processor)(iterator.next());
duke@1: } catch (Throwable t) {
duke@1: if ("ServiceConfigurationError".
duke@1: equals(t.getClass().getSimpleName())) {
duke@1: log.error("proc.bad.config.file", t.getLocalizedMessage());
duke@1: } else {
duke@1: log.error("proc.processor.constructor.error", t.getLocalizedMessage());
duke@1: }
duke@1: throw new Abort(t);
duke@1: }
duke@1: }
duke@1:
duke@1: public void remove() {
duke@1: throw new UnsupportedOperationException();
duke@1: }
duke@1: }
duke@1:
duke@1:
duke@1: private static class NameProcessIterator implements Iterator {
duke@1: Processor nextProc = null;
duke@1: Iterator names;
duke@1: ClassLoader processorCL;
duke@1: Log log;
duke@1:
duke@1: NameProcessIterator(String names, ClassLoader processorCL, Log log) {
duke@1: this.names = Arrays.asList(names.split(",")).iterator();
duke@1: this.processorCL = processorCL;
duke@1: this.log = log;
duke@1: }
duke@1:
duke@1: public boolean hasNext() {
duke@1: if (nextProc != null)
duke@1: return true;
duke@1: else {
duke@1: if (!names.hasNext())
duke@1: return false;
duke@1: else {
duke@1: String processorName = names.next();
duke@1:
duke@1: Processor processor;
duke@1: try {
duke@1: try {
duke@1: processor =
duke@1: (Processor) (processorCL.loadClass(processorName).newInstance());
duke@1: } catch (ClassNotFoundException cnfe) {
duke@1: log.error("proc.processor.not.found", processorName);
duke@1: return false;
duke@1: } catch (ClassCastException cce) {
duke@1: log.error("proc.processor.wrong.type", processorName);
duke@1: return false;
duke@1: } catch (Exception e ) {
duke@1: log.error("proc.processor.cant.instantiate", processorName);
duke@1: return false;
duke@1: }
duke@1: } catch(Throwable t) {
duke@1: throw new AnnotationProcessingError(t);
duke@1: }
duke@1: nextProc = processor;
duke@1: return true;
duke@1: }
duke@1:
duke@1: }
duke@1: }
duke@1:
duke@1: public Processor next() {
duke@1: if (hasNext()) {
duke@1: Processor p = nextProc;
duke@1: nextProc = null;
duke@1: return p;
duke@1: } else
duke@1: throw new NoSuchElementException();
duke@1: }
duke@1:
duke@1: public void remove () {
duke@1: throw new UnsupportedOperationException();
duke@1: }
duke@1: }
duke@1:
duke@1: public boolean atLeastOneProcessor() {
duke@1: return discoveredProcs.iterator().hasNext();
duke@1: }
duke@1:
duke@1: private Map initProcessorOptions(Context context) {
duke@1: Options options = Options.instance(context);
duke@1: Set keySet = options.keySet();
duke@1: Map tempOptions = new LinkedHashMap();
duke@1:
duke@1: for(String key : keySet) {
duke@1: if (key.startsWith("-A") && key.length() > 2) {
duke@1: int sepIndex = key.indexOf('=');
duke@1: String candidateKey = null;
duke@1: String candidateValue = null;
duke@1:
duke@1: if (sepIndex == -1)
duke@1: candidateKey = key.substring(2);
duke@1: else if (sepIndex >= 3) {
duke@1: candidateKey = key.substring(2, sepIndex);
duke@1: candidateValue = (sepIndex < key.length()-1)?
duke@1: key.substring(sepIndex+1) : null;
duke@1: }
duke@1: tempOptions.put(candidateKey, candidateValue);
duke@1: }
duke@1: }
duke@1:
duke@1: return Collections.unmodifiableMap(tempOptions);
duke@1: }
duke@1:
duke@1: private Set initUnmatchedProcessorOptions() {
duke@1: Set unmatchedProcessorOptions = new HashSet();
duke@1: unmatchedProcessorOptions.addAll(processorOptions.keySet());
duke@1: return unmatchedProcessorOptions;
duke@1: }
duke@1:
duke@1: /**
duke@1: * State about how a processor has been used by the tool. If a
duke@1: * processor has been used on a prior round, its process method is
duke@1: * called on all subsequent rounds, perhaps with an empty set of
duke@1: * annotations to process. The {@code annotatedSupported} method
duke@1: * caches the supported annotation information from the first (and
duke@1: * only) getSupportedAnnotationTypes call to the processor.
duke@1: */
duke@1: static class ProcessorState {
duke@1: public Processor processor;
duke@1: public boolean contributed;
duke@1: private ArrayList supportedAnnotationPatterns;
duke@1: private ArrayList supportedOptionNames;
duke@1:
duke@1: ProcessorState(Processor p, Log log, Source source, ProcessingEnvironment env) {
duke@1: processor = p;
duke@1: contributed = false;
duke@1:
duke@1: try {
duke@1: processor.init(env);
duke@1:
duke@1: checkSourceVersionCompatibility(source, log);
duke@1:
duke@1: supportedAnnotationPatterns = new ArrayList();
duke@1: for (String importString : processor.getSupportedAnnotationTypes()) {
duke@1: supportedAnnotationPatterns.add(importStringToPattern(importString,
duke@1: processor,
duke@1: log));
duke@1: }
duke@1:
duke@1: supportedOptionNames = new ArrayList();
duke@1: for (String optionName : processor.getSupportedOptions() ) {
duke@1: if (checkOptionName(optionName, log))
duke@1: supportedOptionNames.add(optionName);
duke@1: }
duke@1:
duke@1: } catch (Throwable t) {
duke@1: throw new AnnotationProcessingError(t);
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * Checks whether or not a processor's source version is
duke@1: * compatible with the compilation source version. The
duke@1: * processor's source version needs to be greater than or
duke@1: * equal to the source version of the compile.
duke@1: */
duke@1: private void checkSourceVersionCompatibility(Source source, Log log) {
duke@1: SourceVersion procSourceVersion = processor.getSupportedSourceVersion();
duke@1:
duke@1: if (procSourceVersion.compareTo(Source.toSourceVersion(source)) < 0 ) {
duke@1: log.warning("proc.processor.incompatible.source.version",
duke@1: procSourceVersion,
duke@1: processor.getClass().getName(),
duke@1: source.name);
duke@1: }
duke@1: }
duke@1:
duke@1: private boolean checkOptionName(String optionName, Log log) {
duke@1: boolean valid = isValidOptionName(optionName);
duke@1: if (!valid)
duke@1: log.error("proc.processor.bad.option.name",
duke@1: optionName,
duke@1: processor.getClass().getName());
duke@1: return valid;
duke@1: }
duke@1:
duke@1: public boolean annotationSupported(String annotationName) {
duke@1: for(Pattern p: supportedAnnotationPatterns) {
duke@1: if (p.matcher(annotationName).matches())
duke@1: return true;
duke@1: }
duke@1: return false;
duke@1: }
duke@1:
duke@1: /**
duke@1: * Remove options that are matched by this processor.
duke@1: */
duke@1: public void removeSupportedOptions(Set unmatchedProcessorOptions) {
duke@1: unmatchedProcessorOptions.removeAll(supportedOptionNames);
duke@1: }
duke@1: }
duke@1:
duke@1: // TODO: These two classes can probably be rewritten better...
duke@1: /**
duke@1: * This class holds information about the processors that have
duke@1: * been discoverd so far as well as the means to discover more, if
duke@1: * necessary. A single iterator should be used per round of
duke@1: * annotation processing. The iterator first visits already
duke@1: * discovered processors then fails over to the service provided
duke@1: * mechanism if additional queries are made.
duke@1: */
duke@1: class DiscoveredProcessors implements Iterable {
duke@1:
duke@1: class ProcessorStateIterator implements Iterator {
duke@1: DiscoveredProcessors psi;
duke@1: Iterator innerIter;
duke@1: boolean onProcInterator;
duke@1:
duke@1: ProcessorStateIterator(DiscoveredProcessors psi) {
duke@1: this.psi = psi;
duke@1: this.innerIter = psi.procStateList.iterator();
duke@1: this.onProcInterator = false;
duke@1: }
duke@1:
duke@1: public ProcessorState next() {
duke@1: if (!onProcInterator) {
duke@1: if (innerIter.hasNext())
duke@1: return innerIter.next();
duke@1: else
duke@1: onProcInterator = true;
duke@1: }
duke@1:
duke@1: if (psi.processorIterator.hasNext()) {
duke@1: ProcessorState ps = new ProcessorState(psi.processorIterator.next(),
duke@1: log, source, JavacProcessingEnvironment.this);
duke@1: psi.procStateList.add(ps);
duke@1: return ps;
duke@1: } else
duke@1: throw new NoSuchElementException();
duke@1: }
duke@1:
duke@1: public boolean hasNext() {
duke@1: if (onProcInterator)
duke@1: return psi.processorIterator.hasNext();
duke@1: else
duke@1: return innerIter.hasNext() || psi.processorIterator.hasNext();
duke@1: }
duke@1:
duke@1: public void remove () {
duke@1: throw new UnsupportedOperationException();
duke@1: }
duke@1:
duke@1: /**
duke@1: * Run all remaining processors on the procStateList that
duke@1: * have not already run this round with an empty set of
duke@1: * annotations.
duke@1: */
duke@1: public void runContributingProcs(RoundEnvironment re) {
duke@1: if (!onProcInterator) {
duke@1: Set emptyTypeElements = Collections.emptySet();
duke@1: while(innerIter.hasNext()) {
duke@1: ProcessorState ps = innerIter.next();
duke@1: if (ps.contributed)
duke@1: callProcessor(ps.processor, emptyTypeElements, re);
duke@1: }
duke@1: }
duke@1: }
duke@1: }
duke@1:
duke@1: Iterator extends Processor> processorIterator;
duke@1: ArrayList procStateList;
duke@1:
duke@1: public ProcessorStateIterator iterator() {
duke@1: return new ProcessorStateIterator(this);
duke@1: }
duke@1:
duke@1: DiscoveredProcessors(Iterator extends Processor> processorIterator) {
duke@1: this.processorIterator = processorIterator;
duke@1: this.procStateList = new ArrayList();
duke@1: }
duke@1: }
duke@1:
duke@1: private void discoverAndRunProcs(Context context,
duke@1: Set annotationsPresent,
duke@1: List topLevelClasses,
duke@1: List packageInfoFiles) {
duke@1: // Writer for -XprintRounds and -XprintProcessorInfo data
duke@1: PrintWriter xout = context.get(Log.outKey);
duke@1:
duke@1: Map unmatchedAnnotations =
duke@1: new HashMap(annotationsPresent.size());
duke@1:
duke@1: for(TypeElement a : annotationsPresent) {
duke@1: unmatchedAnnotations.put(a.getQualifiedName().toString(),
duke@1: a);
duke@1: }
duke@1:
duke@1: // Give "*" processors a chance to match
duke@1: if (unmatchedAnnotations.size() == 0)
duke@1: unmatchedAnnotations.put("", null);
duke@1:
duke@1: DiscoveredProcessors.ProcessorStateIterator psi = discoveredProcs.iterator();
duke@1: // TODO: Create proper argument values; need past round
duke@1: // information to fill in this constructor. Note that the 1
duke@1: // st round of processing could be the last round if there
duke@1: // were parse errors on the initial source files; however, we
duke@1: // are not doing processing in that case.
duke@1:
duke@1: Set rootElements = new LinkedHashSet();
duke@1: rootElements.addAll(topLevelClasses);
duke@1: rootElements.addAll(packageInfoFiles);
duke@1: rootElements = Collections.unmodifiableSet(rootElements);
duke@1:
duke@1: RoundEnvironment renv = new JavacRoundEnvironment(false,
duke@1: false,
duke@1: rootElements,
duke@1: JavacProcessingEnvironment.this);
duke@1:
duke@1: while(unmatchedAnnotations.size() > 0 && psi.hasNext() ) {
duke@1: ProcessorState ps = psi.next();
duke@1: Set matchedNames = new HashSet();
duke@1: Set typeElements = new LinkedHashSet();
duke@1: for (String unmatchedAnnotationName : unmatchedAnnotations.keySet()) {
duke@1: if (ps.annotationSupported(unmatchedAnnotationName) ) {
duke@1: matchedNames.add(unmatchedAnnotationName);
duke@1: TypeElement te = unmatchedAnnotations.get(unmatchedAnnotationName);
duke@1: if (te != null)
duke@1: typeElements.add(te);
duke@1: }
duke@1: }
duke@1:
duke@1: if (matchedNames.size() > 0 || ps.contributed) {
jjg@310: foundTypeProcessors = foundTypeProcessors || (ps.processor instanceof AbstractTypeProcessor);
duke@1: boolean processingResult = callProcessor(ps.processor, typeElements, renv);
duke@1: ps.contributed = true;
duke@1: ps.removeSupportedOptions(unmatchedProcessorOptions);
duke@1:
duke@1: if (printProcessorInfo || verbose) {
duke@1: xout.println(Log.getLocalizedString("x.print.processor.info",
duke@1: ps.processor.getClass().getName(),
duke@1: matchedNames.toString(),
duke@1: processingResult));
duke@1: }
duke@1:
duke@1: if (processingResult) {
duke@1: unmatchedAnnotations.keySet().removeAll(matchedNames);
duke@1: }
duke@1:
duke@1: }
duke@1: }
duke@1: unmatchedAnnotations.remove("");
duke@1:
duke@1: if (lint && unmatchedAnnotations.size() > 0) {
duke@1: // Remove annotations processed by javac
duke@1: unmatchedAnnotations.keySet().removeAll(platformAnnotations);
duke@1: if (unmatchedAnnotations.size() > 0) {
duke@1: log = Log.instance(context);
duke@1: log.warning("proc.annotations.without.processors",
duke@1: unmatchedAnnotations.keySet());
duke@1: }
duke@1: }
duke@1:
duke@1: // Run contributing processors that haven't run yet
duke@1: psi.runContributingProcs(renv);
duke@1:
duke@1: // Debugging
duke@1: if (options.get("displayFilerState") != null)
duke@1: filer.displayState();
duke@1: }
duke@1:
duke@1: /**
duke@1: * Computes the set of annotations on the symbol in question.
duke@1: * Leave class public for external testing purposes.
duke@1: */
duke@1: public static class ComputeAnnotationSet extends
duke@1: ElementScanner6, Set> {
duke@1: final Elements elements;
duke@1:
duke@1: public ComputeAnnotationSet(Elements elements) {
duke@1: super();
duke@1: this.elements = elements;
duke@1: }
duke@1:
duke@1: @Override
duke@1: public Set visitPackage(PackageElement e, Set p) {
duke@1: // Don't scan enclosed elements of a package
duke@1: return p;
duke@1: }
duke@1:
duke@1: @Override
duke@1: public Set scan(Element e, Set p) {
duke@1: for (AnnotationMirror annotationMirror :
duke@1: elements.getAllAnnotationMirrors(e) ) {
duke@1: Element e2 = annotationMirror.getAnnotationType().asElement();
duke@1: p.add((TypeElement) e2);
duke@1: }
duke@1: return super.scan(e, p);
duke@1: }
duke@1: }
duke@1:
duke@1: private boolean callProcessor(Processor proc,
duke@1: Set extends TypeElement> tes,
duke@1: RoundEnvironment renv) {
duke@1: try {
duke@1: return proc.process(tes, renv);
duke@1: } catch (CompletionFailure ex) {
duke@1: StringWriter out = new StringWriter();
duke@1: ex.printStackTrace(new PrintWriter(out));
jjg@12: log.error("proc.cant.access", ex.sym, ex.getDetailValue(), out.toString());
duke@1: return false;
duke@1: } catch (Throwable t) {
duke@1: throw new AnnotationProcessingError(t);
duke@1: }
duke@1: }
duke@1:
duke@1:
duke@1: // TODO: internal catch clauses?; catch and rethrow an annotation
duke@1: // processing error
duke@1: public JavaCompiler doProcessing(Context context,
duke@1: List roots,
duke@1: List classSymbols,
duke@1: Iterable extends PackageSymbol> pckSymbols)
duke@1: throws IOException {
duke@1:
duke@1: log = Log.instance(context);
duke@1: // Writer for -XprintRounds and -XprintProcessorInfo data
duke@1: PrintWriter xout = context.get(Log.outKey);
duke@1: TaskListener taskListener = context.get(TaskListener.class);
duke@1:
duke@1:
duke@1: AnnotationCollector collector = new AnnotationCollector();
duke@1:
duke@1: JavaCompiler compiler = JavaCompiler.instance(context);
duke@1: compiler.todo.clear(); // free the compiler's resources
duke@1:
duke@1: int round = 0;
duke@1:
duke@1: // List annotationsPresentInSource = collector.findAnnotations(roots);
duke@1: List topLevelClasses = getTopLevelClasses(roots);
duke@1:
duke@1: for (ClassSymbol classSym : classSymbols)
duke@1: topLevelClasses = topLevelClasses.prepend(classSym);
duke@1: List packageInfoFiles =
duke@1: getPackageInfoFiles(roots);
duke@1:
duke@1: Set specifiedPackages = new LinkedHashSet();
duke@1: for (PackageSymbol psym : pckSymbols)
duke@1: specifiedPackages.add(psym);
duke@1: this.specifiedPackages = Collections.unmodifiableSet(specifiedPackages);
duke@1:
duke@1: // Use annotation processing to compute the set of annotations present
duke@1: Set annotationsPresent = new LinkedHashSet();
duke@1: ComputeAnnotationSet annotationComputer = new ComputeAnnotationSet(elementUtils);
duke@1: for (ClassSymbol classSym : topLevelClasses)
duke@1: annotationComputer.scan(classSym, annotationsPresent);
duke@1: for (PackageSymbol pkgSym : packageInfoFiles)
duke@1: annotationComputer.scan(pkgSym, annotationsPresent);
duke@1:
duke@1: Context currentContext = context;
duke@1:
duke@1: int roundNumber = 0;
duke@1: boolean errorStatus = false;
duke@1:
duke@1: runAround:
duke@1: while(true) {
duke@1: if (fatalErrors && compiler.errorCount() != 0) {
duke@1: errorStatus = true;
duke@1: break runAround;
duke@1: }
duke@1:
duke@1: this.context = currentContext;
duke@1: roundNumber++;
duke@1: printRoundInfo(xout, roundNumber, topLevelClasses, annotationsPresent, false);
duke@1:
duke@1: if (taskListener != null)
duke@1: taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
duke@1:
duke@1: try {
duke@1: discoverAndRunProcs(currentContext, annotationsPresent, topLevelClasses, packageInfoFiles);
duke@1: } finally {
duke@1: if (taskListener != null)
duke@1: taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
duke@1: }
duke@1:
duke@1: /*
duke@1: * Processors for round n have run to completion. Prepare
duke@1: * for round (n+1) by checked for errors raised by
duke@1: * annotation processors and then checking for syntax
duke@1: * errors on any generated source files.
duke@1: */
duke@1: if (messager.errorRaised()) {
duke@1: errorStatus = true;
duke@1: break runAround;
duke@1: } else {
duke@1: if (moreToDo()) {
duke@1: // annotationsPresentInSource = List.nil();
duke@1: annotationsPresent = new LinkedHashSet();
duke@1: topLevelClasses = List.nil();
duke@1: packageInfoFiles = List.nil();
duke@1:
jjg@113: compiler.close(false);
duke@1: currentContext = contextForNextRound(currentContext, true);
duke@1:
duke@1: JavaFileManager fileManager = currentContext.get(JavaFileManager.class);
duke@1:
duke@1: List fileObjects = List.nil();
duke@1: for (JavaFileObject jfo : filer.getGeneratedSourceFileObjects() ) {
duke@1: fileObjects = fileObjects.prepend(jfo);
duke@1: }
duke@1:
duke@1:
duke@1: compiler = JavaCompiler.instance(currentContext);
duke@1: List parsedFiles = compiler.parseFiles(fileObjects);
duke@1: roots = cleanTrees(roots).reverse();
duke@1:
duke@1:
duke@1: for (JCCompilationUnit unit : parsedFiles)
duke@1: roots = roots.prepend(unit);
duke@1: roots = roots.reverse();
duke@1:
duke@1: // Check for errors after parsing
duke@1: if (compiler.parseErrors()) {
duke@1: errorStatus = true;
duke@1: break runAround;
duke@1: } else {
duke@1: ListBuffer classes = enterNewClassFiles(currentContext);
duke@1: compiler.enterTrees(roots);
duke@1:
duke@1: // annotationsPresentInSource =
duke@1: // collector.findAnnotations(parsedFiles);
duke@1: classes.appendList(getTopLevelClasses(parsedFiles));
duke@1: topLevelClasses = classes.toList();
duke@1: packageInfoFiles = getPackageInfoFiles(parsedFiles);
duke@1:
duke@1: annotationsPresent = new LinkedHashSet();
duke@1: for (ClassSymbol classSym : topLevelClasses)
duke@1: annotationComputer.scan(classSym, annotationsPresent);
duke@1: for (PackageSymbol pkgSym : packageInfoFiles)
duke@1: annotationComputer.scan(pkgSym, annotationsPresent);
duke@1:
duke@1: updateProcessingState(currentContext, false);
duke@1: }
duke@1: } else
duke@1: break runAround; // No new files
duke@1: }
duke@1: }
duke@1: runLastRound(xout, roundNumber, errorStatus, taskListener);
duke@1:
jjg@113: compiler.close(false);
duke@1: currentContext = contextForNextRound(currentContext, true);
duke@1: compiler = JavaCompiler.instance(currentContext);
duke@1: filer.newRound(currentContext, true);
duke@1: filer.warnIfUnclosedFiles();
duke@1: warnIfUnmatchedOptions();
duke@1:
duke@1: /*
duke@1: * If an annotation processor raises an error in a round,
duke@1: * that round runs to completion and one last round occurs.
duke@1: * The last round may also occur because no more source or
duke@1: * class files have been generated. Therefore, if an error
duke@1: * was raised on either of the last *two* rounds, the compile
duke@1: * should exit with a nonzero exit code. The current value of
duke@1: * errorStatus holds whether or not an error was raised on the
duke@1: * second to last round; errorRaised() gives the error status
duke@1: * of the last round.
duke@1: */
duke@1: errorStatus = errorStatus || messager.errorRaised();
duke@1:
duke@1:
duke@1: // Free resources
duke@1: this.close();
duke@1:
duke@1: if (taskListener != null)
duke@1: taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING));
duke@1:
duke@1: if (errorStatus) {
duke@1: compiler.log.nerrors += messager.errorCount();
duke@1: if (compiler.errorCount() == 0)
duke@1: compiler.log.nerrors++;
jjg@310: } else if (procOnly && !foundTypeProcessors) {
duke@1: compiler.todo.clear();
duke@1: } else { // Final compilation
jjg@113: compiler.close(false);
duke@1: currentContext = contextForNextRound(currentContext, true);
jjg@308: this.context = currentContext;
jjg@308: updateProcessingState(currentContext, true);
duke@1: compiler = JavaCompiler.instance(currentContext);
jjg@310: if (procOnly && foundTypeProcessors)
jjg@310: compiler.shouldStopPolicy = CompileState.FLOW;
duke@1:
duke@1: if (true) {
duke@1: compiler.enterTrees(cleanTrees(roots));
duke@1: } else {
duke@1: List fileObjects = List.nil();
duke@1: for (JCCompilationUnit unit : roots)
duke@1: fileObjects = fileObjects.prepend(unit.getSourceFile());
duke@1: roots = null;
duke@1: compiler.enterTrees(compiler.parseFiles(fileObjects.reverse()));
duke@1: }
duke@1: }
duke@1:
duke@1: return compiler;
duke@1: }
duke@1:
duke@1: // Call the last round of annotation processing
duke@1: private void runLastRound(PrintWriter xout,
duke@1: int roundNumber,
duke@1: boolean errorStatus,
duke@1: TaskListener taskListener) throws IOException {
duke@1: roundNumber++;
duke@1: List noTopLevelClasses = List.nil();
duke@1: Set noAnnotations = Collections.emptySet();
duke@1: printRoundInfo(xout, roundNumber, noTopLevelClasses, noAnnotations, true);
duke@1:
duke@1: Set emptyRootElements = Collections.emptySet(); // immutable
duke@1: RoundEnvironment renv = new JavacRoundEnvironment(true,
duke@1: errorStatus,
duke@1: emptyRootElements,
duke@1: JavacProcessingEnvironment.this);
duke@1: if (taskListener != null)
duke@1: taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
duke@1:
duke@1: try {
duke@1: discoveredProcs.iterator().runContributingProcs(renv);
duke@1: } finally {
duke@1: if (taskListener != null)
duke@1: taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
duke@1: }
duke@1: }
duke@1:
duke@1: private void updateProcessingState(Context currentContext, boolean lastRound) {
duke@1: filer.newRound(currentContext, lastRound);
duke@1: messager.newRound(currentContext);
duke@1:
duke@1: elementUtils.setContext(currentContext);
duke@1: typeUtils.setContext(currentContext);
duke@1: }
duke@1:
duke@1: private void warnIfUnmatchedOptions() {
duke@1: if (!unmatchedProcessorOptions.isEmpty()) {
duke@1: log.warning("proc.unmatched.processor.options", unmatchedProcessorOptions.toString());
duke@1: }
duke@1: }
duke@1:
duke@1: private void printRoundInfo(PrintWriter xout,
duke@1: int roundNumber,
duke@1: List topLevelClasses,
duke@1: Set annotationsPresent,
duke@1: boolean lastRound) {
duke@1: if (printRounds || verbose) {
duke@1: xout.println(Log.getLocalizedString("x.print.rounds",
duke@1: roundNumber,
duke@1: "{" + topLevelClasses.toString(", ") + "}",
duke@1: annotationsPresent,
duke@1: lastRound));
duke@1: }
duke@1: }
duke@1:
duke@1: private ListBuffer enterNewClassFiles(Context currentContext) {
duke@1: ClassReader reader = ClassReader.instance(currentContext);
jjg@113: Names names = Names.instance(currentContext);
duke@1: ListBuffer list = new ListBuffer();
duke@1:
duke@1: for (Map.Entry entry : filer.getGeneratedClasses().entrySet()) {
duke@1: Name name = names.fromString(entry.getKey());
duke@1: JavaFileObject file = entry.getValue();
duke@1: if (file.getKind() != JavaFileObject.Kind.CLASS)
duke@1: throw new AssertionError(file);
duke@1: ClassSymbol cs = reader.enterClass(name, file);
duke@1: list.append(cs);
duke@1: }
duke@1: return list;
duke@1: }
duke@1:
duke@1: /**
duke@1: * Free resources related to annotation processing.
duke@1: */
duke@1: public void close() {
duke@1: filer.close();
duke@1: discoveredProcs = null;
duke@1: }
duke@1:
duke@1: private List getTopLevelClasses(List extends JCCompilationUnit> units) {
duke@1: List classes = List.nil();
duke@1: for (JCCompilationUnit unit : units) {
duke@1: for (JCTree node : unit.defs) {
duke@1: if (node.getTag() == JCTree.CLASSDEF) {
duke@1: classes = classes.prepend(((JCClassDecl) node).sym);
duke@1: }
duke@1: }
duke@1: }
duke@1: return classes.reverse();
duke@1: }
duke@1:
duke@1: private List getPackageInfoFiles(List extends JCCompilationUnit> units) {
duke@1: List packages = List.nil();
duke@1: for (JCCompilationUnit unit : units) {
duke@1: boolean isPkgInfo = unit.sourcefile.isNameCompatible("package-info",
duke@1: JavaFileObject.Kind.SOURCE);
duke@1: if (isPkgInfo) {
duke@1: packages = packages.prepend(unit.packge);
duke@1: }
duke@1: }
duke@1: return packages.reverse();
duke@1: }
duke@1:
duke@1: private Context contextForNextRound(Context context, boolean shareNames)
duke@1: throws IOException
duke@1: {
duke@1: Context next = new Context();
duke@1:
duke@1: Options options = Options.instance(context);
duke@1: assert options != null;
duke@1: next.put(Options.optionsKey, options);
duke@1:
duke@1: PrintWriter out = context.get(Log.outKey);
duke@1: assert out != null;
duke@1: next.put(Log.outKey, out);
duke@1:
duke@1: if (shareNames) {
jjg@113: Names names = Names.instance(context);
duke@1: assert names != null;
jjg@113: next.put(Names.namesKey, names);
duke@1: }
duke@1:
mcimadamore@184: DiagnosticListener> dl = context.get(DiagnosticListener.class);
duke@1: if (dl != null)
duke@1: next.put(DiagnosticListener.class, dl);
duke@1:
duke@1: TaskListener tl = context.get(TaskListener.class);
duke@1: if (tl != null)
duke@1: next.put(TaskListener.class, tl);
duke@1:
duke@1: JavaFileManager jfm = context.get(JavaFileManager.class);
duke@1: assert jfm != null;
duke@1: next.put(JavaFileManager.class, jfm);
duke@1: if (jfm instanceof JavacFileManager) {
duke@1: ((JavacFileManager)jfm).setContext(next);
duke@1: }
duke@1:
jjg@113: Names names = Names.instance(context);
duke@1: assert names != null;
jjg@113: next.put(Names.namesKey, names);
duke@1:
duke@1: Keywords keywords = Keywords.instance(context);
duke@1: assert(keywords != null);
duke@1: next.put(Keywords.keywordsKey, keywords);
duke@1:
duke@1: JavaCompiler oldCompiler = JavaCompiler.instance(context);
duke@1: JavaCompiler nextCompiler = JavaCompiler.instance(next);
duke@1: nextCompiler.initRound(oldCompiler);
duke@1:
duke@1: JavacTaskImpl task = context.get(JavacTaskImpl.class);
duke@1: if (task != null) {
duke@1: next.put(JavacTaskImpl.class, task);
duke@1: task.updateContext(next);
duke@1: }
duke@1:
duke@1: context.clear();
duke@1: return next;
duke@1: }
duke@1:
duke@1: /*
duke@1: * Called retroactively to determine if a class loader was required,
duke@1: * after we have failed to create one.
duke@1: */
duke@1: private boolean needClassLoader(String procNames, Iterable extends File> workingpath) {
duke@1: if (procNames != null)
duke@1: return true;
duke@1:
duke@1: String procPath;
duke@1: URL[] urls = new URL[1];
duke@1: for(File pathElement : workingpath) {
duke@1: try {
duke@1: urls[0] = pathElement.toURI().toURL();
duke@1: if (ServiceProxy.hasService(Processor.class, urls))
duke@1: return true;
duke@1: } catch (MalformedURLException ex) {
duke@1: throw new AssertionError(ex);
duke@1: }
duke@1: catch (ServiceProxy.ServiceConfigurationError e) {
duke@1: log.error("proc.bad.config.file", e.getLocalizedMessage());
duke@1: return true;
duke@1: }
duke@1: }
duke@1:
duke@1: return false;
duke@1: }
duke@1:
duke@1: private class AnnotationCollector extends TreeScanner {
duke@1: List path = List.nil();
duke@1: static final boolean verbose = false;
duke@1: List annotations = List.nil();
duke@1:
duke@1: public List findAnnotations(List extends JCTree> nodes) {
duke@1: annotations = List.nil();
duke@1: scan(nodes);
duke@1: List found = annotations;
duke@1: annotations = List.nil();
duke@1: return found.reverse();
duke@1: }
duke@1:
duke@1: public void scan(JCTree node) {
duke@1: if (node == null)
duke@1: return;
duke@1: Symbol sym = TreeInfo.symbolFor(node);
duke@1: if (sym != null)
duke@1: path = path.prepend(node);
duke@1: super.scan(node);
duke@1: if (sym != null)
duke@1: path = path.tail;
duke@1: }
duke@1:
duke@1: public void visitAnnotation(JCAnnotation node) {
duke@1: annotations = annotations.prepend(node);
duke@1: if (verbose) {
duke@1: StringBuilder sb = new StringBuilder();
duke@1: for (JCTree tree : path.reverse()) {
duke@1: System.err.print(sb);
duke@1: System.err.println(TreeInfo.symbolFor(tree));
duke@1: sb.append(" ");
duke@1: }
duke@1: System.err.print(sb);
duke@1: System.err.println(node);
duke@1: }
duke@1: }
duke@1: }
duke@1:
duke@1: private static List cleanTrees(List nodes) {
duke@1: for (T node : nodes)
duke@1: treeCleaner.scan(node);
duke@1: return nodes;
duke@1: }
duke@1:
duke@1: private static TreeScanner treeCleaner = new TreeScanner() {
duke@1: public void scan(JCTree node) {
duke@1: super.scan(node);
duke@1: if (node != null)
duke@1: node.type = null;
duke@1: }
duke@1: public void visitTopLevel(JCCompilationUnit node) {
duke@1: node.packge = null;
duke@1: super.visitTopLevel(node);
duke@1: }
duke@1: public void visitClassDef(JCClassDecl node) {
duke@1: node.sym = null;
duke@1: super.visitClassDef(node);
duke@1: }
duke@1: public void visitMethodDef(JCMethodDecl node) {
duke@1: node.sym = null;
duke@1: super.visitMethodDef(node);
duke@1: }
duke@1: public void visitVarDef(JCVariableDecl node) {
duke@1: node.sym = null;
duke@1: super.visitVarDef(node);
duke@1: }
duke@1: public void visitNewClass(JCNewClass node) {
duke@1: node.constructor = null;
duke@1: super.visitNewClass(node);
duke@1: }
duke@1: public void visitAssignop(JCAssignOp node) {
duke@1: node.operator = null;
duke@1: super.visitAssignop(node);
duke@1: }
duke@1: public void visitUnary(JCUnary node) {
duke@1: node.operator = null;
duke@1: super.visitUnary(node);
duke@1: }
duke@1: public void visitBinary(JCBinary node) {
duke@1: node.operator = null;
duke@1: super.visitBinary(node);
duke@1: }
duke@1: public void visitSelect(JCFieldAccess node) {
duke@1: node.sym = null;
duke@1: super.visitSelect(node);
duke@1: }
duke@1: public void visitIdent(JCIdent node) {
duke@1: node.sym = null;
duke@1: super.visitIdent(node);
duke@1: }
jjg@308: public void visitApply(JCMethodInvocation node) {
jjg@308: scan(node.typeargs);
jjg@308: super.visitApply(node);
jjg@308: }
duke@1: };
duke@1:
duke@1:
duke@1: private boolean moreToDo() {
duke@1: return filer.newFiles();
duke@1: }
duke@1:
duke@1: /**
duke@1: * {@inheritdoc}
duke@1: *
duke@1: * Command line options suitable for presenting to annotation
duke@1: * processors. "-Afoo=bar" should be "-Afoo" => "bar".
duke@1: */
duke@1: public Map getOptions() {
duke@1: return processorOptions;
duke@1: }
duke@1:
duke@1: public Messager getMessager() {
duke@1: return messager;
duke@1: }
duke@1:
duke@1: public Filer getFiler() {
duke@1: return filer;
duke@1: }
duke@1:
duke@1: public JavacElements getElementUtils() {
duke@1: return elementUtils;
duke@1: }
duke@1:
duke@1: public JavacTypes getTypeUtils() {
duke@1: return typeUtils;
duke@1: }
duke@1:
duke@1: public SourceVersion getSourceVersion() {
duke@1: return Source.toSourceVersion(source);
duke@1: }
duke@1:
duke@1: public Locale getLocale() {
mcimadamore@136: return messages.getCurrentLocale();
duke@1: }
duke@1:
duke@1: public Set getSpecifiedPackages() {
duke@1: return specifiedPackages;
duke@1: }
duke@1:
duke@1: // Borrowed from DocletInvoker and apt
duke@1: // TODO: remove from apt's Main
duke@1: /**
duke@1: * Utility method for converting a search path string to an array
duke@1: * of directory and JAR file URLs.
duke@1: *
duke@1: * @param path the search path string
duke@1: * @return the resulting array of directory and JAR file URLs
duke@1: */
duke@1: public static URL[] pathToURLs(String path) {
duke@1: StringTokenizer st = new StringTokenizer(path, File.pathSeparator);
duke@1: URL[] urls = new URL[st.countTokens()];
duke@1: int count = 0;
duke@1: while (st.hasMoreTokens()) {
duke@1: URL url = fileToURL(new File(st.nextToken()));
duke@1: if (url != null) {
duke@1: urls[count++] = url;
duke@1: }
duke@1: }
duke@1: if (urls.length != count) {
duke@1: URL[] tmp = new URL[count];
duke@1: System.arraycopy(urls, 0, tmp, 0, count);
duke@1: urls = tmp;
duke@1: }
duke@1: return urls;
duke@1: }
duke@1:
duke@1: /**
duke@1: * Returns the directory or JAR file URL corresponding to the specified
duke@1: * local file name.
duke@1: *
duke@1: * @param file the File object
duke@1: * @return the resulting directory or JAR file URL, or null if unknown
duke@1: */
duke@1: private static URL fileToURL(File file) {
duke@1: String name;
duke@1: try {
duke@1: name = file.getCanonicalPath();
duke@1: } catch (IOException e) {
duke@1: name = file.getAbsolutePath();
duke@1: }
duke@1: name = name.replace(File.separatorChar, '/');
duke@1: if (!name.startsWith("/")) {
duke@1: name = "/" + name;
duke@1: }
duke@1: // If the file does not exist, then assume that it's a directory
duke@1: if (!file.isFile()) {
duke@1: name = name + "/";
duke@1: }
duke@1: try {
duke@1: return new URL("file", "", name);
duke@1: } catch (MalformedURLException e) {
duke@1: throw new IllegalArgumentException("file");
duke@1: }
duke@1: }
duke@1:
duke@1:
duke@1:
duke@1: private static final Pattern allMatches = Pattern.compile(".*");
duke@1:
duke@1: private static final Pattern noMatches = Pattern.compile("(\\P{all})+");
duke@1: /**
duke@1: * Convert import-style string to regex matching that string. If
duke@1: * the string is a valid import-style string, return a regex that
duke@1: * won't match anything.
duke@1: */
duke@1: // TODO: remove version in Apt.java
duke@1: public static Pattern importStringToPattern(String s, Processor p, Log log) {
duke@1: if (s.equals("*")) {
duke@1: return allMatches;
duke@1: } else {
duke@1: String t = s;
duke@1: boolean star = false;
duke@1:
duke@1: /*
duke@1: * Validate string from factory is legal. If the string
duke@1: * has more than one asterisks or the asterisks does not
duke@1: * appear as the last character (preceded by a period),
duke@1: * the string is not legal.
duke@1: */
duke@1:
duke@1: boolean valid = true;
duke@1: int index = t.indexOf('*');
duke@1: if (index != -1) {
duke@1: // '*' must be last character...
duke@1: if (index == t.length() -1) {
duke@1: // ... and preceeding character must be '.'
duke@1: if ( index-1 >= 0 ) {
duke@1: valid = t.charAt(index-1) == '.';
duke@1: // Strip off ".*$" for identifier checks
duke@1: t = t.substring(0, t.length()-2);
duke@1: }
duke@1: } else
duke@1: valid = false;
duke@1: }
duke@1:
duke@1: // Verify string is off the form (javaId \.)+ or javaId
duke@1: if (valid) {
duke@1: String[] javaIds = t.split("\\.", t.length()+2);
duke@1: for(String javaId: javaIds)
duke@1: valid &= SourceVersion.isIdentifier(javaId);
duke@1: }
duke@1:
duke@1: if (!valid) {
duke@1: log.warning("proc.malformed.supported.string", s, p.getClass().getName());
duke@1: return noMatches; // won't match any valid identifier
duke@1: }
duke@1:
duke@1: String s_prime = s.replaceAll("\\.", "\\\\.");
duke@1:
duke@1: if (s_prime.endsWith("*")) {
duke@1: s_prime = s_prime.substring(0, s_prime.length() - 1) + ".+";
duke@1: }
duke@1:
duke@1: return Pattern.compile(s_prime);
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * For internal use by Sun Microsystems only. This method will be
duke@1: * removed without warning.
duke@1: */
duke@1: public Context getContext() {
duke@1: return context;
duke@1: }
duke@1:
duke@1: public String toString() {
duke@1: return "javac ProcessingEnvironment";
duke@1: }
duke@1:
duke@1: public static boolean isValidOptionName(String optionName) {
duke@1: for(String s : optionName.split("\\.", -1)) {
duke@1: if (!SourceVersion.isIdentifier(s))
duke@1: return false;
duke@1: }
duke@1: return true;
duke@1: }
duke@1: }