All Classes and Interfaces
Class
Description
AbstractTypeMatcher<T extends com.sun.source.tree.Tree>
Base class for type matchers.
A sequence of field names or autovalue accessors, along with a receiver: either a variable or a
reference (explicit or implicit) to
this.Immutable map from local variables or heap access paths to their
AbstractValueAccessPathStore.Builder<V extends org.checkerframework.errorprone.dataflow.analysis.AbstractValue<V>>
Builder for
AccessPathStore instances.Read-only access to
AccessPathStore for convenience.Describes a tree position with adjustments to the start and end indices.
Matches an annotation that does not have a particular argument, possibly because the default
value is being used.
AnnotationMatcher<T extends com.sun.source.tree.Tree>
Matches if the given annotation matcher matches all of or any of the annotations on the tree
node.
Utilities for matching annotations.
Represents the corrected source which we think was intended, by applying a Fix.
Matches arrays.
Matches assert statements which have a condition expression matched by the given matcher.
This class contains utility methods to work with the javac AST.
Scanner for determining what types are thrown by a tree.
An expression's target type, see
ASTHelpers.targetType(com.google.errorprone.VisitorState).An Error Prone compiler that implements
JavaCompiler.Helper class for accumulating a branching tree of alternative fixes designed to help build as set
of potential fixes with different options in them.
Builder class for BranchedSuggestedFixes
A base class for implementing bug checkers.
An accessor for information about a single bug checker, including the metadata in the check's
@BugPattern annotation and the class that implements the check.A
MultiMatcher that applies a matcher across multiple children of a single ancestor node.Interface for a transformation over Java source.
Class to hold AST nodes annotated with the comments that are associated with them
Identifies the position of a comment relative to the associated treenode.
Utilities for attaching comments to relevant AST nodes
A matcher for compile-time-constant expressions.
Combines multiple
CodeTransformers into one.Matcher for a compound-assignment operator expression.
An interface to the constant propagation analysis.
The state that is propagated across a match operation for constructors.
Applies the given matcher to the constructor(s) of the given class.
A matcher that recursively inspects a tree, applying the given matcher to all levels of each tree
and returning
true if any match is found.Provides a wrapper around
Analysis.DataFlow.Result<A extends org.checkerframework.errorprone.dataflow.analysis.AbstractValue<A>,S extends org.checkerframework.errorprone.dataflow.analysis.Store<S>,T extends org.checkerframework.errorprone.dataflow.analysis.TransferFunction<A,S>>
A pair of Analysis and ControlFlowGraph.
Matches sub-types of the given type.
Matches types that are a sub-type of one of the given types.
Simple data object containing the information captured about an AST match.
Builder for
Descriptions.Implementation of a
Diff that performs the modifications that are passed to its DescriptionBasedDiff.onDescribed(com.google.errorprone.matchers.Description) method, with no formatting.Strategies for reporting results.
Factory for creating DescriptionListeners while compiling each file.
All the differences to be applied to a source file to be applied in a refactoring.
Applier of diffs to Java source code
Exception thrown if a
Diff could not be applied by a DiffApplierSupplier of file differences.
File destination which simply throws away the generated file.
Adapt matchers to match against a parent node of a given type.
Enclosing.Block<T extends com.sun.source.tree.Tree>
Enclosing.BlockOrCase<T extends com.sun.source.tree.Tree>
Enclosing.Class<T extends com.sun.source.tree.Tree>
Enclosing.Method<T extends com.sun.source.tree.Tree>
A
TaskListener that runs Error Prone over attributed compilation units.Wraps an unrecoverable error that occurs during analysis with the source position that triggered
the crash.
Represents an immutable map of Error Prone flags to their set values.
Builder for Error Prone command-line flags object.
An injector for ErrorProne.
Processes command-line options specific to error-prone.
Severity levels for an error-prone check that define how the check results should be presented.
Loads custom Error Prone checks from the annotation processor classpath.
Scans the parsed AST, looking for violations of any of the enabled checks.
Adapter from an
ErrorProneScanner to a CodeTransformer.A compatibility wrapper around
com.sun.tools.javac.util.FilterA collection of timing data for the runtime of individual checks.
Wraps a javac
Tokens.Token to return comments in declaration order.A utility for tokenizing and preserving comments.
The Error Prone version.
Matches types that exactly match the given type.
Matches types that exactly match one of the given types.
Static utility methods for creating
Matchers for detecting references to fields.A helper class to find all identifiers in scope at a given program point.
Represents a source code transformation, usually used to fix a bug detected by error-prone.
A
JCDiagnostic.DiagnosticPosition with a fixed position.A
FileDestination that writes content to a destination on the local filesystem.A FileSource that reads source files from the local filesystem.
Matches if the given matcher matches all of/any of the parameters to this method.
Matches if the given matcher matches all of the identifiers under this syntax tree.
Organizes imports based on the default format provided by IntelliJ IDEA.
Parse import order strings.
Organizes import statements when patching files.
Represents an import.
Provides support for building a list of imports from groups and formatting it as a block of
imports.
Represents a list of import statements.
Describes a position that only has a start and end index.
Results of running
NullnessQualifierInference over a method.Utility constants and matchers related to dependency injection.
Matches expressions that can be statically determined to be non-null.
IsSameType<T extends com.sun.source.tree.Tree>
Matches an AST node if its erased type is the same as the given type, e.g.
IsSubtypeOf<T extends com.sun.source.tree.Tree>
Making our errors appear to the user and break their build.
A token uniquely identifying a single invocation of javac.
Matchers for code patterns which appear to be JUnit-based tests.
A utility class for finding the Levenshtein edit distance between strings.
A classloader that allows plugins to access the Error Prone classes from the compiler classpath.
Define a predicate on a
Tree, which also accesses the state of AST traversal.Static factory methods which make the DSL read more fluently.
The state that is propagated across a match operation.
Matches if the given matcher matches all of/any of the parameters to this method.
Represents a Java method.
Matches a method invocation based on a matcher for the method select (receiver + method
identifier) and one for the arguments.
Applies an Expression matcher to an argument of a MethodInvocation by position.
The machinery and type definitions necessary to model and compile a single efficient matcher out
of a list of
MethodMatchers.MethodMatchers.The kinds of things that count as a method invocation.
A rule describing a set of constraints for a method invocation.
A specific value for a property that a method invocation can have.
A token specifying the class or interface in which the invoked method was defined.
A token limiting the
MethodInvocationMatcher.Token.Kind of invocation to match.A token limiting the name of the method being invoked.
A token limiting the types of the formal parameters of the method being invoked.
A token specifying that the class of the object on which the method is being invoked must be
a subtype of another type.
A token specifying the exact type of the object on which the method is being invoked (or the
class in which it is defined, for static methods).
The kinds of properties a matcher can match against.
Deprecated.
Deprecated.
use
Matcher<ExpressionTree> instead of referring directly to this type.Deprecated.
use
Matcher<ExpressionTree> instead of referring directly to this type.Deprecated.
use
Matcher<ExpressionTree> instead of referring directly to this type.Deprecated.
use
Matcher<ExpressionTree> instead of referring directly to this type.Deprecated.
use
Matcher<ExpressionTree> instead of referring directly to this type.Deprecated.
use
Matcher<ExpressionTree> instead of referring directly to this type.Deprecated.
use
Matcher<ExpressionTree> instead of referring directly to this type.Deprecated.
use
Matcher<ExpressionTree> instead of referring directly to this type.Deprecated.
use
Matcher<ExpressionTree> instead of referring directly to this type.A matcher for method visibility (public, private, protected, or default).
The visibility of a member.
Annotation-related utilities.
An matcher that applies a single matcher across multiple tree nodes.
MultiMatcher.MultiMatchResult<N extends com.sun.source.tree.Tree>
A result from the call of
MultiMatcher.multiMatchResult(Tree, VisitorState), containing
information about whether it matched, and if so, what nodes matched.Utility functions for dealing with Java naming conventions
The Needleman-Wunsch algorithm for finding least-cost string edit distances between pairs of
strings.
Represents one of the possible nullness values in our nullness analysis.
An interface to the nullness analysis.
Utilities to extract
Nullness from annotations.Matches an expression based on the result of the nullness dataflow analysis.
Eagerly traverse one
MethodTree at a time and accumulate constraints between nullness
qualifiers.The precedence for an operator kind in the
com.sun.source.tree API.A
FileDestination that writes a unix-patch file to rootPath containing the
suggested changes.An implementation of JLS 14.21 reachability.
Utilities for checks that work with regexes.
A replaced section of a source file.
A collection of
Replacements to be made to a source file.A policy for handling overlapping insertions.
Matches a
return statement whose returned expression is matched by the given matcher.JDK runtime version utilities.
TODO(eaftan): I'm worried about this performance of this code, specifically the part that handles
SuppressWarnings.
Supplies
Scanners and provides access to the backing sets of all BugCheckers and
enabled BugCheckers.This class is responsible for analyzing an expression and telling if the expression can have side
effects.
Signature generation.
A factory for Escaper instances used to escape strings for safe use in Java.
Representation of a mutable Java source file.
JDK source version utilities.
A collector of counters keyed by strings.
A view on top of a
Context allowing additional modifications to be added without
affecting the underlying Context.Builds
SuggestedFixs.Factories for constructing
Fixes.Instructs
SuggestedFixes.addMembers(ClassTree, VisitorState, AdditionPosition, String, String...)
whether to add the new member(s) at the beginning of the class, or at the end.A class to hold the files from the compilation context, with a diff applied to the
currently-processed one; the files can then be recompiled.
The result of the compilation.
Simple supplier pattern, which allows delayed binding to access to runtime elements.
Immutable container of "suppression signals" - annotations or other information gathered from
source - that can be used to determine if a specific
Suppressible object should be
considered suppressed.A utility class for finding the distance between two identifiers.
Matchers for code patterns which appear to be TestNG-based tests.
Matches a
throw statement whose thrown expression is matched by the given matcher.An interface to the "trusting" nullness analysis.
A predicate for testing
Types.A collection of
TypePredicates.Matches expressions that invoke or reference a non-void method or constructor and which do not
use their return value and are not in a context where non-use of the return value is allowed.
Enumeration of known reasons that an unused return value may be allowed because of the context
in which the method is used.
Describes visibilities available via VisibleForTesting annotations, and provides methods to
establish whether a given
Tree should be visible.Matchers for method invocations related to Object.wait() and Condition.await();
Matcher<ExpressionTree>instead of referring directly to this type.