javax.annotation.processing.AbstractProcessor Java Examples

/**
 * Test that the ijar tool preserves EnclosingMethod attributes and doesn't prevent annotation
 * processors from accessing all the elements in a package.
 */
@Test
public void testEnclosingMethod() throws IOException {
  JavaCompiler.CompilationTask task =
      makeCompilationTask("third_party/ijar/test/package-info.java");
  task.setProcessors(
      Arrays.asList(
          new AbstractProcessor() {
            @Override
            public Set<String> getSupportedAnnotationTypes() {
              return Collections.singleton("*");
            }

            @Override
            public boolean process(
                Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
              roundEnv.getElementsAnnotatedWith(java.lang.Override.class);
              return true;
            }
          }));
  if (!task.call()) {
    fail(getFailedCompilationMessage());
  }
}
 

protected void check() throws Exception {
    String[] options = {
        "-XDshouldStopPolicy=ATTR",
        "-XDverboseResolution=success,failure,applicable,inapplicable,deferred-inference,predef"
    };

    AbstractProcessor[] processors = { new ResolveCandidateFinder(), null };

    @SuppressWarnings("unchecked")
    DiagnosticListener<? super JavaFileObject>[] diagListeners =
            new DiagnosticListener[] { new DiagnosticHandler(false), new DiagnosticHandler(true) };

    for (int i = 0 ; i < options.length ; i ++) {
        JavacTask ct = (JavacTask)comp.getTask(null, fm, diagListeners[i],
                Arrays.asList(options[i]), null, Arrays.asList(jfo));
        if (processors[i] != null) {
            ct.setProcessors(Collections.singleton(processors[i]));
        }
        ct.analyze();
    }

    //check diags
    for (Diagnostic<? extends JavaFileObject> diag : diags) {
        for (DiagnosticProcessor proc : diagProcessors) {
            if (proc.matches(diag)) {
                proc.process(diag);
                break;
            }
        }
    }
    //check all candidates have been used up
    for (Map.Entry<ElementKey, Candidate> entry : candidatesMap.entrySet()) {
        if (!seenCandidates.contains(entry.getKey())) {
            error("Redundant @Candidate annotation on method " + entry.getKey().elem + " sig = " + entry.getKey().elem.asType());
        }
    }
}
 

@Test public void errorTypes() {
  JavaFileObject hasErrorTypes =
      JavaFileObjects.forSourceLines(
          "com.squareup.tacos.ErrorTypes",
          "package com.squareup.tacos;",
          "",
          "@SuppressWarnings(\"hook-into-compiler\")",
          "class ErrorTypes {",
          "  Tacos tacos;",
          "  Ingredients.Guacamole guacamole;",
          "}");
  Compilation compilation = javac().withProcessors(new AbstractProcessor() {
    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
      TypeElement classFile =
          processingEnv.getElementUtils().getTypeElement("com.squareup.tacos.ErrorTypes");
      List<VariableElement> fields = fieldsIn(classFile.getEnclosedElements());
      ErrorType topLevel = (ErrorType) fields.get(0).asType();
      ErrorType member = (ErrorType) fields.get(1).asType();

      assertThat(TypeName.get(topLevel)).isEqualTo(ClassName.get("", "Tacos"));
      assertThat(TypeName.get(member)).isEqualTo(ClassName.get("Ingredients", "Guacamole"));
      return false;
    }

    @Override
    public Set<String> getSupportedAnnotationTypes() {
      return Collections.singleton("*");
    }
  }).compile(hasErrorTypes);

  assertThat(compilation).failed();
}
 

@Test
public void testCallbackIssuedAfterEnterWithAPs() throws IOException {
  // We add an unrelated source file here to make the compiler do something
  compiler.addSourceFileContents("Bar.java", "class Bar { }");
  compiler.setProcessors(
      ImmutableList.of(
          new AbstractProcessor() {
            @Override
            public Set<String> getSupportedAnnotationTypes() {
              return Collections.singleton("*");
            }

            @Override
            public boolean process(
                Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
              if (roundEnv.processingOver()) {
                Filer filer = processingEnv.getFiler();
                // We wait until the last possible moment to generate Foo; if the callback is able
                // to get an element for it, that means it ran after the enter phase
                try (OutputStream outputStream =
                    filer.createSourceFile("Foo").openOutputStream()) {
                  outputStream.write("class Foo { }".getBytes());
                } catch (IOException e) {
                  throw new AssertionError(e);
                }
              }
              return false;
            }
          }));
  addCallback("callback");
  compiler.compile();

  assertThat(callbacksIssued, Matchers.contains("callback: Bar, Foo"));
}
 

@Test
public void testGen() throws Exception {

  AtomicInteger count = new AtomicInteger();
  AbstractProcessor proc = new AbstractProcessor() {
    @Override
    public Set<String> getSupportedAnnotationTypes() {
      return Collections.singleton("*");
    }
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
      if  (count.getAndIncrement() == 0) {
        try {
          Filer filer = processingEnv.getFiler();
          Element elt = processingEnv.getElementUtils().getTypeElement("gen.GeneratedClass");
          JavaFileObject src = filer.createSourceFile("io.vertx.test.gen.GeneratedClass", elt);
          try (Writer writer = src.openWriter()) {
            writer.append("package io.vertx.test.gen;\npublic class GeneratedClass {\n}");
          }
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
      return true;
    }
  };

  Compiler<TestGenProcessor> compiler = buildCompiler(new TestGenProcessor(),  "io.vertx.test.gen");
  compiler.addProcessor(proc);
  compiler.assertCompile();
  assertEquals(3, count.get());

}
 

public static void assertProcess(BiConsumer<ProcessingEnvironment, RoundEnvironment> test) {
  File f = null;
  try {
    f = Files.createTempFile("test", ".java").toFile();
    try (PrintWriter writer = new PrintWriter(f)) {
      writer.print("class Empty {}");
    }
  } catch (IOException e) {
    throw new AssertionError(e);
  }
  JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
  StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, Locale.getDefault(), Charset.defaultCharset());
  JavaCompiler.CompilationTask task = compiler.getTask(new PrintWriter(System.out),
      fileManager,
      diagnostics,
      Collections.singletonList("-proc:only"),
      Collections.emptyList(),
      fileManager.getJavaFileObjectsFromFiles(Collections.singletonList(f)));
  task.setLocale(Locale.getDefault());
  task.setProcessors(Collections.singleton(new AbstractProcessor() {
    @Override
    public Set<String> getSupportedAnnotationTypes() {
      return Collections.singleton("*");
    }
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
      test.accept(processingEnv, roundEnv);
      return true;
    }
  }));
  assertTrue(task.call());
}
 

private static AbstractProcessor createWrappedInstance() {
	ClassLoader cl = Main.createShadowClassLoader();
	try {
		Class<?> mc = cl.loadClass("lombok.core.AnnotationProcessor");
		return (AbstractProcessor) mc.newInstance();
	} catch (Throwable t) {
		if (t instanceof Error) throw (Error) t;
		if (t instanceof RuntimeException) throw (RuntimeException) t;
		throw new RuntimeException(t);
	}
}
 

protected void check() throws Exception {
    String[] options = {
        "-XDshouldStopPolicy=ATTR",
        "-XDverboseResolution=success,failure,applicable,inapplicable,deferred-inference,predef"
    };

    AbstractProcessor[] processors = { new ResolveCandidateFinder(), null };

    @SuppressWarnings("unchecked")
    DiagnosticListener<? super JavaFileObject>[] diagListeners =
            new DiagnosticListener[] { new DiagnosticHandler(false), new DiagnosticHandler(true) };

    for (int i = 0 ; i < options.length ; i ++) {
        JavacTask ct = (JavacTask)comp.getTask(null, fm, diagListeners[i],
                Arrays.asList(options[i]), null, Arrays.asList(jfo));
        if (processors[i] != null) {
            ct.setProcessors(Collections.singleton(processors[i]));
        }
        ct.analyze();
    }

    //check diags
    for (Diagnostic<? extends JavaFileObject> diag : diags) {
        for (DiagnosticProcessor proc : diagProcessors) {
            if (proc.matches(diag)) {
                proc.process(diag);
                break;
            }
        }
    }
    //check all candidates have been used up
    for (Map.Entry<ElementKey, Candidate> entry : candidatesMap.entrySet()) {
        if (!seenCandidates.contains(entry.getKey())) {
            error("Redundant @Candidate annotation on method " + entry.getKey().elem + " sig = " + entry.getKey().elem.asType());
        }
    }
}
 

protected void check() throws Exception {
    String[] options = {
        "-XDshouldStopPolicy=ATTR",
        "-XDverboseResolution=success,failure,applicable,inapplicable,deferred-inference,predef"
    };

    AbstractProcessor[] processors = { new ResolveCandidateFinder(), null };

    @SuppressWarnings("unchecked")
    DiagnosticListener<? super JavaFileObject>[] diagListeners =
            new DiagnosticListener[] { new DiagnosticHandler(false), new DiagnosticHandler(true) };

    for (int i = 0 ; i < options.length ; i ++) {
        JavacTask ct = (JavacTask)comp.getTask(null, fm, diagListeners[i],
                Arrays.asList(options[i]), null, Arrays.asList(jfo));
        if (processors[i] != null) {
            ct.setProcessors(Collections.singleton(processors[i]));
        }
        ct.analyze();
    }

    //check diags
    for (Diagnostic<? extends JavaFileObject> diag : diags) {
        for (DiagnosticProcessor proc : diagProcessors) {
            if (proc.matches(diag)) {
                proc.process(diag);
                break;
            }
        }
    }
    //check all candidates have been used up
    for (Map.Entry<ElementKey, Candidate> entry : candidatesMap.entrySet()) {
        if (!seenCandidates.contains(entry.getKey())) {
            error("Redundant @Candidate annotation on method " + entry.getKey().elem + " sig = " + entry.getKey().elem.asType());
        }
    }
}
 

protected void check() throws Exception {
    String[] options = {
        "-XDshouldStopPolicy=ATTR",
        "-XDverboseResolution=success,failure,applicable,inapplicable,deferred-inference,predef"
    };

    AbstractProcessor[] processors = { new ResolveCandidateFinder(), null };

    @SuppressWarnings("unchecked")
    DiagnosticListener<? super JavaFileObject>[] diagListeners =
            new DiagnosticListener[] { new DiagnosticHandler(false), new DiagnosticHandler(true) };

    for (int i = 0 ; i < options.length ; i ++) {
        JavacTask ct = (JavacTask)comp.getTask(null, fm, diagListeners[i],
                Arrays.asList(options[i]), null, Arrays.asList(jfo));
        if (processors[i] != null) {
            ct.setProcessors(Collections.singleton(processors[i]));
        }
        ct.analyze();
    }

    //check diags
    for (Diagnostic<? extends JavaFileObject> diag : diags) {
        for (DiagnosticProcessor proc : diagProcessors) {
            if (proc.matches(diag)) {
                proc.process(diag);
                break;
            }
        }
    }
    //check all candidates have been used up
    for (Map.Entry<ElementKey, Candidate> entry : candidatesMap.entrySet()) {
        if (!seenCandidates.contains(entry.getKey())) {
            error("Redundant @Candidate annotation on method " + entry.getKey().elem + " sig = " + entry.getKey().elem.asType());
        }
    }
}
 

protected void check() throws Exception {
    String[] options = {
        "--should-stop:at=ATTR",
        "--debug:verboseResolution=success,failure,applicable,inapplicable,deferred-inference,predef"
    };

    AbstractProcessor[] processors = { new ResolveCandidateFinder(), null };

    @SuppressWarnings("unchecked")
    DiagnosticListener<? super JavaFileObject>[] diagListeners =
            new DiagnosticListener[] { new DiagnosticHandler(false), new DiagnosticHandler(true) };

    for (int i = 0 ; i < options.length ; i ++) {
        JavacTask ct = (JavacTask)comp.getTask(null, fm, diagListeners[i],
                Arrays.asList(options[i]), null, Arrays.asList(jfo));
        if (processors[i] != null) {
            ct.setProcessors(Collections.singleton(processors[i]));
        }
        ct.analyze();
    }

    //check diags
    for (Diagnostic<? extends JavaFileObject> diag : diags) {
        for (DiagnosticProcessor proc : diagProcessors) {
            if (proc.matches(diag)) {
                proc.process(diag);
                break;
            }
        }
    }
    //check all candidates have been used up
    for (Map.Entry<ElementKey, Candidate> entry : candidatesMap.entrySet()) {
        if (!seenCandidates.contains(entry.getKey())) {
            error("Redundant @Candidate annotation on method " + entry.getKey().elem + " sig = " + entry.getKey().elem.asType());
        }
    }
}
 

protected void check() throws Exception {
    String[] options = {
        "-XDshouldStopPolicy=ATTR",
        "-XDverboseResolution=success,failure,applicable,inapplicable,deferred-inference,predef"
    };

    AbstractProcessor[] processors = { new ResolveCandidateFinder(), null };

    @SuppressWarnings("unchecked")
    DiagnosticListener<? super JavaFileObject>[] diagListeners =
            new DiagnosticListener[] { new DiagnosticHandler(false), new DiagnosticHandler(true) };

    for (int i = 0 ; i < options.length ; i ++) {
        JavacTask ct = (JavacTask)comp.getTask(null, fm, diagListeners[i],
                Arrays.asList(options[i]), null, Arrays.asList(jfo));
        if (processors[i] != null) {
            ct.setProcessors(Collections.singleton(processors[i]));
        }
        ct.analyze();
    }

    //check diags
    for (Diagnostic<? extends JavaFileObject> diag : diags) {
        for (DiagnosticProcessor proc : diagProcessors) {
            if (proc.matches(diag)) {
                proc.process(diag);
                break;
            }
        }
    }
    //check all candidates have been used up
    for (Map.Entry<ElementKey, Candidate> entry : candidatesMap.entrySet()) {
        if (!seenCandidates.contains(entry.getKey())) {
            error("Redundant @Candidate annotation on method " + entry.getKey().elem + " sig = " + entry.getKey().elem.asType());
        }
    }
}
 

protected void check() throws Exception {
    String[] options = {
        "-XDshouldStopPolicy=ATTR",
        "-XDverboseResolution=success,failure,applicable,inapplicable,deferred-inference,predef"
    };

    AbstractProcessor[] processors = { new ResolveCandidateFinder(), null };

    @SuppressWarnings("unchecked")
    DiagnosticListener<? super JavaFileObject>[] diagListeners =
            new DiagnosticListener[] { new DiagnosticHandler(false), new DiagnosticHandler(true) };

    for (int i = 0 ; i < options.length ; i ++) {
        JavacTask ct = (JavacTask)comp.getTask(null, fm, diagListeners[i],
                Arrays.asList(options[i]), null, Arrays.asList(jfo));
        if (processors[i] != null) {
            ct.setProcessors(Collections.singleton(processors[i]));
        }
        ct.analyze();
    }

    //check diags
    for (Diagnostic<? extends JavaFileObject> diag : diags) {
        for (DiagnosticProcessor proc : diagProcessors) {
            if (proc.matches(diag)) {
                proc.process(diag);
                break;
            }
        }
    }
    //check all candidates have been used up
    for (Map.Entry<ElementKey, Candidate> entry : candidatesMap.entrySet()) {
        if (!seenCandidates.contains(entry.getKey())) {
            error("Redundant @Candidate annotation on method " + entry.getKey().elem + " sig = " + entry.getKey().elem.asType());
        }
    }
}
 

private void processAnnotations(RoundEnvironment roundEnv) {
  TypeElement processor =
      processingEnv.getElementUtils().getTypeElement(Processor.class.getCanonicalName());
  TypeElement abstractProcessor =
      processingEnv.getElementUtils().getTypeElement(AbstractProcessor.class.getCanonicalName());
  for (Element e : roundEnv.getElementsAnnotatedWith(IncrementalAnnotationProcessor.class)) {
    if (!checkAnnotatedElement(e, processor)) {
      continue;
    }
    IncrementalAnnotationProcessorType processorType =
        e.getAnnotation(IncrementalAnnotationProcessor.class).value();
    if (processorType == IncrementalAnnotationProcessorType.DYNAMIC
        && processingEnv.getTypeUtils().isSubtype(e.asType(), abstractProcessor.asType())) {
      Element getSupportedOptions =
          processingEnv.getElementUtils().getAllMembers((TypeElement) e).stream()
              .filter(
                  method ->
                      method.getKind() == ElementKind.METHOD
                          && method.getSimpleName().contentEquals(GET_SUPPORTED_OPTIONS)
                          && ((ExecutableElement) method).getParameters().isEmpty())
              .findFirst()
              .orElseThrow(AssertionError::new);
      if (abstractProcessor.equals(getSupportedOptions.getEnclosingElement())) {
        warning(
            "Dynamic incremental annotation processor should override "
                + GET_SUPPORTED_OPTIONS
                + "()",
            e);
      }
    }
    processors.put(
        processingEnv.getElementUtils().getBinaryName((TypeElement) e).toString(), processorType);
  }
}
 

protected void check() throws Exception {
    String[] options = {
        "-XDshouldStopPolicy=ATTR",
        "-XDverboseResolution=success,failure,applicable,inapplicable,deferred-inference,predef"
    };

    AbstractProcessor[] processors = { new ResolveCandidateFinder(), null };

    @SuppressWarnings("unchecked")
    DiagnosticListener<? super JavaFileObject>[] diagListeners =
            new DiagnosticListener[] { new DiagnosticHandler(false), new DiagnosticHandler(true) };

    for (int i = 0 ; i < options.length ; i ++) {
        JavacTask ct = (JavacTask)comp.getTask(null, fm, diagListeners[i],
                Arrays.asList(options[i]), null, Arrays.asList(jfo));
        if (processors[i] != null) {
            ct.setProcessors(Collections.singleton(processors[i]));
        }
        ct.analyze();
    }

    //check diags
    for (Diagnostic<? extends JavaFileObject> diag : diags) {
        for (DiagnosticProcessor proc : diagProcessors) {
            if (proc.matches(diag)) {
                proc.process(diag);
                break;
            }
        }
    }
    //check all candidates have been used up
    for (Map.Entry<ElementKey, Candidate> entry : candidatesMap.entrySet()) {
        if (!seenCandidates.contains(entry.getKey())) {
            error("Redundant @Candidate annotation on method " + entry.getKey().elem + " sig = " + entry.getKey().elem.asType());
        }
    }
}
 

private void runTest(TestRunnable r) throws Exception {
  testCompiler.addSourceFile(getSourceFile("Foo.java"));
  if (testMode == WITH_DEPS) {
    testCompiler.addClasspathSourceFile(getSourceFile("Dependency.java"));
    testCompiler.addClasspathSourceFile(getSourceFile("DependencyException.java"));
    testCompiler.addClasspathSourceFile(getSourceFile("DependencyInterface.java"));
  } else {
    testCompiler.useFrontendOnlyJavacTask();
  }

  testCompiler.setProcessors(
      Collections.singletonList(
          new AbstractProcessor() {
            @Override
            public Set<String> getSupportedOptions() {
              return Collections.emptySet();
            }

            @Override
            public Set<String> getSupportedAnnotationTypes() {
              return Collections.singleton("*");
            }

            @Override
            public SourceVersion getSupportedSourceVersion() {
              return SourceVersion.RELEASE_8;
            }

            @Override
            public boolean process(
                Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
              if (roundEnv.processingOver()) {
                try {
                  r.run();
                } catch (Exception e) {
                  throw new AssertionError(e);
                }
              }
              return false;
            }
          }));

  elements = testCompiler.getElements();
  testCompiler.enter();
}
 

@Test
public void testAnnotationProcessorGetsNewElementsEachRound() throws Exception {
  AtomicBoolean processorRan = new AtomicBoolean(false);

  initCompiler(ImmutableMap.of("Foo.java", "public class Foo { }"));

  testCompiler.setProcessors(
      ImmutableList.of(
          new AbstractProcessor() {
            private Filer filer;
            private Elements elementsFromEnvironment;
            private TypeElement element;

            @Override
            public Set<String> getSupportedAnnotationTypes() {
              return Collections.singleton("*");
            }

            @Override
            public SourceVersion getSupportedSourceVersion() {
              return SourceVersion.latestSupported();
            }

            @Override
            public synchronized void init(ProcessingEnvironment processingEnv) {
              super.init(processingEnv);
              filer = processingEnv.getFiler();
              elementsFromEnvironment = processingEnv.getElementUtils();
            }

            @Override
            public boolean process(
                Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
              TypeElement newElement = elementsFromEnvironment.getTypeElement("Foo");
              assertNotNull(newElement);

              if (elementsFromEnvironment.getTypeElement("Bar") == null) {
                assertNotSame(newElement, element);
                element = newElement;

                try {
                  JavaFileObject fileObject = filer.createSourceFile("Bar", newElement);
                  try (Writer writer = fileObject.openWriter()) {
                    writer.write("public class Bar { }");
                  }
                } catch (IOException e) {
                  throw new RuntimeException(e);
                }
              }

              processorRan.set(roundEnv.processingOver());
              return false;
            }
          }));

  testCompiler.compile();

  assertTrue(processorRan.get());
}
 

@Test
public void testTypeParametersWithAnnotationsOnBounds() {
  @SupportedAnnotationTypes("*")
  class CompilerBugProcessor extends AbstractProcessor {
    boolean checkedAnnotationsOnTypeBounds;
    boolean reportsAnnotationsOnTypeBounds;

    @Override
    public SourceVersion getSupportedSourceVersion() {
      return SourceVersion.latestSupported();
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
      if (roundEnv.processingOver()) {
        TypeElement test = processingEnv.getElementUtils().getTypeElement("com.example.Test");
        TypeParameterElement t = test.getTypeParameters().get(0);
        this.checkedAnnotationsOnTypeBounds = true;
        this.reportsAnnotationsOnTypeBounds =
            !t.getBounds().get(0).getAnnotationMirrors().isEmpty();
      }
      return false;
    }
  }
  CompilerBugProcessor compilerBugProcessor = new CompilerBugProcessor();
  JavaFileObject nullableTypeFileObject =
      JavaFileObjects.forSourceLines(
          "foo.bar.NullableType",
          "package foo.bar;",
          "",
          "import java.lang.annotation.ElementType;",
          "import java.lang.annotation.Target;",
          "",
          "@Target(ElementType.TYPE_USE)",
          "public @interface NullableType {}");
  JavaFileObject autoValueFileObject =
      JavaFileObjects.forSourceLines(
          "com.example.Test",
          "package com.example;",
          "",
          "import com.google.auto.value.AutoValue;",
          "import foo.bar.NullableType;",
          "",
          "@AutoValue",
          "abstract class Test<T extends @NullableType Object & @NullableType Cloneable> {}");
  Compilation compilation =
      javac()
          .withProcessors(new AutoValueProcessor(), compilerBugProcessor)
          .withOptions("-Xlint:-processing", "-implicit:none")
          .compile(nullableTypeFileObject, autoValueFileObject);
  assertThat(compilation).succeededWithoutWarnings();
  assertThat(compilerBugProcessor.checkedAnnotationsOnTypeBounds).isTrue();
  if (compilerBugProcessor.reportsAnnotationsOnTypeBounds) {
    assertThat(compilation)
        .generatedSourceFile("com.example.AutoValue_Test")
        .contentsAsUtf8String()
        .contains(
            "class AutoValue_Test<T extends @NullableType Object & @NullableType Cloneable>"
                + " extends Test<T> {");
  }
}
 

@Override
public Statement apply(final Statement base, Description description) {
  return new Statement() {
    @Override public void evaluate() throws Throwable {
      final AtomicReference<Throwable> thrown = new AtomicReference<>();
      boolean successful = compile(ImmutableList.of(new AbstractProcessor() {
        @Override
        public SourceVersion getSupportedSourceVersion() {
          return SourceVersion.latest();
        }

        @Override
        public Set<String> getSupportedAnnotationTypes() {
          return ImmutableSet.of("*");
        }

        @Override
        public synchronized void init(ProcessingEnvironment processingEnv) {
          super.init(processingEnv);
          elements = processingEnv.getElementUtils();
          types = processingEnv.getTypeUtils();
        }

        @Override
        public boolean process(Set<? extends TypeElement> annotations,
            RoundEnvironment roundEnv) {
          // just run the test on the last round after compilation is over
          if (roundEnv.processingOver()) {
            try {
              base.evaluate();
            } catch (Throwable e) {
              thrown.set(e);
            }
          }
          return false;
        }
      }));
      checkState(successful);
      Throwable t = thrown.get();
      if (t != null) {
        throw t;
      }
    }
  };
}
 

/**
 * 为生成代码的注解处理器创建一个通用注解
 *
 * @param processorType 注解处理器
 * @return 代码生成信息注解
 */
public static AnnotationSpec newProcessorInfoAnnotation(Class<? extends AbstractProcessor> processorType) {
    return AnnotationSpec.builder(Generated.class)
            .addMember("value", "$S", processorType.getCanonicalName())
            .build();
}