org.checkerframework.framework.source.AggregateChecker Maven / Gradle / Ivy
Show all versions of checker Show documentation
package org.checkerframework.framework.source;
import com.sun.source.util.TreePath;
import com.sun.tools.javac.processing.JavacProcessingEnvironment;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.Log;
import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;
/**
* An aggregate checker that packages multiple checkers together. The resulting checker invokes the
* component checkers in turn on the processed files.
*
* There is no communication, interaction, or cooperation between the component checkers, even to
* the extent of being able to read one another's qualifiers. An aggregate checker is merely
* shorthand to invoke a sequence of checkers.
*
*
This class delegates {@code AbstractTypeProcessor} responsibilities to each component checker.
*
*
Checker writers need to subclass this class and only override {@link #getSupportedCheckers()}
* to indicate the classes of the checkers to be bundled.
*/
public abstract class AggregateChecker extends SourceChecker {
protected final List checkers;
/**
* Returns the list of supported checkers to be run together. Subclasses need to override this
* method.
*
* @return the list of checkers to be run
*/
protected abstract Collection> getSupportedCheckers();
/** Supported options for this checker. */
private @MonotonicNonNull Set supportedOptions = null;
/** Options passed to this checker. */
private @MonotonicNonNull Map options = null;
/** Create a new AggregateChecker. */
protected AggregateChecker() {
Collection> checkerClasses = getSupportedCheckers();
checkers = new ArrayList<>(checkerClasses.size());
for (Class checkerClass : checkerClasses) {
try {
SourceChecker instance = checkerClass.getDeclaredConstructor().newInstance();
instance.setParentChecker(this);
checkers.add(instance);
} catch (Exception e) {
message(
Diagnostic.Kind.ERROR,
"Couldn't instantiate an instance of " + checkerClass);
}
}
}
/**
* {@code processingEnv} needs to be set on each checker since we are not calling init on the
* checker, which leaves it null. If one of checkers is an AggregateChecker, its visitors will
* try use checker's processing env which should not be null.
*/
@Override
protected void setProcessingEnvironment(ProcessingEnvironment env) {
super.setProcessingEnvironment(env);
for (SourceChecker checker : checkers) {
checker.setProcessingEnvironment(env);
}
}
@Override
public void initChecker() {
// No need to call super, it might result in reflective instantiations
// of visitor/factory classes.
// super.initChecker();
// To prevent the warning that initChecker wasn't called.
messager = processingEnv.getMessager();
// first initialize all checkers
for (SourceChecker checker : checkers) {
checker.initChecker();
}
// then share options as necessary
for (SourceChecker checker : checkers) {
// We need to add all options that are activated for the aggregate to
// the individual checkers.
checker.addOptions(super.getOptions());
// Each checker should "support" all possible lint options - otherwise
// subchecker A would complain about a lint option for subchecker B.
checker.setSupportedLintOptions(this.getSupportedLintOptions());
}
allCheckersInited = true;
}
// Whether all checkers were successfully initialized.
private boolean allCheckersInited = false;
// AbstractTypeProcessor delegation
@Override
public final void typeProcess(TypeElement element, TreePath tree) {
Context context = ((JavacProcessingEnvironment) processingEnv).getContext();
Log log = Log.instance(context);
if (log.nerrors > this.errsOnLastExit) {
// If there is a Java error, do not perform any of the component type checks, but come
// back for the next compilation unit.
this.errsOnLastExit = log.nerrors;
return;
}
if (!allCheckersInited) {
// If there was an initialization problem, an
// error was already output. Just quit.
return;
}
for (SourceChecker checker : checkers) {
checker.errsOnLastExit = this.errsOnLastExit;
checker.typeProcess(element, tree);
if (checker.javacErrored) {
this.javacErrored = true;
return;
}
this.errsOnLastExit = checker.errsOnLastExit;
}
}
@Override
public void typeProcessingOver() {
for (SourceChecker checker : checkers) {
checker.typeProcessingOver();
}
super.typeProcessingOver();
}
@Override
public final Set getSupportedOptions() {
if (this.supportedOptions == null) {
Set options = new HashSet<>();
for (SourceChecker checker : checkers) {
options.addAll(checker.getSupportedOptions());
}
options.addAll(
expandCFOptions(
Arrays.asList(this.getClass()),
options.toArray(new String[options.size()])));
this.supportedOptions = options;
}
return this.supportedOptions;
}
@Override
public final Map getOptions() {
if (this.options == null) {
Map options = new HashMap<>(super.getOptions());
for (SourceChecker checker : checkers) {
options.putAll(checker.getOptions());
}
this.options = Collections.unmodifiableMap(options);
}
return this.options;
}
@Override
public final Set getSupportedLintOptions() {
Set lints = new HashSet<>();
for (SourceChecker checker : checkers) {
lints.addAll(checker.getSupportedLintOptions());
}
return lints;
}
@Override
protected SourceVisitor createSourceVisitor() {
return new SourceVisitor(this) {
// Aggregate checkers do not visit source,
// the checkers in the aggregate checker do.
};
}
// TODO some methods in a component checker should behave differently if they
// are part of an aggregate, e.g. getSuppressWarningKeys should additionally
// return the name of the aggregate checker.
// We could add a query method in SourceChecker that refers to the aggregate, if present.
// At the moment, all the component checkers manually need to add the name of the aggregate.
}