All Classes and Interfaces

Class

Description

AccessSpecifier

Access specifier.

Added

AllFieldsConstructor

Tells tools that this is the constructor which directly initializes all fields (except "range" and "comment")

AnnotationDeclaration

An annotation type declaration.
@interface X { ... }

AnnotationDeclarationMetaModel

This file, class, and its contents are completely generated based on: The contents and annotations within the package `com.github.javaparser.ast`, and `ALL_NODE_CLASSES` within the class `com.github.javaparser.generator.metamodel.MetaModelGenerator`. For this reason, any changes made directly to this file will be overwritten the next time generators are run.

AnnotationExpr

A base class for the different types of annotations.

AnnotationExprMetaModel

AnnotationMemberDeclaration

The "int id();" in @interface X { int id(); }

AnnotationMemberDeclarationMetaModel

ArrayAccessExpr

Array brackets [] being used to get a value from an array.

ArrayAccessExprMetaModel

ArrayCreationExpr

new int[5][4][][] or new int[][]{{1},{2,3}}.

ArrayCreationExprMetaModel

ArrayCreationLevel

In new int[1][2]; there are two ArrayCreationLevel objects, the first one contains the expression "1", the second the expression "2".

ArrayCreationLevelMetaModel

ArrayInitializerExpr

The initialization of an array.

ArrayInitializerExprMetaModel

ArrayType

To indicate that a type is an array, it gets wrapped in an ArrayType for every array level it has.

ArrayType.ArrayBracketPair

Helper class that stores information about a pair of brackets in a non-recursive way (unlike ArrayType.)

ArrayType.Origin

The origin of a pair of array brackets [].

ArrayTypeMetaModel

AssertStmt

A usage of the keyword "assert"
In assert dead : "Wasn't expecting to be dead here"; the check is "dead" and the message is the string.

AssertStmtMetaModel

AssignExpr

An assignment expression.

AssignExpr.Operator

AssignExprMetaModel

AssociableToAST

A declaration that can be potentially associated with an AST node.

AstObserver

An Observer for an AST element (either a Node or a NodeList).

AstObserver.ListChangeType

Type of change occurring on a List

AstObserverAdapter

BaseNodeMetaModel

Meta-data about all classes in the AST.

BinaryExpr

An expression with an expression on the left, an expression on the right, and an operator in the middle.

BinaryExpr.Operator

BinaryExprMetaModel

BlockComment

AST node that represent block comments.

BlockCommentMetaModel

BlockStmt

Statements in between { and }.

BlockStmtMetaModel

BodyDeclaration<T>

Any declaration that can appear between the { and } of a class, interface, enum, or record.

BodyDeclarationMetaModel

BooleanLiteralExpr

The boolean literals.

BooleanLiteralExprMetaModel

BreakStmt

The break statement

BreakStmtMetaModel

Cache<K,V>

A contract that defines a semi-persistent mapping of keys and values.

CacheStats

CallableDeclaration<T>

Represents a declaration which is callable eg.

CallableDeclaration.Signature

A method or constructor signature.

CallableDeclarationMetaModel

CastExpr

A typecast.

CastExprMetaModel

CatchClause

The catch part of a try-catch-finally.

CatchClauseMetaModel

Change

This represents a change that has happened to a specific Node.

CharLiteralExpr

A literal character.

CharLiteralExprMetaModel

ChildTextElement

Represent the position of a child node in the NodeText of its parent.

ClassExpr

Defines an expression that accesses the class of a type.

ClassExprMetaModel

ClassOrInterfaceDeclaration

A definition of a class or interface.
class X { ... }
interface X { ... }

ClassOrInterfaceDeclarationMetaModel

ClassOrInterfaceType

A class or an interface type.

ClassOrInterfaceTypeMetaModel

ClassUtils

CloneVisitor

A visitor that clones (copies) a node and all its children.

CodeGenerationUtils

Utilities that can be useful when generating code.

CollectionStrategy

A strategy for discovering the structure of a project.

Comment

Abstract class for all AST nodes that represent comments.

CommentMetaModel

CommentsCollection

The comments contained in a certain parsed piece of source code.

CommentsInserter

Assigns comments to nodes of the AST.

CommonValidators

Contains validations that are valid for every Java version.

CompactConstructorDeclaration

The record declaration's constructor

CompactConstructorDeclarationMetaModel

CompilationUnit

This class represents the entire compilation unit.

CompilationUnit.Storage

Information about where this compilation unit was loaded from.

CompilationUnitMetaModel

ConcreteSyntaxModel

The Concrete Syntax Model for a single node type.

ConditionalExpr

The ternary conditional expression.

ConditionalExprHandler

ConditionalExprMetaModel

ConfigurationOption

ConflictingGenericTypesException

ConstructorDeclaration

A constructor declaration: class X { X() { } } where X(){} is the constructor declaration.

ConstructorDeclarationMetaModel

ConstructorResolutionLogic

Context

Context is very similar to scope.

ContinueStmt

A continue statement with an optional label;
continue brains;
continue;

ContinueStmtMetaModel

ConvertibleToUsage

Convert a Type into a ResolvedType.

CsmConditional.Condition

A group of elements that could be in any order.

CsmNone

CsmOrphanCommentsEnding

A key to a piece of data associated with a Node at runtime.

DefaultConfigurationOption

DefaultImportOrderingStrategy

DefaultPrettyPrinter

Pretty printer for AST nodes.

DefaultPrettyPrinterVisitor

Outputs the AST as formatted Java source code.

DefaultPrinterConfiguration

Configuration options for the Printer.

DefaultPrinterConfiguration.ConfigOption

DerivedProperty

Indicate a derived property of a Node, meaning it does supply useful information, but it does so by taking information from other properties.

Difference

A Difference should give me a sequence of elements I should find (to indicate the context) followed by a list of elements to remove or to add and follow by another sequence of elements.

Difference.ArrayIterator<T>

DifferenceElement

DifferenceElementCalculator

DifferenceElementCalculator.ChildPositionInfo

DoStmt

A do-while.

DoStmtMetaModel

DotPrinter

Outputs a Graphviz diagram of the AST.

DoubleLiteralExpr

A float or a double constant.

DoubleLiteralExprMetaModel

EclipseImportOrderingStrategy

EmptyStmt

An empty statement is a ";" where a statement is expected.

EmptyStmtMetaModel

EnclosedExpr

An expression between ( ).

EnclosedExprMetaModel

EnumConstantDeclaration

One of the values an enum can take.

EnumConstantDeclarationMetaModel

EnumDeclaration

The declaration of an enum.
enum X { ... }

EnumDeclarationMetaModel

EqualsVisitor

A visitor that calculates deep node equality by comparing all properties and child nodes of the node.

ExplicitConstructorInvocationStmt

A call to super or this in a constructor or initializer.

ExplicitConstructorInvocationStmtMetaModel

Expression

A base class for all expressions.

ExpressionMetaModel

ExpressionStmt

Used to wrap an expression so that it can take the place of a statement.

ExpressionStmtMetaModel

FieldAccessExpr

Access of a field of an object or a class.

FieldAccessExprMetaModel

FieldDeclaration

The declaration of a field in a class.

FieldDeclarationMetaModel

ForEachStmt

A for-each statement.

ForEachStmtMetaModel

ForStmt

The classic for statement

ForStmtMetaModel

FunctionalInterfaceLogic

Generated

Copied from javax.annotation.Generated and reduced a bit.

GeneratedJavaParser

GeneratedJavaParser.JJCalls

GeneratedJavaParser.LookaheadSuccess

GeneratedJavaParserBase

Base class for GeneratedJavaParser

GeneratedJavaParserConstants

Token literal values and constants.

GeneratedJavaParserTokenManager

Token Manager.

GeneratedJavaParserTokenManagerBase

Base class for GeneratedJavaParserTokenManager

GenericListVisitorAdapter<R,A>

A visitor that has a return value of List<R>, and has a default implementation for all its visit methods that visits their children in an unspecified order, and all visit methods that returns a value be added to a flattened List<R>.

GenericVisitor<R,A>

A visitor that has a return value.

GenericVisitorAdapter<R,A>

A visitor that has a return value (R), and has a default implementation for all its visit methods that visits their children in an unspecified order, and the first visit method that returns a value will stop the visitation and be the end result.

GenericVisitorWithDefaults<R,A>

A visitor that has a return value (R), and has default methods that are used when a specific visit method is not overridden.

HasAccessSpecifier

Anything which can have an AccessSpecifier.

HashCodeVisitor

A visitor that calculates a deep hash code for a node by using the hash codes of all its properties, and the hash codes of all its child nodes (by visiting those too.)

HasParentNode<T>

An object that can have a parent node.

IfStmt

An if-then-else statement.

IfStmtMetaModel

ImportDeclaration

An import declaration.

ImportDeclarationMetaModel

ImportOrderingStrategy

Indentation

This class defines the characteristics of an indentation: the type (space, tabs..) and the size (How many characters must be used to indent the code).

Indentation.IndentType

InferenceContext

InferenceVariableType

An element using during type inference.

InitializerDeclaration

A (possibly static) initializer body.

InitializerDeclarationMetaModel

InstanceOfExpr

The instanceof statement

InstanceOfExprMetaModel

IntegerLiteralExpr

All ways to specify an int literal.

IntegerLiteralExprMetaModel

IntelliJImportOrderingStrategy

InternalProperty

Indicate an internal property of a Node, meaning it is not part of the meta model.

IntersectionType

Represents a set of types.

IntersectionTypeMetaModel

Java1_0Validator

This validator validates according to Java 1.0 syntax rules.

Java1_1Validator

This validator validates according to Java 1.1 syntax rules.

Java1_2Validator

This validator validates according to Java 1.2 syntax rules.

Java1_3Validator

This validator validates according to Java 1.3 syntax rules.

Java1_4Validator

This validator validates according to Java 1.4 syntax rules.

Java10PostProcessor

Processes the generic AST into a Java 10 AST and validates it.

Java10PreviewValidator

This validator validates according to Java 10 syntax rules -- including incubator/preview/second preview features.

Java10Validator

This validator validates according to Java 10 syntax rules.

Java11PostProcessor

Processes the generic AST into a Java 11 AST and validates it.

Java11PreviewValidator

This validator validates according to Java 11 syntax rules -- including incubator/preview/second preview features.

Java11Validator

This validator validates according to Java 11 syntax rules.

Java12PostProcessor

Processes the generic AST into a Java 12 AST and validates it.

Java12PreviewValidator

This validator validates according to Java 12 syntax rules -- including incubator/preview/second preview features.

Java12Validator

This validator validates according to Java 12 syntax rules.

Java13PostProcessor

Processes the generic AST into a Java 13 AST and validates it.

Java13PreviewValidator

This validator validates according to Java 13 syntax rules -- including incubator/preview/second preview features.

Java13Validator

This validator validates according to Java 13 syntax rules.

Java14PostProcessor

Processes the generic AST into a Java 14 AST and validates it.

Java14PreviewValidator

This validator validates according to Java 14 syntax rules -- including incubator/preview/second preview features.

Java14Validator

This validator validates according to Java 14 syntax rules.

Java15PostProcessor

Processes the generic AST into a Java 15 AST and validates it.

Java15PreviewValidator

This validator validates according to Java 15 syntax rules -- including incubator/preview/second preview features.

Java15Validator

This validator validates according to Java 15 syntax rules.

Java16PostProcessor

Processes the generic AST into a Java 16 AST and validates it.

Java16PreviewValidator

This validator validates according to Java 16 syntax rules -- including incubator/preview/second preview features.

Java16Validator

This validator validates according to Java 16 syntax rules.

Java17PostProcessor

Processes the generic AST into a Java 17 AST and validates it.

Java17PreviewValidator

This validator validates according to Java 17 syntax rules -- including incubator/preview/second preview features.

Java17Validator

This validator validates according to Java 17 syntax rules.

Java18PostProcessor

Processes the generic AST into a Java 18 AST and validates it.

Java18Validator

This validator validates according to Java 18 syntax rules.

Java19PostProcessor

Processes the generic AST into a Java 19 AST and validates it.

Java19Validator

This validator validates according to Java 19 syntax rules.

Java20PostProcessor

Processes the generic AST into a Java 20 AST and validates it.

Java20Validator

This validator validates according to Java 20 syntax rules.

Java21PostProcessor

Processes the generic AST into a Java 21 AST and validates it.

Java21Validator

This validator validates according to Java 21 syntax rules.

Java5Validator

This validator validates according to Java 5 syntax rules.

Java6Validator

This validator validates according to Java 6 syntax rules.

Java7Validator

This validator validates according to Java 7 syntax rules.

Java8Validator

This validator validates according to Java 8 syntax rules.

Java9Validator

This validator validates according to Java 9 syntax rules.

Javadoc

The structured content of a single Javadoc comment.

JavadocBlockTag

A block tag.

JavadocBlockTag.Type

The type of tag: it could either correspond to a known tag (param, return, etc.) or represent an unknown tag.

JavadocComment

A Javadoc comment.

JavadocCommentMetaModel

JavadocDescription

A javadoc text, potentially containing inline tags.

JavadocDescriptionElement

An element of a description: either an inline tag or a piece of text.

JavadocInlineTag

An inline tag contained in a Javadoc description.

JavadocInlineTag.Type

The type of tag: it could either correspond to a known tag (code, docRoot, etc.) or represent an unknown tag.

JavadocParser

The class responsible for parsing the content of JavadocComments and producing JavadocDocuments.

JavadocSnippet

A piece of text inside a Javadoc description.

JavaParser

Parse Java source code and creates Abstract Syntax Trees.

JavaParserAdapter

JavaParserBuild

Some information that was available when this library was built by Maven.

JavaParserMetaModel

Warning: The content of this class is partially or completely generated - manual edits risk being overwritten.

JavaToken

A token from a parsed source file.

A statement that is labeled, like label123: println("continuing");

LabeledStmtMetaModel

LambdaArgumentTypePlaceholder

Placeholder used to represent a lambda argument type while it is being calculated.

LambdaExpr

A lambda expression

LambdaExprMetaModel

LazyType

LexicalDifferenceCalculator

LexicalDifferenceCalculator.CalculatedSyntaxModel

The ConcreteSyntaxModel represents the general format.

LexicalDifferenceCalculator.CsmChild

LexicalPreservingPrinter

A Lexical Preserving Printer is used to capture all the lexical information while parsing, update them when operating on the AST and then used them to reproduce the source code in its original formatting including the AST changes.

LexicalPreservingPrinter.Observer

LexicalPreservingVisitor

LineComment

AST node that represent line comments.

LineCommentMetaModel

LineEndingProcessingProvider

Provider un-escaping unicode escape sequences in the input sequence.

LineSeparator

A representation of line endings, that can be used throughout the codebase.

ListAdditionChange

The Addition of an element to a list.

ListRemovalChange

The removal of an element from a list.

ListReplacementChange

The replacement of an element in a list.

LiteralExpr

A base class for all literal expressions.

LiteralExprMetaModel

LiteralStringValueExpr

Any literal value that is stored internally as a String.

LiteralStringValueExprMetaModel

LocalClassDeclarationStmt

A class declaration inside a method.

LocalClassDeclarationStmtMetaModel

LocalRecordDeclarationStmt

A record declaration inside a method.

LocalRecordDeclarationStmtMetaModel

Log

To avoid dependencies on logging frameworks, we have invented yet another logging framework :-)

Log.Adapter

Log.SilentAdapter

This adapter logs nothing.

Log.StandardOutStandardErrorAdapter

This adapter logs to standard out and standard error.

LongLiteralExpr

All ways to specify a long literal.

LongLiteralExprMetaModel

LookaheadIterator<E>

MarkerAnnotationExpr

An annotation that uses only the annotation type name.

MarkerAnnotationExprMetaModel

MemberValuePair

A value for a member of an annotation.

MemberValuePairMetaModel

MethodAmbiguityException

It is not possible to decide how to resolve a method invocation.

MethodCallExpr

A method call on an object or a class.

MethodCallExprMetaModel

MethodDeclaration

A method declaration.

MethodDeclarationMetaModel

MethodReferenceExpr

Method reference expressions introduced in Java 8 specifically designed to simplify lambda Expressions.

MethodReferenceExprMetaModel

MethodResolutionCapability

MethodResolutionLogic

MethodUsage

This is basically a MethodDeclaration with some TypeParameters defined.

Modifier

A modifier, like private, public, or volatile.

Modifier.Keyword

The Java modifier keywords.

ModifierHolder

Helper class for GeneratedJavaParser

ModifierMetaModel

ModifierValidator

Verifies that only allowed modifiers are used where modifiers are expected.

ModifierVisitor<A>

This visitor can be used to save time when some specific nodes needs to be changed.

ModuleDeclaration

A Java 9 Jigsaw module declaration.

ModuleDeclarationMetaModel

ModuleDirective

A module directive.

ModuleDirectiveMetaModel

ModuleExportsDirective

An exports directive in module-info.java.

ModuleExportsDirectiveMetaModel

ModuleOpensDirective

An opens directive in module-info.java.

ModuleOpensDirectiveMetaModel

ModuleProvidesDirective

A provides directive in module-info.java.

ModuleProvidesDirectiveMetaModel

ModuleRequiresDirective

A require directive in module-info.java.

ModuleRequiresDirectiveMetaModel

ModuleUsesDirective

A uses directive in module-info.java.

ModuleUsesDirectiveMetaModel

Name

A name that may consist of multiple identifiers.

NameExpr

Whenever a SimpleName is used in an expression, it is wrapped in NameExpr.

NameExprMetaModel

NameMetaModel

Navigator

This class can be used to easily retrieve nodes from a JavaParser AST.

NoBinaryIntegerLiteralsValidator

NoChange

No change.

NoCommentEqualsVisitor

NoCommentHashCodeVisitor

Node

Base class for all nodes of the abstract syntax tree.

Node.BreadthFirstIterator

Performs a breadth-first node traversal starting with a given node.

Node.DirectChildrenIterator

Performs a simple traversal over all nodes that have the passed node as their parent.

Node.ObserverRegistrationMode

Different registration mode for observers on nodes.

Node.ParentsVisitor

Iterates over the parent of the node, then the parent's parent, then the parent's parent's parent, until running out of parents.

Node.Parsedness

Node.PostOrderIterator

Performs a post-order (or leaves-first) node traversal starting with a given node.

Node.PostOrderIterator.Level

Represents a level in the traversal stack during the post-order iteration.

Node.PreOrderIterator

Performs a pre-order (or depth-first) node traversal starting with a given node.

A list of nodes.

This contains the lexical information for a single node.

NodeWithAbstractModifier<N>

A node that can be abstract.

NodeWithAccessModifiers<N>

A node that can be public, protected, and/or private.

NodeWithAnnotations<N>

A node that can be annotated.

NodeWithArguments<N>

A node with arguments.

NodeWithBlockStmt<N>

A node with a body that is a BlockStmt.

NodeWithBody<N>

NodeWithCondition<N>

NodeWithDeclaration

Node with a declaration representable as a String.

NodeWithExpression<N>

A node that has an expression in it.

NodeWithExtends<N>

A node that explicitly extends other types, using the extends keyword.

NodeWithFinalModifier<N>

A node that can be final.

NodeWithIdentifier<N>

NodeWithImplements<N>

A node that implements other types.

NodeWithJavadoc<N>

A node that can be documented with a Javadoc comment.

NodeWithMembers<N>

A node having members.

NodeWithModifiers<N>

A Node with Modifiers.

NodeWithName<N>

A node with a (qualified) name.

NodeWithOptionalBlockStmt<N>

A node with a body that is a BlockStmt, which is optional.

NodeWithOptionalLabel<T>

A node that has an optional label.

NodeWithOptionalScope<N>

Represents a node which has an optional scope expression eg.

NodeWithParameters<N>

NodeWithPrivateModifier<N>

A node that can be private.

NodeWithProtectedModifier<N>

A node that can be protected.

NodeWithPublicModifier<N>

A node that can be public.

NodeWithRange<N>

A node that has a Range, which is every Node.

NodeWithScope<N>

Represents a node which has a required scope expression eg.

NodeWithSimpleName<N>

A node with a name.

NodeWithStatements<N>

A node that contains a list of statements.

NodeWithStaticModifier<N>

A node that can be static.

NodeWithStrictfpModifier<N>

A node that can be strictfp.

NodeWithThrownExceptions<N>

A node that declares the types of exception it throws.

NodeWithTokenRange<N>

A node that has a Range, which is every Node.

NodeWithTraversableScope

Represents a node which has a scope expression that can be traversed/walked.

NodeWithType<N,T>

A node with a type.

NodeWithTypeArguments<N>

A node that can have type arguments.

NodeWithTypeParameters<N>

A node that can have type parameters.

NodeWithVariables<N>

A node which has a list of variables.

NonEmptyProperty

Indicate that leaving this property empty does not lead to a correct AST.

NormalAnnotationExpr

An annotation that has zero or more key-value pairs.
@Mapping(a=5, d=10)

NormalAnnotationExprMetaModel

NotNull

NoUnderscoresInIntegerLiteralsValidator

Nullable

NullLiteralExpr

A literal "null".

NullLiteralExprMetaModel

NullType

This is a virtual type used to represent null values.

ObjectCreationExpr

A constructor call.

ObjectCreationExprMetaModel

ObjectIdentityEqualsVisitor

A visitor that calculates deep node equality by comparing all properties and child nodes of the node.

ObjectIdentityHashCodeVisitor

A visitor that calculates a deep hash code for a node by using the hash codes of all its properties, and the hash codes of all its child nodes (by visiting those too.)

Observable

Observable element.

ObservableProperty

Properties considered by the AstObserver

ObservableProperty.Type

OptionalProperty

Indicate an optional property of a Node.

PackageDeclaration

A package declaration.

PackageDeclarationMetaModel

Pair<A,B>

Simply a pair of objects.

Parameter

The parameters to a method or lambda.

ParameterMetaModel

ParseException

This exception is thrown when parse errors are encountered.

ParseProblemException

Thrown when parsing problems occur during parsing with the static methods on JavaParser.

ParserCollectionStrategy

A brute force CollectionStrategy for discovering a project structure.

ParserConfiguration

The configuration that is used by the parser.

ParserConfiguration.LanguageLevel

ParseResult<T>

The results given when parsing with an instance of JavaParser.

ParseStart<R>

The start production for JavaParser.

PatternExpr

Pattern Matching in Java

PatternExprMetaModel

PeekingIterator<E>

Decorates an iterator to support one-element lookahead while iterating.

PhantomNodeLogic

Deprecated.

This class is no longer used phantom node are now an attribute of each node

Position

A position in a source file.

PositionUtils

PostProcessors

A post processor that will call a collection of post processors.

Preconditions

PrettyPrinter

Deprecated.

This class could be removed in a future version.

PrettyPrinterConfiguration

Deprecated.

This class could be removed in a future version.

PrettyPrintVisitor

Deprecated.

This class is no longer acceptable to use because it is not sufficiently configurable and it is too tied to a specific implementation.

PrimitiveType

A primitive type.

PrimitiveType.Primitive

PrimitiveTypeMetaModel

PrintableTextElement

Printer

Printer interface defines the API for a printer.

PrinterConfiguration

This interface defines the API for printer configuration.

PrintingHelper

Problem

A problem that was encountered during parsing.

ProblemReporter

A simple interface where validators can report found problems.

Processor

ProjectRoot

The structure of a Java project directory.

PropagatingAstObserver

This AstObserver attach itself to all new nodes added to the nodes already observed.

PropertyChange

The change in value of a property.

PropertyMetaModel

Meta-data about a property of a node in the AST.

Provider

Providers

Factory for providers of source code for JavaParser.

Range

A range of characters in a source file, from "begin" to "end", including the characters at "begin" and "end".

RangedList<T>

Helper class for GeneratedJavaParser

ReceiverParameter

The receiver parameter feature of Java.

ReceiverParameterMetaModel

RecordAsTypeIdentifierNotAllowed

Validates that "record" cannot be used as identifier for type declarations (e.g., classes, enums, and records).

RecordDeclaration

The record declaration

RecordDeclarationMetaModel

RecordDeclarationValidator

RecordPatternExpr

Record Patterns

RecordPatternExprMetaModel

ReferenceType

Base class for reference types.

ReferenceTypeImpl

ReferenceTypeMetaModel

Removed

RemovedGroup

This class represents a group of Removed elements.

ReservedKeywordValidator

Validates that identifiers are not keywords - this for the few keywords that the parser accepts because they were added after Java 1.0.

Reshuffled

Elements in a CsmMix have been reshuffled.

ReshuffledDiffElementExtractor

ReshuffledDiffElementExtractor.MatchClassification

Resolvable<T>

ResolvedAnnotationDeclaration

ResolvedAnnotationMemberDeclaration

ResolvedArrayType

Array Type.

ResolvedClassDeclaration

Declaration of a Class (not an interface or an enum).

ResolvedConstructorDeclaration

A declaration of a constructor.

ResolvedDeclaration

A generic declaration.

ResolvedEnumConstantDeclaration

ResolvedEnumDeclaration

Declaration of an Enum.

ResolvedFieldDeclaration

Declaration of a field.

ResolvedInterfaceDeclaration

An interface declaration.

ResolvedIntersectionType

An intersection type is defined in java as list of types separates by ampersands.

ResolvedLambdaConstraintType

ResolvedMethodDeclaration

A declaration of a method (either in an interface, a class, an enum or an annotation).

ResolvedMethodLikeDeclaration

This is a common interface for MethodDeclaration and ConstructorDeclaration.

ResolvedParameterDeclaration

Declaration of a parameter.

ResolvedPrimitiveType

ResolvedRecordDeclaration

Declaration of a Record (not an interface or an enum).

ResolvedReferenceType

A ReferenceType like a class, an interface or an enum.

ResolvedReferenceTypeDeclaration

ResolvedType

A resolved type.

ResolvedTypeDeclaration

A declaration of a type.

ResolvedTypeParameterDeclaration

Declaration of a type parameter.

ResolvedTypeParameterDeclaration.Bound

A Bound on a Type Parameter.

ResolvedTypeParametersMap

A map of values associated to TypeParameters.

ResolvedTypeParametersMap.Builder

ResolvedTypeParameterValueProvider

ResolvedTypeParametrizable

An entity which has type parameter.

ResolvedTypeParametrized

Something which can have values for TypeParameters.

ResolvedTypePatternDeclaration

Declaration of a type pattern expression.

ResolvedTypeTransformer

ResolvedTypeVariable

From JLS 4.4: A type variable is introduced by the declaration of a type parameter of a generic class, interface, method, or constructor (§8.1.2, §9.1.2, §8.4.4, §8.8.4).

ResolvedUnionType

A union type is defined in java as list of types separates by pipes.

ResolvedValueDeclaration

Declaration of a value.

ResolvedVoidType

The special type void.

ResolvedWildcard

A wildcard can be: - unbounded (?) - have a lower bound (? super Number) - have an upper bound (? extends Number) It is not possible to have both a lower and an upper bound at the same time.

ResolvedWildcard.BoundType

ReturnStmt

The return statement, with an optional expression to return.

ReturnStmtMetaModel

RuntimeXMLStreamException

RuntimeException subclass encapsulationg XMLStreamException.

SeparatedItemStringBuilder

Builds a string containing a list of items with a prefix, a postfix, and a separator.

SimpleCharStream

An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without unicode processing).

SimpleName

A name that consists of a single identifier.

SimpleNameMetaModel

SimpleValidator<N>

Runs a validator on all nodes of a certain type, and adds a problem for all nodes that pass a condition.

SingleMemberAnnotationExpr

An annotation that has a single value.

SingleMemberAnnotationExprMetaModel

SingleNodeTypeValidator<N>

Runs a validator on all nodes of a certain type.

Solver

SourcePrinter

A support class for code that outputs formatted source code.

SourceRoot

A collection of Java source files located in one directory and its subdirectories on the file system.

SourceRoot.Callback

SourceRoot.Callback.Result

SourceRoot.ParallelParse

Executes a recursive file tree walk using threads.

SourceRoot.ParallelParse.VisitFileCallback

SourceZip

A collection of Java source files and its sub-directories located in a ZIP or JAR file on the file system.

SourceZip.Callback

An interface to define a callback for each file that's parsed.

Statement

A base class for all statements.

StatementMetaModel

StaticJavaParser

A simpler, static API than JavaParser.

StreamProvider

NOTE : This generated class can be safely deleted if installing in a GWT installation (use StringProvider instead)

Stringable

Something that has a printable form.

StringEscapeUtils