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