All Classes and Interfaces
Class
Description
Will let the symbol solver look inside an Android aar file while solving types.
A common ancestor for all ClassDeclarations.
Common ancestor for most types.
Access specifier.
Tells tools that this is the constructor which directly initializes all fields (except "range" and "comment")
An annotation type declaration.
@interface X { ... }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.
A base class for the different types of annotations.
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.
The "int id();" in
@interface X { int id(); }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.
A symbol resolution context for an object creation node.
Array brackets [] being used to get a value from an array.
Required to prevent recursive access to the "parent node" (not necessarily the same as the "parent context").
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.
new int[5][4][][] or new int[][]{{1},{2,3}}.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.
In
new int[1][2]; there are two ArrayCreationLevel objects,
the first one contains the expression "1",
the second the expression "2".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.
The initialization of an array.
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.
To indicate that a type is an array, it gets wrapped in an ArrayType for every array level it has.
Helper class that stores information about a pair of brackets in a non-recursive way
(unlike ArrayType.)
The origin of a pair of array brackets [].
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.
A usage of the keyword "assert"
In
In
assert dead : "Wasn't expecting to be dead here"; the check is "dead" and the message is the string.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.
An assignment expression.
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.
A declaration that can be potentially associated with an AST node.
An Observer for an AST element (either a Node or a NodeList).
Type of change occurring on a List
Meta-data about all classes in the AST.
An expression with an expression on the left, an expression on the right, and an operator in the middle.
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.
AST node that represent block comments.
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.
Statements in between { and }.
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.
Any declaration that can appear between the { and } of a class, interface, enum, or record.
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.
The boolean literals.
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.
Bounds are defined for Inference Variables.
The break statement
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.
A contract that defines a semi-persistent mapping of keys and values.
Represents a declaration which is callable eg.
A method or constructor signature.
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.
Capture(G<A1, ..., An>): The variables α1, ..., αn represent the result of capture conversion (§5.1.10)
applied to G<A1, ..., An> (where A1, ..., An may be types or wildcards and may mention inference variables).
A typecast.
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.
The catch part of a try-catch-finally.
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.
This represents a change that has happened to a specific Node.
A literal character.
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.
Represent the position of a child node in the NodeText of its parent.
Defines an expression that accesses the class of a type.
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.
This TypeSolver wraps a ClassLoader.
A definition of a class or interface.
class X { ... }interface X { ... }Limited version of ClassOrInterfaceDeclarationContext that only resolves type parameters for use by
extends and implements part of declaration.
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.
A class or an interface type.
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.
A visitor that clones (copies) a node and all its children.
Utilities that can be useful when generating code.
A strategy for discovering the structure of a project.
A container for type solvers.
Provides some convenience exception handler implementations
Abstract class for all AST nodes that represent comments.
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.
The comments contained in a certain parsed piece of source code.
Assigns comments to nodes of the AST.
Contains validations that are valid for every Java version.
The record declaration's constructor
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.
This class represents the entire compilation unit.
Information about where this compilation unit was loaded from.
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.
The Concrete Syntax Model for a single node type.
The ternary conditional expression.
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.
Constraint formulas are assertions of compatibility or subtyping that may involve inference variables.
A constructor declaration:
class X { X() { } } where X(){} is the constructor declaration.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.
Context is very similar to scope.
A continue statement with an optional label;
continue brains;
continue;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.
Consider Control Flow to determine which statements are reachable.
Convert a
Type into a ResolvedType.A group of elements that could be in any order.
A key to a piece of data associated with a
Node at runtime.Statistics about the performance of a
Cache.This represents the default constructor added by the compiler for objects not declaring one.
Pretty printer for AST nodes.
Outputs the AST as formatted Java source code.
Configuration options for the
Printer.Indicate a derived property of a Node,
meaning it does supply useful information,
but it does so by taking information from other properties.
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.
A do-while.
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.
Outputs a Graphviz diagram of the AST.
A float or a double constant.
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.
An empty statement is a ";" where a statement is expected.
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.
An expression between ( ).
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.
One of the values an enum can take.
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.
The declaration of an enum.
enum X { ... }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.
A visitor that calculates deep node equality by comparing all properties and child nodes of the node.
A call to super or this in a constructor or initializer.
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.
A base class for all expressions.
An expression is compatible in a loose invocation context with type T
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.
Used to wrap an expression so that it can take the place of a statement.
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.
No valid choice of inference variables exists.
Access of a field of an object or a class.
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.
The declaration of a field in a class.
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.
A for-each statement.
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.
The classic for statement
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.
Copied from javax.annotation.Generated and reduced a bit.
Base class for
GeneratedJavaParserToken literal values and constants.
Token Manager.
Base class for
GeneratedJavaParserTokenManagerA visitor that has a return value.
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.
A visitor that has a return value (R), and has default methods that are used when a specific visit method is not
overridden.
This class is used to wrap a Guava
Cache.Anything which can have an AccessSpecifier.
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.)
An object that can have a parent node.
An if-then-else statement.
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.
An import declaration.
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.
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).
Are meta-variables for types - that is, they are special names that allow abstract reasoning about types.
An element using during type inference.
A (possibly static) initializer body.
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.
A cache implementation that stores the information in memory.
The instanceof statement
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.
All ways to specify an int literal.
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.
Indicate an internal property of a Node,
meaning it is not part of the meta model.
Represents a set of types.
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.
Will let the symbol solver look inside a jar file while solving types.
This validator validates according to Java 1.0 syntax rules.
This validator validates according to Java 1.1 syntax rules.
This validator validates according to Java 1.2 syntax rules.
This validator validates according to Java 1.3 syntax rules.
This validator validates according to Java 1.4 syntax rules.
Processes the generic AST into a Java 10 AST and validates it.
This validator validates according to Java 10 syntax rules -- including incubator/preview/second preview features.
This validator validates according to Java 10 syntax rules.
Processes the generic AST into a Java 11 AST and validates it.
This validator validates according to Java 11 syntax rules -- including incubator/preview/second preview features.
This validator validates according to Java 11 syntax rules.
Processes the generic AST into a Java 12 AST and validates it.
This validator validates according to Java 12 syntax rules -- including incubator/preview/second preview features.
This validator validates according to Java 12 syntax rules.
Processes the generic AST into a Java 13 AST and validates it.
This validator validates according to Java 13 syntax rules -- including incubator/preview/second preview features.
This validator validates according to Java 13 syntax rules.
Processes the generic AST into a Java 14 AST and validates it.
This validator validates according to Java 14 syntax rules -- including incubator/preview/second preview features.
This validator validates according to Java 14 syntax rules.
Processes the generic AST into a Java 15 AST and validates it.
This validator validates according to Java 15 syntax rules -- including incubator/preview/second preview features.
This validator validates according to Java 15 syntax rules.
Processes the generic AST into a Java 16 AST and validates it.
This validator validates according to Java 16 syntax rules -- including incubator/preview/second preview features.
This validator validates according to Java 16 syntax rules.
Processes the generic AST into a Java 17 AST and validates it.
This validator validates according to Java 17 syntax rules -- including incubator/preview/second preview features.
This validator validates according to Java 17 syntax rules.
Processes the generic AST into a Java 18 AST and validates it.
This validator validates according to Java 18 syntax rules.
This validator validates according to Java 5 syntax rules.
This validator validates according to Java 6 syntax rules.
This validator validates according to Java 7 syntax rules.
This validator validates according to Java 8 syntax rules.
This validator validates according to Java 9 syntax rules.
The structured content of a single Javadoc comment.
A block tag.
The type of tag: it could either correspond to a known tag (param, return, etc.) or represent
an unknown tag.
A Javadoc comment.
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.
A javadoc text, potentially containing inline tags.
An element of a description: either an inline tag or a piece of text.
An inline tag contained in a Javadoc description.
The type of tag: it could either correspond to a known tag (code, docRoot, etc.) or represent
an unknown tag.
The class responsible for parsing the content of JavadocComments and producing JavadocDocuments.
A piece of text inside a Javadoc description.
Parse Java source code and creates Abstract Syntax Trees.
An anonymous class declaration representation.
Some information that was available when this library was built by Maven.
Needed by ContextHelper
An implicitly declared method
public static E valueOf(String name), which returns the
enum constant of E with the specified name.Needed by ContextHelper
An implicitly declared method
public static E[] values(), which returns an array containing the
enum constants of E, in the same order as they appear in the body of the declaration of E.Class to be used by final users to solve symbols for JavaParser ASTs.
Warning: The content of this class is partially or completely generated - manual edits risk being overwritten.
WARNING: Implemented fairly blindly.
This should not be used to represent fields of parameters.
Defines a directory containing source code that should be used for solving symbols.
This implementation of the SymbolResolver wraps the functionality of the library to make them easily usable
from JavaParser nodes.
A token from a parsed source file.
A statement that is labeled, like
label123: println("continuing");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.
Placeholder used to represent a lambda argument type while it is being
calculated.
A lambda expression
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.
The checked exceptions thrown by the body of the LambdaExpression are declared by the throws clause of the
function type derived from T.
The ConcreteSyntaxModel represents the general format.
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.
AST node that represent line comments.
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.
Provider un-escaping unicode escape sequences in the input sequence.A representation of line endings, that can be used throughout the codebase.
The Addition of an element to a list.
The removal of an element from a list.
The replacement of an element in a list.
A base class for all literal expressions.
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.
Any literal value that is stored internally as a String.
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.
A class declaration inside a method.
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.
A record declaration inside a method.
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.
To avoid dependencies on logging frameworks, we have invented yet another logging framework :-)
This adapter logs nothing.
This adapter logs to standard out and standard error.
All ways to specify a long literal.
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.
An annotation that uses only the annotation type name.
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.
A value for a member of an annotation.
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.
A TypeSolver which only consider the TypeDeclarations provided to it.
It is not possible to decide how to resolve a method invocation.
A method call on an object or a class.
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.
A method declaration.
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.
Method reference expressions introduced in Java 8 specifically designed to simplify lambda Expressions.
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.
The checked exceptions thrown by the referenced method are declared by the throws clause of the function type
derived from T.
A MethodType is an ordered 4-tuple consisting of:
1.
This is basically a MethodDeclaration with some TypeParameters defined.
A modifier, like private, public, or volatile.
The Java modifier keywords.
Helper class for
GeneratedJavaParserThis 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.
Verifies that only allowed modifiers are used where modifiers are expected.
This visitor can be used to save time when some specific nodes needs
to be changed.
A Java 9 Jigsaw module declaration.
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.
A module directive.
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.
An exports directive in module-info.java.
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.
An opens directive in module-info.java.
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.
A provides directive in module-info.java.
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.
A require directive in module-info.java.
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.
A uses directive in module-info.java.
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.
A name that may consist of multiple identifiers.
Context causes a name syntactically to fall into one of seven categories: ModuleName, PackageName, TypeName,
ExpressionName, MethodName, PackageOrTypeName, or AmbiguousName.
Whenever a SimpleName is used in an expression, it is wrapped in NameExpr.
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.
NameLogic contains a set of static methods to implement the abstraction of a "Name" as defined
in Chapter 6 of the JLS.
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.
Each Name can be part either of a Declaration or a Reference to a Declaration.
This class can be used to easily retrieve nodes from a JavaParser AST.
A cache implementation that does not store any information.
No change.
Base class for all nodes of the abstract syntax tree.
Performs a breadth-first node traversal starting with a given node.
Performs a simple traversal over all nodes that have the passed node as their parent.
Different registration mode for observers on nodes.
Iterates over the parent of the node, then the parent's parent, then the parent's parent's parent, until running
out of parents.
Performs a post-order (or leaves-first) node traversal starting with a given node.
Performs a pre-order (or depth-first) node traversal starting with a given node.
A list of nodes.
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.
This contains the lexical information for a single node.
A node that can be abstract.
A node that can be public, protected, and/or private.
A node that can be annotated.
A node with arguments.
A node with a body that is a BlockStmt.
Node with a declaration representable as a String.
A node that has an expression in it.
A node that explicitly extends other types, using the
extends keyword.A node that can be final.
A node that implements other types.
A node that can be documented with a Javadoc comment.
A node having members.
A Node with Modifiers.
A node with a (qualified) name.
A node with a body that is a BlockStmt, which is optional.
A node that has an optional label.
Represents a node which has an optional scope expression eg.
A node that can be private.
A node that can be protected.
A node that can be public.
A node that has a Range, which is every Node.
Represents a node which has a required scope expression eg.
A node with a name.
A node that contains a list of statements.
A node that can be static.
A node that can be strictfp.
A node that declares the types of exception it throws.
A node that has a Range, which is every Node.
Represents a node which has a scope expression that can be traversed/walked.
A node with a type.
A node that can have type arguments.
A node that can have type parameters.
A node which has a list of variables.
Indicate that leaving this property empty does not lead to a correct AST.
An annotation that has zero or more key-value pairs.
@Mapping(a=5, d=10)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.
A literal "null".
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.
This is a virtual type used to represent null values.
A constructor call.
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.
A visitor that calculates deep node equality by comparing all properties and child nodes of the node.
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 element.
Properties considered by the AstObserver
Indicate an optional property of a Node.
A package declaration.
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.
Simply a pair of objects.
The parameters to a method or lambda.
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.
This exception is thrown when parse errors are encountered.
Thrown when parsing problems occur during parsing with the static methods on JavaParser.
A brute force
CollectionStrategy for discovering a project structure.The configuration that is used by the parser.
The results given when parsing with an instance of JavaParser.
The start production for JavaParser.
The instanceof statement
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.
Decorates an iterator to support one-element lookahead while iterating.
Deprecated.
This class is no longer used phantom node are now an attribute of each node
A position in a source file.
A post processor that will call a collection of post processors.
Deprecated.
This class could be removed in a future version.
Deprecated.
This class could be removed in a future version.
Deprecated.
This class is no longer acceptable to use because it is not sufficiently configurable and it is too tied to a specific implementation.
A primitive type.
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.
Printer interface defines the API for a printer.
This interface defines the API for printer configuration.
A problem that was encountered during parsing.
A simple interface where validators can report found problems.
The structure of a Java project directory.
This AstObserver attach itself to all new nodes added to the nodes already observed.
The change in value of a property.
Meta-data about a property of a node in the AST.
Factory for providers of source code for JavaParser.
A range of characters in a source file, from "begin" to "end", including the characters at "begin" and "end".
Helper class for
GeneratedJavaParserThe receiver parameter feature of Java.
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.
Validates that "record" cannot be used as identifier for type declarations (e.g., classes, enums, and records).
The record declaration
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.
Base class for reference types.
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.
WARNING: Implemented fairly blindly.
Uses reflection to resolve types.
This class represents a group of
Removed elements.Validates that identifiers are not keywords - this for the few keywords that the parser
accepts because they were added after Java 1.0.
Elements in a CsmMix have been reshuffled.
Array Type.
Declaration of a Class (not an interface or an enum).
A declaration of a constructor.
A generic declaration.
Declaration of an Enum.
Declaration of a field.
An interface declaration.
An intersection type is defined in java as list of types separates by ampersands.
A declaration of a method (either in an interface, a class, an enum or an annotation).
This is a common interface for MethodDeclaration and ConstructorDeclaration.
Declaration of a parameter.
Declaration of a pattern expression.
A ReferenceType like a class, an interface or an enum.
A resolved type.
A declaration of a type.
Declaration of a type parameter.
A Bound on a Type Parameter.
A map of values associated to TypeParameters.
An entity which has type parameter.
Something which can have values for TypeParameters.
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).
A union type is defined in java as list of types separates by pipes.
Declaration of a value.
The special type void.
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.
The return statement, with an optional expression to return.
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.
RuntimeException subclass encapsulationg XMLStreamException.
S = T, where at least one of S or T is an inference variable: S is the same as T.
Builds a string containing a list of items with a prefix, a postfix, and a separator.
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
A name that consists of a single identifier.
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.
Runs a validator on all nodes of a certain type,
and adds a problem for all nodes that pass a condition.
An annotation that has a single value.
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.
Runs a validator on all nodes of a certain type.
Resolves resolvable nodes from one or more source files, and reports the results.
A support class for code that outputs formatted source code.
A collection of Java source files located in one directory and its subdirectories on the file system.
Executes a recursive file tree walk using threads.
A collection of Java source files and its sub-directories located in a ZIP or JAR file on the file system.
An interface to define a callback for each file that's parsed.
A base class for all statements.
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.
A simpler, static API than
JavaParser.NOTE : This generated class can be safely deleted if installing in a GWT installation (use StringProvider instead)
Something that has a printable form.
Adapted from apache commons-lang3 project.
Adapted from apache commons-lang3 project.
Adapted from apache commons-lang3 project.
Adapted from apache commons-lang3 project.
Adapted from apache commons-lang3 project.
Adapted from apache commons-lang3 project.
A literal string.
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.
S <: T, where at least one of S or T is an inference variable: S is a subtype of T
An occurrence of the "super" keyword.
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.
One case in a switch statement
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.
The switch expression
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.
The common interface of
SwitchExpr and SwitchStmtThe switch statement
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.
A reference to a symbol.
Allows for an implementing declaration type to support solving for field (symbol) usage.
CollectionStrategy which collects all SourceRoots and initialises the TypeSolver and
returns the SourceRoots configured with the TypeSolver in a ProjectRoot object.Usage of the synchronized keyword.
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.
A text block
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.
An occurrence of the "this" keyword.
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.
The inference variable α appears in a throws clause.
Usage of the throw statement.
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.
Describes the input token stream.
Base class for the generated
TokenToken Manager Error.
The range of tokens covered by this node.
Complements GeneratedJavaParserConstants
Iterate over all the nodes in (a part of) the AST.
A validator that walks the whole tree, visiting every node.
The try statement
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.
Base class for types.
A type S is compatible in a loose invocation context with type T
A type argument S is contained by a type argument T
A base class for all types of type declarations.
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.
A validator that validates a known node type.
This class is just instantiated as scopes for MethodReferenceExpr nodes to encapsulate Types.
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.
The term "type" is used loosely in this chapter to include type-like syntax that contains inference variables.
The API exposed by the TypeInference subsystem.
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.
A type parameter.
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.
A type S is the same as a type T (§4.3.4), or a type argument S is the same as type argument T
An element able to find TypeDeclaration from their name.
TypeSolverBuilder was created with the objective of simplifying
the process of creating new type solved.
A reference type S is a subtype of a reference type T
An expression where an operator is applied to a single expression.
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.
Provider un-escaping unicode escape sequences in the input sequence.Processor keeping track of the current line and column in a stream of
incoming characters.
An algorithm mapping
Position form two corresponding files.The union type
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.
An unknown parameter type object.
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.
A statement that had parse errors.
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.
This exception is thrown when a symbol cannot be resolved.
Suggestion to upgrade the Java language level.
Any kind of utility.
A validator that can be run on a node to check for semantic errors.
A validator that will call a collection of validators.
Any type of value.
A declaration of variables.
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.
The declaration of a variable.
In
In
int x = 14, y = 3; "int x = 14" and "int y = 3" are
VariableDeclarators.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.
A type called "var" waiting for Java to infer it.
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.
A list that overrides the equals and hashcode calculation of the added nodes
by using another equals and hashcode visitor for those methods.
A map that overrides the equals and hashcode calculation of the added nodes
by using another equals and hashcode visitor for those methods.
A set that overrides the equals and hashcode calculation of the added nodes
by using another equals and hashcode visitor for those methods.
A validator that uses a visitor for validation.
The return type of a
MethodDeclaration
when it returns void.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.
A visitor that does not return anything.
A visitor that returns nothing, and has a default implementation for all its visit
methods that simply visit their children in an unspecified order.
A visitor that returns nothing, and has default methods that are used when a specific visit method is not
overridden.
A while statement.
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.
A wildcard type argument.
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.
Outputs an XML file containing the AST meant for inspecting it.
Outputs a YAML file containing the AST meant for inspecting it.
The yield statement
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.