All Classes
Class
Description
Will let the symbol solver look inside an Android aar file while solving types.
A common ancestor for all ClassDeclarations.
AbstractMethodLikeDeclarationContext<T extends Node & NodeWithParameters<T> & NodeWithTypeParameters<T>>
Common ancestor for most types.
A symbol resolution context for an object creation node.
Required to prevent recursive access to the "parent node" (not necessarily the same as the "parent context").
Bounds are defined for Inference Variables.
A contract that defines a semi-persistent mapping of keys and values.
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).
This TypeSolver wraps a ClassLoader.
Limited version of ClassOrInterfaceDeclarationContext that only resolves type parameters for use by
extends and implements part of declaration.
A container for type solvers.
Provides some convenience exception handler implementations
Constraint formulas are assertions of compatibility or subtyping that may involve inference variables.
Context is very similar to scope.
Consider Control Flow to determine which statements are reachable.
This represents the default constructor added by the compiler for objects not declaring one.
An expression is compatible in a loose invocation context with type T
No valid choice of inference variables exists.
This class is used to wrap a Guava
Cache.Are meta-variables for types - that is, they are special names that allow abstract reasoning about types.
An element using during type inference.
A cache implementation that stores the information in memory.
Will let the symbol solver look inside a jar file while solving types.
An anonymous class declaration representation.
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: 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.
Placeholder used to represent a lambda argument type while it is being
calculated.
The checked exceptions thrown by the body of the LambdaExpression are declared by the throws clause of the
function type derived from T.
A TypeSolver which only consider the TypeDeclarations provided to it.
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.
Context causes a name syntactically to fall into one of seven categories: ModuleName, PackageName, TypeName,
ExpressionName, MethodName, PackageOrTypeName, or AmbiguousName.
NameLogic contains a set of static methods to implement the abstraction of a "Name" as defined
in Chapter 6 of the JLS.
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.
This is a virtual type used to represent null values.
WARNING: Implemented fairly blindly.
Uses reflection to resolve types.
S = T, where at least one of S or T is an inference variable: S is the same as T.
Resolves resolvable nodes from one or more source files, and reports the results.
S <: T, where at least one of S or T is an inference variable: S is a subtype of T
A reference to a symbol.
CollectionStrategy which collects all SourceRoots and initialises the TypeSolver and
returns the SourceRoots configured with the TypeSolver in a ProjectRoot object.The inference variable α appears in a throws clause.
A type S is compatible in a loose invocation context with type T
A type argument S is contained by a type argument T
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.
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.
A reference type S is a subtype of a reference type T
Any type of value.