Class AbstractTypeProcessor

All Implemented Interfaces:
Direct Known Subclasses:
BasicTypeProcessor, SignaturePrinter, SourceChecker, TreePrinter

public abstract class AbstractTypeProcessor extends AbstractProcessor
This class is an abstract annotation processor designed to be a convenient superclass for concrete "type processors", processors that require the type information in the processed source.

Type processing occurs in one round after the tool (e.g. Java compiler) analyzes the source (all sources taken as input to the tool and sources generated by other annotation processors).

The tool infrastructure will interact with classes extending this abstract class as follows.

1-3 are identical to the Processor life cycle. 4-5 are unique to AbstractTypeProcessor subclasses.

  1. If an existing Processor object is not being used, to create an instance of a processor the tool calls the no-arg constructor of the processor class.
  2. Next, the tool calls the init method with an appropriate ProcessingEnvironment.
  3. Afterwards, the tool calls getSupportedAnnotationTypes, getSupportedOptions, and getSupportedSourceVersion. These methods are only called once per run, not on each round.
  4. For each class containing a supported annotation, the tool calls typeProcess method on the Processor. The class is guaranteed to be type-checked Java code and all the tree type and symbol information is resolved.
  5. Finally, the tool calls the typeProcessingOver method on the Processor.

The tool is permitted to ask type processors to process a class once it is analyzed before the rest of classes are analyzed. The tool is also permitted to stop type processing immediately if any errors are raised, without invoking typeProcessingOver().

A subclass may override any of the methods in this class, as long as the general Processor contract is obeyed, with one notable exception. process(Set, RoundEnvironment) may not be overridden, as it is called during the declaration annotation phase before classes are analyzed.

  • Constructor Details

    • AbstractTypeProcessor

      protected AbstractTypeProcessor()
      Constructor for subclasses to call.
  • Method Details

    • init

      public void init(ProcessingEnvironment env)

      Register a TaskListener that will get called after FLOW.

      Specified by:
      init in interface Processor
      init in class AbstractProcessor
    • process

      public final boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv)
      The use of this method is obsolete in type processors. The method is called during declaration annotation processing phase only. It registers the names of elements to process.
      Specified by:
      process in interface Processor
      Specified by:
      process in class AbstractProcessor
    • typeProcessingStart

      public void typeProcessingStart()
      A method to be called once before the first call to typeProcess.

      Subclasses may override this method to do any initialization work.

    • typeProcess

      public abstract void typeProcess(TypeElement element, TreePath tree)
      Processes a fully-analyzed class that contains a supported annotation (see AbstractProcessor.getSupportedAnnotationTypes()).

      The passed class is always valid type-checked Java code.

      element - element of the analyzed class
      tree - the tree path to the element, with the leaf being a ClassTree
    • typeProcessingOver

      public void typeProcessingOver()
      A method to be called once all the classes are processed.

      Subclasses may override this method to do any aggregate analysis (e.g. generate report, persistence) or resource deallocation.

      Method getCompilerLog() can be used to access the number of compiler errors.

    • getCompilerLog

      @SideEffectFree public getCompilerLog()
      Return the compiler log, which contains errors and warnings.
      the compiler log, which contains errors and warnings