1 /*
   2  * Copyright (c) 2005, 2025, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.tools.javac.processing;
  27 
  28 import java.io.Closeable;
  29 import java.io.IOException;
  30 import java.io.PrintWriter;
  31 import java.io.StringWriter;
  32 import java.lang.reflect.Method;
  33 import java.util.*;
  34 import java.util.Map.Entry;
  35 import java.util.function.Predicate;
  36 import java.util.regex.*;
  37 
  38 import javax.annotation.processing.*;
  39 import javax.lang.model.SourceVersion;
  40 import javax.lang.model.element.*;
  41 import javax.lang.model.util.*;
  42 import javax.tools.Diagnostic;
  43 import javax.tools.JavaFileManager;
  44 import javax.tools.JavaFileObject;
  45 import javax.tools.JavaFileObject.Kind;
  46 
  47 import static javax.tools.StandardLocation.*;
  48 
  49 import com.sun.source.util.TaskEvent;
  50 import com.sun.tools.javac.api.MultiTaskListener;
  51 import com.sun.tools.javac.code.*;
  52 import com.sun.tools.javac.code.DeferredCompletionFailureHandler.Handler;
  53 import com.sun.tools.javac.code.Scope.WriteableScope;
  54 import com.sun.tools.javac.code.Source.Feature;
  55 import com.sun.tools.javac.code.Symbol.*;
  56 import com.sun.tools.javac.code.Type.ClassType;
  57 import com.sun.tools.javac.code.Types;
  58 import com.sun.tools.javac.comp.AttrContext;
  59 import com.sun.tools.javac.comp.Check;
  60 import com.sun.tools.javac.comp.Enter;
  61 import com.sun.tools.javac.comp.Env;
  62 import com.sun.tools.javac.comp.Modules;
  63 import com.sun.tools.javac.main.JavaCompiler;
  64 import com.sun.tools.javac.main.Option;
  65 import com.sun.tools.javac.model.JavacElements;
  66 import com.sun.tools.javac.model.JavacTypes;
  67 import com.sun.tools.javac.platform.PlatformDescription;
  68 import com.sun.tools.javac.platform.PlatformDescription.PluginInfo;
  69 import com.sun.tools.javac.resources.CompilerProperties.Errors;
  70 import com.sun.tools.javac.resources.CompilerProperties.LintWarnings;
  71 import com.sun.tools.javac.resources.CompilerProperties.Warnings;
  72 import com.sun.tools.javac.tree.*;
  73 import com.sun.tools.javac.tree.JCTree.*;
  74 import com.sun.tools.javac.util.Abort;
  75 import com.sun.tools.javac.util.Assert;
  76 import com.sun.tools.javac.util.ClientCodeException;
  77 import com.sun.tools.javac.util.Context;
  78 import com.sun.tools.javac.util.Convert;
  79 import com.sun.tools.javac.util.DefinedBy;
  80 import com.sun.tools.javac.util.DefinedBy.Api;
  81 import com.sun.tools.javac.util.Iterators;
  82 import com.sun.tools.javac.util.JCDiagnostic;
  83 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag;
  84 import com.sun.tools.javac.util.JavacMessages;
  85 import com.sun.tools.javac.util.List;
  86 import com.sun.tools.javac.util.Log;
  87 import com.sun.tools.javac.util.MatchingUtils;
  88 import com.sun.tools.javac.util.ModuleHelper;
  89 import com.sun.tools.javac.util.Name;
  90 import com.sun.tools.javac.util.Names;
  91 import com.sun.tools.javac.util.Options;
  92 
  93 import static com.sun.tools.javac.code.Lint.LintCategory.PROCESSING;
  94 import static com.sun.tools.javac.code.Kinds.Kind.*;
  95 import com.sun.tools.javac.comp.Annotate;
  96 import static com.sun.tools.javac.comp.CompileStates.CompileState;
  97 import static com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag.*;
  98 
  99 /**
 100  * Objects of this class hold and manage the state needed to support
 101  * annotation processing.
 102  *
 103  * <p><b>This is NOT part of any supported API.
 104  * If you write code that depends on this, you do so at your own risk.
 105  * This code and its internal interfaces are subject to change or
 106  * deletion without notice.</b>
 107  */
 108 public class JavacProcessingEnvironment implements ProcessingEnvironment, Closeable {
 109     private final Options options;
 110 
 111     private final boolean printProcessorInfo;
 112     private final boolean printRounds;
 113     private final boolean verbose;
 114     private final boolean fatalErrors;
 115     private final boolean werror;
 116     private final boolean showResolveErrors;
 117 
 118     private final JavacFiler filer;
 119     private final JavacMessager messager;
 120     private final JavacElements elementUtils;
 121     private final JavacTypes typeUtils;
 122     private final JavaCompiler compiler;
 123     private final Modules modules;
 124     private final Types types;
 125     private final Annotate annotate;
 126 
 127     /**
 128      * Holds relevant state history of which processors have been
 129      * used.
 130      */
 131     private DiscoveredProcessors discoveredProcs;
 132 
 133     /**
 134      * Map of processor-specific options.
 135      */
 136     private final Map<String, String> processorOptions;
 137 
 138     /**
 139      */
 140     private final Set<String> unmatchedProcessorOptions;
 141 
 142     /**
 143      * Annotations implicitly processed and claimed by javac.
 144      */
 145     private final Set<String> platformAnnotations;
 146 
 147     /**
 148      * Set of packages given on command line.
 149      */
 150     private Set<PackageSymbol> specifiedPackages = Collections.emptySet();
 151 
 152     /** The log to be used for error reporting.
 153      */
 154     final Log log;
 155 
 156     /** Diagnostic factory.
 157      */
 158     JCDiagnostic.Factory diags;
 159 
 160     /**
 161      * Source level of the compile.
 162      */
 163     Source source;
 164 
 165     private ClassLoader processorClassLoader;
 166     private ServiceLoader<Processor> serviceLoader;
 167 
 168     private final JavaFileManager fileManager;
 169 
 170     /**
 171      * JavacMessages object used for localization
 172      */
 173     private JavacMessages messages;
 174 
 175     private MultiTaskListener taskListener;
 176     private final Symtab symtab;
 177     private final DeferredCompletionFailureHandler dcfh;
 178     private final Names names;
 179     private final Enter enter;
 180     private final Completer initialCompleter;
 181     private final Check chk;
 182 
 183     private final Context context;
 184 
 185     /**
 186      * Support for preview language features.
 187      */
 188     private final Preview preview;
 189 
 190     /** Get the JavacProcessingEnvironment instance for this context. */
 191     public static JavacProcessingEnvironment instance(Context context) {
 192         JavacProcessingEnvironment instance = context.get(JavacProcessingEnvironment.class);
 193         if (instance == null)
 194             instance = new JavacProcessingEnvironment(context);
 195         return instance;
 196     }
 197 
 198     protected JavacProcessingEnvironment(Context context) {
 199         this.context = context;
 200         context.put(JavacProcessingEnvironment.class, this);
 201         log = Log.instance(context);
 202         source = Source.instance(context);
 203         diags = JCDiagnostic.Factory.instance(context);
 204         options = Options.instance(context);
 205         printProcessorInfo = options.isSet(Option.XPRINTPROCESSORINFO);
 206         printRounds = options.isSet(Option.XPRINTROUNDS);
 207         verbose = options.isSet(Option.VERBOSE);
 208         compiler = JavaCompiler.instance(context);
 209         if (options.isSet(Option.PROC, "only") || options.isSet(Option.XPRINT)) {
 210             compiler.shouldStopPolicyIfNoError = CompileState.PROCESS;
 211         }
 212         fatalErrors = options.isSet("fatalEnterError");
 213         showResolveErrors = options.isSet("showResolveErrors");
 214         werror = options.isSet(Option.WERROR);
 215         fileManager = context.get(JavaFileManager.class);
 216         platformAnnotations = initPlatformAnnotations();
 217 
 218         // Initialize services before any processors are initialized
 219         // in case processors use them.
 220         filer = new JavacFiler(context);
 221         messager = new JavacMessager(context, this);
 222         elementUtils = JavacElements.instance(context);
 223         typeUtils = JavacTypes.instance(context);
 224         modules = Modules.instance(context);
 225         types = Types.instance(context);
 226         annotate = Annotate.instance(context);
 227         processorOptions = initProcessorOptions();
 228         unmatchedProcessorOptions = initUnmatchedProcessorOptions();
 229         messages = JavacMessages.instance(context);
 230         taskListener = MultiTaskListener.instance(context);
 231         symtab = Symtab.instance(context);
 232         dcfh = DeferredCompletionFailureHandler.instance(context);
 233         names = Names.instance(context);
 234         enter = Enter.instance(context);
 235         initialCompleter = ClassFinder.instance(context).getCompleter();
 236         chk = Check.instance(context);
 237         preview = Preview.instance(context);
 238         initProcessorLoader();
 239     }
 240 
 241     public void setProcessors(Iterable<? extends Processor> processors) {
 242         Assert.checkNull(discoveredProcs);
 243         initProcessorIterator(processors);
 244     }
 245 
 246     private Set<String> initPlatformAnnotations() {
 247         final String module_prefix =
 248             Feature.MODULES.allowedInSource(source) ? "java.base/" : "";
 249         return Set.of(module_prefix + "java.lang.Deprecated",
 250                       module_prefix + "java.lang.FunctionalInterface",
 251                       module_prefix + "java.lang.Override",
 252                       module_prefix + "java.lang.SafeVarargs",
 253                       module_prefix + "java.lang.SuppressWarnings",
 254 
 255                       module_prefix + "java.lang.annotation.Documented",
 256                       module_prefix + "java.lang.annotation.Inherited",
 257                       module_prefix + "java.lang.annotation.Native",
 258                       module_prefix + "java.lang.annotation.Repeatable",
 259                       module_prefix + "java.lang.annotation.Retention",
 260                       module_prefix + "java.lang.annotation.Target",
 261 
 262                       module_prefix + "java.io.Serial");
 263     }
 264 
 265     private void initProcessorLoader() {
 266         if (fileManager.hasLocation(ANNOTATION_PROCESSOR_MODULE_PATH)) {
 267             try {
 268                 serviceLoader = fileManager.getServiceLoader(ANNOTATION_PROCESSOR_MODULE_PATH, Processor.class);
 269             } catch (IOException e) {
 270                 throw new Abort(e);
 271             }
 272         } else {
 273             // If processorpath is not explicitly set, use the classpath.
 274             processorClassLoader = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
 275                 ? fileManager.getClassLoader(ANNOTATION_PROCESSOR_PATH)
 276                 : fileManager.getClassLoader(CLASS_PATH);
 277 
 278             if (options.isSet("accessInternalAPI"))
 279                 ModuleHelper.addExports(getClass().getModule(), processorClassLoader.getUnnamedModule());
 280 
 281             if (processorClassLoader != null && processorClassLoader instanceof Closeable closeable) {
 282                 compiler.closeables = compiler.closeables.prepend(closeable);
 283             }
 284         }
 285     }
 286 
 287     private void initProcessorIterator(Iterable<? extends Processor> processors) {
 288         Iterator<? extends Processor> processorIterator;
 289 
 290         if (options.isSet(Option.XPRINT)) {
 291             try {
 292                 processorIterator = List.of(new PrintingProcessor()).iterator();
 293             } catch (Throwable t) {
 294                 throw new AssertionError("Problem instantiating PrintingProcessor.", t);
 295             }
 296         } else if (processors != null) {
 297             processorIterator = processors.iterator();
 298         } else {
 299             /*
 300              * If the "-processor" option is used, search the appropriate
 301              * path for the named class.  Otherwise, use a service
 302              * provider mechanism to create the processor iterator.
 303              *
 304              * Note: if an explicit processor path is not set,
 305              * only the class path and _not_ the module path are
 306              * searched for processors.
 307              */
 308             String processorNames = options.get(Option.PROCESSOR);
 309             if (fileManager.hasLocation(ANNOTATION_PROCESSOR_MODULE_PATH)) {
 310                 processorIterator = (processorNames == null) ?
 311                         new ServiceIterator(serviceLoader, log) :
 312                         new NameServiceIterator(serviceLoader, log, processorNames);
 313             } else if (processorNames != null) {
 314                 processorIterator = new NameProcessIterator(processorNames, processorClassLoader, log);
 315             } else {
 316                 processorIterator = new ServiceIterator(processorClassLoader, log);
 317             }
 318         }
 319         PlatformDescription platformProvider = context.get(PlatformDescription.class);
 320         java.util.List<Processor> platformProcessors = Collections.emptyList();
 321         if (platformProvider != null) {
 322             platformProcessors = platformProvider.getAnnotationProcessors()
 323                                                  .stream()
 324                                                  .map(PluginInfo::getPlugin)
 325                                                  .toList();
 326         }
 327         List<Iterator<? extends Processor>> iterators = List.of(processorIterator,
 328                                                                 platformProcessors.iterator());
 329         Iterator<? extends Processor> compoundIterator =
 330                 Iterators.createCompoundIterator(iterators, i -> i);
 331         discoveredProcs = new DiscoveredProcessors(compoundIterator);
 332     }
 333 
 334     public <S> ServiceLoader<S> getServiceLoader(Class<S> service) {
 335         if (fileManager.hasLocation(ANNOTATION_PROCESSOR_MODULE_PATH)) {
 336             try {
 337                 return fileManager.getServiceLoader(ANNOTATION_PROCESSOR_MODULE_PATH, service);
 338             } catch (IOException e) {
 339                 throw new Abort(e);
 340             }
 341         } else {
 342             return ServiceLoader.load(service, getProcessorClassLoader());
 343         }
 344     }
 345 
 346     /**
 347      * Use a service loader appropriate for the platform to provide an
 348      * iterator over annotations processors; fails if a loader is
 349      * needed but unavailable.
 350      */
 351     private class ServiceIterator implements Iterator<Processor> {
 352         Iterator<Processor> iterator;
 353         Log log;
 354         ServiceLoader<Processor> loader;
 355 
 356         ServiceIterator(ClassLoader classLoader, Log log) {
 357             this.log = log;
 358             try {
 359                 loader = ServiceLoader.load(Processor.class, classLoader);
 360                 this.iterator = loader.iterator();
 361             } catch (Throwable t) {
 362                 log.error(Errors.ProcServiceProblem);
 363                 throw new Abort(t);
 364             }
 365         }
 366 
 367         ServiceIterator(ServiceLoader<Processor> loader, Log log) {
 368             this.log = log;
 369             this.loader = loader;
 370             this.iterator = loader.iterator();
 371         }
 372 
 373         @Override
 374         public boolean hasNext() {
 375             try {
 376                 return internalHasNext();
 377             } catch(ServiceConfigurationError sce) {
 378                 log.error(Errors.ProcBadConfigFile(sce.getLocalizedMessage()));
 379                 throw new Abort(sce);
 380             } catch (UnsupportedClassVersionError ucve) {
 381                 log.error(Errors.ProcCantLoadClass(ucve.getLocalizedMessage()));
 382                 throw new Abort(ucve);
 383             } catch (ClassFormatError cfe) {
 384                 log.error(Errors.ProcCantLoadClass(cfe.getLocalizedMessage()));
 385                 throw new Abort(cfe);
 386             } catch (Throwable t) {
 387                 log.error(Errors.ProcBadConfigFile(t.getLocalizedMessage()));
 388                 throw new Abort(t);
 389             }
 390         }
 391 
 392         boolean internalHasNext() {
 393             return iterator.hasNext();
 394         }
 395 
 396         @Override
 397         public Processor next() {
 398             try {
 399                 return internalNext();
 400             } catch (ServiceConfigurationError sce) {
 401                 log.error(Errors.ProcBadConfigFile(sce.getLocalizedMessage()));
 402                 throw new Abort(sce);
 403             } catch (Throwable t) {
 404                 log.error(Errors.ProcBadConfigFile(t.getLocalizedMessage()));
 405                 throw new Abort(t);
 406             }
 407         }
 408 
 409         Processor internalNext() {
 410             return iterator.next();
 411         }
 412 
 413         @Override
 414         public void remove() {
 415             throw new UnsupportedOperationException();
 416         }
 417 
 418         public void close() {
 419             if (loader != null) {
 420                 try {
 421                     loader.reload();
 422                 } catch(Exception e) {
 423                     // Ignore problems during a call to reload.
 424                 }
 425             }
 426         }
 427     }
 428 
 429     private class NameServiceIterator extends ServiceIterator {
 430         private Map<String, Processor> namedProcessorsMap = new HashMap<>();
 431         private Iterator<String> processorNames = null;
 432         private Processor nextProc = null;
 433 
 434         public NameServiceIterator(ServiceLoader<Processor> loader, Log log, String theNames) {
 435             super(loader, log);
 436             this.processorNames = Arrays.asList(theNames.split(",")).iterator();
 437         }
 438 
 439         @Override
 440         boolean internalHasNext() {
 441             if (nextProc != null) {
 442                 return true;
 443             }
 444             if (!processorNames.hasNext()) {
 445                 namedProcessorsMap = null;
 446                 return false;
 447             }
 448             String processorName = processorNames.next();
 449             Processor theProcessor = namedProcessorsMap.get(processorName);
 450             if (theProcessor != null) {
 451                 namedProcessorsMap.remove(processorName);
 452                 nextProc = theProcessor;
 453                 return true;
 454             } else {
 455                 while (iterator.hasNext()) {
 456                     theProcessor = iterator.next();
 457                     String name = theProcessor.getClass().getName();
 458                     if (name.equals(processorName)) {
 459                         nextProc = theProcessor;
 460                         return true;
 461                     } else {
 462                         namedProcessorsMap.put(name, theProcessor);
 463                     }
 464                 }
 465                 log.error(Errors.ProcProcessorNotFound(processorName));
 466                 return false;
 467             }
 468         }
 469 
 470         @Override
 471         Processor internalNext() {
 472             if (hasNext()) {
 473                 Processor p = nextProc;
 474                 nextProc = null;
 475                 return p;
 476             } else {
 477                 throw new NoSuchElementException();
 478             }
 479         }
 480     }
 481 
 482     private static class NameProcessIterator implements Iterator<Processor> {
 483         Processor nextProc = null;
 484         Iterator<String> names;
 485         ClassLoader processorCL;
 486         Log log;
 487 
 488         NameProcessIterator(String names, ClassLoader processorCL, Log log) {
 489             this.names = Arrays.asList(names.split(",")).iterator();
 490             this.processorCL = processorCL;
 491             this.log = log;
 492         }
 493 
 494         public boolean hasNext() {
 495             if (nextProc != null)
 496                 return true;
 497             else {
 498                 if (!names.hasNext()) {
 499                     return false;
 500                 } else {
 501                     Processor processor = getNextProcessor(names.next());
 502                     if (processor == null) {
 503                         return false;
 504                     } else {
 505                         nextProc = processor;
 506                         return true;
 507                     }
 508                 }
 509             }
 510         }
 511 
 512         private Processor getNextProcessor(String processorName) {
 513             try {
 514                 try {
 515                     Class<?> processorClass = processorCL.loadClass(processorName);
 516                     ensureReadable(processorClass);
 517                     return (Processor) processorClass.getConstructor().newInstance();
 518                 } catch (ClassNotFoundException cnfe) {
 519                     log.error(Errors.ProcProcessorNotFound(processorName));
 520                     return null;
 521                 } catch (ClassCastException cce) {
 522                     log.error(Errors.ProcProcessorWrongType(processorName));
 523                     return null;
 524                 } catch (Exception e ) {
 525                     log.error(Errors.ProcProcessorCantInstantiate(processorName));
 526                     return null;
 527                 }
 528             } catch (ClientCodeException e) {
 529                 throw e;
 530             } catch (Throwable t) {
 531                 throw new AnnotationProcessingError(t);
 532             }
 533         }
 534 
 535         public Processor next() {
 536             if (hasNext()) {
 537                 Processor p = nextProc;
 538                 nextProc = null;
 539                 return p;
 540             } else
 541                 throw new NoSuchElementException();
 542         }
 543 
 544         public void remove () {
 545             throw new UnsupportedOperationException();
 546         }
 547 
 548         /**
 549          * Ensures that the module of the given class is readable to this
 550          * module.
 551          */
 552         private void ensureReadable(Class<?> targetClass) {
 553             try {
 554                 Method getModuleMethod = Class.class.getMethod("getModule");
 555                 Object thisModule = getModuleMethod.invoke(this.getClass());
 556                 Object targetModule = getModuleMethod.invoke(targetClass);
 557 
 558                 Class<?> moduleClass = getModuleMethod.getReturnType();
 559                 Method addReadsMethod = moduleClass.getMethod("addReads", moduleClass);
 560                 addReadsMethod.invoke(thisModule, targetModule);
 561             } catch (NoSuchMethodException e) {
 562                 // ignore
 563             } catch (Exception e) {
 564                 throw new InternalError(e);
 565             }
 566         }
 567     }
 568 
 569     public boolean atLeastOneProcessor() {
 570         return discoveredProcs.iterator().hasNext();
 571     }
 572 
 573     private Map<String, String> initProcessorOptions() {
 574         Set<String> keySet = options.keySet();
 575         Map<String, String> tempOptions = new LinkedHashMap<>();
 576 
 577         for(String key : keySet) {
 578             if (key.startsWith("-A") && key.length() > 2) {
 579                 int sepIndex = key.indexOf('=');
 580                 String candidateKey = null;
 581                 String candidateValue = null;
 582 
 583                 if (sepIndex == -1)
 584                     candidateKey = key.substring(2);
 585                 else if (sepIndex >= 3) {
 586                     candidateKey = key.substring(2, sepIndex);
 587                     candidateValue = (sepIndex < key.length()-1)?
 588                         key.substring(sepIndex+1) : null;
 589                 }
 590                 tempOptions.put(candidateKey, candidateValue);
 591             }
 592         }
 593 
 594         PlatformDescription platformProvider = context.get(PlatformDescription.class);
 595 
 596         if (platformProvider != null) {
 597             for (PluginInfo<Processor> ap : platformProvider.getAnnotationProcessors()) {
 598                 tempOptions.putAll(ap.getOptions());
 599             }
 600         }
 601 
 602         return Collections.unmodifiableMap(tempOptions);
 603     }
 604 
 605     private Set<String> initUnmatchedProcessorOptions() {
 606         Set<String> unmatchedProcessorOptions = new HashSet<>();
 607         unmatchedProcessorOptions.addAll(processorOptions.keySet());
 608         return unmatchedProcessorOptions;
 609     }
 610 
 611     /**
 612      * State about how a processor has been used by the tool.  If a
 613      * processor has been used on a prior round, its process method is
 614      * called on all subsequent rounds, perhaps with an empty set of
 615      * annotations to process.  The {@code annotationSupported} method
 616      * caches the supported annotation information from the first (and
 617      * only) getSupportedAnnotationTypes call to the processor.
 618      */
 619     static class ProcessorState {
 620         public Processor processor;
 621         public boolean   contributed;
 622         private Set<String> supportedAnnotationStrings; // Used for warning generation
 623         private Set<Pattern> supportedAnnotationPatterns;
 624         private Set<String> supportedOptionNames;
 625 
 626         ProcessorState(Processor p, Log log, Source source, DeferredCompletionFailureHandler dcfh,
 627                        boolean allowModules, ProcessingEnvironment env) {
 628             processor = p;
 629             contributed = false;
 630 
 631             Handler prevDeferredHandler = dcfh.setHandler(dcfh.userCodeHandler);
 632             try {
 633                 processor.init(env);
 634 
 635                 checkSourceVersionCompatibility(source, log);
 636 
 637 
 638                 // Check for direct duplicates in the strings of
 639                 // supported annotation types. Do not check for
 640                 // duplicates that would result after stripping of
 641                 // module prefixes.
 642                 supportedAnnotationStrings = new LinkedHashSet<>();
 643                 supportedAnnotationPatterns = new LinkedHashSet<>();
 644                 for (String annotationPattern : processor.getSupportedAnnotationTypes()) {
 645                     boolean patternAdded = supportedAnnotationStrings.add(annotationPattern);
 646 
 647                     supportedAnnotationPatterns.
 648                         add(importStringToPattern(allowModules, annotationPattern, processor, log));
 649                     if (!patternAdded) {
 650                         log.warning(LintWarnings.ProcDuplicateSupportedAnnotation(annotationPattern,
 651                                                                               p.getClass().getName()));
 652                     }
 653                 }
 654 
 655                 // If a processor supports "*", that matches
 656                 // everything and other entries are redundant. With
 657                 // more work, it could be checked that the supported
 658                 // annotation types were otherwise non-overlapping
 659                 // with each other in other cases, for example "foo.*"
 660                 // and "foo.bar.*".
 661                 if (supportedAnnotationPatterns.contains(MatchingUtils.validImportStringToPattern("*")) &&
 662                     supportedAnnotationPatterns.size() > 1) {
 663                     log.warning(LintWarnings.ProcRedundantTypesWithWildcard(p.getClass().getName()));
 664                 }
 665 
 666                 supportedOptionNames = new LinkedHashSet<>();
 667                 for (String optionName : processor.getSupportedOptions() ) {
 668                     if (checkOptionName(optionName, log)) {
 669                         boolean optionAdded = supportedOptionNames.add(optionName);
 670                         if (!optionAdded) {
 671                             log.warning(LintWarnings.ProcDuplicateOptionName(optionName, p.getClass().getName()));
 672                         }
 673                     }
 674                 }
 675 
 676             } catch (ClientCodeException e) {
 677                 throw e;
 678             } catch (Throwable t) {
 679                 throw new AnnotationProcessingError(t);
 680             } finally {
 681                 dcfh.setHandler(prevDeferredHandler);
 682             }
 683         }
 684 
 685         /**
 686          * Checks whether or not a processor's source version is
 687          * compatible with the compilation source version.  The
 688          * processor's source version needs to be greater than or
 689          * equal to the source version of the compile.
 690          */
 691         private void checkSourceVersionCompatibility(Source source, Log log) {
 692             SourceVersion procSourceVersion = processor.getSupportedSourceVersion();
 693             if (procSourceVersion.compareTo(Source.toSourceVersion(source)) < 0 )  {
 694                 log.warning(Warnings.ProcProcessorIncompatibleSourceVersion(procSourceVersion,
 695                                                                             processor.getClass().getName(),
 696                                                                             source.name));
 697             }
 698         }
 699 
 700         private boolean checkOptionName(String optionName, Log log) {
 701             boolean valid = isValidOptionName(optionName);
 702             if (!valid)
 703                 log.error(Errors.ProcProcessorBadOptionName(optionName,
 704                                                             processor.getClass().getName()));
 705             return valid;
 706         }
 707 
 708         public boolean annotationSupported(String annotationName) {
 709             for(Pattern p: supportedAnnotationPatterns) {
 710                 if (p.matcher(annotationName).matches())
 711                     return true;
 712             }
 713             return false;
 714         }
 715 
 716         /**
 717          * Remove options that are matched by this processor.
 718          */
 719         public void removeSupportedOptions(Set<String> unmatchedProcessorOptions) {
 720             unmatchedProcessorOptions.removeAll(supportedOptionNames);
 721         }
 722     }
 723 
 724     // TODO: These two classes can probably be rewritten better...
 725     /**
 726      * This class holds information about the processors that have
 727      * been discovered so far as well as the means to discover more, if
 728      * necessary.  A single iterator should be used per round of
 729      * annotation processing.  The iterator first visits already
 730      * discovered processors then fails over to the service provider
 731      * mechanism if additional queries are made.
 732      */
 733     class DiscoveredProcessors implements Iterable<ProcessorState> {
 734 
 735         class ProcessorStateIterator implements Iterator<ProcessorState> {
 736             DiscoveredProcessors psi;
 737             Iterator<ProcessorState> innerIter;
 738             boolean onProcIterator;
 739 
 740             ProcessorStateIterator(DiscoveredProcessors psi) {
 741                 this.psi = psi;
 742                 this.innerIter = psi.procStateList.iterator();
 743                 this.onProcIterator = false;
 744             }
 745 
 746             public ProcessorState next() {
 747                 if (!onProcIterator) {
 748                     if (innerIter.hasNext())
 749                         return innerIter.next();
 750                     else
 751                         onProcIterator = true;
 752                 }
 753 
 754                 if (psi.processorIterator.hasNext()) {
 755                     ProcessorState ps = new ProcessorState(psi.processorIterator.next(),
 756                                                            log, source, dcfh,
 757                                                            Feature.MODULES.allowedInSource(source),
 758                                                            JavacProcessingEnvironment.this);
 759                     psi.procStateList.add(ps);
 760                     return ps;
 761                 } else
 762                     throw new NoSuchElementException();
 763             }
 764 
 765             public boolean hasNext() {
 766                 if (onProcIterator)
 767                     return  psi.processorIterator.hasNext();
 768                 else
 769                     return innerIter.hasNext() || psi.processorIterator.hasNext();
 770             }
 771 
 772             public void remove () {
 773                 throw new UnsupportedOperationException();
 774             }
 775 
 776             /**
 777              * Run all remaining processors on the procStateList that
 778              * have not already run this round with an empty set of
 779              * annotations.
 780              */
 781             public void runContributingProcs(RoundEnvironment re) {
 782                 if (!onProcIterator) {
 783                     Set<TypeElement> emptyTypeElements = Collections.emptySet();
 784                     while(innerIter.hasNext()) {
 785                         ProcessorState ps = innerIter.next();
 786                         if (ps.contributed)
 787                             callProcessor(ps.processor, emptyTypeElements, re);
 788                     }
 789                 }
 790             }
 791         }
 792 
 793         Iterator<? extends Processor> processorIterator;
 794         ArrayList<ProcessorState>  procStateList;
 795 
 796         public ProcessorStateIterator iterator() {
 797             return new ProcessorStateIterator(this);
 798         }
 799 
 800         DiscoveredProcessors(Iterator<? extends Processor> processorIterator) {
 801             this.processorIterator = processorIterator;
 802             this.procStateList = new ArrayList<>();
 803         }
 804 
 805         /**
 806          * Free jar files, etc. if using a service loader.
 807          */
 808         public void close() {
 809             if (processorIterator != null &&
 810                 processorIterator instanceof ServiceIterator serviceIterator) {
 811                 serviceIterator.close();
 812             }
 813         }
 814     }
 815 
 816     private void discoverAndRunProcs(Set<TypeElement> annotationsPresent,
 817                                      List<ClassSymbol> topLevelClasses,
 818                                      List<PackageSymbol> packageInfoFiles,
 819                                      List<ModuleSymbol> moduleInfoFiles) {
 820         Map<String, TypeElement> unmatchedAnnotations = new HashMap<>(annotationsPresent.size());
 821 
 822         for(TypeElement a  : annotationsPresent) {
 823             ModuleElement mod = elementUtils.getModuleOf(a);
 824             String moduleSpec = Feature.MODULES.allowedInSource(source) && mod != null ? mod.getQualifiedName() + "/" : "";
 825             unmatchedAnnotations.put(moduleSpec + a.getQualifiedName().toString(),
 826                                      a);
 827         }
 828 
 829         // Give "*" processors a chance to match
 830         if (unmatchedAnnotations.size() == 0)
 831             unmatchedAnnotations.put("", null);
 832 
 833         DiscoveredProcessors.ProcessorStateIterator psi = discoveredProcs.iterator();
 834         // TODO: Create proper argument values; need past round
 835         // information to fill in this constructor.  Note that the 1
 836         // st round of processing could be the last round if there
 837         // were parse errors on the initial source files; however, we
 838         // are not doing processing in that case.
 839 
 840         Set<Element> rootElements = new LinkedHashSet<>();
 841         rootElements.addAll(topLevelClasses);
 842         rootElements.addAll(packageInfoFiles);
 843         rootElements.addAll(moduleInfoFiles);
 844         rootElements = Collections.unmodifiableSet(rootElements);
 845 
 846         RoundEnvironment renv = new JavacRoundEnvironment(false,
 847                                                           false,
 848                                                           rootElements,
 849                                                           JavacProcessingEnvironment.this);
 850 
 851         while(unmatchedAnnotations.size() > 0 && psi.hasNext() ) {
 852             ProcessorState ps = psi.next();
 853             Set<String>  matchedNames = new HashSet<>();
 854             Set<TypeElement> typeElements = new LinkedHashSet<>();
 855 
 856             for (Map.Entry<String, TypeElement> entry: unmatchedAnnotations.entrySet()) {
 857                 String unmatchedAnnotationName = entry.getKey();
 858                 if (ps.annotationSupported(unmatchedAnnotationName) ) {
 859                     matchedNames.add(unmatchedAnnotationName);
 860                     TypeElement te = entry.getValue();
 861                     if (te != null)
 862                         typeElements.add(te);
 863                 }
 864             }
 865 
 866             if (matchedNames.size() > 0 || ps.contributed) {
 867                 boolean processingResult = callProcessor(ps.processor, typeElements, renv);
 868                 ps.contributed = true;
 869                 ps.removeSupportedOptions(unmatchedProcessorOptions);
 870 
 871                 if (printProcessorInfo || verbose) {
 872                     log.printLines("x.print.processor.info",
 873                             ps.processor.getClass().getName(),
 874                             matchedNames.toString(),
 875                             processingResult);
 876                 }
 877 
 878                 if (processingResult) {
 879                     unmatchedAnnotations.keySet().removeAll(matchedNames);
 880                 }
 881 
 882             }
 883         }
 884         unmatchedAnnotations.remove("");
 885 
 886         if (unmatchedAnnotations.size() > 0) {
 887             // Remove annotations processed by javac
 888             unmatchedAnnotations.keySet().removeAll(platformAnnotations);
 889             if (unmatchedAnnotations.size() > 0) {
 890                 log.warning(LintWarnings.ProcAnnotationsWithoutProcessors(unmatchedAnnotations.keySet()));
 891             }
 892         }
 893 
 894         // Run contributing processors that haven't run yet
 895         psi.runContributingProcs(renv);
 896     }
 897 
 898     /**
 899      * Computes the set of annotations on the symbol in question.
 900      * Leave class public for external testing purposes.
 901      */
 902     public static class ComputeAnnotationSet extends
 903         ElementScanner14<Set<TypeElement>, Set<TypeElement>> {
 904         final Elements elements;
 905 
 906         public ComputeAnnotationSet(Elements elements) {
 907             super();
 908             this.elements = elements;
 909         }
 910 
 911         @Override @DefinedBy(Api.LANGUAGE_MODEL)
 912         public Set<TypeElement> visitPackage(PackageElement e, Set<TypeElement> p) {
 913             // Don't scan enclosed elements of a package
 914             return p;
 915         }
 916 
 917         @Override @DefinedBy(Api.LANGUAGE_MODEL)
 918         public Set<TypeElement> visitType(TypeElement e, Set<TypeElement> p) {
 919             // Type parameters are not considered to be enclosed by a type
 920             scan(e.getTypeParameters(), p);
 921             return super.visitType(e, p);
 922         }
 923 
 924         @Override @DefinedBy(Api.LANGUAGE_MODEL)
 925         public Set<TypeElement> visitExecutable(ExecutableElement e, Set<TypeElement> p) {
 926             // Type parameters are not considered to be enclosed by an executable
 927             scan(e.getTypeParameters(), p);
 928             return super.visitExecutable(e, p);
 929         }
 930 
 931         void addAnnotations(Element e, Set<TypeElement> p) {
 932             for (AnnotationMirror annotationMirror :
 933                      elements.getAllAnnotationMirrors(e) ) {
 934                 Element e2 = annotationMirror.getAnnotationType().asElement();
 935                 p.add((TypeElement) e2);
 936             }
 937         }
 938 
 939         @Override @DefinedBy(Api.LANGUAGE_MODEL)
 940         public Set<TypeElement> scan(Element e, Set<TypeElement> p) {
 941             addAnnotations(e, p);
 942             return super.scan(e, p);
 943         }
 944     }
 945 
 946     private boolean callProcessor(Processor proc,
 947                                          Set<? extends TypeElement> tes,
 948                                          RoundEnvironment renv) {
 949         Handler prevDeferredHandler = dcfh.setHandler(dcfh.userCodeHandler);
 950         try {
 951             return proc.process(tes, renv);
 952         } catch (ClassFinder.BadClassFile ex) {
 953             log.error(Errors.ProcCantAccess1(ex.sym, ex.getDetailValue()));
 954             return false;
 955         } catch (CompletionFailure ex) {
 956             StringWriter out = new StringWriter();
 957             ex.printStackTrace(new PrintWriter(out));
 958             log.error(Errors.ProcCantAccess(ex.sym, ex.getDetailValue(), out.toString()));
 959             return false;
 960         } catch (ClientCodeException e) {
 961             throw e;
 962         } catch (Throwable t) {
 963             throw new AnnotationProcessingError(t);
 964         } finally {
 965             dcfh.setHandler(prevDeferredHandler);
 966         }
 967     }
 968 
 969     /**
 970      * Helper object for a single round of annotation processing.
 971      */
 972     class Round {
 973         /** The round number. */
 974         final int number;
 975         /** The diagnostic handler for the round. */
 976         final Log.DeferredDiagnosticHandler deferredDiagnosticHandler;
 977 
 978         /** The ASTs to be compiled. */
 979         List<JCCompilationUnit> roots;
 980         /** The trees that need to be cleaned - includes roots and implicitly parsed trees. */
 981         Set<JCCompilationUnit> treesToClean;
 982         /** The classes to be compiler that have were generated. */
 983         Map<ModuleSymbol, Map<String, JavaFileObject>> genClassFiles;
 984 
 985         /** The set of annotations to be processed this round. */
 986         Set<TypeElement> annotationsPresent;
 987         /** The set of top level classes to be processed this round. */
 988         List<ClassSymbol> topLevelClasses;
 989         /** The set of package-info files to be processed this round. */
 990         List<PackageSymbol> packageInfoFiles;
 991         /** The set of module-info files to be processed this round. */
 992         List<ModuleSymbol> moduleInfoFiles;
 993 
 994         /** Create a round (common code). */
 995         private Round(int number, Set<JCCompilationUnit> treesToClean,
 996                 Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
 997             this.number = number;
 998 
 999             if (number == 1) {
1000                 Assert.checkNonNull(deferredDiagnosticHandler);
1001                 this.deferredDiagnosticHandler = deferredDiagnosticHandler;
1002             } else {
1003                 this.deferredDiagnosticHandler = log.new DeferredDiagnosticHandler();
1004                 compiler.setDeferredDiagnosticHandler(this.deferredDiagnosticHandler);
1005             }
1006 
1007             // the following will be populated as needed
1008             topLevelClasses  = List.nil();
1009             packageInfoFiles = List.nil();
1010             moduleInfoFiles = List.nil();
1011             this.treesToClean = treesToClean;
1012         }
1013 
1014         /** Create the first round. */
1015         Round(List<JCCompilationUnit> roots,
1016               List<ClassSymbol> classSymbols,
1017               Set<JCCompilationUnit> treesToClean,
1018               Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
1019             this(1, treesToClean, deferredDiagnosticHandler);
1020             this.roots = roots;
1021             genClassFiles = new HashMap<>();
1022 
1023             // The reverse() in the following line is to maintain behavioural
1024             // compatibility with the previous revision of the code. Strictly speaking,
1025             // it should not be necessary, but a javah golden file test fails without it.
1026             topLevelClasses =
1027                 getTopLevelClasses(roots).prependList(classSymbols.reverse());
1028 
1029             packageInfoFiles = getPackageInfoFiles(roots);
1030 
1031             moduleInfoFiles = getModuleInfoFiles(roots);
1032 
1033             findAnnotationsPresent();
1034         }
1035 
1036         /** Create a new round. */
1037         private Round(Round prev,
1038                 Set<JavaFileObject> newSourceFiles, Map<ModuleSymbol, Map<String,JavaFileObject>> newClassFiles) {
1039             this(prev.number+1, prev.treesToClean, null);
1040             prev.newRound();
1041             this.genClassFiles = prev.genClassFiles;
1042 
1043             //parse the generated files even despite errors reported so far, to eliminate
1044             //recoverable errors related to the type declared in the generated files:
1045             List<JCCompilationUnit> parsedFiles = compiler.parseFiles(newSourceFiles, true);
1046             roots = prev.roots.appendList(parsedFiles);
1047 
1048             // Check for errors after parsing
1049             if (unrecoverableError()) {
1050                 compiler.initModules(List.nil());
1051                 return;
1052             }
1053 
1054             roots = compiler.initModules(roots);
1055 
1056             enterClassFiles(genClassFiles);
1057             List<ClassSymbol> newClasses = enterClassFiles(newClassFiles);
1058             for (Entry<ModuleSymbol, Map<String, JavaFileObject>> moduleAndClassFiles : newClassFiles.entrySet()) {
1059                 genClassFiles.computeIfAbsent(moduleAndClassFiles.getKey(), m -> new LinkedHashMap<>()).putAll(moduleAndClassFiles.getValue());
1060             }
1061             enterTrees(roots);
1062 
1063             if (unrecoverableError())
1064                 return;
1065 
1066             topLevelClasses = join(
1067                     getTopLevelClasses(parsedFiles),
1068                     getTopLevelClassesFromClasses(newClasses));
1069 
1070             packageInfoFiles = join(
1071                     getPackageInfoFiles(parsedFiles),
1072                     getPackageInfoFilesFromClasses(newClasses));
1073 
1074             moduleInfoFiles = List.nil(); //module-info cannot be generated
1075 
1076             findAnnotationsPresent();
1077         }
1078 
1079         /** Create the next round to be used. */
1080         Round next(Set<JavaFileObject> newSourceFiles, Map<ModuleSymbol, Map<String, JavaFileObject>> newClassFiles) {
1081             return new Round(this, newSourceFiles, newClassFiles);
1082         }
1083 
1084         /** Prepare the compiler for the final compilation. */
1085         void finalCompiler() {
1086             newRound();
1087         }
1088 
1089         /** Return the number of errors found so far in this round.
1090          * This may include unrecoverable errors, such as parse errors,
1091          * and transient errors, such as missing symbols. */
1092         int errorCount() {
1093             return compiler.errorCount();
1094         }
1095 
1096         /** Return the number of warnings found so far in this round. */
1097         int warningCount() {
1098             return compiler.warningCount();
1099         }
1100 
1101         /** Return whether or not an unrecoverable error has occurred. */
1102         boolean unrecoverableError() {
1103             if (messager.errorRaised())
1104                 return true;
1105 
1106             return deferredDiagnosticHandler.getDiagnostics().stream()
1107               .anyMatch(d -> (d.getKind() == Diagnostic.Kind.WARNING && werror) ||
1108                              (d.getKind() == Diagnostic.Kind.ERROR && (fatalErrors || !d.isFlagSet(RECOVERABLE))));
1109         }
1110 
1111         /** Find the set of annotations present in the set of top level
1112          *  classes and package info files to be processed this round. */
1113         void findAnnotationsPresent() {
1114             ComputeAnnotationSet annotationComputer = new ComputeAnnotationSet(elementUtils);
1115             // Use annotation processing to compute the set of annotations present
1116             annotationsPresent = new LinkedHashSet<>();
1117             for (ClassSymbol classSym : topLevelClasses)
1118                 annotationComputer.scan(classSym, annotationsPresent);
1119             for (PackageSymbol pkgSym : packageInfoFiles)
1120                 annotationComputer.scan(pkgSym, annotationsPresent);
1121             for (ModuleSymbol mdlSym : moduleInfoFiles)
1122                 annotationComputer.scan(mdlSym, annotationsPresent);
1123         }
1124 
1125         /** Enter a set of generated class files. */
1126         private List<ClassSymbol> enterClassFiles(Map<ModuleSymbol, Map<String, JavaFileObject>> modulesAndClassFiles) {
1127             List<ClassSymbol> list = List.nil();
1128 
1129             for (Entry<ModuleSymbol, Map<String, JavaFileObject>> moduleAndClassFiles : modulesAndClassFiles.entrySet()) {
1130                 for (Map.Entry<String,JavaFileObject> entry : moduleAndClassFiles.getValue().entrySet()) {
1131                     Name name = names.fromString(entry.getKey());
1132                     JavaFileObject file = entry.getValue();
1133                     if (file.getKind() != JavaFileObject.Kind.CLASS)
1134                         throw new AssertionError(file);
1135                     ClassSymbol cs;
1136                     if (isPkgInfo(file, JavaFileObject.Kind.CLASS)) {
1137                         Name packageName = Convert.packagePart(name);
1138                         PackageSymbol p = symtab.enterPackage(moduleAndClassFiles.getKey(), packageName);
1139                         if (p.package_info == null)
1140                             p.package_info = symtab.enterClass(moduleAndClassFiles.getKey(), Convert.shortName(name), p);
1141                         cs = p.package_info;
1142                         cs.reset();
1143                         if (cs.classfile == null)
1144                             cs.classfile = file;
1145                         cs.completer = initialCompleter;
1146                     } else {
1147                         cs = symtab.enterClass(moduleAndClassFiles.getKey(), name);
1148                         cs.reset();
1149                         cs.classfile = file;
1150                         cs.completer = initialCompleter;
1151                         if (cs.owner.kind == PCK) {
1152                             cs.owner.members().enter(cs); //XXX - OverwriteBetweenCompilations; syms.getClass is not sufficient anymore
1153                         }
1154                     }
1155                     list = list.prepend(cs);
1156                 }
1157             }
1158             return list.reverse();
1159         }
1160 
1161         /** Enter a set of syntax trees. */
1162         private void enterTrees(List<JCCompilationUnit> roots) {
1163             compiler.enterTrees(roots);
1164         }
1165 
1166         /** Run a processing round. */
1167         void run(boolean lastRound, boolean errorStatus) {
1168             printRoundInfo(lastRound);
1169 
1170             if (!taskListener.isEmpty())
1171                 taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
1172 
1173             try {
1174                 if (lastRound) {
1175                     filer.setLastRound(true);
1176                     Set<Element> emptyRootElements = Collections.emptySet(); // immutable
1177                     RoundEnvironment renv = new JavacRoundEnvironment(true,
1178                             errorStatus,
1179                             emptyRootElements,
1180                             JavacProcessingEnvironment.this);
1181                     discoveredProcs.iterator().runContributingProcs(renv);
1182                 } else {
1183                     discoverAndRunProcs(annotationsPresent, topLevelClasses, packageInfoFiles, moduleInfoFiles);
1184                 }
1185             } catch (Throwable t) {
1186                 // we're specifically expecting Abort here, but if any Throwable
1187                 // comes by, we should flush all deferred diagnostics, rather than
1188                 // drop them on the ground.
1189                 compiler.reportDeferredDiagnosticAndClearHandler();
1190                 throw t;
1191             } finally {
1192                 if (!taskListener.isEmpty())
1193                     taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
1194             }
1195         }
1196 
1197         void showDiagnostics(boolean showAll) {
1198             deferredDiagnosticHandler.reportDeferredDiagnostics(showAll ? ACCEPT_ALL
1199                                                                         : ACCEPT_NON_RECOVERABLE);
1200             log.popDiagnosticHandler(deferredDiagnosticHandler);
1201             compiler.setDeferredDiagnosticHandler(null);
1202         }
1203         //where:
1204             private final Predicate<JCDiagnostic> ACCEPT_NON_RECOVERABLE =
1205                     d -> d.getKind() != JCDiagnostic.Kind.ERROR ||
1206                          !d.isFlagSet(DiagnosticFlag.RECOVERABLE) ||
1207                          d.isFlagSet(DiagnosticFlag.API);
1208             private final Predicate<JCDiagnostic> ACCEPT_ALL = d -> true;
1209 
1210         /** Print info about this round. */
1211         private void printRoundInfo(boolean lastRound) {
1212             if (printRounds || verbose) {
1213                 List<ClassSymbol> tlc = lastRound ? List.nil() : topLevelClasses;
1214                 Set<TypeElement> ap = lastRound ? Collections.emptySet() : annotationsPresent;
1215                 log.printLines("x.print.rounds",
1216                         number,
1217                         "{" + tlc.toString(", ") + "}",
1218                         ap,
1219                         lastRound);
1220             }
1221         }
1222 
1223         /** Prepare for new round of annotation processing. Cleans trees, resets symbols, and
1224          * asks selected services to prepare to a new round of annotation processing.
1225          */
1226         private void newRound() {
1227             //ensure treesToClean contains all trees, including implicitly parsed ones
1228             for (Env<AttrContext> env : enter.getEnvs()) {
1229                 treesToClean.add(env.toplevel);
1230             }
1231             for (JCCompilationUnit node : treesToClean) {
1232                 treeCleaner.scan(node);
1233             }
1234             chk.newRound();
1235             enter.newRound();
1236             filer.newRound();
1237             messager.newRound();
1238             compiler.newRound();
1239             modules.newRound();
1240             types.newRound();
1241             annotate.newRound();
1242             elementUtils.newRound();
1243 
1244             boolean foundError = false;
1245 
1246             for (ClassSymbol cs : symtab.getAllClasses()) {
1247                 if (cs.kind == ERR) {
1248                     foundError = true;
1249                     break;
1250                 }
1251             }
1252 
1253             if (foundError) {
1254                 for (ClassSymbol cs : symtab.getAllClasses()) {
1255                     if (cs.classfile != null || cs.kind == ERR) {
1256                         Kinds.Kind symKind = cs.kind;
1257                         cs.reset();
1258                         if (symKind == ERR) {
1259                             cs.type = new ClassType(cs.type.getEnclosingType(), null, cs);
1260                         }
1261                         if (cs.isCompleted()) {
1262                             cs.completer = initialCompleter;
1263                         }
1264                     }
1265                 }
1266             }
1267         }
1268     }
1269 
1270 
1271     // TODO: internal catch clauses?; catch and rethrow an annotation
1272     // processing error
1273     public boolean doProcessing(List<JCCompilationUnit> roots,
1274                                 List<ClassSymbol> classSymbols,
1275                                 Iterable<? extends PackageSymbol> pckSymbols,
1276                                 Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
1277         final Set<JCCompilationUnit> treesToClean =
1278                 Collections.newSetFromMap(new IdentityHashMap<JCCompilationUnit, Boolean>());
1279 
1280         //fill already attributed implicit trees:
1281         for (Env<AttrContext> env : enter.getEnvs()) {
1282             treesToClean.add(env.toplevel);
1283         }
1284 
1285         Set<PackageSymbol> specifiedPackages = new LinkedHashSet<>();
1286         for (PackageSymbol psym : pckSymbols)
1287             specifiedPackages.add(psym);
1288         this.specifiedPackages = Collections.unmodifiableSet(specifiedPackages);
1289 
1290         Round round = new Round(roots, classSymbols, treesToClean, deferredDiagnosticHandler);
1291 
1292         boolean errorStatus;
1293         boolean moreToDo;
1294         do {
1295             // Run processors for round n
1296             round.run(false, false);
1297 
1298             // Processors for round n have run to completion.
1299             // Check for errors and whether there is more work to do.
1300             errorStatus = round.unrecoverableError();
1301             moreToDo = moreToDo();
1302 
1303             round.showDiagnostics(showResolveErrors);
1304 
1305             // Set up next round.
1306             // Copy mutable collections returned from filer.
1307             round = round.next(
1308                     new LinkedHashSet<>(filer.getGeneratedSourceFileObjects()),
1309                     new LinkedHashMap<>(filer.getGeneratedClasses()));
1310 
1311              // Check for errors during setup.
1312             if (round.unrecoverableError())
1313                 errorStatus = true;
1314 
1315         } while (moreToDo && !errorStatus);
1316 
1317         // run last round
1318         round.run(true, errorStatus);
1319         round.showDiagnostics(true);
1320 
1321         filer.warnIfUnclosedFiles();
1322         warnIfUnmatchedOptions();
1323 
1324         /*
1325          * If an annotation processor raises an error in a round,
1326          * that round runs to completion and one last round occurs.
1327          * The last round may also occur because no more source or
1328          * class files have been generated.  Therefore, if an error
1329          * was raised on either of the last *two* rounds, the compile
1330          * should exit with a nonzero exit code.  The current value of
1331          * errorStatus holds whether or not an error was raised on the
1332          * second to last round; errorRaised() gives the error status
1333          * of the last round.
1334          */
1335         if (messager.errorRaised()
1336                 || werror && round.warningCount() > 0 && round.errorCount() > 0)
1337             errorStatus = true;
1338 
1339         Set<JavaFileObject> newSourceFiles =
1340                 new LinkedHashSet<>(filer.getGeneratedSourceFileObjects());
1341         roots = round.roots;
1342 
1343         errorStatus = errorStatus || (compiler.errorCount() > 0);
1344 
1345 
1346         if (newSourceFiles.size() > 0)
1347             roots = roots.appendList(compiler.parseFiles(newSourceFiles));
1348 
1349         errorStatus = errorStatus || (compiler.errorCount() > 0);
1350 
1351         if (errorStatus && compiler.errorCount() == 0) {
1352             compiler.log.nerrors++;
1353         }
1354 
1355         if (compiler.continueAfterProcessAnnotations()) {
1356             round.finalCompiler();
1357             compiler.enterTrees(compiler.initModules(roots));
1358         } else {
1359             compiler.todo.clear();
1360         }
1361 
1362         // Free resources
1363         this.close();
1364 
1365         if (!taskListener.isEmpty())
1366             taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING));
1367 
1368         return true;
1369     }
1370 
1371     private void warnIfUnmatchedOptions() {
1372         if (!unmatchedProcessorOptions.isEmpty()) {
1373             log.warning(Warnings.ProcUnmatchedProcessorOptions(unmatchedProcessorOptions.toString()));
1374         }
1375     }
1376 
1377     /**
1378      * Free resources related to annotation processing.
1379      */
1380     public void close() {
1381         filer.close();
1382         if (discoveredProcs != null) // Make calling close idempotent
1383             discoveredProcs.close();
1384         discoveredProcs = null;
1385     }
1386 
1387     private List<ClassSymbol> getTopLevelClasses(List<? extends JCCompilationUnit> units) {
1388         List<ClassSymbol> classes = List.nil();
1389         for (JCCompilationUnit unit : units) {
1390             for (JCTree node : unit.defs) {
1391                 if (node.hasTag(JCTree.Tag.CLASSDEF)) {
1392                     ClassSymbol sym = ((JCClassDecl) node).sym;
1393                     Assert.checkNonNull(sym);
1394                     classes = classes.prepend(sym);
1395                 }
1396             }
1397         }
1398         return classes.reverse();
1399     }
1400 
1401     private List<ClassSymbol> getTopLevelClassesFromClasses(List<? extends ClassSymbol> syms) {
1402         List<ClassSymbol> classes = List.nil();
1403         for (ClassSymbol sym : syms) {
1404             if (!isPkgInfo(sym)) {
1405                 classes = classes.prepend(sym);
1406             }
1407         }
1408         return classes.reverse();
1409     }
1410 
1411     private List<PackageSymbol> getPackageInfoFiles(List<? extends JCCompilationUnit> units) {
1412         List<PackageSymbol> packages = List.nil();
1413         for (JCCompilationUnit unit : units) {
1414             if (isPkgInfo(unit.sourcefile, JavaFileObject.Kind.SOURCE)) {
1415                 packages = packages.prepend(unit.packge);
1416             }
1417         }
1418         return packages.reverse();
1419     }
1420 
1421     private List<PackageSymbol> getPackageInfoFilesFromClasses(List<? extends ClassSymbol> syms) {
1422         List<PackageSymbol> packages = List.nil();
1423         for (ClassSymbol sym : syms) {
1424             if (isPkgInfo(sym)) {
1425                 packages = packages.prepend((PackageSymbol) sym.owner);
1426             }
1427         }
1428         return packages.reverse();
1429     }
1430 
1431     private List<ModuleSymbol> getModuleInfoFiles(List<? extends JCCompilationUnit> units) {
1432         List<ModuleSymbol> modules = List.nil();
1433         for (JCCompilationUnit unit : units) {
1434             if (isModuleInfo(unit.sourcefile, JavaFileObject.Kind.SOURCE) && unit.defs.nonEmpty()) {
1435                 for (JCTree tree : unit.defs) {
1436                     if (tree.hasTag(Tag.IMPORT)) {
1437                         continue;
1438                     }
1439                     else if (tree.hasTag(Tag.MODULEDEF)) {
1440                         modules = modules.prepend(unit.modle);
1441                         break;
1442                     }
1443                     else {
1444                         break;
1445                     }
1446                 }
1447             }
1448         }
1449         return modules.reverse();
1450     }
1451 
1452     // avoid unchecked warning from use of varargs
1453     private static <T> List<T> join(List<T> list1, List<T> list2) {
1454         return list1.appendList(list2);
1455     }
1456 
1457     private boolean isPkgInfo(JavaFileObject fo, JavaFileObject.Kind kind) {
1458         return fo.isNameCompatible("package-info", kind);
1459     }
1460 
1461     private boolean isPkgInfo(ClassSymbol sym) {
1462         return isPkgInfo(sym.classfile, JavaFileObject.Kind.CLASS) && (sym.packge().package_info == sym);
1463     }
1464 
1465     private boolean isModuleInfo(JavaFileObject fo, JavaFileObject.Kind kind) {
1466         return fo.isNameCompatible("module-info", kind);
1467     }
1468 
1469     class ImplicitCompleter implements Completer {
1470 
1471         private final JCCompilationUnit topLevel;
1472 
1473         public ImplicitCompleter(JCCompilationUnit topLevel) {
1474             this.topLevel = topLevel;
1475         }
1476 
1477         @Override public void complete(Symbol sym) throws CompletionFailure {
1478             compiler.readSourceFile(topLevel, (ClassSymbol) sym);
1479         }
1480     }
1481 
1482     private final TreeScanner treeCleaner = new TreeScanner() {
1483             public void scan(JCTree node) {
1484                 super.scan(node);
1485                 if (node != null)
1486                     node.type = null;
1487             }
1488             JCCompilationUnit topLevel;
1489             public void visitTopLevel(JCCompilationUnit node) {
1490                 if (node.packge != null) {
1491                     if (isPkgInfo(node.sourcefile, Kind.SOURCE)) {
1492                         node.packge.package_info.reset();
1493                     }
1494                     node.packge.reset();
1495                 }
1496                 if (isModuleInfo(node.sourcefile, Kind.SOURCE)) {
1497                     node.modle.reset();
1498                     node.modle.completer = sym -> modules.enter(List.of(node), node.modle.module_info);
1499                     node.modle.module_info.reset();
1500                     node.modle.module_info.members_field = WriteableScope.create(node.modle.module_info);
1501                 }
1502                 node.packge = null;
1503                 topLevel = node;
1504                 try {
1505                     super.visitTopLevel(node);
1506                 } finally {
1507                     topLevel = null;
1508                 }
1509             }
1510             public void visitClassDef(JCClassDecl node) {
1511                 super.visitClassDef(node);
1512                 // remove generated constructor that may have been added during attribution:
1513                 List<JCTree> beforeConstructor = List.nil();
1514                 List<JCTree> defs = node.defs;
1515                 while (defs.nonEmpty() && !defs.head.hasTag(Tag.METHODDEF)) {
1516                     beforeConstructor = beforeConstructor.prepend(defs.head);
1517                     defs = defs.tail;
1518                 }
1519                 if (defs.nonEmpty() &&
1520                     (((JCMethodDecl) defs.head).mods.flags & Flags.GENERATEDCONSTR) != 0) {
1521                     defs = defs.tail;
1522                     while (beforeConstructor.nonEmpty()) {
1523                         defs = defs.prepend(beforeConstructor.head);
1524                         beforeConstructor = beforeConstructor.tail;
1525                     }
1526                     node.defs = defs;
1527                 }
1528                 if (node.sym != null) {
1529                     node.sym.completer = new ImplicitCompleter(topLevel);
1530                     List<? extends RecordComponent> recordComponents = node.sym.getRecordComponents();
1531                     for (RecordComponent rc : recordComponents) {
1532                         List<JCAnnotation> originalAnnos = rc.getOriginalAnnos();
1533                         originalAnnos.forEach(a -> visitAnnotation(a));
1534                     }
1535                     // we should empty the list of permitted subclasses for next round
1536                     node.sym.clearPermittedSubclasses();
1537                 }
1538                 node.sym = null;
1539             }
1540             public void visitMethodDef(JCMethodDecl node) {
1541                 // remove super constructor call that may have been added during attribution:
1542                 if (TreeInfo.isConstructor(node) && node.sym != null && node.sym.owner.isEnum() &&
1543                     node.body != null && node.body.stats.nonEmpty() && TreeInfo.isSuperCall(node.body.stats.head) &&
1544                     node.body.stats.head.pos == node.body.pos) {
1545                     node.body.stats = node.body.stats.tail;
1546                 }
1547                 node.sym = null;
1548                 super.visitMethodDef(node);
1549             }
1550             public void visitVarDef(JCVariableDecl node) {
1551                 node.sym = null;
1552                 super.visitVarDef(node);
1553             }
1554             public void visitNewClass(JCNewClass node) {
1555                 node.constructor = null;
1556                 super.visitNewClass(node);
1557             }
1558             public void visitAssignop(JCAssignOp node) {
1559                 node.operator = null;
1560                 super.visitAssignop(node);
1561             }
1562             public void visitUnary(JCUnary node) {
1563                 node.operator = null;
1564                 super.visitUnary(node);
1565             }
1566             public void visitBinary(JCBinary node) {
1567                 node.operator = null;
1568                 super.visitBinary(node);
1569             }
1570             public void visitSelect(JCFieldAccess node) {
1571                 node.sym = null;
1572                 super.visitSelect(node);
1573             }
1574             public void visitIdent(JCIdent node) {
1575                 node.sym = null;
1576                 super.visitIdent(node);
1577             }
1578             public void visitAnnotation(JCAnnotation node) {
1579                 node.attribute = null;
1580                 super.visitAnnotation(node);
1581             }
1582         };
1583 
1584 
1585     private boolean moreToDo() {
1586         return filer.newFiles();
1587     }
1588 
1589     /**
1590      * {@inheritDoc}
1591      *
1592      * Command line options suitable for presenting to annotation
1593      * processors.
1594      * {@literal "-Afoo=bar"} should be {@literal "-Afoo" => "bar"}.
1595      */
1596     @DefinedBy(Api.ANNOTATION_PROCESSING)
1597     public Map<String,String> getOptions() {
1598         return processorOptions;
1599     }
1600 
1601     @DefinedBy(Api.ANNOTATION_PROCESSING)
1602     public Messager getMessager() {
1603         return messager;
1604     }
1605 
1606     @DefinedBy(Api.ANNOTATION_PROCESSING)
1607     public JavacFiler getFiler() {
1608         return filer;
1609     }
1610 
1611     @DefinedBy(Api.ANNOTATION_PROCESSING)
1612     public JavacElements getElementUtils() {
1613         return elementUtils;
1614     }
1615 
1616     @DefinedBy(Api.ANNOTATION_PROCESSING)
1617     public JavacTypes getTypeUtils() {
1618         return typeUtils;
1619     }
1620 
1621     @DefinedBy(Api.ANNOTATION_PROCESSING)
1622     public SourceVersion getSourceVersion() {
1623         return Source.toSourceVersion(source);
1624     }
1625 
1626     @DefinedBy(Api.ANNOTATION_PROCESSING)
1627     public Locale getLocale() {
1628         return messages.getCurrentLocale();
1629     }
1630 
1631     @DefinedBy(Api.ANNOTATION_PROCESSING)
1632     public boolean isPreviewEnabled() {
1633         return preview.isEnabled();
1634     }
1635 
1636     public Set<Symbol.PackageSymbol> getSpecifiedPackages() {
1637         return specifiedPackages;
1638     }
1639 
1640     public static final Pattern noMatches  = Pattern.compile("(\\P{all})+");
1641 
1642     /**
1643      * Convert import-style string for supported annotations into a
1644      * regex matching that string.  If the string is not a valid
1645      * import-style string, return a regex that won't match anything.
1646      */
1647     private static Pattern importStringToPattern(boolean allowModules, String s, Processor p, Log log) {
1648         String module;
1649         String pkg;
1650         int slash = s.indexOf('/');
1651         if (slash == (-1)) {
1652             if (s.equals("*")) {
1653                 return MatchingUtils.validImportStringToPattern(s);
1654             }
1655             module = allowModules ? ".*/" : "";
1656             pkg = s;
1657         } else {
1658             String moduleName = s.substring(0, slash);
1659             if (!SourceVersion.isName(moduleName)) {
1660                 return warnAndNoMatches(s, p, log);
1661             }
1662             module = Pattern.quote(moduleName + "/");
1663             // And warn if module is specified if modules aren't supported, conditional on -Xlint:proc?
1664             pkg = s.substring(slash + 1);
1665         }
1666         if (MatchingUtils.isValidImportString(pkg)) {
1667             return Pattern.compile(module + MatchingUtils.validImportStringToPatternString(pkg));
1668         } else {
1669             return warnAndNoMatches(s, p, log);
1670         }
1671     }
1672 
1673     private static Pattern warnAndNoMatches(String s, Processor p, Log log) {
1674         log.warning(LintWarnings.ProcMalformedSupportedString(s, p.getClass().getName()));
1675         return noMatches; // won't match any valid identifier
1676     }
1677 
1678     /**
1679      * For internal use only.  This method may be removed without warning.
1680      */
1681     public Context getContext() {
1682         return context;
1683     }
1684 
1685     /**
1686      * For internal use only.  This method may be removed without warning.
1687      */
1688     public ClassLoader getProcessorClassLoader() {
1689         return processorClassLoader;
1690     }
1691 
1692     public String toString() {
1693         return "javac ProcessingEnvironment";
1694     }
1695 
1696     public static boolean isValidOptionName(String optionName) {
1697         for(String s : optionName.split("\\.", -1)) {
1698             if (!SourceVersion.isIdentifier(s))
1699                 return false;
1700         }
1701         return true;
1702     }
1703 }