All Classes and Interfaces
Class
Description
Validates abbreviations (consecutive capital letters) length in
identifier name, it also allows to enforce camel case naming.
Abstract class for checking a class member (field/method)'s name conforms to
a specified pattern.
The base class for checks.
The actual context holder.
Base class for coupling calculation.
Ensures that the names of abstract classes conforming to some pattern
and check that
abstract modifier exists.Abstract base class for all handlers.
Provides common functionality for many FileSetChecks.
The actual context holder.
Abstract super class for header checks.
Represents a tree of import rules for controlling whether packages or
classes are allowed to be used.
Base class for import rules.
Base class for Checks that process Javadoc comments.
The file context holder.
Abstract class for checking that names conform to a specified format.
Represents general class for
ElementNode, RootNode and AttributeNode.Abstract class for checking the padding of parentheses.
Abstract class for checking that an overriding method with no parameters
invokes the super method.
Stack node for a method definition and a record of
whether the method has a call to the super method.
Serves as an abstract base class for all modules that report inspection
findings.
This enum represents access modifiers.
Represents the result of an access check.
Handler for annotation array initialization blocks.
Checks location of annotation on language elements.
Checks that annotations are located on the same line with their targets.
Checks the style of elements in annotations.
Defines the two styles for defining
elements in an annotation.
Defines the styles for defining elements in an annotation.
Defines the two styles for defining
elements in an annotation.
Contains utility methods designed to work with annotations.
Checks for long anonymous inner classes.
Handler for array initialization blocks.
Checks that array initialization contains a trailing comma.
Checks the style of array type definitions.
Class for printing AST to String.
Checks the order of
javadoc block-tags or javadoc tags.
Represents attribute of the element.
Raw event for audit.
Represents the default formatter for log message.
Represents the formatter interface for log message.
Listener in charge of receiving events from the Checker.
A Java Bean that implements the component lifecycle interfaces by
calling the bean's setters for all configuration attributes.
Enum to specify behaviour regarding ignored modules.
A converter that converts strings to patterns.
A converter that converts strings to
AccessModifierOption.A converter that does not care whether the array elements contain String
characters like '*' or '_'.
A converter that converts strings to scope.
A converter that converts strings to severity level.
A converter that converts strings to uri.
Detects double brace initialization.
Restricts using
Unicode escapes
(such as \u221e).
Detects inline conditionals.
Finds nested blocks (blocks that are used freely in the code).
Checks if call to superclass constructor without arguments is present.
Checks that there are no import statements that use the
* notation.
Checks that there are no static import statements.
A base class for CellEditors, providing default implementations for all
methods in the CellEditor interface and support for managing a series
of listeners.
File filter
BeforeExecutionExclusionFileFilter decides which files should be
excluded from being processed by the utility.An interface for before execution file filtering events.
A before execution file filter set applies filters to events.
Utility class that has methods to check javadoc comment position in java file.
Represents the policy for checking block statements.
Handler for parents of blocks ('if', 'else', 'while', etc).
Tools for parsing block tags from a Javadoc comment.
Restricts the number of boolean operators (
&&, ||,
&, | and ^) in an expression.Handler for case statements.
Handler for catch blocks.
Checks that
catch parameter names conform to a specified pattern.Resolves chained properties from a user-defined property file.
This class provides the functionality to check a set of files.
An implementation of a ANT task for calling checkstyle.
Details about a formatter to be used.
Poor mans enumeration for the formatter types.
Represents a property that consists of a key and value.
Represents an error condition within Checkstyle.
Extending BailErrorStrategy allows us to report errors while
cancelling the parsing operation.
Contains utility methods for the checks.
Measures the number of instantiations of other classes
within the given class or record.
Handler for class definitions.
Checks the number of other types a given class/record/interface/enum/annotation
relies on.
Represents whether a class is allowed to be imported or not.
Checks for implicit modifiers on nested types in classes and records.
Checks that class type parameter names conform to a specified pattern.
Contains utility methods for code point.
Helper class to select a code.
Presentation model for CodeSelector.
Representation of the comment block.
This interface is used to be notified by parser about comments
in the parsed code.
Controls the indentation between comments and surrounding code.
Implementation of a
MatchSuppressor that suppresses based on
whether in a comment.Contains utility methods.
A component that can be configured.
A Configuration is used to configure a Configurable component.
Loads a configuration from a standard configuration XML file.
Enum to specify behaviour regarding ignored modules.
Checks that constant names conform to a specified pattern.
A context to be used in subcomponents.
A Component that needs context information from it's container(parent object) to work.
Checks that classes and records which define a covariant
equals() method
also override method equals(Object).Extends the LexerATNSimulator class in order to override
the 'consume()' method so that we can handle '\r' line
endings (pre-OSX macOs line endings) correctly in the
ANTLR lexer.
This filter element is immutable and accepts an integer that matches a CSV value, where
each value is an integer or a range of integers.
Checks that the groups of import declarations appear in the order specified
by the user.
Contains import attributes as line number, import full path, import
group.
Contains matching attributes assisting in definition of "best matching"
group for import.
Checks cyclomatic complexity against a specified limit.
Checks that the parts of a class, record, or interface declaration appear in the order
suggested by the
Code Conventions for the Java Programming Language.
Private class to encapsulate the state.
Check that the
default is after all the cases in a switch statement.Default implementation of the Configuration interface.
A default implementation of the Context interface.
Simple plain logger for text output.
Represents a message that can be localised.
Contains constant definitions common to the package.
Recursive-free implementation of the descendant axis iterator.
Enum defines starting node for iterator.
Checks for restricted tokens beneath other tokens.
Checks that classes are designed for extension (subclass creation).
A interface of Checkstyle's AST nodes for traversing trees generated from the
Java code.
The implementation of
DetailAST.Represents a set of abstract syntax tree.
DetailNode is used to construct tree during parsing Javadoc comments.
Parses file as javadoc DetailNode tree and prints to system output stream.
Options for a detector.
Handler for do...while blocks.
Represents element node of Xpath-tree.
Handler for else blocks.
Checks for empty blocks.
Checks for empty catch blocks.
Checks the padding of an empty for initializer; that is whether a white
space is required at an empty for initializer, or such white space is
forbidden.
Checks the padding of an empty for iterator; that is whether a white
space is required at an empty for iterator, or such white space is
forbidden.
Checks for empty line separators before package, all import declarations,
fields, constructors, methods, nested classes,
static initializers and instance initializers.
Detects empty statements (standalone
";" semicolon).
Checks that any combination of String literals
is on the left side of an
equals() comparison.Holds the names of fields of a type.
Checks that classes that either override
equals() or hashCode() also
overrides the other.
Restricts the number of executable statements to a specified limit.
Class to encapsulate counting information about one member.
Checks if any class or object member is explicitly initialized
to default for its type value (
null for object
references, zero for numeric types and char
and false for boolean.The following interface should be implemented by each module (inheritor of
AbstractCheck, implementor of FileSetCheck, or Filter) which uses
external resources of any kind for its configuration.
Checks for fall-through in
switch statements.Represents the contents of a file.
Represents an import rules for a specific file.
Checks for long source files.
Interface for Checking a set of files for some criteria.
This annotation means that the check contains file-related context and therefore
cannot be used from the others threads at the same time.
Checks that there are no tab characters (
'\t') in the source code.Represents the text contents of a file of arbitrary plain text type.
An interface for filtering AuditEvents.
A filter set applies filters to AuditEvents.
Utility methods for suppression filters.
Checks that a class which has only private constructors
is declared as final.
Maintains information about class' ctors.
Checks that local variables that never have their values changed are declared final.
Represents information about final local variable candidate.
Holder for the scope data.
Handler for finally blocks.
Checks that parameters for methods, constructors, catch and for-each blocks are final.
Recursive-free implementation of the following axis iterator.
Handler for for loops.
Represents a full identifier, including dots, with associated
position information.
Checks that the whitespace around the Generic tokens (angle brackets)
"<" and ">" are correct to the typical convention.
This annotation means that the check contains global context,
which will be updated while Checkstyle processes files.
Factory for handlers.
Checks that a source file begins with a specified header.
Checks that a local variable or a parameter does not shadow
a field that is defined in the same class.
Holds the names of static and instance fields of a type.
Makes sure that utility classes (classes that contain only static methods or fields in their API)
do not have a public constructor.
Details of class that are required for validation.
Used to keep track of a tag and the text that follows it.
Handler for if statements.
Checks that certain exception types do not appear in a
catch statement.
Checks identifiers with a pattern for a set of illegal names, such as those
that are restricted or contextual keywords.
Checks for imports from a set of illegal packages.
Checks for illegal instantiations where a factory method is preferred.
Checks that specified types are not declared to be thrown.
Checks for illegal tokens.
Checks specified tokens text for matching an illegal pattern.
Checks that particular classes or interfaces are never used.
Controls what can be imported in each package and file.
Responsible for loading the contents of an import control configuration file.
Handler for import statements.
Checks the ordering/grouping of imports.
Represents the policy for checking import order statements.
Checks correct indentation of Java code.
Encapsulates representation of notion of expected indentation levels.
Handler for array index operation.
Tools for extracting inline tags from Javadoc comments.
Checks for assignments in subexpressions, such as in
String s = Integer.toString(i = 2);.
Checks nested (internal) classes/interfaces are declared at the bottom of the
primary (top-level) class after all init and static init blocks,
method, constructor and field declarations.
Implements Joshua Bloch, Effective Java, Item 17 -
Use Interfaces only to define types.
Checks for implicit modifiers on interface members and nested types.
Checks that interface type parameter names conform to a specified pattern.
An interface for filtering Integer.
This filter element is immutable and accepts a matching Integer.
This filter element is immutable and accepts an Integer in a range.
Checks that Javadocs are located at the correct position.
Value object for storing data about an invalid Javadoc validTags.
Visitor class used to build Checkstyle's Java AST from the parse tree produced by
JavaLanguageParser.Used to swap and organize DetailAstImpl subtrees.
Checks that a
javadoc block tag appears only at the beginning of a line, ignoring
leading asterisks and white space.
Checks that the Javadoc content begins from the same position
for all Javadoc comments in the project.
Represents the locations for the javadoc content.
Used for parsing Javadoc comment as DetailNode tree.
Custom error listener for JavadocParser that prints user readable errors.
Contains information about parse error message.
Contains result of parsing javadoc comment: DetailNode tree and parse
error message.
Class for scraping module metadata from the corresponding class' class-level javadoc.
Checks the Javadoc of a method or constructor.
Contains class's
Token.Stores useful information about declared exception.
Represents text element with location in the text.
Checks if the javadoc has
leading asterisks on each line.
Checks that there is at least one whitespace after the leading asterisk.
Implementation of DetailNode interface that is mutable.
Checks that each Java package has a Javadoc file used for commenting.
Checks the Javadoc paragraph.
This class provides an empty implementation of
JavadocParserVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.This interface defines a complete generic visitor for a parse tree produced
by
JavadocParser.This class is used internally in the build process to write a property file
with short descriptions (the first sentences) of TokenTypes constants.
Helper class encapsulating the command line options and positional parameters.
Validates Javadoc comments to help ensure they are well formed.
Represents a Javadoc tag.
Checks the indentation of the continuation lines in block tags.
This enum defines the various Javadoc tags and there properties.
The Javadoc Type.
Value object for combining the list of valid validTags with information
about invalid validTags encountered in a certain Javadoc comment.
Contains the constants for all the tokens contained in the Abstract
Syntax Tree for the javadoc grammar.
Checks the Javadoc comments for type definitions.
Contains utility methods for working with Javadoc.
The type of Javadoc tag we want returned.
Checks that a variable has a Javadoc comment.
This class provides an empty implementation of
JavaLanguageParserVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.This interface defines a complete generic visitor for a parse tree produced
by
JavaLanguageParser.
Determines complexity of methods, classes and files by counting
the Non Commenting Source Statements (NCSS).
Class representing a counter.
Helper methods to parse java source files.
Custom error listener to provide detailed exception message.
Enum to be used for test if comments should be used.
Handler for labels.
Checks lambda body length.
Handler for lambda expressions.
Checks lambda parameter names.
Checks for the placement of left curly braces (
'{') for code blocks.Represents the options for placing the left curly brace
'{'.Immutable line and column numbers.
Checks for long lines.
Represents the options for line separator settings.
This class checks line-wrapping into definitions and expressions.
Enum to be used for test if first line's indentation should be checked or not.
ListToTreeSelectionModelWrapper extends DefaultTreeSelectionModel
to listen for changes in the ListSelectionModel it maintains.
Checks that local final variable names conform to a specified pattern.
Checks that local, non-
final variable names conform to a specified pattern.
Checks that there are no
"magic numbers" where a magic
number is a numeric literal that is not defined as a constant.
Entry point for starting the checkstyle GUI.
Wrapper command line program for the Checker.
Command line options.
Log Filter used in debug mode.
Enumeration over the possible output formats.
Displays information about a parse tree.
Filter for Java files.
Model for checkstyle frame.
Parsing modes which available in GUI.
Represents a suppressor for matches.
Evaluates Xpath query and report violation on all matching AST nodes.
Handler for member definitions.
Checks that instance variable names conform to a specified pattern.
Used by FileSetChecks to distribute AuditEvents to AuditListeners.
Exception for metadata generation errors.
Class which handles all the metadata generation and writing calls.
Handler for method calls.
Checks the number of methods declared in each type declaration by access modifier
or total count.
Marker class used to collect data about the number of methods per
class.
Handler for method definitions.
Checks for long methods and constructors.
Checks that method names conform to a specified pattern.
Checks the padding between the identifier of a method definition,
constructor definition, method call, or constructor invocation;
and the left parenthesis of the parameter list.
Checks that method type parameter names conform to a specified pattern.
Represents the strategy when none of the rules (allow/disallow tags) match
inside subpackage and import-control tag of ImportControlCheck config.
Checks that classes (except abstract ones) define a constructor and don't rely
on the default one.
Verifies that the annotation
@Deprecated and the Javadoc tag
@deprecated are both present when either of them is present.
Checks for missing Javadoc comments for a method or constructor.
Checks for missing Javadoc comments in package-info.java files.
Checks for missing Javadoc comments for class, enum, interface, and annotation interface
definitions.
Verifies that the
@Override annotation is present
when the @inheritDoc javadoc tag is present.
Checks that switch statement has a
default clause.
Checks that for loop control variables are not modified
inside the for block.
Checks that the order of modifiers conforms to the suggestions in the
Java Language specification, § 8.1.1, 8.3.1, 8.4.3 and
9.4.
Simple POJO class for module details.
A module factory creates Objects from a given name.
Simple POJO class module's property details.
Contains utility methods for module reflection.
Enum holding the types of module which can exist.
A detector that matches across multiple lines.
Checks for multiple occurrences of the same string literal within a single file.
Checks that each variable declaration is in its own statement
and on its own line.
Ensures that exception classes (classes with names conforming to some pattern
and explicitly extending classes with names conforming to other
pattern) are immutable, that is, that they have only final fields.
Checks for braces around code blocks.
Restricts nested
for blocks to a specified depth.
Restricts nested if-else blocks to a specified depth.
Restricts nested try-catch-finally blocks to a specified depth.
An implementation of
MatchSuppressor that never suppresses a
match.Handler for operator new.
Checks whether files end with a line separator.
Checks that array initialization do not contain a trailing comma.
Checks that the clone method is not overridden from the
Object class.
Checks whether file contains code.
Checks that enum definition does not contain a trailing comma.
Checks that there is no method
finalize with zero parameters.Checks that chosen statements are not line-wrapped.
Checks that the block tag is followed by description.
Checks that there is no whitespace after a token.
Checks that there is no whitespace before the colon in a switch block.
Checks that there is no whitespace before a token.
Checks the NPATH complexity against a specified limit.
Coordinates of token end.
Class that store range value and expression value.
Handler for inner classes.
Checks that there is only one statement per line.
Checks that each top-level class, interface, enum
or annotation resides in a source file of its own.
Checks the policy on how to wrap lines on operators.
Detects if keys in properties files are in correct order.
Private property implementation that keeps order of properties like in file.
Checks that the outer type name and the file name match.
Checks for the number of types declared at the outer (or root) level in a file.
Checks that overloaded methods are grouped together.
Checks that all package annotations are in the package-info.java file.
Ensures that a class has a package declaration, and (optionally) whether
the package name matches the directory name for the source file.
Handler for package definitions.
Checks that package names conform to a specified pattern.
Loads a list of package names from a package name XML file.
A factory for creating objects from package names and names.
Enum class to define loading options.
Represents the options for whitespace around parentheses.
Disallows assignment of parameters.
Checks that method parameter names conform to a specified pattern.
Checks the number of parameters of a method or constructor.
Checks the policy on the padding of parentheses; that is whether a space is required
after a left parenthesis and before a right parenthesis, or such spaces are
forbidden.
Contains utility methods for parser to use while creating ast.
The model that backs the parse tree in the GUI.
The model that backs the parse tree in the GUI.
Checks that pattern variable names conform to a specified pattern.
Represents a tree of import rules for a specific package.
Represents whether a package is allowed to be imported or not.
Recursive-free implementation of the preceding axis iterator.
A default no-op handler.
Resolves external properties from an
underlying
Properties object.This class maintains a persistent(on file-system) store of the files
that have checked ok(no validation events) and their associated
timestamp.
Class which represents external resource.
Resolves properties in module configurations.
Represents the custom property type used in documentation and configuration files.
Checks that record component names conform to a specified pattern.
Checks the number of record components in the
header of a record definition.
Checks that record type parameter names conform to a specified pattern.
Checks for redundant import statements.
Checks for redundant modifiers.
Checks that a specified pattern exists, exists less than
a set number of times, or does not exist in the file.
Checks the header of a source file against a header that contains a
pattern for each line of the source header.
Checks that a specified pattern matches across multiple lines in any file type.
Checks that a specified pattern matches based on file and/or folder path.
Checks that a specified pattern matches a single line in any file type.
Checks that a specified pattern matches a single line in Java files.
Checks that one blank line before the block tag if it is present in Javadoc.
Checks that references to instance variables and methods of the present
object are explicitly of the form "this.varName" or "this.methodName(args)"
and that those references don't rely on the default behavior when "this." is absent.
A declaration frame.
An anonymous class frame; holds instance variable names.
A frame initiated on entering a statement list; holds local variable names.
A frame initiated on entering a catch block; holds local catch variable names.
A frame initiated at class, enum or interface definition; holds instance variable names.
A frame initiated at constructor definition.
A frame initiated on entering a for block; holds local for variable names.
An AbstractFrame type.
A frame initiated at method definition; holds a method definition token.
Restricts the number of return statements in methods, constructors and lambda expressions.
Recursive-free implementation of the descendant axis iterator.
Iterates list in backward direction.
Checks the placement of right curly braces (
''}) for code blocks.Structure that contains all details for validation.
Represents the options for placing the right curly brace
'}'.The first module that is run as part of Checkstyle and controls its entire
behavior and children.
Represents root node of Xpath-tree.
Simple SARIF logger.
Represents a Java visibility scope.
Contains utility methods for working on scope.
Checks line wrapping with separators.
Severity level for a check violation.
An audit listener that counts how many
AuditEvents
of a given severity have been generated.
Filter
SeverityMatchFilter decides audit events according to the
severity level of the event.
Checks for over-complicated boolean expressions.
Checks for over-complicated boolean return statements.
A detector that matches individual lines.
Checks that a Javadoc block can fit in a single line and doesn't contain block tags.
Checks that non-whitespace characters are separated by no more than one
whitespace.
Handler for a list of statements.
This annotation means that the check does not contain mutable state and
may be safely used from others threads at the same time.
Handler for static initialization blocks.
Checks that
static, non-final variable names conform to a specified pattern.
Checks that string literals are not used with
== or !=.
Checks that
Javadoc summary sentence does not contain phrases that are not recommended to use.
Checks that an overriding
clone() method invokes super.clone().
Checks that an overriding
finalize() method invokes super.finalize().This filter element is immutable and processes
AuditEvent
objects based on the criteria of file, check, module id, line, and
column.
Filter
SuppressionCommentFilter uses pairs of comments to suppress audit events.A Tag holds a suppression comment and its location, and determines
whether the suppression turns checkstyle reporting on or off.
Enum to be used for switching checkstyle reporting for tags.
Filter
SuppressionFilter rejects audit events for Check violations according to a
suppressions XML document
in a file.
Filter
SuppressionSingleFilter suppresses audit events for Checks violations in the
specified file, class, checks, message, module id, lines, and columns.Loads a filter chain of suppressions.
Class for constructing xpath queries to suppress nodes
with specified line and column number.
Filter
SuppressionXpathFilter works as
SuppressionFilter.
Filter
SuppressionXpathSingleFilter suppresses audit events for Checks
violations in the specified file, class, checks, message, module id, and xpath.
Allows to specify what warnings that
@SuppressWarnings is not allowed to suppress.
Filter
SuppressWarningsFilter uses annotation
SuppressWarnings to suppress audit events.
Maintains a set of check suppressions from
@SuppressWarnings annotations.Records a particular suppression for a region of a file.
Filter
SuppressWithNearbyCommentFilter uses nearby comments to suppress audit events.A Tag holds a suppression comment and its location.
Filter
SuppressWithPlainTextCommentFilter uses plain text to suppress
audit events.The class which represents the suppression.
Enum which represents the type of the suppression.
Handler for switch statements.
Handler for switch rules.
Handler for synchronized statements.
Value object for storing data about a parsed tag.
Helper class used to parse HTML tags or generic type identifiers
from a single line of text.
Represents current position in the text.
A block of text from an input file that does not necessarily
have any grammatical structure.
Thread mode settings for the checkstyle modules.
Restricts throws statements to a specified count.
Checks for
TODO: comments.Contains the constants for all the tokens contained in the Abstract
Syntax Tree.
Contains utility methods for tokens.
The check to ensure that lines with code do not end with comment.
Ensures the correct translation of code by checking property files for consistency
regarding their keys.
Class which represents a resource bundle.
This example shows how to create a simple TreeTable component,
by using a JTree as a renderer (and editor) for the cells in a
particular column in the JTable.
A TreeCellRenderer that displays a JTree.
This is a wrapper class takes a TreeTableModel and implements
the table model interface.
Responsible for walking an abstract syntax tree and notifying interested
checks at each each node.
State of AST.
Raw
TreeWalker event for audit.An interface for filtering
TreeWalkerAuditEvent.Handler for try blocks.
Checks the policy on the padding of parentheses for typecasts.
Checks that type names conform to a specified pattern.
Detects uncommented
main methods.
Detects duplicated keys in properties files.
Properties subclass to store duplicated property keys in a separate map.
Checks if unnecessary parentheses are used in a statement or expression.
Checks if unnecessary semicolon is used after type declaration.
Checks if unnecessary semicolon is used after type member declaration.
Checks if unnecessary semicolon is in enum definitions.
Checks if unnecessary semicolon is used in last resource declaration.
Checks for unused import statements.
Holds the names of referenced types and names of declared inner types.
Checks that a local variable is declared and/or assigned, but not used.
Maintains information about the type declaration.
Maintains information about the variable.
Checks that long constants are defined with an upper ell.
Checks the distance between declaration of variable and its first usage.
Represents a violation that can be localised.
Custom ResourceBundle.Control implementation which allows explicitly read
the properties files as UTF-8.
Checks visibility of class members.
Handler for while loops.
Checks that a token is followed by whitespace, with the exception that it
does not check for whitespace after the semicolon of an empty for iterator.
Checks that a token is surrounded by whitespace.
Represents the options for wrapping on an operator.
Requires user defined Javadoc tag to be present in Javadoc comment with defined format.
The type of property used in documentation and configuration files
for clarification of the user friendly type.
Contains the common implementation of a loader, for loading a configuration
from an XML file.
Used for setting specific for secure java installations features to SAXParserFactory.
Simple XML logger.
The registered file messages.
Class having utilities required to read module details from an XML metadata file of a module.
Class to write module details object into an XML file.
Catches
TreeWalkerAuditEvent and generates corresponding xpath query.Generates suppressions.xml file, based on violations occurred.
This filter element is immutable and processes
TreeWalkerAuditEvent
objects based on the criteria of file, check, module id, xpathQuery.Generates xpath queries.
Contains utility methods for xpath.
Handler for yield expression.