javax.annotation.processing.Processor Java Examples

/**
 * Check if we should process annotations.
 * If so, and if no scanner is yet registered, then set up the DocCommentScanner
 * to catch doc comments, and set keepComments so the parser records them in
 * the compilation unit.
 *
 * @param processors user provided annotation processors to bypass
 * discovery, {@code null} means that no processors were provided
 */
public void initProcessAnnotations(Iterable<? extends Processor> processors) {
    // Process annotations if processing is not disabled and there
    // is at least one Processor available.
    if (options.isSet(PROC, "none")) {
        processAnnotations = false;
    } else if (procEnvImpl == null) {
        procEnvImpl = JavacProcessingEnvironment.instance(context);
        procEnvImpl.setProcessors(processors);
        processAnnotations = procEnvImpl.atLeastOneProcessor();

        if (processAnnotations) {
            options.put("save-parameter-names", "save-parameter-names");
            reader.saveParameterNames = true;
            keepComments = true;
            genEndPos = true;
            if (!taskListener.isEmpty())
                taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING));
            deferredDiagnosticHandler = new Log.DeferredDiagnosticHandler(log);
        } else { // free resources
            procEnvImpl.close();
        }
    }
}
 

public void testBadAnnotationProcessor(Path base) throws Exception {
    Path apDir = base.resolve("annoprocessor");
    ToolBox.writeFile(apDir.resolve("META-INF").resolve("services")
                      .resolve(Processor.class.getCanonicalName()), "BadAnnoProcessor");
    ToolBox.writeFile(apDir.resolve("BadAnnoProcessor.class"), "badannoprocessor");

    Path classes = base.resolve("classes");
    Files.createDirectories(classes);

    List<String> actualErrors = new ArrayList<>();
    ToolBox.JavaToolArgs args = new ToolBox.JavaToolArgs();
    args.setSources("package test; public class Test {}")
        .appendArgs("-XDrawDiagnostics",
                    "-d", classes.toString(),
                    "-classpath", "",
                    "-processorpath", apDir.toString())
        .set(ToolBox.Expect.FAIL)
        .setErrOutput(actualErrors);
    ToolBox.javac(args);

    System.out.println(actualErrors.get(0));
    if (!actualErrors.get(0).contains("- compiler.err.proc.cant.load.class: " +
                                      "Incompatible magic value")) {
        throw new AssertionError("Unexpected errors reported: " + actualErrors);
    }
}
 

public void testMissingAnnotationProcessor(Path base) throws Exception {
    Path apDir = base.resolve("annoprocessor");
    ToolBox.writeFile(apDir.resolve("META-INF").resolve("services").resolve(Processor.class.getCanonicalName()),
                 "MissingAnnoProcessor");

    Path classes = base.resolve("classes");
    Files.createDirectories(classes);

    List<String> actualErrors = new ArrayList<>();
    ToolBox.JavaToolArgs args = new ToolBox.JavaToolArgs();
    args.setSources("package test; public class Test {}")
        .appendArgs("-XDrawDiagnostics",
                    "-d", classes.toString(),
                    "-classpath", "",
                    "-processorpath", apDir.toString())
        .set(ToolBox.Expect.FAIL)
        .setErrOutput(actualErrors);
    ToolBox.javac(args);

    if (!actualErrors.get(0).contains("- compiler.err.proc.bad.config.file: " +
        "javax.annotation.processing.Processor: Provider MissingAnnoProcessor not found")) {
        throw new AssertionError("Unexpected errors reported: " + actualErrors);
    }
}
 

/**
 * Check if we should process annotations.
 * If so, and if no scanner is yet registered, then set up the DocCommentScanner
 * to catch doc comments, and set keepComments so the parser records them in
 * the compilation unit.
 *
 * @param processors user provided annotation processors to bypass
 * discovery, {@code null} means that no processors were provided
 */
public void initProcessAnnotations(Iterable<? extends Processor> processors) {
    // Process annotations if processing is not disabled and there
    // is at least one Processor available.
    if (options.isSet(PROC, "none")) {
        processAnnotations = false;
    } else if (procEnvImpl == null) {
        procEnvImpl = JavacProcessingEnvironment.instance(context);
        procEnvImpl.setProcessors(processors);
        processAnnotations = procEnvImpl.atLeastOneProcessor();

        if (processAnnotations) {
            options.put("save-parameter-names", "save-parameter-names");
            reader.saveParameterNames = true;
            keepComments = true;
            genEndPos = true;
            if (!taskListener.isEmpty())
                taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING));
            deferredDiagnosticHandler = new Log.DeferredDiagnosticHandler(log);
        } else { // free resources
            procEnvImpl.close();
        }
    }
}
 

public void testMissingAnnotationProcessor(Path base) throws Exception {
    Path apDir = base.resolve("annoprocessor");
    ToolBox.writeFile(apDir.resolve("META-INF").resolve("services").resolve(Processor.class.getCanonicalName()),
                 "MissingAnnoProcessor");

    Path classes = base.resolve("classes");
    Files.createDirectories(classes);

    List<String> actualErrors = new ArrayList<>();
    ToolBox.JavaToolArgs args = new ToolBox.JavaToolArgs();
    args.setSources("package test; public class Test {}")
        .appendArgs("-XDrawDiagnostics",
                    "-d", classes.toString(),
                    "-classpath", "",
                    "-processorpath", apDir.toString())
        .set(ToolBox.Expect.FAIL)
        .setErrOutput(actualErrors);
    ToolBox.javac(args);

    if (!actualErrors.get(0).contains("- compiler.err.proc.bad.config.file: " +
        "javax.annotation.processing.Processor: Provider MissingAnnoProcessor not found")) {
        throw new AssertionError("Unexpected errors reported: " + actualErrors);
    }
}
 

/**
 * Returns an empty processor iterator if no processors are on the
 * relevant path, otherwise if processors are present, logs an
 * error.  Called when a service loader is unavailable for some
 * reason, either because a service loader class cannot be found
 * or because a security policy prevents class loaders from being
 * created.
 *
 * @param key The resource key to use to log an error message
 * @param e   If non-null, pass this exception to Abort
 */
private Iterator<Processor> handleServiceLoaderUnavailability(String key, Exception e) {
    if (fileManager instanceof JavacFileManager) {
        StandardJavaFileManager standardFileManager = (JavacFileManager) fileManager;
        Iterable<? extends File> workingPath = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
            ? standardFileManager.getLocation(ANNOTATION_PROCESSOR_PATH)
            : standardFileManager.getLocation(CLASS_PATH);

        if (needClassLoader(options.get(Option.PROCESSOR), workingPath) )
            handleException(key, e);

    } else {
        handleException(key, e);
    }

    java.util.List<Processor> pl = Collections.emptyList();
    return pl.iterator();
}
 

private boolean needClassLoader(String procNames, Iterable<? extends File> workingpath) {
    if (procNames != null)
        return true;

    URL[] urls = new URL[1];
    for(File pathElement : workingpath) {
        try {
            urls[0] = pathElement.toURI().toURL();
            if (ServiceProxy.hasService(Processor.class, urls))
                return true;
        } catch (MalformedURLException ex) {
            throw new AssertionError(ex);
        }
        catch (ServiceProxy.ServiceConfigurationError e) {
            log.error(Errors.ProcBadConfigFile(e.getLocalizedMessage()));
            return true;
        }
    }

    return false;
}
 

private Collection<Processor> lookupProcessors(ClassLoader cl, boolean onScan, boolean isModule) {
    Iterable<? extends String> processorNames = aptOptions.annotationProcessorsToRun();
    if (processorNames == null) {
        processorNames = getProcessorNames(cl, isModule);
    }
    List<Processor> result = new LinkedList<Processor>();
    for (String name : processorNames) {
        try {
            Class<?> clazz = Class.forName(name, true, cl);
            Object instance = clazz.newInstance();
            if (instance instanceof Processor) {
                result.add(new ErrorToleratingProcessor((Processor) instance));
            }
        } catch (ThreadDeath td) {
            throw td;
        } catch (Throwable t) {
            LOG.log(Level.FINE, null, t);
        }
    }
    if (!onScan)
        result.addAll(HARDCODED_PROCESSORS.lookupAll(Processor.class));
    return result;
}
 

@Test
public void testOriginatingElement() {
  JavaFileObject source =
      JavaFileObjects.forSourceString(
          "test.TestOriginatingElement",
          Joiner.on('\n')
              .join( //
                  "package test;", //
                  "import javax.inject.Inject;", //
                  "public class TestOriginatingElement {", //
                  "  @Inject public TestOriginatingElement() {}", //
                  "}" //
                  ));

  Iterable<? extends Processor> processors = ProcessorTestUtilities.factoryProcessors();

  assert_().about(javaSource()).that(source).processedWith(processors).compilesWithoutError();

  FactoryProcessor factoryProcessor = (FactoryProcessor) processors.iterator().next();
  TypeElement enclosingElement =
      factoryProcessor.getOriginatingElement("test.TestOriginatingElement__Factory");
  assertTrue(enclosingElement.getQualifiedName().contentEquals("test.TestOriginatingElement"));
}
 

/**
 * Check if we should process annotations.
 * If so, and if no scanner is yet registered, then set up the DocCommentScanner
 * to catch doc comments, and set keepComments so the parser records them in
 * the compilation unit.
 *
 * @param processors user provided annotation processors to bypass
 * discovery, {@code null} means that no processors were provided
 */
public void initProcessAnnotations(Iterable<? extends Processor> processors) {
    // Process annotations if processing is not disabled and there
    // is at least one Processor available.
    if (options.isSet(PROC, "none")) {
        processAnnotations = false;
    } else if (procEnvImpl == null) {
        procEnvImpl = JavacProcessingEnvironment.instance(context);
        procEnvImpl.setProcessors(processors);
        processAnnotations = procEnvImpl.atLeastOneProcessor();

        if (processAnnotations) {
            options.put("save-parameter-names", "save-parameter-names");
            reader.saveParameterNames = true;
            keepComments = true;
            genEndPos = true;
            if (!taskListener.isEmpty())
                taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING));
            deferredDiagnosticHandler = new Log.DeferredDiagnosticHandler(log);
        } else { // free resources
            procEnvImpl.close();
        }
    }
}
 

/**
 * Check if we should process annotations.
 * If so, and if no scanner is yet registered, then set up the DocCommentScanner
 * to catch doc comments, and set keepComments so the parser records them in
 * the compilation unit.
 *
 * @param processors user provided annotation processors to bypass
 * discovery, {@code null} means that no processors were provided
 */
public void initProcessAnnotations(Iterable<? extends Processor> processors) {
    // Process annotations if processing is not disabled and there
    // is at least one Processor available.
    if (options.isSet(PROC, "none")) {
        processAnnotations = false;
    } else if (procEnvImpl == null) {
        procEnvImpl = JavacProcessingEnvironment.instance(context);
        procEnvImpl.setProcessors(processors);
        processAnnotations = procEnvImpl.atLeastOneProcessor();

        if (processAnnotations) {
            options.put("save-parameter-names", "save-parameter-names");
            reader.saveParameterNames = true;
            keepComments = true;
            genEndPos = true;
            if (!taskListener.isEmpty())
                taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING));
            deferredDiagnosticHandler = new Log.DeferredDiagnosticHandler(log);
        } else { // free resources
            procEnvImpl.close();
        }
    }
}
 

/**
 * Main method: compile a list of files, return all compiled classes
 *
 * @param sourceFileObjects file objects to be compiled
 * @param classnames class names to process for annotations
 * @param processors user provided annotation processors to bypass
 * discovery, {@code null} means that no processors were provided
 */
public void compile(List<JavaFileObject> sourceFileObjects,
                    List<String> classnames,
                    Iterable<? extends Processor> processors)
{
    if (processors != null && processors.iterator().hasNext())
        explicitAnnotationProcessingRequested = true;
    // as a JavaCompiler can only be used once, throw an exception if
    // it has been used before.
    if (hasBeenUsed)
        throw new AssertionError("attempt to reuse JavaCompiler");
    hasBeenUsed = true;

    // forcibly set the equivalent of -Xlint:-options, so that no further
    // warnings about command line options are generated from this point on
    options.put(XLINT_CUSTOM.text + "-" + LintCategory.OPTIONS.option, "true");
    options.remove(XLINT_CUSTOM.text + LintCategory.OPTIONS.option);

    start_msec = now();

    try {
        initProcessAnnotations(processors);

        // These method calls must be chained to avoid memory leaks
        delegateCompiler =
            processAnnotations(
                enterTrees(stopIfError(CompileState.PARSE, parseFiles(sourceFileObjects))),
                classnames);

        delegateCompiler.compile2();
        delegateCompiler.close();
        elapsed_msec = delegateCompiler.elapsed_msec;
    } catch (Abort ex) {
        if (devVerbose)
            ex.printStackTrace(System.err);
    } finally {
        if (procEnvImpl != null)
            procEnvImpl.close();
    }
}
 

/** Programmatic interface for main function.
 * @param args    The command line parameters.
 */
public Result compile(String[] args,
                   Context context,
                   List<JavaFileObject> fileObjects,
                   Iterable<? extends Processor> processors)
{
    return compile(args,  null, context, fileObjects, processors);
}
 

/**
 * Main method: compile a list of files, return all compiled classes
 *
 * @param sourceFileObjects file objects to be compiled
 * @param classnames class names to process for annotations
 * @param processors user provided annotation processors to bypass
 * discovery, {@code null} means that no processors were provided
 */
public void compile(List<JavaFileObject> sourceFileObjects,
                    List<String> classnames,
                    Iterable<? extends Processor> processors)
{
    if (processors != null && processors.iterator().hasNext())
        explicitAnnotationProcessingRequested = true;
    // as a JavaCompiler can only be used once, throw an exception if
    // it has been used before.
    if (hasBeenUsed)
        throw new AssertionError("attempt to reuse JavaCompiler");
    hasBeenUsed = true;

    // forcibly set the equivalent of -Xlint:-options, so that no further
    // warnings about command line options are generated from this point on
    options.put(XLINT_CUSTOM.text + "-" + LintCategory.OPTIONS.option, "true");
    options.remove(XLINT_CUSTOM.text + LintCategory.OPTIONS.option);

    start_msec = now();

    try {
        initProcessAnnotations(processors);

        // These method calls must be chained to avoid memory leaks
        delegateCompiler =
            processAnnotations(
                enterTrees(stopIfError(CompileState.PARSE, parseFiles(sourceFileObjects))),
                classnames);

        delegateCompiler.compile2();
        delegateCompiler.close();
        elapsed_msec = delegateCompiler.elapsed_msec;
    } catch (Abort ex) {
        if (devVerbose)
            ex.printStackTrace(System.err);
    } finally {
        if (procEnvImpl != null)
            procEnvImpl.close();
    }
}
 

public boolean apply(Processor processor) {
  ProcessingEnvironment processingEnvironment = mock(ProcessingEnvironment.class);
  when(processingEnvironment.getOptions()).thenReturn(options);
  when(processingEnvironment.getTypeUtils()).thenReturn(types);
  when(processingEnvironment.getElementUtils()).thenReturn(elements);
  processor.init(processingEnvironment);

  return processor.process(environment.getAnnotations(), environment);
}
 

public void setProcessors(Iterable<? extends Processor> processors) {
    processors.getClass(); // null check
    // not mt-safe
    if (used.get())
        throw new IllegalStateException();
    this.processors = processors;
}
 

private void analyzeClasses(Map<String, Type> types, Set<Import> imports, Map<String, List<String>> interfaces,
        Collection<Path> pathsToCommpile, String note) {
    /*
     * There should not be compilation errors, but without our own diagnostic listener any compilation errors will
     * appear in the build output. We want to suppress those because we want to gather information about the interfaces
     * and classes, not actually compile them into .class files.
     */
    DiagnosticListener<JavaFileObject> diagListener = diagnostic -> {
        debugLog(() -> diagnostic.toString());
    };

    JavaCompiler jc = ToolProvider.getSystemJavaCompiler();
    StandardJavaFileManager fm = jc.getStandardFileManager(null, null, null);

    JavaCompiler.CompilationTask task = jc.getTask(null, fm, diagListener, null, null,
            javaFilesToCompile(fm, pathsToCommpile));
    List<Processor> procs = new ArrayList<>();
    EndpointProcessor ep = new EndpointProcessor(new EndpointScanner(types, imports, interfaces));
    procs.add(ep);
    task.setProcessors(procs);
    task.call();

    getLog().info(String.format("Types prepared for %s: %d", note, types.size()));
    debugLog(() -> String.format("Types prepared for %s: %s", note, types));
    debugLog(() -> String.format("Imports after analyzing %s: %s", note,
            imports.stream().sorted().map(Import::toString).collect(Collectors.joining(","))));
    debugLog(() -> String.format("Interface impls after analyzing %s: %s", note, interfaces));
}
 

/**
 * Main method: compile a list of files, return all compiled classes
 *
 * @param sourceFileObjects file objects to be compiled
 * @param classnames class names to process for annotations
 * @param processors user provided annotation processors to bypass
 * discovery, {@code null} means that no processors were provided
 */
public void compile(List<JavaFileObject> sourceFileObjects,
                    List<String> classnames,
                    Iterable<? extends Processor> processors)
{
    if (processors != null && processors.iterator().hasNext())
        explicitAnnotationProcessingRequested = true;
    // as a JavaCompiler can only be used once, throw an exception if
    // it has been used before.
    if (hasBeenUsed)
        throw new AssertionError("attempt to reuse JavaCompiler");
    hasBeenUsed = true;

    // forcibly set the equivalent of -Xlint:-options, so that no further
    // warnings about command line options are generated from this point on
    options.put(XLINT_CUSTOM.text + "-" + LintCategory.OPTIONS.option, "true");
    options.remove(XLINT_CUSTOM.text + LintCategory.OPTIONS.option);

    start_msec = now();

    try {
        initProcessAnnotations(processors);

        // These method calls must be chained to avoid memory leaks
        delegateCompiler =
            processAnnotations(
                enterTrees(stopIfError(CompileState.PARSE, parseFiles(sourceFileObjects))),
                classnames);

        delegateCompiler.compile2();
        delegateCompiler.close();
        elapsed_msec = delegateCompiler.elapsed_msec;
    } catch (Abort ex) {
        if (devVerbose)
            ex.printStackTrace(System.err);
    } finally {
        if (procEnvImpl != null)
            procEnvImpl.close();
    }
}
 

/**
 * Main method: compile a list of files, return all compiled classes
 *
 * @param sourceFileObjects file objects to be compiled
 * @param classnames        class names to process for annotations
 * @param processors        user provided annotation processors to bypass
 *                          discovery, {@code null} means that no processors were provided
 */
public void compile(List<JavaFileObject> sourceFileObjects,
                    List<String> classnames,
                    Iterable<? extends Processor> processors) {
    if (processors != null && processors.iterator().hasNext())
        explicitAnnotationProcessingRequested = true;
    // as a JavaCompiler can only be used once, throw an exception if
    // it has been used before.
    if (hasBeenUsed)
        throw new AssertionError("attempt to reuse JavaCompiler");
    hasBeenUsed = true;

    // forcibly set the equivalent of -Xlint:-options, so that no further
    // warnings about command line options are generated from this point on
    options.put(XLINT_CUSTOM + "-" + LintCategory.OPTIONS.option, "true");
    options.remove(XLINT_CUSTOM + LintCategory.OPTIONS.option);

    start_msec = now();

    try {
        initProcessAnnotations(processors);

        // These method calls must be chained to avoid memory leaks
        delegateCompiler =
                processAnnotations(
                        enterTrees(stopIfError(CompileState.PARSE, parseFiles(sourceFileObjects))),
                        classnames);

        delegateCompiler.compile2();
        delegateCompiler.close();
        elapsed_msec = delegateCompiler.elapsed_msec;
    } catch (Abort ex) {
        if (devVerbose)
            ex.printStackTrace(System.err);
    } finally {
        if (procEnvImpl != null)
            procEnvImpl.close();
    }
}
 

static Iterable<? extends Processor> factoryProcessorsWithAdditionalTypes(String... types) {
  FactoryProcessor factoryProcessor = new FactoryProcessor();
  for (String type : types) {
    factoryProcessor.addSupportedAnnotationType(type);
  }

  return Arrays.asList(factoryProcessor);
}
 

/** Programmatic interface for main function.
 * @param args    The command line parameters.
 */
public Result compile(String[] args,
                   Context context,
                   List<JavaFileObject> fileObjects,
                   Iterable<? extends Processor> processors)
{
    return compile(args,  null, context, fileObjects, processors);
}
 

/**
 * Main method: compile a list of files, return all compiled classes
 *
 * @param sourceFileObjects file objects to be compiled
 * @param classnames class names to process for annotations
 * @param processors user provided annotation processors to bypass
 * discovery, {@code null} means that no processors were provided
 */
public void compile(List<JavaFileObject> sourceFileObjects,
                    List<String> classnames,
                    Iterable<? extends Processor> processors)
{
    if (processors != null && processors.iterator().hasNext())
        explicitAnnotationProcessingRequested = true;
    // as a JavaCompiler can only be used once, throw an exception if
    // it has been used before.
    if (hasBeenUsed)
        throw new AssertionError("attempt to reuse JavaCompiler");
    hasBeenUsed = true;

    // forcibly set the equivalent of -Xlint:-options, so that no further
    // warnings about command line options are generated from this point on
    options.put(XLINT_CUSTOM.text + "-" + LintCategory.OPTIONS.option, "true");
    options.remove(XLINT_CUSTOM.text + LintCategory.OPTIONS.option);

    start_msec = now();

    try {
        initProcessAnnotations(processors);

        // These method calls must be chained to avoid memory leaks
        delegateCompiler =
            processAnnotations(
                enterTrees(stopIfError(CompileState.PARSE, parseFiles(sourceFileObjects))),
                classnames);

        delegateCompiler.compile2();
        delegateCompiler.close();
        elapsed_msec = delegateCompiler.elapsed_msec;
    } catch (Abort ex) {
        if (devVerbose)
            ex.printStackTrace(System.err);
    } finally {
        if (procEnvImpl != null)
            procEnvImpl.close();
    }
}
 

/**
 * Create a ProcessorInfo wrapping a particular Processor. The Processor must already have been
 * initialized (that is,
 * {@link Processor#init(javax.annotation.processing.ProcessingEnvironment)} must already have
 * been called). Its getSupportedXXX() methods will be called and the results will be cached.
 */
public ProcessorInfo(Processor p) 
{
	_processor = p;
	_hasBeenCalled = false;
	_supportedSourceVersion = p.getSupportedSourceVersion();
	_supportedOptions = p.getSupportedOptions();
	Set<String> supportedAnnotationTypes = p.getSupportedAnnotationTypes();
	
	boolean supportsStar = false;
	if (null != supportedAnnotationTypes && !supportedAnnotationTypes.isEmpty()) {
		StringBuilder regex = new StringBuilder();
		Iterator<String> iName = supportedAnnotationTypes.iterator();
		while (true) {
			String name = iName.next();
			supportsStar |= "*".equals(name);  //$NON-NLS-1$
			String escapedName1 = name.replace(".", "\\."); //$NON-NLS-1$ //$NON-NLS-2$
			String escapedName2 = escapedName1.replace("*", ".*"); //$NON-NLS-1$ //$NON-NLS-2$
			regex.append(escapedName2);
			if (!iName.hasNext()) {
				break;
			}
			regex.append('|');
		}
		_supportedAnnotationTypesPattern = Pattern.compile(regex.toString());
	}
	else {
		_supportedAnnotationTypesPattern = null;
	}
	_supportsStar = supportsStar;
}
 

public void setProcessors(Iterable<? extends Processor> processors) {
    processors.getClass(); // null check
    // not mt-safe
    if (used.get())
        throw new IllegalStateException();
    this.processors = processors;
}
 

public void testWrongClassFileVersion(Path base) throws Exception {
    Path apDir = base.resolve("annoprocessor");
    ToolBox.writeFile(apDir.resolve("META-INF").resolve("services").resolve(Processor.class.getCanonicalName()),
                 "WrongClassFileVersion");

    ToolBox.JavaToolArgs args = new ToolBox.JavaToolArgs();
    args.setSources("class WrongClassFileVersion {}")
        .appendArgs("-d", apDir.toString())
        .set(ToolBox.Expect.SUCCESS);
    ToolBox.javac(args);

    increaseMajor(apDir.resolve("WrongClassFileVersion.class"), 1);

    Path classes = base.resolve("classes");
    Files.createDirectories(classes);

    List<String> actualErrors = new ArrayList<>();
    args = new ToolBox.JavaToolArgs();
    args.setSources("package test; public class Test {}")
        .appendArgs("-XDrawDiagnostics",
                    "-d", classes.toString(),
                    "-classpath", "",
                    "-processorpath", apDir.toString())
        .set(ToolBox.Expect.FAIL)
        .setErrOutput(actualErrors);
    ToolBox.javac(args);

    if (!actualErrors.get(0).contains("- compiler.err.proc.cant.load.class: " +
        "WrongClassFileVersion has been compiled by a more recent version")) {
        throw new AssertionError("Unexpected errors reported: " + actualErrors);
    }
}
 

ServiceIterator(ClassLoader classLoader, Log log) {
    this.log = log;
    try {
        try {
            loader = ServiceLoader.load(Processor.class, classLoader);
            this.iterator = loader.iterator();
        } catch (Exception e) {
            // Fail softly if a loader is not actually needed.
            this.iterator = handleServiceLoaderUnavailability("proc.no.service", null);
        }
    } catch (Throwable t) {
        log.error(Errors.ProcServiceProblem);
        throw new Abort(t);
    }
}
 

public CompilationSubject compiles() {
  if (compilationException != null) {
    throw compilationException;
  }
  if (subject == null) {
    SingleBehaviorTester tester = new SingleBehaviorTester(features);
    for (Processor processor : processors) {
      tester.with(processor);
    }
    processors = null;  // Allow compilers to be reclaimed by GC (processors retain a reference)
    for (JavaFileObject compilationUnit : compilationUnits.values()) {
      tester.with(compilationUnit);
    }
    for (TestSource testSource : testSources) {
      tester.with(testSource);
    }
    for (Package pkg : permittedPackages) {
      tester.withPermittedPackage(pkg);
    }
    try {
      subject = tester.compiles();
    } catch (RuntimeException e) {
      compilationException = e;
      throw e;
    }
  }
  return subject;
}
 

@Override
public Processor next() {
    try {
        return internalNext();
    } catch (ServiceConfigurationError sce) {
        log.error(Errors.ProcBadConfigFile(sce.getLocalizedMessage()));
        throw new Abort(sce);
    } catch (Throwable t) {
        throw new Abort(t);
    }
}
 

@Override
boolean internalHasNext() {
    if (nextProc != null) {
        return true;
    }
    if (!processorNames.hasNext()) {
        namedProcessorsMap = null;
        return false;
    }
    String processorName = processorNames.next();
    Processor theProcessor = namedProcessorsMap.get(processorName);
    if (theProcessor != null) {
        namedProcessorsMap.remove(processorName);
        nextProc = theProcessor;
        return true;
    } else {
        while (iterator.hasNext()) {
            theProcessor = iterator.next();
            String name = theProcessor.getClass().getName();
            if (name.equals(processorName)) {
                nextProc = theProcessor;
                return true;
            } else {
                namedProcessorsMap.put(name, theProcessor);
            }
        }
        log.error(Errors.ProcProcessorNotFound(processorName));
        return false;
    }
}
 

@Override
Processor internalNext() {
    if (hasNext()) {
        Processor p = nextProc;
        nextProc = null;
        return p;
    } else {
        throw new NoSuchElementException();
    }
}