# All Classes and Interfaces

Class
Description
AbstractASTTransformation
Abstract base class for AST transformations.
AbstractButtonProperties
Supplies synthetic binding definitions for `AbstractButton`.
AbstractCallSite
Base class for all classic (non-`invokedynamic`) call sites.
AbstractComparator<T>
Base class for Groovy comparators.
AbstractExtensionMethodCache
Per-`ClassLoader` cache of extension methods (DGM and friends, or another mapper such as macro methods).
AbstractFactory
Base `Factory` implementation with default no-op lifecycle hooks.
AbstractFullBinding
Base implementation for `FullBinding` that handles validation and value conversion.
AbstractFunctionalInterfaceWriter
Shared bytecode and deserialization support for statically-compiled functional interface implementations, including both lambdas and method references.
AbstractFunctionalInterfaceWriter.SerializedLambdaFingerprint
Compile-time identity of one serialized functional-interface target used by `$deserializeLambda$` dispatch.
AbstractGinqExpression
Represents GINQ expression which could hold metadata
AbstractHttpServlet
A base class dealing with common HTTP servlet API housekeeping aspects.
AbstractInterruptibleASTTransformation
Base class for AST Transformations which will automatically throw an `InterruptedException` when some conditions are met.
AbstractLexer
Because antlr4 does not support generating lexer with specified interface, we have to create a super class for it and implement the interface.
AbstractParser
Because antlr4 does not support generating parser with specified interface, we have to create a super class for it and implement the interface.
AbstractReaderSource
For ReaderSources that can choose a parent class, a base that provides common functionality.
AbstractSyntheticBinding
Base class for bindings that observe synthetic Swing properties.
AbstractTypeCheckingExtension
Custom type checking extensions may extend this method in order to benefit from a lot of support methods.
AbstractTypeCheckingExtension.TypeCheckingScope
Map-backed scope used to share data across extension callbacks.
ActiveMethod
Marks a method within an `ActiveObject` class for actor-backed execution.
ActiveObject
Marks a class as an active object whose `ActiveMethod`-annotated methods are automatically routed through an internal actor for thread-safe, serialized execution.
ActiveObjectASTTransformation
Handles the `ActiveObject` annotation, transforming `ActiveMethod`-annotated methods to route through an internal actor for serialized execution.
Actor<T>
A lightweight message-passing actor for concurrent state management.
ActorContext<T>
Context handle passed to context-aware actor handlers.
ActorOptions
Construction-time configuration for an `Actor`.
ActorOptions.Overflow
Policy applied when `Actor.send(Object)` is called on an actor whose bounded mailbox is full.
ActorOptions.StashOverflow
Policy applied when `ActorContext.stash()` is called and the actor's bounded stash is already at capacity.
AdaptingMetaClass
An interface for MetaClass instances that "adapt" other MetaClass instances such as a proxy or delegating MetaClass.
Agent<T>
A thread-safe mutable-value container inspired by Clojure's agents and GPars' `Agent`.
AggregateBinding
An aggregation of multiple bindings
AllControlToUndefined
Replaces XML-disallowed control characters and Unicode noncharacters with `U+FFFD`.
AllTestSuite
AllTestSuite can be used in extension of GroovyTestSuite to execute TestCases written in Groovy from inside a Java IDE.
AndroidSupport
AnnotatedNode
Base class for any AST node which is capable of being annotated
AnnotatedNodeUtils
Utility class for working with AnnotatedNodes
AnnotationClosureVisitor
Visits interfaces & classes and looks for `@Requires` or `@Ensures` and creates `Closure` classes for the annotation closures.
AnnotationCollector
The AnnotationCollector can be used to define aliases for annotations and attributes.
AnnotationCollectorMode
Conflict resolution modes for `AnnotationCollector`.
AnnotationCollectorTransform
This class is the base for any annotation alias processor.
AnnotationCollectorTransform.ClassChanger
Class used by `CompilationUnit` to transform the alias class into what is needed by the compiler.
AnnotationConstantExpression
Represents an annotation "constant" that may appear in annotation attributes (mainly used as a marker).
AnnotationConstantsVisitor
Resolves constants in annotation definitions.
AnnotationContractParameterVisitor
This `BaseVisitor` walks up the class hierarchy for the given `ClassNode` and adds `ContractElement` annotations to method parameters.
AnnotationNode
Represents an annotation which can be attached to interfaces, classes, methods, fields, parameters, and other places.
AnnotationProcessor
Base class for modifying the internal domain model, starting at `Contract`, and adding parts to it.
AnnotationProcessorImplementation
Indicates what `AnnotationProcessor` implementation should be used to process the correlating annotation.
AnnotationProcessorVisitor
Visits annotations of meta-type `ContractElement` and applies the AST transformations of the underlying `AnnotationProcessor` implementation.
AnnotationUtils
Helper methods for reading/getting `AnnotationNode` instances.
AnnotationVisitor
An Annotation visitor responsible for: reading annotation metadata (@Retention, @Target, attribute types) verify that an `AnnotationNode` conforms to annotation meta enhancing an `AnnotationNode` AST to reflect real annotation meta
AntBuilder
Allows Ant tasks to be used with a Groovy builder-style markup.
Antlr4ParserPlugin
A parser plugin for the new parser.
Antlr4PluginFactory
A parser plugin factory for the new parser.
AntProjectPropertiesDelegate
Live `Hashtable`-style view over an Ant project's immutable properties.
AotDispatch
Ahead-of-time link mode for indy dispatch (incubating).
ArgumentListExpression
Represents one or more arguments being passed into a method
ArrayCachedClass
Provides optimized reflection caching for Java arrays.
ArrayClassDocWrapper
A `GroovyClassDoc` decorator that wraps a component-type class doc for array-type representations.
ArrayExpression
Represents an array literal or array construction expression.
ArrayGetAtMetaMethod
ArrayGroovyMethods
Defines new groovy methods which appear on arrays inside the Groovy environment.
ArrayIterable<T>
Allows an array to be used where an Iterable is expected.
ArrayIterator<T>
Allows an array to be used where an Iterator is expected.
ArrayMetaMethod
ArrayPutAtMetaMethod
Arrays
Array utilities.
ArrayTypeUtils
Utilities for handling array types
ArrayUtil
This is a generated class used internally during the writing of bytecode within the CallSiteWriter logic.
ArrayUtils
Array helpers used by the JSON internals.
AsmClassGenerator
Generates Java class versions of Groovy classes using ASM.
AsmDecompiler
Utility class responsible for decompiling JVM class files into `ClassStub` objects that reflect their bytecode structure.
AsmReferenceResolver
Helper class for resolving class references encountered in bytecode stubs decompiled from compiled classes.
Assertion<T extends Assertion>
Base class for all assertion types.
AssertionMap<T extends Assertion<T>>
Maps methods to their accumulated contract assertions.
AssertionRenderer
Creates a string representation of an assertion and its recorded values.
AssertionViolation
Abstract base class for all assertion violations.
AssertionWriter
Emits bytecode for Groovy `assert` statements.
AssertStatement
Represents an assert statement that enforces a condition with an optional error message.
AssertStatementCreationUtility
Central place to create `AssertStatement` instances in groovy-contracts.
AssertStatementCreationUtility.AddAssertionCallStatementToReturnStatementVisitor
Replaces a given `ReturnStatement` with the appropriate assertion call statement and returns a result variable expression.
AssertStatementCreationUtility.AddResultReturnStatementVisitor
Replaces a given `ReturnStatement` with the appropriate assertion call statement and returns a result variable expression.
AssertStatementCreationUtility.ReturnStatementVisitor
Collects all `ReturnStatement` instances from a given code block.
Associative
Declares that a two-argument combining method is associative: `combine(a, combine(b, c))` produces the same result as `combine(combine(a, b), c)` for all inputs.
AstBuilder
Builds the AST from the parse tree generated by Antlr4.
AstBuilderTransformation
Transformation to capture ASTBuilder from code statements.
AstContext
The enclosing context of a candidate node during an `AstQuery` traversal.
AstHelper
Helping to create a few standard AST constructs
ASTHelper
Common base class providing shared AST helper methods used by both the classic and new parsers.
ASTNode
Base class for any AST node.
ASTNodeMetaData
Holds all constants to be used as AST node metadata keys.
ASTNodePredicate
Predicate used to test AST nodes.
AstQuery<T extends ASTNode>
A small, read-only, fluent query API over a Groovy AST subtree.
AstStringCompiler
This class handles converting Strings to ASTNode lists.
ASTTest
This AST transformation aims at helping in debugging other AST transformations.
AstToTextHelper
Helper class for converting AST into text.
ASTTransformation
This class is instantiated and invoked when an AST transformation is activated.
ASTTransformationCollectorCodeVisitor
Walks the AST and collects references to annotations that are annotated themselves by `GroovyASTTransformation`.
ASTTransformationsContext
Stores state information about global AST transformations applied to a compilation unit.
ASTTransformationVisitor
This class handles the invocation of the ASTAnnotationTransformation when it is encountered by a tree walk.
AsyncChannel<T>
An asynchronous channel for inter-task communication with optional buffering.
AsyncClosureUtils
Closure-specific async utilities that have no pure-Java equivalent.
AsyncScope
A structured concurrency scope that ensures all child tasks complete (or are cancelled) before the scope exits.
AsyncSupport
Internal runtime support for the `async`/`await`/`defer` language features.
AsyncTransformHelper
Shared AST utilities for the `async`/`await`/`defer` language features.
AtnManager
Manage ATN to avoid memory leak.
Attribute
Lazy evaluated representation of a node attribute.
AttributeExpression
Represents an attribute access (accessing the field of a class) such as the expression "foo.@bar".
Attributes
Lazy evaluated representation of a node's attributes.
AutoClone
Class annotation used to assist in the creation of `Cloneable` classes.
AutoCloneASTStubber
Joint-compilation stubber for `AutoClone`.
AutoCloneASTTransformation
Handles generation of code for the @AutoClone annotation.
AutoCloneStyle
Intended style to use for cloning when using the `@`AutoClone annotation.
AutoFinal
Annotation to automatically add the final qualifier to method, constructor, and closure parameters.
AutoFinalASTTransformation
Handles generation of code for the `AutoFinal` annotation.
AutoImplement
Class annotation used to provide default dummy methods for a class extending an abstract super class or implementing one or more interfaces.
AutoImplementASTStubber
Joint-compilation stubber for `AutoImplement`.
AutoImplementASTTransformation
Generates code for the `@AutoImplement` annotation.
Awaitable<T>
Core abstraction for asynchronous computations in Groovy.
AwaitableAdapter
Service Provider Interface (SPI) for adapting third-party asynchronous types to Groovy's `Awaitable` abstraction and to iterables for `for await` loops.
AwaitableAdapterRegistry
Central registry for `AwaitableAdapter` instances.
AwaitResult<T>
Represents the outcome of an asynchronous computation that may have succeeded or failed.
BalancedGroup
A node in the tree of balanced groups extracted by `BalancedGroup.find(java.lang.CharSequence, java.lang.String, java.lang.String)`, also exposed on `CharSequence` via `StringGroovyMethods.findBalancedGroups(CharSequence, String, String)`.
BalancedGroup.MatchOptions
Options controlling balanced-group matching.
BaseASTTransformation
Base AST transformation encapsulating all common helper methods and implementing `ASTTransformation`.
BaseDuration
Deprecated.
Superseded by the quirk-free DSLs: `org.apache.groovy.dateutil.TimeCategory` (and its `java.util.Date`-based duration classes) or `org.apache.groovy.datetime.TimeCategory` (producing `java.time` types).
BaseDuration
Base class for date and time durations (dequirked, `java.util.Date`-flavored).
BaseDuration.From
Helper for computing dates relative to the current time.
BaseDuration.From
Helper for computing dates relative to the current time.
BaseGenerator
Base class for groovy-contracts code generators.
BaseJsonParser
Base JSON parser.
BaseLifecycle
Base implementation class for interface `Lifecycle`.
BaseMarkupBuilder
Runtime support for `StreamingMarkupBuilder` closures bound to namespace-aware tag handlers.
BaseScript
Variable annotation used for changing the base script class of the current script.
BaseScriptASTTransformation
Handles transformation for the @BaseScript annotation.
BaseTemplate
All templates compiled through `MarkupTemplateEngine` extend this abstract class, which provides a number of utility methods to generate markup.
BaseVisitor
Base class for `ClassCodeVisitorSupport` descendants.
BatchingPreparedStatementWrapper
Class which delegates to a PreparedStatement but keeps track of a batch count size.
BatchingStatementWrapper
Class which delegates to a Statement but keeps track of a batch count size.
BeanUtils
Utility methods for working with JavaBean-style property names.
BeanUtils
Utility methods for discovering and working with bean properties on `ClassNode` instances.
BenchmarkInterceptor
Interceptor that registers the timestamp of each method call before and after invocation.
BigDecimalCachedClass
Provides optimized reflection caching for `BigDecimal`.
BigDecimalMath
Arbitrary-precision decimal arithmetic operations.
BigIntegerCachedClass
Provides optimized reflection caching for `BigInteger`.
BigIntegerMath
Arbitrary-precision integer arithmetic operations.
BinaryBooleanExpressionHelper
Binary write operations specialised for Booleans
BinaryDoubleExpressionHelper
Binary expression helper specialized for `double` operations.
BinaryExpression
Represents a binary operation between two expressions, such as addition, subtraction, comparison, or array/map access.
BinaryExpressionHelper
Emits bytecode for dynamic binary expressions.
BinaryExpressionMultiTypeDispatcher
This class is for internal use only! This class will dispatch to the right type adapters according to the kind of binary expression that is provided.
BinaryExpressionTransformer
Rewrites binary expressions into forms that generate better static-compilation bytecode.
BinaryExpressionWriter
Base class for writing primitive typed operations
BinaryFloatExpressionHelper
Binary expression helper specialized for `float` operations.
BinaryIntExpressionHelper
Emits optimized bytecode for integer binary operations.
BinaryLongExpressionHelper
Binary expression helper specialized for `long` operations.
BinaryObjectExpressionHelper
Binary expression helper used for object operations that fall back to dynamic dispatch.
Bindable
Annotates a groovy property or a class.
BindableASTStubber
Joint-compilation stubber for `Bindable` (class-level use).
BindableASTTransformation
Handles generation of code for the `@Bindable` annotation when `@Vetoable` is not present.
Binding
Represents the variable bindings of a script which can be altered from outside the script object or created outside of a script and passed into it.
BindingProxy
This class returns half bound `FullBinding`s on the source half to the model object for every property reference (and I do mean every, valid or not, queried before or not).
BindingUpdatable
BindPath
The bind path object.
BitwiseNegationExpression
BlockStatement
Represents a compound statement consisting of an ordered sequence of `Statement`s within a specific `VariableScope`.
Body
Marks a method parameter as the HTTP request body.
BodyText
Marks a method parameter as a plain text request body.
BooleanArrayGetAtMetaMethod
BooleanArrayIterator
Allows a boolean array to be used where an Iterator is expected.
BooleanArrayPutAtMetaMethod
BooleanCachedClass
Provides optimized reflection caching for `boolean` and `Boolean`.
BooleanClosureForMapPredicate<K,V>
Adapts a `Closure` to a `Predicate` over `Map.Entry` values.
BooleanClosureForMapPredicate<K,V>
Deprecated, for removal: This API element is subject to removal in a future version.
Use `BooleanClosureForMapPredicate` instead.
BooleanClosurePredicate<T>
Adapts a `Closure` to a `Predicate`, converting the closure's return value to a boolean using Groovy truth semantics.
BooleanClosurePredicate<T>
Deprecated, for removal: This API element is subject to removal in a future version.
Use `BooleanClosurePredicate` instead.
BooleanClosureWrapper
Helper class for internal use only.
BooleanClosureWrapper
Deprecated, for removal: This API element is subject to removal in a future version.
Use `BooleanClosureWrapper` instead.
BooleanExpression
Represents a boolean expression
BooleanReturningMethodInvoker
Deprecated, for removal: This API element is subject to removal in a future version.
BooleanWrapper
Wrapper for `boolean` values that preserves the primitive constrained type.
BreakStatement
Represents a break statement that terminates execution of a loop or switch statement.
BroadcastChannel<T>
A one-to-many broadcast channel where each value sent is delivered to all subscribers.
BufferedIterator<T>
An iterator that allows examining the next element without consuming it.
Buildable
Defines a type that can render itself into a builder.
Builder
The `@Builder` AST transformation is used to help write classes that can be created using fluent api calls. The transform supports multiple building strategies to cover a range of cases and there are a number of configuration options to customize the building process.
Builder
Base support for streaming markup builders that dispatch tags through namespace-specific closures.
Builder.Built
Base class for bound markup documents produced by `Builder.bind(Closure)`.
BuilderASTStubber
Joint-compilation stubber for `Builder`, covering the two most common shapes: `DefaultStrategy` on a class-level annotation: emits the inner builder class with fluent setters and a `build()` method, plus a static `Foo.builder()` factory on the buildee. `SimpleStrategy` with a non-default `prefix`: emits chained `Foo prefixName(T value)` setters on the buildee itself.
BuilderASTTransformation
Handles generation of code for the `Builder` annotation.
BuilderASTTransformation.AbstractBuilderStrategy
Base class for builder generation strategies.
BuilderASTTransformation.AbstractBuilderStrategy.PropertyInfo
Holds information about a builder property.
BuilderASTTransformation.BuilderStrategy
Strategy interface for builder code generation.
BuilderSupport
Base class for creating arbitrary nested trees of objects or events.
ByteArrayGetAtMetaMethod
ByteArrayIterator
Allows a byte array to be used where an Iterator is expected.
ByteArrayPutAtMetaMethod
ByteCachedClass
Provides optimized reflection caching for `byte` and `Byte`.
BytecodeDumper
A utility class which can be used in test cases to dump generated bytecode.
BytecodeExpression
Represents some custom bytecode generation by the compiler.
BytecodeHelper
A helper class for bytecode generation with AsmClassGenerator.
BytecodeInstruction
Helper class used by the class generator.
BytecodeInterface8
This class contains methods special to optimizations used directly from bytecode in Groovy 1.8
BytecodeProcessor
Post-processes generated class bytes before they are written out.
BytecodeSequence
This class represents a sequence of `BytecodeInstruction`s or `ASTNode`s.
BytecodeVariable
Represents compile time variable metadata while compiling a method.
ByteScanner
Utilities for rendering bytes as hexadecimal ASCII characters.
ByteWrapper
Wrapper for `byte` values that preserves the primitive constrained type.
Cache<KEY,VALUE>
Cache
CacheableCallSite
Represents a cacheable call site, which can reduce the cost of resolving methods
CacheAccessControlException
Exception thrown when access control restrictions prevent reflection operations on cached classes.
CachedClass
Caches reflection information for a class including its fields, methods, constructors, and interfaces.
CachedClass.CachedMethodComparatorByName
Comparator for ordering cached methods by name.
CachedClass.CachedMethodComparatorWithString
Comparator for ordering cached methods against string names.
CachedClosureClass
Provides optimized reflection caching for Groovy `Closure` classes.
CachedConstructor
Caches reflection information about a single constructor for fast lookup and invocation.
CachedField
Caches reflection information about a single field for efficient access and modification.
CachedMethod
Caches reflection information about a single method for fast lookup and invocation.
CachedMethodCallSites
Creates optimized call sites for `CachedMethod` instances.
CachedSAMClass
Provides optimized reflection caching for Single Abstract Method (SAM) types.
CacheType
Identifiers for cache eviction policies.
CallSite
Classic (non-`invokedynamic`) call site.
CallSiteArray
Array of classic (non-`invokedynamic`) call sites for a compiled class.
CallSiteClassLoader
Class loader used when generating specialized classic call-site classes.
CallSiteGenerator
Generates specialized call-site classes for the classic (non-indy) call-site cache.
CallSiteWriter
Bytecode writer for classic (non-`invokedynamic`) call sites.
Cancellable
A handle for a scheduled action that can be called off before it fires (or that can have its further firings suppressed, in the case of a recurring schedule).
CandidateChecks
Functions in this class are used to determine whether a certain AST node fulfills certain assertion requirements.
CaseStatement
Represents a case arm of a `SwitchStatement` or a `SwitchExpression`.
CastExpression
Represents a type cast expression in Groovy.
CastExpressionOptimizer
Simplifies casts and coercions that the static compiler can safely emit directly.
CatchStatement
Represents a catch (Exception var) { } statement that handles exceptions in a try-catch block.
Category
Transforms an instance-style Groovy class or interface to become a static-style conventional Groovy category.
CategoryASTTransformation
Handles generation of code for the @Category annotation.
ChannelClosedException
Thrown when an `AsyncChannel` operation is attempted after the channel has been closed.
ChannelSelect
Selects the first offer that can complete among multiple `AsyncChannel` operations.
ChannelSelect.Offer
One branch of a select: an input guard created by `ChannelSelect.receive(AsyncChannel)`, an output guard created by `ChannelSelect.send(AsyncChannel, Object)`, or a timeout created by `ChannelSelect.after(long)`.
ChannelSelect.Result
The result of a `ChannelSelect.select()` operation, indicating which offer committed.
CharacterArrayGetAtMetaMethod
CharacterArrayPutAtMetaMethod
CharacterCachedClass
Provides optimized reflection caching for `char` and `Character`.
CharacterSource
Character cursor abstraction used by the streaming JSON parsers.
CharArrayIterator
Allows a char array to be used where an Iterator is expected.
CharBuf
Growable character buffer used by the JSON internals.
CharScanner
Low-level character scanning utilities used while parsing JSON values.
CharSequenceReader
`Reader` implementation that can read from String, StringBuffer, StringBuilder, CharBuffer or GString.
CharSequenceValue
Overlay-backed `Value` that keeps a character slice until conversion is required.
CharsetToolkit
Utility class to guess the encoding of a given text file.
CharWrapper
Wrapper for `char` values that preserves the primitive constrained type.
Chr
Character array helpers used by the JSON internals.
CircularAssertionCallException
Thrown whenever pre- or post-conditions are called in a cyclic way.
ClassCodeExpressionTransformer
Transforms expressions in a whole class.
ClassCodeVisitorSupport
Abstract base class for visitors that process class nodes and their members, extending the default visitor traversal with class-specific and annotation processing.
ClassCompletionVerifier
Checks that a class satisfies various conditions including: Incorrect class or method access modifiers No abstract methods appear in a non-abstract class Existence and correct visibility for inherited members Invalid attempts to override final members
ClassExpression
Represents access to a Java or Groovy class object as an expression.
ClassFinder
Find classes under the specified package via some classpath entry Usage:
ClassFindFailedException
Represents error occurred during finding classes
ClassGenerator
Abstract base class for generator of Java class versions of Groovy AST classes
ClassGeneratorException
An exception thrown by the class generator
ClassHelper
Helper for `ClassNode` creation and type management.
ClassInfo
Handle for all information we want to keep about the class
ClassInfo.ClassInfoAction
Functional interface for performing actions on `ClassInfo` instances.
ClassInvariant
Indicates that annotations being marked as `@ClassInvariant` are to be treated as class invariant modifying annotations.
ClassInvariant
A class-invariant assertion.
ClassInvariantAnnotationProcessor
Internal `AnnotationProcessor` implementation for class-invariants.
ClassInvariantGenerator
Code generator for class invariants.
ClassInvariantLifecycle
Internal `Lifecycle` implementation for class-invariants.
ClassInvariantViolation
Thrown whenever a class invariant violation occurs.
ClassLoaderForClassArtifacts
A specialized `ClassLoader` used to define per-class artifact classes such as generated meta-method dispatchers.
ClassNode
Represents a class in the AST.
ClassNodeResolver
Pluggable lookup of class names to a `ClassNode` or a `SourceUnit`.
ClassNodeResolver.LookupResult
Helper class to return either a SourceUnit or ClassNode.
ClassNodeUtils
Utility class for working with ClassNodes
ClasspathResourceManager
Loads documentation resources from the classpath.
ClassStub
Data container holding bytecode-extracted class metadata for efficient decompilation.
ClassTag
Parameter annotation marking a `Class` parameter as compiler-supplied under static compilation.
ClassTree
GROOVY-11942: builds the inheritance/extension trees rendered by the `overview-tree.html` and `package-tree.html` templates.
ClassTree.Node
A node in an inheritance/extension tree.
Closure<V>
Represents any closure object in Groovy.
ClosureComparator<T>
A Comparator which uses a closure to compare 2 values being equal
ClosureException
An exception thrown by a closure invocation
ClosureExpression
Represents a closure expression such as `{ statement }` or `{ i -> statement }` or `{ i, x, String y -> statement }`.
ClosureExpressionEvaluationASTTransformation
Evaluates `ClosureExpression` instances in annotation parameters and generates special contract closure classes from them.
ClosureExpressionTransformer
Applies static-compilation-specific rewrites to closure expressions.
ClosureInvokingMethod
An interface for MetaMethods that invoke closures to implements.
ClosureListExpression
This class represents a list of expressions used to create closures.
ClosureMetaClass
A metaclass for closures generated by the Groovy compiler.
ClosureMetaMethod
A MetaMethod that accepts a closure in the constructor which is invoked when the MetaMethod is called.
ClosureModel
Represents a value model using a closure to extract the value from some source model and an optional write closure for updating the value.
ClosureParams
Parameter annotation aimed at helping IDEs or the static type checker to infer the parameter types of a closure.
ClosureRenderer
Shared Swing renderer that delegates rendering customization to a Groovy closure.
Closures
Helpers that return hybrid one-argument functions which are both `Closure` and the appropriate `java.util.function` SAM (`Predicate`, `Function` or `Consumer`).
Closures.ConsumerClosure<T>
Hybrid one-argument function that is both a `Closure` and a `Consumer`.
Closures.FunctionClosure<T,R>
Hybrid one-argument function that is both a `Closure` and a `Function`.
Closures.PredicateClosure<T>
Hybrid one-argument function that is both a `Closure` and a `Predicate`.
ClosureSignatureConflictResolver
If multiple candidate signatures are found after applying type hints, a conflict resolver can attempt to resolve the ambiguity.
ClosureSignatureHint
A closure signature hint class is always used in conjunction with the `ClosureParams` annotation.
ClosureSourceBinding
Uses a closure invocation to compute a source value for a binding.
ClosureStaticMetaMethod
This class represents a MetaMethod that is a closure that pretends to be a static method.
ClosureTriggerBinding
Creates bindings that track the property path referenced by a closure expression.
ClosureUtils
Handy methods when working with Closure AST data structures.
ClosureWriter
Generates bytecode for closure expressions.
ClosureWriter.CorrectAccessedVariableVisitor
Visitor that rewrites `VariableExpression` nodes whose accessed variable is a `FieldNode` in an outer class to instead reference the corresponding field in the generated closure inner class.
ClosureWriter.UseExistingReference
Marker interface for using existing reference.
CodeVisitorSupport
Abstract base class for implementing the `GroovyCodeVisitor` interface, providing default implementations for all visit methods that perform depth-first traversal of the AST.
CollectRecursiveCalls
Collect all recursive calls within method
CommonCache<K,V>
Represents a simple key-value cache, which is NOT thread safe and backed by a `Map` instance
Commons
This local transform adds a logging ability to your program using Apache Commons logging.
Commons.CommonsLoggingStrategy
Logging strategy for Apache Commons Logging.
CompareIdentityExpression
Compares two objects using identity comparison.
CompareToNullExpression
Specializes a comparison against `null` for static compilation.
CompilationCustomizer
Users wanting to customize the configuration process such as adding imports, restricting the language features or apply AST transformations by default should implement this class, then call the `CompilerConfiguration.addCompilationCustomizers(CompilationCustomizer...)` method.
CompilationFailedException
Thrown when compilation fails from source errors.
CompilationUnit
The CompilationUnit collects all compilation data as it is generated by the compiler system.
CompilationUnit.ClassgenCallback
A callback interface you can use during the `classgen` phase of compilation as the compiler traverses the ClassNode tree.
CompilationUnit.GroovyClassOperation
Deprecated.
CompilationUnit.IGroovyClassOperation
Performs an operation for each generated `GroovyClass`.
CompilationUnit.IPrimaryClassNodeOperation
Performs an operation for each primary class node in the compilation.
CompilationUnit.ISourceUnitOperation
Performs an operation for each source unit in the compilation.
CompilationUnit.PrimaryClassNodeOperation
Deprecated.
CompilationUnit.ProgressCallback
A callback interface you can use to get a callback after every unit of the compile process.
CompilationUnit.SourceUnitOperation
Deprecated.
CompilationUnitAware
This interface is for AST transformations which must be aware of the compilation unit where they are applied.
CompileDynamicProcessor
CompilePhase
The phases of the GroovyCompiler.
Compiler
A convenience front end for getting standard compilations done.
CompilerConfiguration
Compilation control flags and coordination stuff.
CompileStack
Manages different aspects of the code of a code block like handling labels, defining variables, and scopes.
CompileStack.BlockRecorder
Records a block for finally or other special handling.
CompileStack.LabelRange
Represents a label range for exception handling or other scoping.
CompileStack.SwitchExpressionContext
Join-point information for a switch expression being compiled (GROOVY-12255).
CompileStatic
This will let the Groovy compiler use compile time checks in the style of Java then perform static compilation, thus bypassing the Groovy meta object protocol.
CompileTaskSupport
Support for compilation related tasks.
CompileUnit
Represents a complete compilation step involving one or more `ModuleNode` instances.
ComposedClosure<V>
A wrapper for Closure to support composition.
Comprehensions
Runtime bind/map dispatcher for monadic comprehensions — the emit target of the `DO` macro.
ConcurrentCommonCache<K,V>
Represents a simple key-value cache, which is thread safe and backed by a `Map` instance
ConcurrentConfig
Central configuration for Groovy's concurrent and parallel features.
ConcurrentLinkedHashMap<K,V>
A hash table supporting full concurrency of retrievals, adjustable expected concurrency for updates, and a maximum capacity to bound the map by.
ConcurrentLinkedHashMap.Builder<K,V>
A builder that creates `ConcurrentLinkedHashMap` instances.
ConcurrentReaderHashMap
A hash table that supports mostly-concurrent reading, but exclusive writing.
ConcurrentReaderHashMap.BarrierLock
A Serializable class for barrier lock
ConcurrentReaderHashMap.Entry
ConcurrentReaderHashMap collision list entry.
ConcurrentReferenceHashMap<K,V>
An advanced hash table supporting configurable garbage collection semantics of keys and values, optional referential-equality, full concurrency of retrievals, and adjustable expected concurrency for updates.
ConcurrentReferenceHashMap.InitializableEntry<K,V>
Reusable entry implementation for cached entry iteration.
ConcurrentReferenceHashMap.Option
Behavior-changing configuration options for the map
ConcurrentReferenceHashMap.ReferenceType
An option specifying which Java reference type should be used to refer to a key and/or value.
ConcurrentReferenceHashMap.SimpleEntry<K,V>
Simple mutable entry implementation used by the map views.
ConcurrentSoftCache<K,V>
Represents concurrent cache holding SoftReference instance as value
ConfigObject
A ConfigObject at a simple level is a Map that creates configuration entries (other ConfigObjects) when referencing them.
ConfigurationException
Thrown when configuration data is invalid.
ConfigurationSetup
Makes some initialization in order to use the `Configurator` for determining which assertions in what packages will be executed.
Configurator
Handles `-ea` and `-da` runtime input arguments for enabling and disabling contract elements.
ConsoleSupport
Base support class for consoles that evaluate Groovy scripts and render styled output.
ConsoleTextEditor
Component which provides a styled editor for the console.
ConstantExpression
Represents a constant value expression such as literals (null, true, false, numbers, strings), class literals, and other compile-time constant values.
ConstructorCallExpression
Represents a constructor call expression.
ConstructorCallTransformer
Rewrites constructor calls that have a more direct static-compilation form.
ConstructorMetaClassSite
ConstructorMetaMethodSite
Call site for invoking static methods metaclass - cached method - not cached
ConstructorNode
Represents a constructor declaration
ConstructorNodeUtils
Utility class for working with ConstructorNodes
ConstructorSite
ConstructorSite.ConstructorSiteNoUnwrap
Call site where we know there is no need to unwrap arguments
ConstructorSite.ConstructorSiteNoUnwrapNoCoerce
Call site where we know there is no need neither unwrap nor coerce arguments
ConstructorSite.NoParamSite
ConstructorSite.NoParamSiteInnerClass
ContextualClassCodeVisitor
A class code visitor which is capable of remembering the context of the current visit.
ContinueStatement
Represents a continue statement that skips the remainder of the current loop iteration.
Contract
Represents a contract between a supplier and a customer of a class.
ContractClosureWriter
Replaces annotation closures with closure implementation classes.
Contracted
Package-level and class-level annotation indicating that the package is enabled for class-invariants, pre- and post-conditions.
ContractElement
Indicates that annotations being marked as `@ContractElement` are to be used by some contract element being either a class-invariant, pre- or post-condition.
ContractElementVisitor
Checks whether the given `ClassNode` is relevant for further processing.
ContractExecutionTracker
Keeps track of contract executions to avoid cyclic contract checks.
ContractExecutionTracker.ContractExecution
Identifies one contract execution so recursive re-entry can be suppressed.
ConversionHandler
This class is a general adapter to map a call to a Java interface to a given delegate.
ConvertedClosure
This class is a general adapter to adapt a closure to any Java interface.
ConvertedMap
This class is a general adapter to adapt a map of closures to any Java interface.
CopyWithRecorder
Recording delegate for the transactional `copyWith { }` block.
CopyWithUtils
Shared AST-generation glue for nested-path `copyWith`, used by both the `@Immutable` and `@RecordType` transforms so the generated code (and its evolution) stays identical across the two.
CSTNode
Abstract base class for nodes in the concrete syntax tree (CST) produced by parsing.
CsvBuilder
Builds CSV output from collections of maps or typed objects.
CsvRuntimeException
Represents runtime exception occurred when parsing or building CSV
CsvSlurper
Represents a CSV parser.
CurriedClosure<V>
A wrapper for Closure to support currying.
CustomizersFactory
This factory generates an array of compilation customizers.
DataflowVariable<T>
A single-assignment variable for dataflow-style programming.
DataSet
An enhancement of Groovy's Sql class providing support for accessing and querying databases using POGO fields and operators rather than JDBC-level API calls and RDBMS column names.
DataSourceExpression
Represents data source expression
DataSourceHolder
Represents data source holder, e.g.
Dates
Date helpers used by the JSON parser for supported timestamp formats.
DateTimeExtensions
This class defines new Groovy methods which appear on normal JDK Date/Time API (java.time) classes inside the Groovy environment.
DateTimeStaticExtensions
This class defines new static extension methods which appear on normal JDK Date/Time API (java.time) classes inside the Groovy environment.
DateUtilExtensions
This class defines new groovy methods which appear on normal JDK Date and Calendar classes inside the Groovy environment.
DateUtilStaticExtensions
This class defines new groovy static methods which appear on normal JDK Date and Calendar classes inside the Groovy environment.
DatumDependentDuration
Deprecated.
Superseded by `org.apache.groovy.dateutil.DatumDependentDuration` (the dequirked `java.util.Date` flavor) or `java.time.Period`.
DatumDependentDuration
A duration that includes years and/or months, whose exact length depends on the datum.
DeclarationExpression
Represents one or more local variables.
DecompiledClassNode
Represents a `ClassNode` for classes loaded from compiled bytecode files decompiled using ASM.
Decreases
Specifies a termination measure, either for a loop or for a (recursive) method.
DefaultAction
An `Action` implementation that delegates execution to a Groovy closure.
DefaultActor<T>
Default implementation of `Actor`.
DefaultAsyncChannel<T>
Default lock-based implementation of `AsyncChannel`.
DefaultAsyncScope
Default implementation of `AsyncScope` providing structured concurrency with configurable failure policy.
DefaultCachedMethodKey
A default implementation of MethodKey
DefaultFastStringService
Internal class for fast processing of Strings during JSON parsing - default version
DefaultFastStringServiceFactory
Default factory for the standard `FastStringService` implementation.
DefaultGroovyMethods
Defines new groovy methods which appear on classes inside the Groovy environment.
DefaultGroovyMethodsSupport
Support methods for DefaultGroovyMethods and PluginDefaultMethods.
DefaultGroovyStaticMethods
This class defines all the new static groovy methods which appear on normal JDK classes inside the Groovy environment.
DefaultJsonGenerator
A JsonGenerator that can be configured with various `JsonGenerator.Options`.
DefaultJsonGenerator.ClosureConverter
A converter that handles converting a given type using a closure.
DefaultMetaClassInfo
WARNING: This class is for internal use only! We use this class to store information about if a default MetaClass is used for certain primitives.
DefaultMetaClassInfo.ConstantMetaClassVersioning
Represents a constant version of the metaclass configuration at a point in time.
DefaultMethodKey
A default implementation of MethodKey
DefaultPool
Default implementation of `Pool`.
DefaultPropertyAccessor
Default `PropertyAccessor` implementation backed by the standard Groovy property reader and writer.
DefaultPropertyHandler
Default implementation for validating and initializing transformed properties.
DefaultPropertyReader
Default `PropertyReader` implementation using Groovy property access.
DefaultPropertyWriter
Default `PropertyWriter` implementation using Groovy property access.
DefaultsMode
Intended mode to use when generating constructors to emulate default parameter values when using the `TupleConstructor` annotation.
DefaultStrategy
This strategy is used with the `Builder` AST transform to create a builder helper class for the fluent creation of instances of a specified class. It can be used at the class, static method or constructor levels.
DefaultTableColumn
A `TableColumn` backed by a `ValueModel` for reading and writing cell values.
DefaultTableModel
A table model built from row and column `ValueModel` instances.
DefaultTableModel.MyTableColumnModel
Column model implementation that keeps model indexes aligned with the current column order.
DefaultTypeCheckingExtension
The default type checking handler is used by the standard type checker and doesn't handle any of the type checking errors by default.
DefaultTypeTransformation
Class providing various type conversions, coercions and boxing/unboxing operations.
Delegate
Annotation to automatically delegate part of the functionality of an owner class to the annotated delegation target.
DelegateASTStubber
Joint-compilation stubber for `Delegate`.
DelegateASTTransformation
Handles generation of code for the `@Delegate` annotation
DelegatesTo
This annotation can be used by API or DSL writers to specify what the delegate type of a closure will be.
DelegatesTo.Target
Specifies the delegate for a `@DelegatesTo` annotated parameter of the same method.
DelegatingController
This class will delegate all calls to a WriterController given in the constructor.
DelegatingCustomizer
Base class for compilation customizers which delegate to another customizer.
DelegatingIndentWriter
A writer which delegates to another writer and supports an additional indenting level.
DelegatingMetaClass
`MetaClass` implementation that forwards all operations to another meta class.
DelegatingScript
`Script` that performs method invocations and property access like `Closure` does.
Delete
Marks an interface method as an HTTP DELETE request.
DependencyTracker
Tracks type dependencies referenced from a source unit and stores them in a `StringSetMap`.
DeprecationException
Use this exception to mark a method implementation as being deprecated.
DescriptiveErrorStrategy
Fail-fast parser error strategy with friendly diagnostics (default Parrot mode).
DgmConverter
Generates `GeneratedMetaMethod` adapter classes and metadata for the default Groovy methods.
Diagnostic
A format-neutral view of a `Message`: what it says and, when known, the source and position it applies to.
DirectInvoker
JIT-constant trampoline for a single `Method`.
DomainModelInjectionVisitor
Visits the given `ClassNode` and injects the current `Contract` into the given AST nodes.
DOMBuilder
A helper class for creating a W3C DOM tree
DOMCategory
Category class which adds GPath style operations to Java's DOM classes.
DomToGroovy
Turns a DOM document into the `MarkupBuilder` calls that would produce it, as an aid to writing builder code by hand.
DoubleArrayGetAtMetaMethod
DoubleArrayIterable
Allows a double array to be used where an Iterable is expected.
DoubleArrayIterator
Allows a double array to be used where an Iterator is expected.
DoubleArrayPutAtMetaMethod
DoubleCachedClass
Provides optimized reflection caching for `double` and `Double`.
DoubleComparator
A comparator of two double values.
DoubleDoubleArrayColumnIterator
An iterator providing the columns of a double[][].
DoubleQuoteFilter
Escapes double quotes for XML attribute output.
DoubleWrapper
Wrapper for `double` values that preserves the primitive constrained type.
DoWhileStatement
Represents a do { ...
DummyClassGenerator
To generate a class that has all the fields and methods, except that fields are not initialized and methods are empty.
Duration
Deprecated.
Superseded by `org.apache.groovy.dateutil.Duration` (the dequirked `java.util.Date` flavor) or `java.time.Duration`/`java.time.Period`.
Duration
A context-independent duration: days and below, whose length is known without a datum.
DynamicSetterInjectionVisitor
Implements contract support for setter methods and default constructors of POGOs.
DynamicVariable
ElvisOperatorExpression
Represents a short ternary expression x ?: y, which is equal to
EmptyExpression
Placeholder for an empty expression.
EmptyRange<T extends Comparable>
Constructing Ranges like 0..<0
EmptyStatement
Represents an empty statement that performs no operation.
EncodingAwareBufferedWriter
A buffered writer only for OutputStreamWriter that is aware of the encoding of the OutputStreamWriter.
EncodingGroovyMethods
This class defines all the encoding/decoding groovy methods which enhance the normal JDK classes when inside the Groovy environment.
EncodingGroovyMethodsSupport
Keep this constant in a separate file as it is troublesome for Antlr to parse for doc purposes.
Ensures
Represents a method postcondition.
EnsuresAnnotationProcessor
Internal `AnnotationProcessor` implementation for post-conditions.
EnsuresConditions
Container annotation for multiple `Ensures` postconditions on the same target.
EntryWeigher<K,V>
A class that can determine the weight of an entry.
EnumCompletionVisitor
Enums have a parent constructor with two arguments from java.lang.Enum.
EnumConstantClassNode
Represents the anonymous inner class for an enum constant.
EnumHelper
EnumTypeCheckingExtension
A type checking extension that will take care of handling errors which are specific to enums.
EnumVisitor
Transforms enum classes by adding required methods and fields according to Java enum semantics.
EqualsAndHashCode
Class annotation used to assist in creating appropriate `equals()` and `hashCode()` methods.
EqualsAndHashCodeASTStubber
Joint-compilation stubber for `EqualsAndHashCode`.
EqualsAndHashCodeASTTransformation
Handles generation of equals() and hashCode() methods via the `EqualsAndHashCode` annotation.
ErrorCollecting
An AST transform with the ability to report errors.
ErrorCollector
A base class for collecting messages and errors during processing.
ErrorFormat
How compilation errors and warnings are rendered (GROOVY-12312).
ErrorReporter
Provides services for reporting compilation errors to the user.
Eval
Allow easy integration from Groovy into Java through convenience methods.
EventTriggerBinding
Creates bindings that update whenever a named event handler property fires.
EvictableCache<K,V>
Represents an evictable memoize cache with its essential methods
EvictableCache.Action<K,V,R>
Represents the action to deal with the cache
EvictableCache.EvictionStrategy
Represents an eviction strategy for the cache with limited size
EvictionListener<K,V>
A listener registered for notification when an entry is evicted.
ExceptionMessage
A class for error messages produced by the parser system.
Exceptions
Internal exception helpers used by the JSON parser implementation.
Exceptions.JsonInternalException
Runtime exception used inside the JSON internals to simplify propagation.
ExpandedVariable
Identifies a variable to be expanded into the sql string rather than representing a placeholder.
Expando
Represents a dynamically expandable bean.
ExpandoMetaClass
ExpandoMetaClass is a MetaClass that behaves like an Expando, allowing the addition or replacement of methods, properties and constructors on the fly.
ExpandoMetaClassCreationHandle
A handle for the MetaClassRegistry that changes all classes loaded into the Grails VM to use ExpandoMetaClass instances
ExpectedToFail
Inverts the pass/fail outcome of the annotated test method (or every test method on the annotated class): a test that throws is reported as passing, and a test that completes normally is reported as failing.
ExpectedToFailContext
Delegate for closure predicates supplied to `ExpectedToFail`, exposing the thrown exception under three convenient names: `ex` (the `Throwable` itself), `message` (its message), and `cause` (its cause, possibly `null`).
ExpectedToFailExtension
JUnit 5 `InvocationInterceptor` backing the `ExpectedToFail` annotation.
Expression
Base class for all expression nodes in the Groovy AST.
ExpressionAsVariableSlot
Helper class that takes an Expression and if visited will load it normally, storing the result in a helper variable, which then can be requested after the visit is completed.
ExpressionStatement
Represents an expression statement that executes an expression where the return value is ignored.
ExpressionTransformer
Functional interface for transforming `Expression` nodes during AST traversal and manipulation.
ExpressionUtils
Utility methods for reasoning about Groovy AST expressions.
ExpressionUtils
Internal utility class for extracting a boolean expression from the given expression or statement.
ExtendedElementType
Groovy-specific element types that extend `ElementType` to cover Groovy language constructs not present in the JDK.
ExtendedTarget
Indicates Groovy-specific element types on which an annotation is allowed, complementing `Target` for constructs that have no corresponding `ElementType`.
ExtendedVerifier
A specialized Groovy AST visitor meant to perform additional verifications upon the current AST.
ExtensionMethodCache
This class is used to make extension methods lookup faster.
ExtensionMethodNode
Represents method nodes which are used by the static type checker to virtually add methods coming from `DGM-like` methods.
ExtensionModule
An extension module is a class responsible for providing a list of `meta methods` to the Groovy compiler and runtime.
ExtensionModuleRegistry
The extension method registry is responsible for collecting methods (or static methods) which are added to existing classes and may be called like regular methods.
ExtensionModuleScanner
A module extension scanner is responsible for searching classpath modules, loading metadata from module descriptors, then perform custom tasks for each module.
ExtensionModuleScanner.ExtensionModuleListener
Listener interface for extension module discovery events.
ExternalGroovyClassDoc
Represents a class not in the codebase being processed.
ExternalizeMethods
Class annotation used to assist in the creation of `Externalizable` classes.
ExternalizeMethodsASTStubber
Joint-compilation stubber for `ExternalizeMethods`.
ExternalizeMethodsASTTransformation
Handles generation of code for the @ExternalizeMethods annotation.
ExternalizeVerifier
Class annotation used to assist in the creation of `Externalizable` classes.
ExternalizeVerifierASTTransformation
ExternalStrategy
This strategy is used with the `Builder` AST transform to populate a builder helper class so that it can be used for the fluent creation of instances of a specified class. The specified class is not modified in any way and may be a Java class.
Factory
Defines lifecycle hooks used by `FactoryBuilderSupport` when creating nodes.
FactoryBuilderSupport
Mix of BuilderSupport and SwingBuilder's factory support.
FactorySupport
Support class for creating hardened JAXP factories.
FastArray
Resizable object array optimized for append-heavy internal use and lightweight list views.
FastStringService
Service for fast string-to-character conversion used by JSON parsing internals.
FastStringServiceFactory
Factory method to create the service.
FastStringUtils
Internal class for fast processing of Strings during JSON parsing
Field
Variable annotation used for changing the scope of a variable within a script from being within the run method of the script to being at the class level for the script.
FieldASTTransformation
Handles transformation for the @Field annotation.
FieldExpression
Represents a field access such as the expression "this.foo".
FieldNode
Represents a field (member variable)
FieldValues
This utility is meant to be used to replace direct calls to private field variables in class invariants.
FileIterator
`FileIterator` is an iterator over a number of files from a collection of FileSet instances.
FileOutputTool
Writes generated documentation and copied resources to the file system.
FileReaderSource
A ReaderSource for source files.
FileScanner
`FileScanner` is a bean which allows the iteration over a number of files from a collection of FileSet instances.
FileSystemCompiler
Command-line compiler (aka.
FileSystemCompiler.CompilationOptions
Command-line options accepted by the `groovyc` launcher.
FileSystemCompiler.VersionProvider
Supplies version text for the `groovyc` command line.
FileSystemCompilerFacade
This is a helper class, to provide a controlled entry point for the groovyc ant task forked mode.
FileSystemResourceManager
Loads documentation resources from the local file system.
FileType
Represents particular files of interest.
FileVisitResult
Represents special return values for the 'preDir', 'postDir' and 'visit'/supplied Closures used with `ResourceGroovyMethods.traverse(java.io.File, java.util.Map, groovy.lang.Closure)` and related methods to control subsequent traversal behavior.
FilteredAttributes
Lazy evaluated representation of a node's attributes filtered by a Closure.
FilteredNodeChildren
Lazy evaluated representation of child nodes filtered by a Closure.
FilterExpression
Represents filter expression
Final
Annotation to add the final modifier to classes, methods, constructors, and fields.
FinalASTStubber
Joint-compilation stubber for `Final`.
FinalASTTransformation
Handles generation of code for the `Final` annotation.
Finalizable
Callback for objects that need cleanup when an associated reference is processed.
FinalVariableAnalyzer
Analyzes variable assignments to determine if variables are effectively final, which is required for use in closures and lambda expressions.
FinalVariableAnalyzer.VariableNotFinalCallback
Callback interface notified when effectively final analysis detects a problem.
FindReplaceUtility
Shared find/replace dialog support for text components used by the console.
FirstParam
A hint used to instruct the type checker to pick the first parameter type.
FirstParam.Component
A hint used to instruct the type checker to pick the type of the component of the first parameter type, which is therefore expected to be an array, like in this example:
FirstParam.FirstGenericType
A hint used to instruct the type checker to pick the first generic type of the first parameter type.
FirstParam.SecondGenericType
A hint used to instruct the type checker to pick the second generic type of the first parameter type.
FirstParam.ThirdGenericType
A hint used to instruct the type checker to pick the third generic type of the first parameter type.
FlexibleCache<K,V>
An EvictableCache supporting a getAndPut variant with additional control over caching.
FloatArrayGetAtMetaMethod
FloatArrayIterable
Allows a primitive float array to be used where an Iterable is expected.
FloatArrayIterator
Allows a float array to be used where an Iterator is expected.
FloatArrayPutAtMetaMethod
FloatCachedClass
Provides optimized reflection caching for `float` and `Float`.
FloatComparator
A comparator of two float values.
FloatFloatArrayColumnIterator
An iterator providing the columns of a float[][].
FloatingPointMath
Binary floating-point arithmetic operations.
FloatUnaryOperator
Represents an operation that takes a `float`-valued operand and produces a `float`-valued result.
FloatWrapper
Wrapper for `float` values that preserves the primitive constrained type.
FlowPublisherAdapter
Adapter for `Flow.Publisher`, the JDK's built-in Reactive Streams type.
FlushingStreamWriter
Stream writer which flushes after each write operation.
ForkedJvm
Runs the annotated test method (or every test method on the annotated class) in a freshly forked JVM, optionally configured with extra system properties and JVM arguments.
ForkedJvmExtension
JUnit 5 `InvocationInterceptor` backing the `ForkedJvm` annotation.
ForkedJvmTestRunner
Child-JVM entry point for `ForkedJvm`-annotated tests.
Form
Marks a method as sending a form-encoded POST body.
FormatHelper
Formatting methods
FormModel
Represents a number of field models which can be ValueModel, PropertyModel, TableModel, TreeModel or nested FormModel instances
ForStatement
Represents a for loop in Groovy, supporting both for-in loops (with values and optional indices) and classic (C-style) for loops with initialization, condition, and update expressions.
FromAbstractTypeMethods
This signature hint uses abstract methods from some type (abstract class or interface) in order to infer the expected parameter types.
FromExpression
Represents the from expression
FromString
A closure parameter hint class that is convenient if you want to use a String representation of the signature.
FullBinding
Coordinates value propagation between a `SourceBinding` and a `TargetBinding`.
Function<T,R>
Backport of Java8 Function.
GContractsASTTransformation
Custom AST transformation that removes closure annotations of `Invariant`, `Requires` and `Ensures` and adds Java assertions executing the closure-code.
GeneralUtils
Handy methods when working with the Groovy AST.
GeneralUtils.ConditionValue
Represents the compile-time constant value of a boolean loop-condition or branch expression.
Generated
Marks class members that have been generated by the compiler.
GeneratedClosure
Marker interface to identify closures generated by the groovy compiler.
GeneratedDispatcher
A per-class table of compiler-generated dispatch targets, reached by a compact integer id instead of a `MethodHandle`.
GeneratedDispatcher.Arity1
Array-free companion for targets taking exactly one value beyond the receiver.
GeneratedDispatcher.Arity2
Array-free companion for targets taking exactly two values beyond the receiver.
GeneratedDispatcher.Bundle
The hosting class's three dispatch shapes, linked once by `GeneratedDispatcher.bootstrap(java.lang.invoke.MethodHandles.Lookup, java.lang.String, java.lang.invoke.MethodType)` and shared by all of that class's adapters.
GeneratedGroovyProxy
An interface implemented by some Groovy proxies which gives access to the proxied object.
GeneratedLambda
Marker interface to identify lambda generated by the groovy compiler.
GeneratedMetaMethod
GeneratedMetaMethod.DgmMethodRecord
GeneratedMetaMethod.Proxy
GenerateStubsTask
Generates Java stubs from Groovy sources.
GeneratorBridge<T>
A producer/consumer bridge for async generators (`yield return`).
GeneratorContext
A context shared across generations of a class and its inner classes.
GenericsType
Represents generic type information for parameterized types in Groovy/Java, including type variables, wildcard types, and type bounds.
GenericsType.GenericsTypeName
Represents the name of a `GenericsType` for use as a map key.
GenericsUtils
Utility methods for working with parameterized (generic) types in Groovy AST.
GenericsVisitor
Verify correct usage of generics.
Get
Marks an interface method as an HTTP GET request.
GetEffectivePogoFieldSite
GetEffectivePojoPropertySite
GinqAstBaseVisitor
The default base visitor for GINQ AST
GinqAstBuilder
Build the AST for GINQ
GinqASTTransformation
Handles generation of code for the `@GQ` annotation.
GinqAstVisitor<R>
Represents the visitor for AST of GINQ
GinqExpression
Represents GINQ expression, which has the following structure:
GinqSyntaxError
Represents GINQ syntax error
GotoRecurHereException
Exception will be thrown by recursive calls in closures and caught in while loop to continue to LOOP_LABEL
GPathResult
Base class for representing lazy evaluated GPath expressions.
GQ
Method annotation to make a method call returning GINQ result
Grab
Used to grab the referenced artifact and its dependencies and make it available on the Classpath.
GrabAnnotationTransformation
Transformation for declarative dependency management.
GrabConfig
Used to modify the grape configuration for grab requests.
GrabExclude
Used to exclude an indirectly referenced artifact (a transitive dependency) from the classpath.
GrabResolver
Used to add a repository for resolving Grape dependencies.
Grape
Facade to GrapeEngine.
GrapeEngine
Contract for Grape dependency resolution engines.
Grapes
Sometimes we will need more than one grab per class, but we can only add one annotation type per annotatable node.
GrapeUtil
Utility methods for parsing compact Grape dependency coordinates.
Groovy
Executes a series of Groovy statements.
GroovyABI
Marks a program element as part of Groovy's binary ABI.
GroovyAnnotationRef
Describes an annotation reference attached to a documented element.
GroovyAssert
`GroovyAssert` contains a set of static assertion and test helper methods for JUnit 4+.
GroovyASTTransformation
This is an annotation on a class, currently just `ASTTransformation`.
GroovyASTTransformationClass
This is an annotation on some item that indicates that an associated transform classes should be executed.
GroovyBugError
This class represents an error that is thrown when a bug is recognized inside the runtime.
Groovyc
Compiles Groovy source files using Ant.
GroovyCallable<V>
A special "marker" style interface allowing Groovy classes to implement both Runnable and Callable yet give preference to Runnable (for backwards compatibility) for APIs having both Runnable and Callable methods.
GroovyCastException
Exception thrown when a type cast or coercion fails.
GroovyCategorySupport
Support methods for Groovy category usage
GroovyCategorySupport.CategoryMethod
GroovyCategorySupport.CategoryMethodList
GroovyCategorySupport.ThreadCategoryInfo
GroovyClass
Holds the binary form of a compiled Groovy class.
GroovyClassDoc
Describes a Groovy type together with the members and relationships needed to render its documentation.
GroovyClassLoader
A ClassLoader which can load Groovy classes.
GroovyClassLoader.ClassCollector
Collects classes defined during a compilation unit callback.
GroovyClassLoader.InnerLoader
Loader used while defining classes during a compilation round.
GroovyClassValue<T>
Abstraction for Java version dependent ClassValue implementations.
GroovyClassValue.ComputeValue<T>
GroovyClassValueJava7<T>
GroovyClassValue implementation that simply delegates to Java 7's java.lang.ClassValue
GroovyClassVisitor
A special visitor for working with the structure of a class.
GroovyCodeSource
CodeSource wrapper class that allows specific security policies to be associated with a class compiled from groovy source.
GroovyCodeSourcePermission
Permission required to explicitly specify a codebase for a groovy script whose codebase cannot be determined.
GroovyCodeVisitor
Defines the visitor interface for traversing and processing Groovy AST nodes using the visitor pattern.
GroovyCodeVisitorAdapter
Adapter class providing default no-op implementations of all methods in the `GroovyCodeVisitor` interface.
GroovyCollections
Utility methods for working with combinations, subsequences, and aggregate collection operations.
GroovyCompiledScript
Used to represent compiled Groovy scripts.
GroovyConstructorDoc
Describes a constructor in the Groovydoc model.
GroovycTask
Compiles Groovy source files.
Groovydoc
An annotation to hold the groovydoc for the annotated element at runtime, we call it "Runtime Groovydoc".
Groovydoc
Represents groovydoc
Groovydoc
Access to the GroovyDoc tool from Ant.
GroovyDoc
Base contract for documented program elements exposed by Groovydoc.
GroovydocAnnotationUtils
Utilities shared between `GroovydocVisitor` (Groovy AST) and `GroovydocJavaVisitor` (JavaParser AST).
GroovyDocErrorReporter
Reports errors, warnings, and notices discovered while building documentation.
GroovydocHolder<T>
Represents Groovydoc Holder
GroovydocJavaVisitor
JavaParser AST visitor that extracts Groovydoc information from Java source files, producing a map of `GroovyClassDoc` instances keyed by full path.
GroovydocManager
A utilities for managing groovydoc, e.g.
GroovyDocParser
Parses Groovy and Java source files and builds `GroovyClassDoc` maps.
GroovyDocParserI
Parses a single source unit into Groovydoc class documentation objects.
GroovydocTag
TODO parse groovydoc to get tag content
GroovyDocTemplateEngine
Process Groovydoc templates.
GroovyDocTemplateInfo
Defines the default GString template paths used by GroovyDoc for generating HTML documentation.
GroovyDocTool
Coordinates source parsing and template-driven rendering for GroovyDoc generation.
GroovyDocUtil
Utility methods for deriving package and file names from source paths.
GroovydocVisitor
A visitor which collects Groovydoc information.
GroovyDocWriter
Write GroovyDoc resources to destination.
GroovyEngine
Implements Groovy ScriptEngine.
GroovyEngine.AccessRules
Encapsulates access rules for code completion.
GroovyEngine.Cloner
Strategy used to clone session values for completion and inspection workflows.
GroovyEngine.EngineClassLoader
Custom class loader for dynamically loaded Groovy classes.
GroovyEngine.Format
Serialization/deserialization format options.
GroovyException
Base exception class for Groovy compiler errors and warnings.
GroovyExceptionInterface
An interface for use by all Groovy compiler exceptions.
GroovyExecutableMemberDoc
Describes an executable member such as a method or constructor.
GroovyFieldDoc
Describes a field or property in the Groovydoc model.
GroovyFilter
Regex-based syntax-highlighting filter for Groovy source text.
GroovyInterceptable
Marker interface used to notify that all methods should be intercepted through the `invokeMethod` mechanism of `GroovyObject`.
GroovyLangLexer
The lexer for Groovy programming language, which is based on the lexer generated by Antlr4
GroovyLangParser
The parser for Groovy programming language, which is based on the parser generated by Antlr4
GroovyLexer
GroovyMain
A Command line to execute groovy.
GroovyMain.VersionProvider
Supplies version text for the command-line interface.
GroovyMBean
A GroovyObject facade for an underlying MBean which acts like a normal groovy object but which is actually implemented via an underlying JMX MBean.
GroovyMemberDoc
Describes a member declared within a documented type.
GroovyMethodDoc
Describes a method in the Groovydoc model.
GroovyObject
The interface implemented by all Groovy objects.
GroovyObjectSupport
Base class for Java objects wishing to be Groovy objects.
GroovyObjectWrapper
Wraps an existing `GroovyObject` while constraining the type it should present to the runtime.
GroovyPackageDoc
Describes a documented package and the types it contains.
GroovyParameter
Describes a parameter declared by a documented executable member.
GroovyParser
GroovyParser.AdditiveExprAltContext
GroovyParser.AndExprAltContext
GroovyParser.AnnotatedQualifiedClassNameContext
GroovyParser.AnnotationContext
GroovyParser.AnnotationNameContext
GroovyParser.AnnotationsOptContext
GroovyParser.AnonymousInnerClassDeclarationContext
GroovyParser.ArgumentsContext
GroovyParser.ArrayInitializerContext
GroovyParser.AssertStatementContext
GroovyParser.AssertStmtAltContext
GroovyParser.AssignmentExprAltContext
GroovyParser.AsyncClosureExprAltContext
GroovyParser.AwaitExprAltContext
GroovyParser.BlockContext
GroovyParser.BlockStatementContext
GroovyParser.BlockStatementsContext
GroovyParser.BlockStatementsOptContext
GroovyParser.BlockStmtAltContext
GroovyParser.BooleanLiteralAltContext
GroovyParser.BreakStatementContext
GroovyParser.BreakStmtAltContext
GroovyParser.BuiltInTypeContext
GroovyParser.BuiltInTypePrmrAltContext
GroovyParser.CastExprAltContext
GroovyParser.CastParExpressionContext
GroovyParser.CatchClauseContext
GroovyParser.CatchTypeContext
GroovyParser.ClassBodyContext
GroovyParser.ClassBodyDeclarationContext
GroovyParser.ClassDeclarationContext
GroovyParser.ClassNameContext
GroovyParser.ClassOrInterfaceModifierContext
GroovyParser.ClassOrInterfaceModifiersContext
GroovyParser.ClassOrInterfaceModifiersOptContext
GroovyParser.ClosureContext
GroovyParser.ClosureOrLambdaExpressionContext
GroovyParser.ClosureOrLambdaExpressionPrmrAltContext
GroovyParser.CoercionTypeContext
GroovyParser.CommandArgumentContext
GroovyParser.CommandExprAltContext
GroovyParser.CommandExpressionContext
GroovyParser.CompactConstructorDeclarationContext
GroovyParser.CompilationUnitContext
GroovyParser.ConditionalExprAltContext
GroovyParser.ConditionalStatementContext
GroovyParser.ConditionalStmtAltContext
GroovyParser.ContinueStatementContext
GroovyParser.ContinueStmtAltContext
GroovyParser.CreatedNameContext
GroovyParser.CreatorContext
GroovyParser.DeferStmtAltContext
GroovyParser.Dim0Context
GroovyParser.Dim1Context
GroovyParser.DoWhileStmtAltContext
GroovyParser.DynamicMemberNameContext
GroovyParser.ElementValueArrayInitializerContext
GroovyParser.ElementValueContext
GroovyParser.ElementValuePairContext
GroovyParser.ElementValuePairNameContext
GroovyParser.ElementValuePairsContext
GroovyParser.ElementValuesContext
GroovyParser.EmptyStmtAltContext
GroovyParser.EnhancedArgumentListElementContext
GroovyParser.EnhancedArgumentListInParContext
GroovyParser.EnhancedExpressionContext
GroovyParser.EnhancedForControlContext
GroovyParser.EnhancedStatementExpressionContext
GroovyParser.EnumConstantContext
GroovyParser.EnumConstantsContext
GroovyParser.EqualityExprAltContext
GroovyParser.ExclusiveOrExprAltContext
GroovyParser.ExpressionContext
GroovyParser.ExpressionInParContext
GroovyParser.ExpressionListContext
GroovyParser.ExpressionListElementContext
GroovyParser.ExpressionStmtAltContext
GroovyParser.FieldDeclarationContext
GroovyParser.FinallyBlockContext
GroovyParser.FloatingPointLiteralAltContext
GroovyParser.ForControlContext
GroovyParser.ForInitContext
GroovyParser.FormalParameterContext
GroovyParser.FormalParameterListContext
GroovyParser.FormalParametersContext
GroovyParser.ForStmtAltContext
GroovyParser.ForUpdateContext
GroovyParser.GroovyParserRuleContext
GroovyParser.GstringContext
GroovyParser.GstringPathContext
GroovyParser.GstringPrmrAltContext
GroovyParser.GstringValueContext
GroovyParser.IdentifierContext
GroovyParser.IdentifierPrmrAltContext
GroovyParser.IfElseStatementContext
GroovyParser.ImplicationExprAltContext
GroovyParser.ImportDeclarationContext
GroovyParser.InclusiveOrExprAltContext
GroovyParser.IndexPropertyArgsContext
GroovyParser.IndexVariableContext
GroovyParser.IntegerLiteralAltContext
GroovyParser.IntersectionTypeContext
GroovyParser.KeyedPairContext
GroovyParser.KeywordsContext
GroovyParser.LabeledStmtAltContext
GroovyParser.LambdaBodyContext
GroovyParser.ListContext
GroovyParser.ListPrmrAltContext
GroovyParser.LiteralContext
GroovyParser.LiteralPrmrAltContext
GroovyParser.LocalVariableDeclarationContext
GroovyParser.LocalVariableDeclarationStmtAltContext
GroovyParser.LogicalAndExprAltContext
GroovyParser.LogicalOrExprAltContext
GroovyParser.LoopStatementContext
GroovyParser.LoopStmtAltContext
GroovyParser.MapContext
GroovyParser.MapEntryContext
GroovyParser.MapEntryLabelContext
GroovyParser.MapEntryListContext
GroovyParser.MapPrmrAltContext
GroovyParser.MatchingTypeContext
GroovyParser.MemberDeclarationContext
GroovyParser.MethodBodyContext
GroovyParser.MethodDeclarationContext
GroovyParser.MethodNameContext
GroovyParser.ModifierContext
GroovyParser.ModifiersContext
GroovyParser.ModifiersOptContext
GroovyParser.MultipleAssignmentExprAltContext
GroovyParser.MultiplicativeExprAltContext
GroovyParser.NamedPropertyArgsContext
GroovyParser.NamePartContext
GroovyParser.NewPrmrAltContext
GroovyParser.NonWildcardTypeArgumentsContext
GroovyParser.NotInstanceofTypeContext
GroovyParser.NullLiteralAltContext
GroovyParser.OriginalForControlContext
GroovyParser.PackageDeclarationContext
GroovyParser.ParenPrmrAltContext
GroovyParser.ParExpressionContext
GroovyParser.PathElementContext
GroovyParser.PathExpressionContext
GroovyParser.PostfixExprAltContext
GroovyParser.PostfixExpressionContext
GroovyParser.PowerExprAltContext
GroovyParser.PrimaryContext
GroovyParser.PrimitiveTypeContext
GroovyParser.QualifiedClassNameContext
GroovyParser.QualifiedClassNameListContext
GroovyParser.QualifiedNameContext
GroovyParser.QualifiedNameElementContext
GroovyParser.QualifiedNameElementsContext
GroovyParser.QualifiedStandardClassNameContext
GroovyParser.ReferenceTypeContext
GroovyParser.RegexExprAltContext
GroovyParser.RelationalExprAltContext
GroovyParser.ResourceContext
GroovyParser.ResourceListContext
GroovyParser.ResourcesContext
GroovyParser.ReturnStmtAltContext
GroovyParser.ReturnTypeContext
GroovyParser.ScriptStatementContext
GroovyParser.ScriptStatementsContext
GroovyParser.SepContext
GroovyParser.ShiftExprAltContext
GroovyParser.StandardLambdaExpressionContext
GroovyParser.StandardLambdaParametersContext
GroovyParser.StatementContext
GroovyParser.StatementExpressionContext
GroovyParser.StringLiteralAltContext
GroovyParser.StringLiteralContext
GroovyParser.SuperPrmrAltContext
GroovyParser.SwitchBlockStatementExpressionGroupContext
GroovyParser.SwitchBlockStatementGroupContext
GroovyParser.SwitchExprAltContext
GroovyParser.SwitchExpressionContext
GroovyParser.SwitchExpressionLabelContext
GroovyParser.SwitchLabelContext
GroovyParser.SwitchStatementContext
GroovyParser.SynchronizedStmtAltContext
GroovyParser.ThisFormalParameterContext
GroovyParser.ThisPrmrAltContext
GroovyParser.ThrowStmtAltContext
GroovyParser.TryCatchStatementContext
GroovyParser.TryCatchStmtAltContext
GroovyParser.TypeArgumentContext
GroovyParser.TypeArgumentsContext
GroovyParser.TypeArgumentsOrDiamondContext
GroovyParser.TypeBoundContext
GroovyParser.TypeContext
GroovyParser.TypeDeclarationContext
GroovyParser.TypeListContext
GroovyParser.TypeNamePairContext
GroovyParser.TypeNamePairsContext
GroovyParser.TypeParameterContext
GroovyParser.TypeParametersContext
GroovyParser.UnaryAddExprAltContext
GroovyParser.UnaryNotExprAltContext
GroovyParser.VariableDeclarationContext
GroovyParser.VariableDeclaratorContext
GroovyParser.VariableDeclaratorIdContext
GroovyParser.VariableDeclaratorsContext
GroovyParser.VariableInitializerContext
GroovyParser.VariableModifierContext
GroovyParser.VariableModifiersContext
GroovyParser.VariableModifiersOptContext
GroovyParser.VariableNamesContext
GroovyParser.WhileStmtAltContext
GroovyParser.YieldReturnStmtAltContext
GroovyParser.YieldStatementContext
GroovyParser.YieldStmtAltContext
GroovyParserBaseVisitor<Result>
This class provides an empty implementation of `GroovyParserVisitor`, which can be extended to create a visitor which only needs to handle a subset of the available methods.
GroovyParserVisitor<Result>
This interface defines a complete generic visitor for a parse tree produced by `GroovyParser`.
GroovyPosixCommands
Groovy-aware implementations of groovysh POSIX-style commands.
GroovyPrintStream
A PrintStream that outputs objects in Groovy style.
GroovyPrintWriter
A PrintWriter that outputs objects in Groovy style.
GroovyProgramElementDoc
Describes a documented program element that can appear within a package or type.
GroovyPromise<T>
Default `Awaitable` implementation backed by a `CompletableFuture`.
GroovyResourceLoader
Allows frameworks that integrate with Groovy to determine how Groovy files are resolved.
GroovyResultSet
Represents an extent of objects
GroovyResultSetExtension
GroovyResultSetExtension implements additional logic for ResultSet.
GroovyResultSetProxy
GroovyResultSetProxy is used to create a proxy for GroovyResultSet.
GroovyRootDoc
Root object for a Groovydoc run, exposing the discovered packages, classes, and diagnostics APIs.
GroovyRootDocBuilder
Builds a `SimpleGroovyRootDoc` from source files by dispatching each file to either the Groovy AST visitor or the Java parser.
GroovyRowResult
Represents an extent of objects.
GroovyRunner
Classes which can run scripts should implement this interface.
GroovyRunnerRegistry
Registry of services that implement the `GroovyRunner` interface.
GroovyRuntimeException
An exception thrown by the interpreter
GroovyScriptEngine
Specific script engine able to reload modified scripts as well as dealing properly with dependent scripts.
GroovyScriptEngineFactory
A factory class conforming to JSR-223 which is used to instantiate Groovy `ScriptEngines` and also exposes metadata describing Groovy's engine class.
GroovyScriptEngineImpl
JSR-223 Engine implementation.
GroovyServlet
This servlet will run Groovy scripts as Groovlets.
GroovyShell
Represents a groovy shell capable of running arbitrary groovy scripts
GroovySocketServer
Simple server that executes supplied script against a socket.
GroovyStarter
Helper class to initialize the Groovy runtime.
GroovySyntaxError
Represents a syntax error of groovy program
GroovySystem
Central access point for Groovy runtime-wide services and configuration.
GroovyTag
Describes a block tag extracted from a documentation comment.
GroovyTestCase
A JUnit 3 `TestCase` base class in Groovy.
GroovyTestSuite
A TestSuite which will run a Groovy unit test case inside any Java IDE either as a unit test case or as an application.
GroovyType
Describes a type reference used throughout the Groovydoc model.
GroovyTypeCheckingExtensionSupport
Base class for type checking extensions written in Groovy.
GroovyTypeCheckingExtensionSupport.TypeCheckingDSL
Event handler registration: setup Registers closure that runs after the type checker finishes initialization finish Registers closure that runs after the type checker completes type checking beforeVisitClass Registers closure that runs before type checking a class afterVisitClass Registers closure that runs after having finished the visit of a type checked class beforeVisitMethod Registers closure that runs before type checking a method body afterVisitMethod Registers closure that runs after type checking a method body beforeMethodCall Registers closure that runs before the type checker starts type checking a method call afterMethodCall Registers closure that runs once the type checker has finished type checking a method call methodNotFound Registers closure that runs when it fails to find an appropriate method for a method call ambiguousMethods Registers closure that runs when the type checker cannot choose between several candidate methods onMethodSelection Registers closure that runs when it finds a method appropriate for a method call unresolvedVariable Registers closure that runs when the type checker finds an unresolved variable unresolvedProperty Registers closure that runs when the type checker cannot find a property on the receiver unresolvedAttribute Registers closure that runs when the type checker cannot find an attribute on the receiver incompatibleAssignment Registers closure that runs when the type checker thinks that the right-hand side of an assignment is incompatible with the left-hand side incompatibleReturnType Registers closure that runs when the type checker thinks that a return value is incompatibe with the return type Expression categorization: isAnnotationConstantExpression Determines if argument is an `AnnotationConstantExpression` isArgumentListExpression Determines if argument is an `ArgumentListExpression` isArrayExpression Determines if argument is an `ArrayExpression` isAttributeExpression Determines if argument is an `AttributeExpression` isBinaryExpression Determines if argument is a `BinaryExpression` isBitwiseNegationExpression Determines if argument is a `BitwiseNegationExpression` isBooleanExpression Determines if argument is a `BooleanExpression` isCastExpression Determines if argument is a `CastExpression` isClassExpression Determines if argument is a `ClassExpression` isClosureExpression Determines if argument is a `ClosureExpression` isConstantExpression Determines if argument is a `ConstantExpression` isConstructorCallExpression Determines if argument is a `ConstructorCallExpression` isDeclarationExpression Determines if argument is a `DeclarationExpression` isElvisOperatorExpression Determines if argument is an `ElvisOperatorExpression` isEmptyExpression Determines if argument is an `EmptyExpression` isFieldExpression Determines if argument is a `FieldExpression` isGStringExpression Determines if argument is a `GStringExpression` isLambdaExpression Determines if argument is a `LambdaExpression` isListExpression Determines if argument is a `ListExpression` isMapExpression Determines if argument is a `MapExpression` isMapEntryExpression Determines if argument is a `MapEntryExpression` isMethodCallExpression Determines if argument is a `MethodCallExpression` isMethodPointerExpression Determines if argument is a `MethodPointerExpression` isMethodReferenceExpression Determines if argument is a `MethodReferenceExpression` isNamedArgumentListExpression Determines if argument is a `NamedArgumentListExpression` isNotExpression Determines if argument is a `NotExpression` isPostfixExpression Determines if argument is a `PostfixExpression` isPrefixExpression Determines if argument is a `PrefixExpression` isPropertyExpression Determines if argument is a `PropertyExpression` isRangeExpression Determines if argument is a `RangeExpression` isSpreadExpression Determines if argument is a `SpreadExpression` isSpreadMapExpression Determines if argument is a `SpreadMapExpression` isStaticMethodCallExpression Determines if argument is a `StaticMethodCallExpression` isTernaryExpression Determines if argument is a `TernaryExpression` isTupleExpression Determines if argument is a `TupleExpression` isUnaryMinusExpression Determines if argument is a `UnaryMinusExpression` isUnaryPlusExpression Determines if argument is a `UnaryPlusExpression` isVariableExpression Determines if argument is a `VariableExpression` General utility: Delegates to `AbstractTypeCheckingExtension` Imports static members of `ClassHelper` Imports static members of `StaticTypeCheckingSupport`
Group<T>
Represents group
GroupExpression
Represents group by expression
GroupResult<K,T>
Represents a group result from a `groupby...into` clause.
GString
Represents a String which contains embedded values such as "hello there ${user} how are you?" which can be evaluated lazily.
GStringExpression
Represents a GString (interpolated string) expression containing embedded values.
GStringImpl
Default implementation of a GString used by the compiler.
GStringTemplateEngine
Processes template source files substituting variables and expressions into placeholders in a template source text to produce the desired output using a streaming approach.
GStringUtil
This class is primarily intended for INTERNAL USE.
HandleMetaClass
HasCleanup
An interface for things that need to be cleaned up after operations complete.
HashCodeHelper
A utility class to help calculate hashcode values using an algorithm similar to that outlined in "Effective Java, Joshua Bloch, 2nd Edition".
HasRecursiveCalls
Check if there are any recursive calls in a method
HavingExpression
Represents having expression
Header
Declares a default HTTP header.
Headers
Container annotation for repeatable `Header` annotations.
HiddenClassDefiner
Central facility for defining hidden classes (JEP 371).
HttpBuilderClient
Marks an interface as a declarative HTTP client.
IFileNameFinder
Locates file names matching Ant-style include and exclude patterns.
IfStatement
Represents an if (condition) { then-block } else { else-block } conditional statement in Groovy.
IllegalPropertyAccessException
An exception occurred if a dynamic property dispatch fails with a field not accessible.
ImmutableASTTransformation
Handles generation of code for the @Immutable annotation.
ImmutableBase
Class annotation used to assist in the creation of immutable classes.
ImmutableOptions
Class annotation used to assist in the creation of immutable classes.
ImmutablePropertyHandler
Property handler used by immutable-style transforms.
ImmutablePropertyUtils
Utility methods for immutable-property analysis and code generation.
ImportCustomizer
This compilation customizer allows adding various types of imports to the compilation unit.
ImportCustomizerFactory
This factory allows the generation of an `import customizer`.
ImportNode
Represents an import statement in Groovy source code, supporting single-type imports, wildcard imports, and static imports.
IncorrectClosureArgumentsException
An exception occurred when invoking a Closure with the wrong number and/or types of arguments
IncorrectTypeHintException
Indicates that a `ClosureParams` hint declaration is invalid.
Incubating
Indicates experimental and still-to-be-refined API, which may change at any time.
IndentPrinter
A helper class for printing indented text.
IndexedProperty
Field annotation used with properties to provide an indexed getter and setter for the property.
IndexedPropertyASTStubber
Joint-compilation stubber for `IndexedProperty`.
IndexedPropertyASTTransformation
Handles generation of code for the `@`IndexedProperty annotation.
IndyArrayAccess
Class for handling array access through invokedynamic using static callsite information
IndyBinHelper
Binary-expression helper that routes prefix and postfix operations through the indy invocation path.
IndyCallSiteWriter
Dummy class used by the indy implementation.
IndyCompoundAssign
GEP-15: resolver for dynamic compound-assignment operators (`+=`, `-=`, ...).
IndyGuardsFiltersAndSignatures
This class contains guards, runtime filters and MethodType signatures used by indy.
IndyInterface
Deprecated.
IndyInterface
Bytecode level interface for bootstrap methods used by invokedynamic.
IndyInterface.CallType
Enum for easy differentiation between call types
IndyInterface.CallType
Enum for easy differentiation between call types.
IndyInvalidation
Scoped invokedynamic `SwitchPoint` invalidation for the Groovy MOP (GROOVY-12191).
IndyMath
This class contains math operations used by indy instead of the normal meta method and call site caching system.
IndyStaticTypesMultiTypeDispatcher
Deprecated.
Since 6.0.0, use `StaticTypesBinaryExpressionMultiTypeDispatcher` instead; indy array access is no longer used in static compilation.
InheritConstructors
Class annotation to make constructors from a super class available in a subclass.
InheritConstructorsASTStubber
Joint-compilation stubber for `InheritConstructors`.
InheritConstructorsASTTransformation
Handles generation of code for the `@`InheritConstructors annotation.
InitializerStrategy
This strategy is used with the `Builder` AST transform to create a builder helper class for the fluent and type-safe creation of instances of a specified class.
InitializerStrategy.SET
Internal phantom type used by the `InitializerStrategy` to indicate that a property has been set.
InitializerStrategy.UNSET
Internal phantom type used by the `InitializerStrategy` to indicate that a property remains unset.
InlinedASTCustomizerFactory
This factory lets a user define a compilation customizer without having to define an anonymous inner class.
InListParameter
Marker that expands a collection into a comma-separated list of positional placeholders when bound to a SQL `IN` clause.
InnerClassCompletionVisitor
Completes the transformation of inner classes by adding synthetic fields and constructor parameters needed to maintain references to outer class instances.
InnerClassNode
Represents a nested (inner) class definition within an outer class.
InnerClassVisitor
Processes inner classes during compilation, handling the creation of synthetic fields and parameters needed for inner class instances to reference their enclosing instances.
InnerClassVisitorHelper
Abstract base class providing helper methods for inner class visitors.
InOutParameter
A typed parameter passed to, and returned from a CallableStatement.
InParameter
A typed parameter to pass to a query
InputStreamReaderSource
A ReaderSource for source strings.
Inspector
The Inspector provides a unified access to an object's information that can be determined by introspection.
Inspector.MemberComparator
Comparator for member information arrays.
Inspector.MemberComparatorWithValue
Comparator for property tuples that include values.
InstanceOfVerifier
Verifies that `instanceof` checks do not use unsupported target types.
IntArrayIterable
Allows an int array to be used where an Iterable is expected.
IntArrayIterator
Allows an int array to be used where an Iterator is expected.
IntComparator
A comparator of two int values.
IntegerArrayGetAtMetaMethod
IntegerArrayPutAtMetaMethod
IntegerCachedClass
Provides optimized reflection caching for `int` and `Integer`.
IntegerMath
32-bit integer (int) arithmetic operations.
Interceptor
Implementers of this interface can be registered in the ProxyMetaClass for notifications about method calls for objects managed by the ProxyMetaClass.
InterfaceHelperClassNode
Represents an inner class defined as helper for an interface.
Internal
Marks class members that are intended for internal use.
IntersectionCastSupport
Runtime support for intersection-type cast and `as` coercion (GROOVY-11998).
IntersectionTypeClassNode
Represents a user-written intersection type used as the target of a cast expression or `as` coercion, e.g.
IntIntArrayColumnIterator
An iterator providing the columns of an int[][].
IntRange
Represents a list of Integer objects starting at and potentially including a specified `from` value up (or down) to and potentially including a given `to` value.
IntWrapper
Wrapper for `int` values that preserves the primitive constrained type.
InvalidOptionException
Represents invalid options, e.g.
Invariant
Represents a class-invariant or a loop invariant.
Invariants
Container annotation for multiple `Invariant` declarations on the same type.
InvocationWriter
Handles method and constructor invocations, generating appropriate bytecode.
InvokeDynamicWriter
This Writer is used to generate the call invocation byte codes for usage by invokedynamic.
InvokerFactory
Factory for `DirectInvoker` instances bound to one `CachedMethod`.
InvokerHelper
A static helper class to make bytecode generation easier and act as a facade over the Invoker
InvokerInvocationException
Exception thrown when a method invocation targets and throws an exception.
InWhileLoopWrapper
Wrap the body of a method in a while loop, nested in a try-catch.
IO
Reader and writer helpers used by the JSON parser internals.
IO
Container for input/output handles.
IO.Verbosity
Verbosity for simple logging: QUIET, INFO, VERBOSE, DEBUG
IOGroovyMethods
This class defines new groovy methods for Readers, Writers, InputStreams and OutputStreams which appear on normal JDK classes inside the Groovy environment.
Iterables
Provides some iterable based generators.
IteratorBufferedIterator<T>
An implementation for BufferedIterator wraps Iterator.
IteratorClosureAdapter<T>
A closure which stores calls in a List so that method calls can be iterated over in a 'yield' style way
Iterators
Provides some iterator based generators.
JacksonHelper
Internal helper for optional Jackson databinding support.
Janitor
An agent that can be used to defer cleanup operations to a later time.
Java10
Deprecated, for removal: This API element is subject to removal in a future version.
Use `Java17` instead.
Java16
Deprecated, for removal: This API element is subject to removal in a future version.
Use `Java17` instead.
Java17
Java 17 based functions.
Java8
Deprecated, for removal: This API element is subject to removal in a future version.
Use `Java17` instead.
Java9
Deprecated, for removal: This API element is subject to removal in a future version.
Use `Java17` instead.
JavaAwareCompilationUnit
Compilation Unit capable of compiling Java source files.
JavaAwareResolveVisitor
Resolve visitor variant used during joint compilation to revisit special constructor calls and track missing imports for Java sources.
JavacCompilerFactory
Factory creating the default `JavacJavaCompiler` implementation.
JavacJavaCompiler
`JavaCompiler` implementation that delegates to the JDK system Java compiler.
JavaCompiler
Strategy interface for compiling Java sources during Groovy joint compilation.
JavaCompilerFactory
Factory for creating Java compiler instances used by joint compilation.
JavaShell
A shell for compiling or running pure Java code in-memory using the platform's `JavaCompiler`.
JavaShellCompilationException
Indicates that `JavaShell` could not compile the supplied Java source.
JavaStubCompilationUnit
Compilation unit to only generate stubs.
JavaStubGenerator
Generates Java stub source for Groovy classes during joint compilation.
JComboBoxProperties
Supplies synthetic binding definitions for `JComboBox`.
JComponentProperties
Supplies synthetic binding definitions for generic `JComponent` geometry and visibility properties.
JmxBuilderException
Runtime exception used by JmxBuilder.
JmxBuilderModelMBean
The JmxBuilderModelMBean is the MBean class that proxies exported POGO/POJO inside the MBeanServer.
JmxEventEmitter
The JmxEventEmitter is a JMX Broadcaster class that is used to send generic events on the MBeanServer's event bus.
JmxEventEmitterMBean
This is the management interface for JmxEventEmitter.
JmxEventListener
The JmxEventListener class is used by the builder to listen to events on the event bus.
JoinExpression
Represents join expression
JrtJavaBasePackages
Helper class to resolve java.base module classes
JScrollBarProperties
Supplies synthetic binding definitions for `JScrollBar`.
JSliderProperties
Supplies synthetic binding definitions for `JSlider`.
JsonBuilder
A builder for creating JSON payloads.
JsonDateHandling
What a slurper makes of a string in a full ISO-8601 or JSON-date form.
JsonDelegate
Utility class used as delegate of closures representing JSON objects.
JsonException
`JsonException` is the exception thrown by the JSON builder and slurper classes, whenever a problem occurs when creating or parsing JSON data structures.
JsonFastParser
This works in index overlay mode or chop mode.
JsonGenerator
Generates JSON from objects.
JsonGenerator.Converter
Handles converting a given type.
JsonGenerator.Options
A builder used to construct a `JsonGenerator` instance that allows control over the serialized JSON output.
JsonLexer
The lexer reads JSON tokens in a streaming fashion from the underlying reader.
JsonOutput
Class responsible for the actual String serialization of the possible values of a JSON structure.
JsonOutput.JsonUnescaped
Represents unescaped JSON
JsonParser
This is the parser interface that backs the new JsonSlurper.
JsonParserCharArray
Converts an input JSON String into Java objects works with String or char array as input.
JsonParserLax
JSON parser variant that also accepts comments, single quotes, and unquoted strings.
JsonParserType
Allows selection of parser type for new JsonSlurper.
JsonParserUsingCharacterSource
Converts an input JSON String into Java objects works with String or char array as input.
JsonSlurper
This has the same interface as the original JsonSlurper written for version 1.8.0, but its implementation has completely changed.
JsonSlurperClassic
This is the original slurper included in case someone relies on its exact behavior.
JsonStringDecoder
Decodes JSON string escape sequences from character buffers.
JsonToken
A JSON token, with a type, line / column information, and the text of that token.
JsonTokenType
The original slurper and lexer use this class.
JSpinnerProperties
Supplies synthetic binding definitions for `JSpinner`.
JTableProperties
Supplies synthetic binding definitions for `JTable`.
JTextComponentProperties
Supplies synthetic binding definitions for `JTextComponent`.
JUnit5Runner
Integration code for running JUnit5 tests in Groovy.
JUnit6Runner
Integration code for running JUnit 6 (Jupiter) tests in Groovy.
KnownImmutable
Class annotation used as a marker for immutable classes.
LabelVerifier
This class checks the handling of labels in the AST
LambdaExpression
Represents a lambda expression such as one of these:
Lambdas
Helpers that return `java.util.function` types.
LambdaWriter
Generates bytecode for lambda expressions.
Lazy
Field annotation to simplify lazy initialization.
LazyASTStubber
Joint-compilation stubber for `Lazy`.
LazyASTTransformation
Handles generation of code for the @Lazy annotation
LazyInitializable
A `LazyInitializable` is an object that can be initialized lazily.
LazyMap
A map that defers creating its backing map, so the small objects that dominate JSON documents do not incur that overhead.
LazyReference<T>
Soft reference with lazy initialization under lock
LazyValueMap
This class is important to the performance of the parser.
LegacyHashMapPropertyHandler
The `@Immutable` transformation in earlier versions of Groovy tried to be smart in the case of an immutable class with a single HashMap property, the supplied Map constructor tried to be compatible with both expected tuple behavior and expected named-argument behavior by peeking into the supplied map and guessing as to which approach might be applicable.
LexerAtnManager
Manage ATN for lexer to avoid memory leak
LexerFrame
Swing application to graphically display the tokens produced by the lexer.
Lifecycle
Specifies life-cycle hook-ins for applying AST transformation logic before and after the annotation processors have been run.
LifecycleAfterTransformationVisitor
AST transformation visitor which is triggered after applying `AnnotationProcessor` related transformations.
LifecycleBeforeTransformationVisitor
AST transformation visitor which is triggered before applying `AnnotationProcessor` related transformations.
LifecycleImplementationLoader<S>
Finds and loads implementation classes of interface `Lifecycle`.
LimitExpression
Represents limit expression
LineColumnReader
The `LineColumnReader` is an extension to `BufferedReader` that keeps track of the line and column information of where the cursor is.
LinkArgument
Represents a link pair (href, packages) with optional JPMS module.
ListBufferedIterator<T>
An implementation for BufferedIterator wraps ListIterator.
ListExpression
Represents a list expression [1, 2, 3] which creates a mutable List
ListHashMap<K,V>
Represents a `Map` that is optimized for a small number of entries.
ListOfExpressionsExpression
This class is used internally by the compiler to transform expressions like multiple assignments into a list of assignments.
ListWithDefault<T>
A wrapper for `List` which automatically grows the list when either `ListWithDefault.get(int)` or `ListWithDefault.getAt(int)` is called with an index greater than or equal to `size()`.
ListWrapperListModel<E>
A `ListModel` implementation that's backed by a live `List`.
LoaderConfiguration
Class used to configure a RootLoader from a stream or by using its methods.
LocatedMessage
A base class for compilation messages.
LockableObject
A bit simplified lock designed to be inherited by.
Log
This local transform adds a logging ability to your program using java.util.logging.
Log.JavaUtilLoggingStrategy
This class contains the logic of how to weave a Java Util Logging logger into the host class.
Log4j
This local transform adds a logging ability to your program using Log4j logging.
Log4j.Log4jLoggingStrategy
Logging strategy for Log4j 1.x.
Log4j2
This local transform adds a logging ability to your program using Log4j2 logging.
Log4j2.Log4j2LoggingStrategy
Logging strategy for Log4j 2.
LogASTTransformation
This class provides an AST Transformation to add a log field to a class.
LogASTTransformation.AbstractLoggingStrategy
Base class for logging strategy implementations.
LogASTTransformation.AbstractLoggingStrategyV2
Base class for logging strategy implementations supporting the v2 logging API.
LogASTTransformation.LoggingStrategy
A LoggingStrategy defines how to wire a new logger instance into an existing class.
LogASTTransformation.LoggingStrategyV2
A LoggingStrategy defines how to wire a new logger instance into an existing class.
LoggableClassVisitor
A ClassVisitor proxy, which can log bytecode generation
LoggableTextifier
Logging bytecode generation, which can make debugging easy
Logger
Provides a very, very basic logging API.
LoggingHelper
Helper to make logging from Ant easier.
LongArrayGetAtMetaMethod
LongArrayIterable
Allows a long array to be used where an Iterable is expected.
LongArrayIterator
Allows a long array to be used where an Iterator is expected.
LongArrayPutAtMetaMethod
LongCachedClass
Provides optimized reflection caching for `long` and `Long`.
LongComparator
A comparator of two long values.
LongLongArrayColumnIterator
An iterator providing the columns of a long[][].
LongMath
64-bit long integer (long) arithmetic operations.
LongWrapper
Wrapper for `long` values that preserves the primitive constrained type.
LoopingStatement
This is an AST Node that provides some sort of looping mechanism.
LoopInvariant
A loop-invariant assertion that must hold at the start of each iteration.
LoopInvariantASTTransformation
Handles `Invariant` annotations placed on loop statements (`for`, `while`, `do-while`).
LoopInvariantViolation
Thrown whenever a loop invariant violation occurs.
LoopVariantASTTransformation
Handles `Decreases` annotations placed on loop statements (`for`, `while`, `do-while`).
LoopVariantViolation
Thrown whenever a loop variant (decreases/increases) violation occurs.
LRUCache<K,V>
A cache backed by a ConcurrentLinkedHashMap
Macro
MacroBuilder
Runtime support for
MacroClass
Marker base class for anonymous classes expanded into `ClassNode` instances.
MacroClassTransformation
Transforms `MacroClass` calls into its ClassNode
MacroContext
Macro method context.
MacroGroovyMethods
Macro extension methods and helpers used during macro expansion.
MacroGroovyMethods.MacroValuePlaceholder
Delegate used inside macro closures for `$v` substitutions.
MacroLibGroovyMethods
Macro library helpers for string and named-value expansion.
MacroStub
Stub for macro calls.
MacroTransformation
ManagedConcurrentLinkedQueue<T>
A queue that stores values wrapped in a Reference, the type of which is determined by the provided `ReferenceBundle`.
ManagedConcurrentValueMap<K,V>
This is a basic implementation of a map able to forget its values.
ManagedIdentityConcurrentMap<K,V>
This is a basic implementation of a map able to forget its keys could be weak/soft/strong references.
ManagedReference<T>
Reference wrapper that couples a referent with a `ReferenceManager` cleanup lifecycle.
MapConstructor
Class annotation used to assist in the creation of map constructors in classes.
MapConstructorASTStubber
Joint-compilation stubber for `MapConstructor`.
MapConstructorASTTransformation
Handles generation of code for the @MapConstructor annotation.
MapEntry
A Map.Entry implementation.
MapEntryExpression
Represents an entry inside a map expression such as `1 : 2` or `'foo' : 'bar'`.
MapEntryOrKeyValue
A special hint which handles a common use case in the Groovy methods that work on maps.
MapExpression
Represents a map expression [1 : 2, "a" : "b", x : y] which creates a mutable Map
MapItemValue
This holds a mapping from value key to value value to maximize laziness.
Maps
Map utilities.
MapWithDefault<K,V>
A wrapper for Map which allows a default value to be supplied by a Closure.
MarkdownDocument
A parsed Markdown document, exposed as a list of node maps with convenience accessors for the most common navigation patterns.
MarkdownRenderer
GROOVY-11542: support for JEP 467 Markdown documentation comments (triple-slash `///` runs, captured by `GroovydocVisitor`).
MarkdownRuntimeException
Represents a runtime exception that occurred while parsing Markdown.
MarkdownSlurper
Parses CommonMark Markdown into a `MarkdownDocument` backed by nested lists and maps.
MarkupBuilder
A helper class for creating XML or HTML markup.
MarkupBuilder.CharFilter
Identifiers for built-in character filtering strategies.
MarkupBuilder.DefaultXmlEscapingFunction
Default character replacement function used for XML content and attribute escaping.
MarkupBuilderHelper
A helper class for MarkupBuilder.
MarkupTemplateEngine
A template engine which leverages `StreamingMarkupBuilder` to generate XML/XHTML.
MarkupTemplateEngine.CachingTemplateResolver
A template resolver which avoids calling `ClassLoader.getResource(String)` if a template path already has been queried before.
MarkupTemplateEngine.DefaultTemplateResolver
Default resolver that loads templates from the configured template class loader and applies locale fallback rules.
MarkupTemplateEngine.TemplateResource
Describes a template resource name split into base name, optional locale suffix, and extension.
MatchingHighlighter
Represents highlighter to highlight matched parentheses, brackets and curly braces when caret touching them
MemJavaFileObject
Represents a Java source file in memory to compile
Memoize
Implements memoize for Closures.
MemoizeCache<K,V>
Represents a memoize cache with its essential methods
MemoizeCache.ValueProvider<K,V>
Represents a provider used to create value
Memoized
Method annotation that creates a cache for the results of the execution of the annotated method.
MemoizedASTTransformation
Handles generation of code for the `Memoized` annotation.
Message
A base class for compilation messages.
MessageSource
Message source backed up by one or more `ResourceBundle` instances for simple i18n support.
MetaArrayLengthProperty
Represents the length property of an array.
MetaBeanProperty
Represents a property on a bean which may have a getter and/or a setter
MetaClass
A MetaClass within Groovy defines the behaviour of any given Groovy or Java class.
MetaClass<T>
A MetaClass within Groovy defines the behaviour of any given Groovy or Java class
MetaClassCallSites
Builds classic (non-indy) call sites for a `MetaClassImpl`.
MetaClassConstant<T>
The one and only implementation of a metaclass.
MetaClassConstructorSite
Call site for constructor metaclass - cached method - not cached
MetaClassHelper
MetaClassImpl
Allows methods to be dynamically added to existing classes at runtime
MetaClassImpl.MetaConstructor
This is a helper class which is used only by indy.
MetaClassRegistry
A MetaClassRegistry is an object that is responsible for managing a cache of MetaClass instances.
MetaClassRegistry.MetaClassCreationHandle
Class used as base for the creation of MetaClass implementations.
MetaClassRegistryChangeEvent
An event used to propagate metaclass updates
MetaClassRegistryChangeEventListener
A listener called whenever a constant MetaClass is set, removed or replaced.
MetaClassRegistryImpl
A registry of MetaClass instances which caches introspection and reflection information and allows methods to be dynamically added to existing classes at runtime
MetaClassSite
Call site which holds reference to metaclass.
MetaExpandoProperty
Represents a property in an Expando object
MetaInfExtensionModule
A `SimpleExtensionModule` implementation which reads extension class metadata from META-INF.
MetaMember
Common values of a class member -- a field, property, method, or constructor.
MetaMethod
Represents a Method on a Java object a little like `Method` except without using reflection to invoke the method
MetaMethodIndex
An index of metamethods for a class, organized by method name and signature.
MetaMethodIndex.Cache
A cache of metamethods indexed by name.
MetaMethodIndex.MetaMethodCache
A cache entry for a metamethod with its parameter types.
MetaMethodSite
Call site which caches meta method
MetaObjectProtocol
An interface that defines the API usable by clients of Groovy's Meta Object Protocol (MOP).
MetaProperty
Represents a property on a bean which may have a getter and/or a setter
MethodCall
Interface defining common methods for method calls.
MethodCaller
A helper class to invoke methods more easily in ASM
MethodCallerMultiAdapter
Multi-adapter for method callers that handles different argument counts and safe/spread-safe variants.
MethodCallExpression
Represents a method call on an object or class, including receiver object, method name/expression, and arguments.
MethodCallTransformation
MethodCallUtils
Utility class for commonly called methods
MethodClosure
Represents a method on an object using a closure, which can be invoked at any time.
MethodInvocationTrap
Abstract base class for AST visitors that trap and intercept specific method invocations.
MethodKey
An abstract base class for a key used for comparators and Map keys to look up a method by name and parameter types
MethodMetaProperty
Wrapper for a method for a property get or set.
MethodMetaProperty.GetBeanMethodMetaProperty
Wrapper for a method realizing the property getter.
MethodMetaProperty.GetMethodMetaProperty
Wrapper for a method realizing the property get.
MethodNode
Represents a method declaration.
MethodNodeUtils
Utility class for working with MethodNodes
MethodPointerExpression
Represents a method pointer on an object such as `foo.&bar` which means find the method pointer for the `bar` method on the `foo` instance.
MethodPointerExpressionWriter
Generates bytecode for method pointer expressions.
MethodRankHelper
Utility class for MissingMethodException, MissingPropertyException, etc.
MethodReferenceExpression
Represents a method reference or a constructor reference, e.g.
MethodReferenceExpressionWriter
Generates bytecode for method reference expressions.
MethodSelectionException
This exception is thrown if the runtime is unable to select a method.
MethodVariantASTTransformation
Handles a `Decreases` annotation placed on a method (the loop case is handled by `LoopVariantASTTransformation`).
MethodVariantInheritanceASTTransformation
Inherits a method-level `Decreases` termination measure onto an override that does not redeclare it — mirroring how groovy-contracts inherits `@Requires`/`@Ensures` (Liskov substitution).
MethodVariantSupport
Runtime support for a method-level `Decreases` recursion termination measure.
MissingClassException
An exception occurred if a dynamic method dispatch fails with an unknown class.
MissingFieldException
An exception occurred if a dynamic field dispatch fails with an unknown field.
MissingMethodException
An exception occurred if a dynamic method dispatch fails with an unknown method.
MissingMethodExceptionNoStack
A `MissingMethodException` that does not populate the stack trace.
MissingMethodExecutionFailed
A stack-less exception used to indicate that the execution of a missingMethod method failed with a MissingMethodException.
MissingPropertyException
An exception occurred if a dynamic property dispatch fails with an unknown property.
MissingPropertyExceptionNoStack
A `MissingPropertyException` that does not populate the stack trace.
MixedInMetaClass
A delegating MetaClass that allows mixing in a mixin object.
Mixin
Deprecated.
Static mixins have been deprecated in favour of traits.
MixinASTTransformation
Deprecated.
static mixins have been deprecated in favour of traits (trait keyword).
MixinInMetaClass
Manages the integration of mixin classes into expandable metaclasses.
MixinInstanceMetaMethod
MetaMethod for mixed in classes.
MixinInstanceMetaProperty
MetaProperty for properties in mixed in classes.
MixinNode
Represents a mixin which can be applied to any ClassNode to implement mixins
MockOutputTool
In-memory `OutputTool` used by tests.
MockProxyMetaClass
The ProxyMetaClass for the MockInterceptor.
ModifierNode
Represents a modifier keyword or annotation in Groovy source code.
Modifies
Declares the frame condition for a method: the set of fields and parameters that the method is allowed to modify.
ModifiesASTTransformation
Handles `Modifies` annotations placed on methods.
ModifiesConditions
Container for multiple `Modifies` annotations on the same method.
ModifiesEnsuresValidationTransformation
Validates that `@Ensures` postconditions on a method only reference fields via `old.xxx` that are declared as modifiable by `@Modifies`.
ModuleImportHelper
Shared utilities for expanding JPMS module imports into package-level star imports.
ModuleNode
Represents a module, which consists typically of a class declaration but could include some imports, some statements and multiple classes intermixed with statements like scripts in Python or Ruby
Monadic
Marks a type as participating in monadic comprehensions (the `DO` macro).
MonadicCarrierRegistry
The standard carrier allow-list for monadic comprehensions: stdlib and Groovy-core carriers whose bind/map method names diverge from the structural `flatMap`/`map` convention.
MonadicCarrierRegistry.Entry
One `Class`-keyed allow-list row.
MonadicCarrierRegistry.NamedEntry
One name-keyed allow-list row, for carriers Groovy must not depend on.
MopWriter
Generates bytecode for Meta Object Protocol (MOP) methods.
MopWriter.Factory
Factory interface for creating MopWriter instances.
MultipleAssignmentMetadata
AST node metadata keys used by the multi-assignment destructuring pipeline introduced in GEP-20.
MultipleAssignmentSupport
Runtime helpers used by the GEP-20 multi-assignment destructuring bytecode.
MultipleCompilationErrorsException
Represents multiple other exceptions
MultipleSetterProperty
This class represents a property with multiple setters.
MutableMetaClass
An interface that defines methods that implementers of mutable Meta classes should specify.
MutualPropertyBinding
Maintains two synchronized `PropertyBinding` instances that update each other.
NamedArgumentListExpression
Represents one or more arguments being passed into a method by name
NamedDelegate
Marker interface used to indicate that the property names of the annotated parameter represent valid key names when using named arguments and that the property types are applicable for type checking purposes.
NamedParam
Marker interface used to indicate that the name of the annotated parameter (or specified optional name) is a valid key name when using named arguments and that the parameter type is applicable for type checking purposes.
NamedParams
Collector annotation for `NamedParam`.
NamedValue<T>
Represents a value with name
NamedVariant
Allows construction of a named-arg equivalent method or constructor.
NamedVariantASTStubber
Joint-compilation stubber for `NamedVariant`.
NamedVariantASTTransformation
Handles generation of variant methods with named parameters via the `NamedVariant` annotation.
Namespace
A simple helper class which acts as a factory of `QName` instances.
NamespaceAwareHashMap
Attribute map that resolves namespace-prefixed keys into QName-style names on demand.
NamespaceBuilder
A helper class for creating namespaces for GroovyMarkup
NamespaceBuilderSupport
A helper class for creating namespaced GroovyMarkup
NestedCopyWithSupport
Runtime support for nested-path `copyWith`.
NestedValueModel
Represents a nested value model such as a PropertyModel or a ClosureModel
Newify
Annotation that supports writing constructor call expressions without the 'new' keyword.
NewifyASTTransformation
Handles generation of code for the `@Newify` AST transform.
NewInstanceMetaMethod
A MetaMethod implementation where the underlying method is really a static helper method on some class but it appears to be an instance method on a class.
NewMetaMethod
Base class for NewInstanceMetaMethod and NewStaticMetaMethod
NewStaticMetaMethod
A MetaMethod implementation where the underlying method is really a static helper method on some class.
NioExtensions
This class defines new groovy methods for Readers, Writers, InputStreams and OutputStreams which appear on normal JDK classes inside the Groovy environment.
NoChildren
Lazy evaluated representation of a GPath expression returning no children.
Node
Represents an arbitrary tree node which can be used for structured metadata or any arbitrary XML-like tree.
Node
Represents a node.
NodeBuilder
A helper class for creating nested trees of Node objects for handling arbitrary data
NodeChild
Lazy evaluated representation of a child node.
NodeChildren
Lazy evaluated representation of child nodes.
NodeComparator
Compares two AST nodes for matcher purposes.
NodeIterator
Helper class for iterating through nodes.
NodeList
A List implementation which is returned by queries on a `Node` which provides some XPath like helper methods for GPath.
NodeMetaDataHandler
An interface to mark a node being able to handle metadata.
NodeParents
Lazy evaluated representation of parent nodes without duplicates
NodePrinter
A helper class for creating nested trees of data
NonEmptySequence
Represents a sequence of one or more objects of a given type.
NonSealed
Class annotation used to demarcate non-sealed classes.
NonSealedASTTransformation
Handles generation of code for the @Sealed annotation.
NotExpression
NotYetImplemented
Method annotation used to invert test case results.
NotYetImplementedASTTransformation
Generates code for the `@NotYetImplemented` annotation.
NullCallSite
NullCheck
Class, method or constructor annotation which indicates that each parameter should be checked to ensure it isn't null.
NullCheckASTTransformation
Handles generation of code for the @NullCheck annotation.
NullObject
A singleton representing the Groovy `null` object, providing null-safe method dispatch and special handling for operations on null values.
NullProtectionStorage
A NullObject pattern implementation for ProtectionStorage Doesn't protect any resources.
NullWriter
A Writer that eats its input.
NumberAwareComparator<T>
Compares two objects using Groovy's friendly comparison algorithm, i.e.
NumberCachedClass
Base class for optimized reflection caching of numeric types.
NumberMath
Stateless objects used to perform math on the various Number subclasses.
NumberMathModificationInfo
Tracks modifications to arithmetic operations on numeric types.
NumberNumberDiv
NumberNumberMetaMethod
Base class for number-operator meta methods registered with the MOP.
NumberNumberMinus
NumberNumberMultiply
NumberNumberPlus
NumberRange
Represents an immutable list of Numbers from a value to a value with a particular step size.
Numbers
Utility class for processing and parsing Groovy numeric literals.
NumberValue
Overlay-backed numeric `Value` that parses JSON numbers on demand.
ObjectArrayGetAtMetaMethod
ObjectArrayPutAtMetaMethod
ObjectCachedClass
Provides optimized reflection caching for `Object`.
ObjectGraphBuilder
A builder for creating object graphs.
Each node defines the class to be created and the property on its parent (if any) at the same time.
ObjectGraphBuilder.ChildPropertySetter
Strategy for setting a child node on its parent.
Useful for handling Lists/Arrays vs normal properties.
ObjectGraphBuilder.ClassNameResolver
Strategy for resolving a classname.
ObjectGraphBuilder.DefaultChildPropertySetter
Default impl that calls parent.propertyName = child
If parent.propertyName is a Collection it will try to add child to the collection.
ObjectGraphBuilder.DefaultClassNameResolver
Default impl that capitalizes the classname.
ObjectGraphBuilder.DefaultIdentifierResolver
Default impl, always returns 'id'
ObjectGraphBuilder.DefaultNewInstanceResolver
Default impl that calls Class.newInstance()
ObjectGraphBuilder.DefaultReferenceResolver
Default impl, always returns 'refId'
ObjectGraphBuilder.DefaultRelationNameResolver
Default impl that returns parentName and childName accordingly.
ObjectGraphBuilder.IdentifierResolver
Strategy for picking the correct synthetic identifier.
ObjectGraphBuilder.NewInstanceResolver
Strategy for creating new instances of a class.
Useful for plug-in calls to non-default constructors.
ObjectGraphBuilder.ReferenceResolver
Strategy for picking the correct synthetic reference identifier.
ObjectGraphBuilder.RelationNameResolver
Strategy for resolving a relationship property name.
ObjectHolder<T>
Just hold an object
ObjectRange
Represents an inclusive list of objects from a value to a value using comparators.
ObjectUtil
Deprecated.
retained only so Groovy 4 compiled bytecode keeps linking; not emitted by any current transform and not intended for direct use
ObservableList
List decorator that will trigger PropertyChangeEvents when a value changes.
An optional Closure may be specified and will work as a filter, if it returns true the property will trigger an event (if the value indeed changed), otherwise it won't.
ObservableList.ChangeType
Enumerates the specialized list change events.
ObservableList.ElementAddedEvent
Event fired when one element is added.
ObservableList.ElementClearedEvent
Event fired when the list is cleared.
ObservableList.ElementEvent
Base event type for observable list content changes.
ObservableList.ElementRemovedEvent
Event fired when one element is removed.
ObservableList.ElementUpdatedEvent
Event fired when one element is updated.
ObservableList.MultiElementAddedEvent
Event fired when multiple elements are added.
ObservableList.MultiElementRemovedEvent
Event fired when multiple elements are removed.
ObservableMap
Map decorator that will trigger PropertyChangeEvents when a value changes.
An optional Closure may be specified and will work as a filter, if it returns true the property will trigger an event (if the value indeed changed), otherwise it won't.
ObservableMap.ChangeType
Enumerates the specialized map change events.
ObservableMap.MultiPropertyEvent
Event fired when multiple property changes are aggregated.
ObservableMap.PropertyAddedEvent
Event fired when a property is added.
ObservableMap.PropertyClearedEvent
Event fired when the map is cleared.
ObservableMap.PropertyEvent
Base event type for observable map changes.
ObservableMap.PropertyRemovedEvent
Event fired when a property is removed.
ObservableMap.PropertyUpdatedEvent
Event fired when a property value changes.
ObservableSet<E>
Set decorator that will trigger PropertyChangeEvents when a value changes.
An optional Closure may be specified and will work as a filter, if it returns true the property will trigger an event (if the value indeed changed), otherwise it won't.
ObservableSet.ChangeType
Enumerates the specialized set change events.
ObservableSet.ElementAddedEvent
Event fired when one element is added.
ObservableSet.ElementClearedEvent
Event fired when the set is cleared.
ObservableSet.ElementEvent
Base event type for observable set content changes.
ObservableSet.ElementRemovedEvent
Event fired when one element is removed.
ObservableSet.MultiElementAddedEvent
Event fired when multiple elements are added.
ObservableSet.MultiElementRemovedEvent
Event fired when multiple elements are removed.
OldVariableGenerationUtility
Central place where code generation for the `old` closure variable takes place.
OnExpression
Represents on expression
OperandStack
Tracks the JVM operand stack during bytecode generation, maintaining a parallel list of `ClassNode` type descriptors for each slot.
OperatorRename
Allows renaming of Groovy's operator methods.
OperatorRenameASTTransformation
Handles transformation for the @OperatorRename annotation.
OptimizerVisitor
Visitor to produce several optimizations: to replace numbered constants with references to static fields remove superfluous references to GroovyObject interface
OptimizingStatementWriter
A `StatementWriter` that emits optimized fast-path bytecode for statements involving integer (and other primitive) operations.
OptimizingStatementWriter.ClassNodeSkip
Marker metadata used to skip optimization analysis for a class node.
OptimizingStatementWriter.StatementMeta
Stores optimization metadata collected for a statement or expression.
Option
Indicates that a method or property can be used to set a CLI option.
OrderBy<T>
A helper class for sorting objects via a closure to return the field or operation on which to sort.
OrderExpression
Represents order by expression
OutParameter
A parameter to be returned from a CallableStatement.
OutputTool
Receives rendered documentation output and supporting resource copies.
OwnedMetaClass
An abstract delegating MetaClass that delegates calls to an owner object's MetaClass.
PackageHelper
Discovers classes and package entries from file systems, jars, and Groovy class loaders.
PackageNode
Represents a package in the AST.
PackageScope
Annotation used for turning off Groovy's auto visibility conventions.
PackageScopeASTTransformation
Handles transformation for the @PackageScope annotation.
PackageScopeTarget
Intended target when `@`PackageScope is placed at the class level.
PackedClosure
The shared `Closure` adapter family for `@PackedClosures` compact closure compilation.
PackedClosure.Fixed0
Fixed-arity members of the adapter family: the compiler instantiates the member matching the literal's declared parameter count (`PackedClosure.FixedN` serves higher arities), so a packed closure's arity is visible to class-level introspection exactly as on a generated closure class — notably `MetaClassHelper`'s SAM-overload disambiguation, which reflects the argument class's declared `doCall` and cannot consult the instance.
PackedClosure.Fixed1
PackedClosure.Fixed2
PackedClosure.Fixed3
PackedClosure.Fixed4
PackedClosure.FixedIt
The implicit-parameter literal (`{ it * 2 }`): a generated closure class declares both `doCall()` and `doCall(Object)` for it, which class-level introspection reads as the fuzzy "0 or 1" arity that lets the closure match both zero- and one-parameter SAM overloads (GROOVY-10905) — so this member declares the same pair.
PackedClosure.FixedN
Arities above four (rare) and vararg-shaped literals (trailing array parameter, e.g.
PackedClosureMetaClass
The stock metaclass for `PackedClosure`, giving packed closures their own MOP standing (the analog of `ClosureMetaClass` for generated closure classes, whose per-class metaclasses packed closures deliberately do not have).
PackedClosures
Opt-in for compact closure compilation: within the annotated class or method, an eligible closure literal's body is hoisted into a synthetic method on the enclosing class and the literal is replaced by a shared `PackedClosure` adapter, instead of generating one inner class per closure.
PackedClosures.PackMode
The packing behaviour of a `PackedClosures` scope.
PackStrategy
The compilation strategy the GEP-27 capability analysis selects for a closure literal: keep today's per-closure class, or pack the closure by hoisting its body to a method on the enclosing class behind a shared `PackedClosure` adapter.
Parallel
Runs each iteration of an annotated `for` loop in parallel using the current pool or default executor, with structured completion.
ParallelASTTransformation
Local AST transform for `Parallel`: rewrites annotated `for-in` loops into `collection.eachParallel { item -> body }`.
ParallelCollectionExtensions
DGM-like extension methods that add parallel collection operations to `Collection`.
ParallelScope
Convenience API for running work within a pool-isolated `AsyncScope`.
Parameter
Represents a parameter in a method or constructor declaration.
ParameterTypes
Manages parameter type information for methods and constructors, supporting lazy initialization.
ParameterUtils
Utility methods for working with method and constructor parameters.
ParserAtnManager
Manage ATN for parser to avoid memory leak
ParserException
Exception thrown when a parse error is encountered by the parser.
ParserPlugin
A simple extension point to allow us to switch between the classic Groovy parser and the new Antlr based parser(s).
ParserPluginFactory
A factory of parser plugin instances.
Partition<T>
Represents partition
Patch
Marks an interface method as an HTTP PATCH request.
PeepholeOptimizingClassVisitor
Class-level installation point for Groovy's single-pass bytecode peephole layer.
PeepholeOptimizingMethodVisitor
Single-pass, stack-local bytecode compaction for methods emitted by the Groovy class generator.
PerInstancePojoMetaClassSite
PermutationGenerator<E>
Systematically generate permutations.
Phases
Compilation phase identifiers.
PickAnyArgumentHint
Base class for hints which use the type of a parameter of the annotated method as the signature.
PickFirstResolver
Returns the first of several candidates found.
PlaceholderVisitor
Marks repeated underscore placeholders used in tuple and closure parameters.
PlainObjectMetaMethodSite
Plain ordinary object call site metaclass - cached method - cached
PlatformLineWriter
A buffered writer that gobbles any \r characters and replaces every \n with a platform specific newline.
PlatformLog
This local transform adds a logging ability to your program using java.logging.
PlatformLog.JavaUtilLoggingStrategy
This class contains the logic of how to weave a Java platform logger into the host class.
PluginDefaultGroovyMethods
Defines new Groovy methods which appear on normal JDK 10 classes inside the Groovy environment.
PluginDefaultGroovyMethods
Defines new Groovy methods which appear on standard Java 8 classes within the Groovy environment.
PluginDefaultGroovyMethods
Defines new Groovy methods which appear on normal JDK 9 classes inside the Groovy environment.
PogoGetPropertySite
PogoInterceptableSite
Call site for GroovyInterceptable
PogoMetaClassGetPropertySite
PogoMetaClassSite
PogoMetaMethodSite
POGO call site metaclass - cached method - cached
PogoMetaMethodSite.PogoCachedMethodSite
PogoMetaMethodSite.PogoCachedMethodSiteNoUnwrap
PogoMetaMethodSite.PogoCachedMethodSiteNoUnwrapNoCoerce
PogoMetaMethodSite.PogoMetaMethodSiteNoUnwrap
Call site where we know there is no need to unwrap arguments
PogoMetaMethodSite.PogoMetaMethodSiteNoUnwrapNoCoerce
Call site where we know there is no need neither unwrap nor coerce arguments
POJO
Marker interface to indicate that the normal GroovyObject methods should not be added.
PojoMetaClassGetPropertySite
PojoMetaClassSite
POJO call site metaclass - cached method - not cached
PojoMetaMethodSite
POJO call site metaclass - cached method - cached
PojoMetaMethodSite.PojoCachedMethodSite
PojoMetaMethodSite.PojoCachedMethodSiteNoUnwrap
PojoMetaMethodSite.PojoCachedMethodSiteNoUnwrapNoCoerce
PojoMetaMethodSite.PojoMetaMethodSiteNoUnwrap
Call site where we know there is no need to unwrap arguments
PojoMetaMethodSite.PojoMetaMethodSiteNoUnwrapNoCoerce
Call site where we know there is no need neither unwrap nor coerce arguments
PojoWrapper
Wraps a plain Java object and routes GroovyObject operations through a delegated `MetaClass`.
Pool
A managed thread pool for parallel and concurrent operations.
PositionConfigureUtils
Utilities for configuring node positions
PositionInfo
Post
Marks an interface method as an HTTP POST request.
PostCompletionFactory
A helper interface for factories which require post-processing of generated nodes.
Postcondition
Indicates that annotations being marked as `@Postcondition` are to be treated as post-condition modifying annotations.
Postcondition
A post-condition assertion.
PostconditionGenerator
Code generator for postconditions.
PostconditionLifecycle
Internal `Lifecycle` implementation for post-conditions.
PostconditionViolation
Thrown whenever a postcondition violation occurs.
PostfixExpression
Represents a postfix unary expression like `i++` or `value--`.
PowerAssertionError
Indicates that a power assertion has failed.
Precondition
Indicates that annotations being marked as `@Precondition` are to be treated as pre-condition modifying annotations.
Precondition
A pre-condition assertion.
PreconditionGenerator
Code generator for preconditions.
PreconditionLifecycle
Internal `Lifecycle` implementation for pre-conditions.
PreconditionViolation
Thrown whenever a precondition violation occurs.
Preferences
Container for shell preferences.
PrefixExpression
Represents a prefix unary expression like `++i` or `--value`.
PreLanguageRewriter
Post-process pass that retrofits syntax-highlighting classes onto bare `<pre>` blocks in generated HTML.
PrimitiveHelper
ProcessExpression
Represents process expression, e.g.
ProcessGroovyMethods
This class defines new groovy methods which appear on normal JDK classes related to process management.
ProcessGroovyMethods.ProcessRunner
A Runnable which waits for a process to complete together with a notification scheme allowing another thread to wait a maximum number of seconds for the process to complete before killing it.
ProcessingContextInformation
Holds all context-specific information which is needed during the transformation phase of a single `Contract` and its related `ClassNode`.
ProcessingUnit
A base class for data structures that can collect messages and errors during processing.
ProcessResult
Captures the result of executing an external process, including the standard output, standard error, and exit code.
PropertiesModuleFactory
This is the base class for classes responsible for creating modules using properties.
PropertyAccessInterceptor
An interface that adds the ability to intercept property getters/setters
PropertyAccessor
Strategy for reading and writing named properties.
PropertyBinding
Binds directly to a bean property and can act as a source, target, or trigger binding.
PropertyBinding.UpdateStrategy
Defines the thread on which target updates should run.
PropertyChangeProxyTargetBinding
Adapts a `PropertyChangeListener` so it can be used as a `TargetBinding`.
PropertyExpression
Represents a property access such as the expression "foo.bar".
PropertyHandler
Used to provide custom property handling when getting, setting or initializing properties.
PropertyModel
Exposes a named property of another `ValueModel` as its own value model.
PropertyNode
Represents a property (member variable, a getter and setter)
PropertyNodeUtils
PropertyOptions
Marker annotation used to indicate that special property handling code will be generated for this class.
PropertyPathFullBinding
A full binding that watches an entire property path rather than a single observable bean property.
PropertyReader
Strategy for reading a named property from an object.
PropertyValue
A mutable view of a bean property value.
PropertyWriter
Strategy for writing a named property on an object.
Proxy
Dynamic groovy proxy for another object.
ProxyGenerator
Generates 'Proxy' objects which implement interfaces, maps of closures and/or extend classes/delegates.
ProxyGeneratorAdapter
A proxy generator responsible for mapping a map of closures to a class implementing a list of interfaces.
ProxyMetaClass
As subclass of MetaClass, ProxyMetaClass manages calls from Groovy Objects to POJOs.
Pure
Marks the return value of "pure" method only comes from expressions involving constants or other pure methods.
Put
Marks an interface method as an HTTP PUT request.
QName
`QName` class represents the value of a qualified name as specified in XML Schema Part2: Datatypes specification.
Query
Marks a method parameter as an HTTP query parameter.
Queryable<T>
Represents the queryable objects, e.g.
Queryable.Order<T,U extends Comparable<? super U>>
Represents an order rule
Range<T extends Comparable>
A Range represents the list of discrete items between some starting (or `from`) value and working up towards some ending (or `to`) value.
RangeExpression
Represents a range expression for creating range objects with bounded endpoints.
RangeExpressionTransformer
This transformer focuses on ranges to produce optimized bytecode.
RangeInfo
Holds information about a range, including its boundaries and direction.
RawJavaFileObject
Represents a Java source file in file to compile
ReactorAwaitableAdapter
Adapter for Project Reactor types, enabling: `await mono` — awaits a single-value `Mono` `for await (item in flux)` — iterates over a `Flux`
ReactorHandler<T,R>
Context-aware handler for reactor actors.
ReaderCharacterSource
Buffered `CharacterSource` implementation backed by a `Reader`.
ReaderSource
An interface for things that can supply (and potentially resupply) a Reader on a source stream.
ReadException
Exception that wraps I/O exceptions (`IOException`) in a Groovy-specific context.
ReadOnlyPropertyException
This exception is thrown if an attempt is made to set a read-only property.
ReadWriteLockASTTransformation
Handles generation of code for the `@`WithReadLock and `@`WithWriteLock annotation.
This transformation adds an instance of ReentrantReadWriteLock to the class.
Any method annotated with `@`WithReadLock will obtain a read lock and release it in a finally block.
Any method annotated with `@`WithWriteLock will obtain a write lock and release it in a finally block.
For more information see `WithReadLock` and `WithWriteLock`
Realm
A Realm is the representation of a metaclass layer in a tree of realm objects.
Receiver<T>
Describes a method-call receiver together with optional auxiliary data.
RecordBase
Class annotation used to assist in the creation of record-like classes.
RecordBaseASTStubber
Joint-compilation stubber for `RecordBase`.
RecordCompletionASTTransformation
Handles completion of code for the @RecordType annotation.
RecordComponentNode
Represents a component (field) of a record class definition introduced in Java 16.
RecordOptions
Class annotation used to assist in the creation of record-like classes.
RecordTypeASTTransformation
Handles generation of code for the @RecordType annotation.
RecordTypeMode
Intended mode to use for records when using the `@RecordType` annotation (or `record` keyword).
RecoveringDescriptiveErrorStrategy
Recovering parser error strategy with the same friendly diagnostics as `DescriptiveErrorStrategy`.
RecursionVariantViolation
Thrown when a method-level `Decreases` recursion termination measure fails — either a recursive re-entry did not strictly decrease the measure, or the measure became negative (not well-founded).
RecursivenessTester
Test if a method call is recursive if called within a given method node.
Reducer
Declares that a two-argument combining method is associative and has an identity element — together, the algebraic contract a seeded parallel reduction relies on.
Reduction
A syntax reduction produced by the Parser during syntactic analysis.
ReevaluatingReference<T>
This class represents a reference to the most actual incarnation of a Metaclass.
Reference<T>
Represents a reference to a value
Reference<T,V extends Finalizable>
Abstraction over reference implementations that keep a cleanup handler alongside the referent.
ReferenceBundle
Couples a `ReferenceType` with the `ReferenceManager` responsible for processing it.
ReferenceManager
Coordinates cleanup of managed references using idling, callback-driven, or threaded processing.
ReferenceType
Supported reference implementations for managed references.
ReflectionCache
Central registry for obtaining cached class information.
ReflectionMetaMethod
A MetaMethod implementation that wraps a reflection-based method call.
ReflectionMethodInvoker
Utility class to call methods through reflection, and falls through using the `Invoker` to call the method if it fails.
ReflectionUtils
This class contains utility methods to determine which class called the current class to multiple levels of depth.
Reflector
Provides as alternative to reflection using bytecode generation.
ReflectorLoader
Deprecated, for removal: This API element is subject to removal in a future version.
No production callers remain; kept only for binary compatibility.
RegexGuard
Deadline-guarded regular expression evaluation, protecting against Regular Expression Denial of Service (ReDoS) when patterns or inputs come from untrusted sources.
RegexSupport
Used to store the last regex match.
RegexTimeoutException
Thrown when a regular expression evaluation guarded by `RegexGuard` exceeds its configured deadline.
ReleaseInfo
Exposes the Groovy release information
ReplacementNode
Helper base class used for lazy updates.
Requires
Represents a method precondition.
RequiresAnnotationProcessor
Internal `AnnotationProcessor` implementation for pre-conditions.
RequiresConditions
Container annotation for multiple `Requires` preconditions on the same target.
ResolveVisitor
Visitor to resolve types and convert VariableExpression to ClassExpressions if needed.
ResourceConnector
Base interface for customizing where resources can be found for the `GroovyScriptEngine`.
ResourceException
Indicates a problem loading or accessing a resource.
ResourceGroovyMethods
This class defines new groovy methods for Files, URLs, URIs which appear on normal JDK classes inside the Groovy environment.
ResourceManager
Provides character streams for documentation templates and related resources.
ResultSetMetaDataWrapper
This class defines a wrapper for accessing a specific column in `ResultSetMetaData`.
ResultSetOutParameter
A ResultSet out parameter.
ReturnAdder
Utility class to add return statements.
ReturnAdder.ReturnStatementListener
Listener notified when a synthetic return statement is created.
ReturnAdderForClosures
Adds explicit return statements to implicit return points in a closure.
ReturnStatement
Represents a return statement that terminates a method and optionally returns a value.
ReturnStatementToIterationConverter
Translates all return statements into an invocation of the next iteration.
ReversedList<E>
Represents view of reversed list
ReverseListIterator<T>
A reverse iterator over a list.
RootLoader
This ClassLoader should be used as root of class loaders.
RootLoaderRef
Sets the RootLoader as reference.
RowBound
Represents row bounds of window frame
RuntimeParserException
A runtime exception wrapper for parser errors, allowing parser exceptions to be thrown from contexts that cannot throw checked exceptions.
RxJavaAwaitableAdapter
Adapter for RxJava 3 types, enabling: `await single` — awaits a `Single` `await maybe` — awaits a `Maybe` (nullable result) `await completable` — awaits a `Completable` `for await (item in observable)` — iterates over an `Observable` `for await (item in flowable)` — iterates over a `Flowable`
SafeRegex
Guards the regex operators within the annotated scope against Regular Expression Denial of Service (ReDoS).
SafeRegexASTTransformation
Handles transformation for the @SafeRegex annotation: rewrites the regex operators within the annotated scope to deadline-guarded `RegexGuard` calls.
SAXBuilder
A builder for generating W3C SAX events.
ScopedLocal<T>
A thread-scoped value holder that abstracts over `ThreadLocal` (JDK < 25) and `java.lang.ScopedValue` (JDK 25+), presenting a unified API modelled after `ScopedValue`.
ScopedLocal.Carrier
An immutable set of scoped-local bindings that can be applied atomically for the duration of a `Runnable` or `Supplier`.
Script
This object represents a Groovy script
ScriptBytecodeAdapter
A static helper class to interface bytecode and runtime
ScriptException
Indicates an error while processing a script.
ScriptExtensions
This class defines new Java 6 specific groovy methods which extend the normal JDK classes inside the Groovy environment.
ScriptReference
Represents a reference to a variable in a script
ScriptRunner
The tool to simulate running script files via groovy command
ScriptStaticExtensions
This class defines new Java 6 specific static groovy methods which extend the normal JDK classes inside the Groovy environment.
ScriptTestAdapter
An adapter to make any Groovy Script class an instance of a JUnit Test
Sealed
Class annotation used to assist in the creation of sealed classes.
SealedASTTransformation
Handles generation of code for the @Sealed annotation.
SealedCompletionASTTransformation
Handles sealed class permitted subclass detection.
SealedMode
Intended mode to use for sealed classes when using the `@Sealed` annotation (or `sealed` keyword).
SealedOptions
Class annotation used to assist in the creation of sealed classes.
SecondParam
A hint used to instruct the type checker to pick the second parameter type.
SecondParam.Component
A hint used to instruct the type checker to pick the type of the component of the second parameter type, which is therefore expected to be an array, like in this example:
SecondParam.FirstGenericType
A hint used to instruct the type checker to pick the first generic type of the second parameter type.
SecondParam.SecondGenericType
A hint used to instruct the type checker to pick the second generic type of the second parameter type.
SecondParam.ThirdGenericType
A hint used to instruct the type checker to pick the second generic type of the second parameter type.
SecureASTCustomizer
Restricts the grammar available to the source being compiled, so that a shell or domain specific language (DSL) offers only a chosen subset of the Groovy language.
SecureASTCustomizer.ExpressionChecker
This interface allows the user to provide a custom expression checker if the dis/allowed expression lists are not sufficient
SecureASTCustomizer.StatementChecker
This interface allows the user to provide a custom statement checker if the dis/allowed statement lists are not sufficient
SecureASTCustomizerFactory
This factory allows the generation of a `SecureASTCustomizer`.
SelectClaim
The single-winner state of one selection: the arbiter through which a group of competing offers (the branches of a `ChannelSelect`, or a lone channel operation) commits exactly one outcome between them.
SelectExpression
Represents the select expression
Selector
Base state holder for invokedynamic method, property, constructor, and cast selection.
SelfType
This annotation can be added on a trait to declare the list of types that a class implementing that trait is supposed to extend.
SemanticPredicates
Some semantic predicates for altering the behaviour of the lexer and parser
Sequence
Represents a sequence of zero or more objects of a given type.
SerializeOptions
Options for controlling XML serialization via `XmlUtil.serialize(org.w3c.dom.Element)`.
ServletBinding
Servlet-specific binding extension to lazy load the writer or the output stream from the response.
ServletCategory
Servlet support.
SetOperationExpression
Represents a set operation (union, unionall, intersect, minus) combining two GINQ expressions.
SharedVariableCollector
A visitor which collects the list of variable expressions which are closure shared.
ShortArrayGetAtMetaMethod
ShortArrayIterator
Allows a short array to be used where an Iterator is expected.
ShortArrayPutAtMetaMethod
ShortCachedClass
Provides optimized reflection caching for `short` and `Short`.
ShortTypeHandling
High-performance type casting and conversion utilities.
ShortWrapper
Wrapper for `short` values that preserves the primitive constrained type.
ShutdownExpression
Represent the shutdown expression
SignatureCodec
A signature codec is responsible for encoding and decoding of inferred returned types as stored in bytecode.
SignatureCodecVersion1
First implementation of an inferred type signature codec.
SimpleCache<K,V>
Thin adapter that exposes `CommonCache` through the internal `Cache` API.
SimpleExtensionModule
An extension module which provides extension methods using a `DefaultGroovyMethods`-like implementation, that is to say using static methods defined in an "extension class".
SimpleGroovyAbstractableElementDoc
Base implementation for documented elements that can carry the `abstract` modifier.
SimpleGroovyAnnotationRef
Default `GroovyAnnotationRef` implementation backed by parsed source text.
SimpleGroovyClassDoc
Default `GroovyClassDoc` implementation for classes parsed from Groovy or Java source.
SimpleGroovyConstructorDoc
Default `GroovyConstructorDoc` implementation.
SimpleGroovyDoc
Base implementation of the `GroovyDoc` contract.
SimpleGroovyExecutableMemberDoc
Base implementation for executable members such as methods and constructors.
SimpleGroovyFieldDoc
Default `GroovyFieldDoc` implementation.
SimpleGroovyMemberDoc
Base implementation for documented members declared within a class.
SimpleGroovyMethodDoc
Default `GroovyMethodDoc` implementation.
SimpleGroovyPackageDoc
Default `GroovyPackageDoc` implementation.
SimpleGroovyParameter
Default `GroovyParameter` implementation.
SimpleGroovyProgramElementDoc
Base implementation for documented program elements with modifiers, package ownership, and annotations.
SimpleGroovyRootDoc
Default `GroovyRootDoc` implementation used to collect packages, classes, and lookup caches.
SimpleGroovyTag
Stores info about GroovyDoc tags.
SimpleGroovyType
Simple immutable `GroovyType` implementation backed by a type name string.
SimpleMessage
A base class for compilation messages.
SimpleStrategy
This strategy is used with the `Builder` AST transform to modify your Groovy objects so that the setter methods for properties return the original object, thus allowing chained usage of the setters.
SimpleTemplateEngine
Processes template source files substituting variables and expressions into placeholders in a template source text to produce the desired output.
SimpleType
Hint that resolves closure parameter types directly from option class names.
SingleQuoteFilter
Escapes single quotes for XML attribute output.
SingleSignatureClosureHint
A simplified version of a `ClosureSignatureHint` which is suitable for monomorphic closures, that is to say closures which only respond to a single signature.
Singleton
Class annotation to make a singleton class.
SingletonASTStubber
Joint-compilation stubber for `Singleton`.
SingletonASTTransformation
Handles generation of code for the @Singleton annotation
Slf4j
This local transform adds a logging ability to your program using LogBack logging.
Slf4j.Slf4jLoggingStrategy
Logging strategy for SLF4J.
SmartDocumentFilter
The document filter based on Parrot's lexer is for highlighting the content of text editor
SocketGroovyMethods
This class defines new groovy methods for Sockets which enhance JDK classes inside the Groovy environment.
Sortable
A class annotation used to make a class Comparable by (potentially) multiple Comparators.
SortableASTStubber
Adds a minimal `Comparable` surface for `Sortable` classes in an earlier phase so joint compilation can evolve independently from full Sortable codegen.
SortableASTTransformation
Injects a set of Comparators and sort methods.
SourceAwareCustomizer
A base class for customizers which only have to be applied on specific source units.
SourceAwareCustomizerFactory
Factory for use with `CompilerCustomizationBuilder`.
SourceAwareCustomizerFactory.SourceOptions
Collected builder options used to create a `SourceAwareCustomizer`.
SourceBinding
Supplies values from the source side of a binding.
SourceExtensionHandler
Looks for source file extensions in META-INF/services/org.codehaus.groovy.source.Extensions
SourceText
Provides the source text for an assertion statement and translates coordinates in the original source text to coordinates relative to the assertion's (normalized) source text.
SourceTextNotAvailableException
Indicates that the source text for an assertion statement is not available.
SourceUnit
Provides an anchor for a single source unit (usually a script file) as it passes through the compiler system.
SourceURI
Variable annotation used for getting the URI of the current script.
SourceURIASTTransformation
Handles transformation for the @SourceURI annotation.
SpreadExpression
Represents a spread expression *x in the list expression [1, *x, 2].
SpreadListEvaluatingException
Thrown when evaluating a spread list expression fails.
SpreadMap
Helper to turn a list with an even number of elements into a Map.
SpreadMapEvaluatingException
Thrown when evaluating a spread map expression fails.
SpreadMapExpression
Represents a spread map expression *:m in the map expression [1, *:m, 2, "c":100] or in the method invoke expression func(1, *:m, 2, "c":100).
Sql
A facade over Java's normal JDBC APIs providing greatly simplified resource management and result set handling.
SqlExtensions
This class defines all the new SQL-related groovy methods which enhance the normal JDK SQL classes when inside the Groovy environment.
SqlOrderByVisitor
Derives an SQL `ORDER BY` fragment from a simple sort closure, used by `DataSet`.
SqlWhereVisitor
AST visitor used by `DataSet` to derive an SQL `WHERE` clause and positional parameter list from a supported filter closure.
SqlWithParams
Holds an SQL string together with the positional parameters that should be bound to it.
StackTraceUtils
Originally was grails.utils.GrailsUtils, removed some grails specific stuff.
StampedCommonCache<K,V>
Represents a simple key-value cache, which is thread safe and backed by a `Map` instance.
StandardControlToUndefined
Replaces XML-disallowed control characters with `U+FFFD`.
StandardPropertiesModuleFactory
This is the standard Groovy module factory.
StandardXmlAttributeFilter
Escapes XML attribute characters that must be written as numeric entities.
StandardXmlFilter
Escapes the standard XML text markup characters.
StatefulHandler<S,T>
Context-aware handler for stateful actors.
Statement
Base class for all statement nodes in the Groovy AST.
StatementMetaTypeChooser
A `TypeChooser` which is aware of statement metadata.
StatementReplacer
Tool for replacing Statement objects in an AST by other Statement instances.
StatementWriter
Generates bytecode for Groovy statements by visiting AST statement nodes and emitting corresponding JVM instructions via the `WriterController`.
StaticCompilationMetadataKeys
Static compilation AST node metadata keys.
StaticCompilationMopWriter
A MOP Writer that skips the generation of MOP methods.
StaticCompilationTransformer
Some expressions use symbols as aliases to method calls (<<, +=, ...).
StaticCompilationVisitor
This visitor is responsible for amending the AST with static compilation metadata or transform the AST so that a class or a method can be statically compiled.
StaticCompileTransformation
Handles the implementation of the `CompileStatic` transformation.
StaticImportVisitor
Visitor to resolve constants and method calls from static imports.
StaticInvocationWriter
Invocation writer for statically compiled code paths.
StaticMetaClassSite
Call site for invoking static methods metaclass - cached method - not cached
StaticMetaMethodSite
POJO call site metaclass - cached method - cached
StaticMetaMethodSite.StaticMetaMethodSiteNoUnwrap
Call site where we know there is no need to unwrap arguments
StaticMetaMethodSite.StaticMetaMethodSiteNoUnwrapNoCoerce
Call site where we know there is no need neither unwrap nor coerce arguments
StaticMethodCallExpression
A static method call on a class
StaticPropertyAccessHelper
Facilitates the generation of statically-compiled bytecode for property access.
StaticTypeCheckingSupport
Support methods for `StaticTypeCheckingVisitor`.
StaticTypeCheckingSupport.BooleanArrayStaticTypesHelper
DGM-like helpers for `boolean[]` access.
StaticTypeCheckingSupport.ByteArrayStaticTypesHelper
DGM-like helpers for `byte[]` access.
StaticTypeCheckingSupport.CharArrayStaticTypesHelper
DGM-like helpers for `char[]` access.
StaticTypeCheckingSupport.DoubleArrayStaticTypesHelper
DGM-like helpers for `double[]` access.
StaticTypeCheckingSupport.FloatArrayStaticTypesHelper
DGM-like helpers for `float[]` access.
StaticTypeCheckingSupport.IntArrayStaticTypesHelper
DGM-like helpers for `int[]` access.
StaticTypeCheckingSupport.LongArrayStaticTypesHelper
DGM-like helpers for `long[]` access.
StaticTypeCheckingSupport.ObjectArrayStaticTypesHelper
DGM-like helpers for object arrays.
StaticTypeCheckingSupport.ShortArrayStaticTypesHelper
DGM-like helpers for `short[]` access.
StaticTypeCheckingVisitor
The main class code visitor responsible for static type checking.
StaticTypeCheckingVisitor.SignatureCodecFactory
Creates signature codecs for serialized type checking metadata.
StaticTypesBinaryExpressionMultiTypeDispatcher
A specialized version of the multi type binary expression dispatcher which is aware of static compilation.
StaticTypesCallSiteWriter
A call site writer which replaces call site caching with static calls.
StaticTypesClosureWriter
Writer responsible for generating closure classes in statically compiled mode.
StaticTypesLambdaWriter
Writer responsible for generating lambda classes in statically compiled mode.
StaticTypesMarker
This enumeration is used by the AST transformations which rely on static type checking, either to store or to retrieve information from AST node metadata.
StaticTypesMethodReferenceExpressionWriter
Generates bytecode for method reference expressions in statically-compiled code.
StaticTypesStatementWriter
A class to write out the optimized statements.
StaticTypesSwitchExpressionWriter
Static-compilation writer for `SwitchExpression`.
StaticTypesTransformation
Handles the implementation of the `TypeChecked` transformation.
StaticTypesTypeChooser
A `TypeChooser` which reads type information from node metadata generated by the static type checker.
StaticTypesUnaryExpressionHelper
An expression helper which generates optimized bytecode depending on the current type on top of the operand stack.
StaticTypesWriterController
An alternative `WriterController` which handles static types and method dispatch.
StaticTypesWriterControllerFactoryImpl
Factory that wraps the standard writer controller with static-compilation behavior.
StaticVerifier
Checks for dynamic variables in static contexts.
StreamGroovyMethods
StreamingJsonBuilder
A builder for creating JSON payloads.
StreamingJsonBuilder.StreamingJsonDelegate
The delegate used when invoking closures
StreamingMarkupWriter
Writer used by streaming markup support to escape XML lazily while honoring output encoding limits.
StreamingTemplateEngine
Processes template source files substituting variables and expressions into placeholders in a template source text to produce the desired output using a closure based approach.
StringBufferWriter
This class codes around a silly limitation of StringWriter which doesn't allow a StringBuffer to be passed in as a constructor for some bizarre reason.
StringBuilderWriter
Copied from https://github.com/apache/commons-io/blob/master/src/main/java/org/apache/commons/io/output/StringBuilderWriter.java
StringCachedClass
Provides optimized reflection caching for `String`.
StringEscapeUtils
Escapes and unescapes `String`s for Java, Java Script, HTML, XML, and SQL.
StringGroovyMethods
This class defines new groovy methods which appear on String-related JDK classes (String, CharSequence, Matcher) inside the Groovy environment.
StringHelper
String utility methods used by Groovy command-line tooling.
StringReaderSource
A ReaderSource for source strings.
StringSetMap
Map from string keys to lazily created sets of strings.
StringUtils
Utilities for handling strings
StringWriterIOException
An IO exception occurred trying to append to a StringWriter which should never happen.
StructuredSyntaxDocumentFilter
Document filter that applies regex-driven syntax highlighting to styled text.
StructuredSyntaxHandler
SAX handler that reads structured syntax definitions into a document filter.
StructuredSyntaxResources
Contains all the basic resources and values used by the utility framework.
StubberSupport
Utilities for GEP-21 Shape C joint-compilation stubbers.
Supplier<T>
Backport of Java8 Supplier.
SurrogateToUndefined
Replaces surrogate characters that cannot be emitted directly with `U+FFFD`.
SwingExtensions
This class defines all the new Swing-related groovy methods which enhance the normal JDK Swing classes when inside the Groovy environment.
SwingTimerTriggerBinding
Creates bindings driven by a Swing timer.
SwitchExpression
Represents a `switch` used as an expression, as specified by JEP 361 (Switch Expressions).
SwitchExpressionUtils
Shared classification of switch-expression labels for static compilation.
SwitchExpressionWriter
Emits JVM bytecode for a `SwitchExpression`.
SwitchPointInvalidator
Lazily allocates a `SwitchPoint` and retires it on demand.
SwitchStatement
Represents a switch (object) { case value: ...
Synchronized
Method annotation to make a method call synchronized for concurrency handling with some useful baked-in conventions.
SynchronizedASTTransformation
Handles generation of code for the `@Synchronized` annotation.
SynchronizedStatement
Represents a synchronized statement that provides mutual exclusion for a code block.
SyntaxErrorMessage
A class for error messages produced by the parser system.
SyntaxErrorReportable
Supports reporting the syntax error of GINQ
SyntaxErrorReportable
A SyntaxErrorReportable is a recognizer that can report syntax error
SyntaxException
Base exception class indicating a syntax error detected during parsing.
SystemOutputInterceptor
Intercepts System.out/System.err.
SystemUtil
Utility methods for interacting with system properties in a safe manner.
TableLayout
A lightweight container that arranges children using table-like row and cell semantics.
TableLayoutCell
Represents a cell in a table layout.
TableLayoutRow
Represents a single row in a `TableLayout`.
TableMap
In a chain of data manipulators some behaviour is common.
TableSorter
A sorter for TableModels.
TailRecursive
Method annotation used to transform methods with tail recursive calls into iterative methods automagically since the JVM cannot do this itself.
TailRecursiveASTTransformation
Handles generation of code for the @TailRecursive annotation.
TargetBinding
Receives values on the target side of a binding.
Template
A template is a block of text with an associated binding that can be output to a writer or evaluated to a string.
TemplateConfiguration
Configuration options for the `markup template engine`.
TemplateEngine
A template engine is a factory for creating a Template instance for a given text input.
TemplateExecutionException
A custom exception class to flag template execution errors
TemplateParseException
A custom exception class to flag template parsing errors
TemplateResolver
Interface for template resolvers, which, given a template identifier, return a URL where the template can be loaded.
TemplateServlet
A generic servlet for serving (mostly HTML) templates.
TemporaryMethodKey
A temporary implementation of MethodKey used to perform a fast lookup for a method using a set of arguments to a method
TemporaryVariableExpression
A front-end class for `ExpressionAsVariableSlot` which allows defining temporary variables loaded from variable slots directly at the AST level, without any knowledge of `AsmClassGenerator`.
TernaryExpression
Represents a ternary expression (booleanExpression) ? expression : expression
TernaryToIfStatementConverter
Since a ternary statement has more than one exit point tail-recursiveness testing cannot be easily done.
TestNgRunner
Integration code for running TestNG tests in Groovy.
TextEditor
A simple text pane that is printable and wrapping is optional.
TextUndoManager
To use this, simply drop this as an UndoableEditListener into your document, and then create actions to call undo/redo as needed (checking can undo/redo first, of course).
ThirdParam
A hint used to instruct the type checker to pick the third parameter type.
ThirdParam.Component
A hint used to instruct the type checker to pick the type of the component of the third parameter type, which is therefore expected to be an array, like in this example:
ThirdParam.FirstGenericType
A hint used to instruct the type checker to pick the first generic type of the third parameter type.
ThirdParam.SecondGenericType
A hint used to instruct the type checker to pick the second generic type of the third parameter type.
ThirdParam.ThirdGenericType
A hint used to instruct the type checker to pick the second generic type of the third parameter type.
ThreadHelper
Helper for starting threads that prefers virtual threads when running on Java 21+, falling back to platform threads on older runtimes.
ThreadManagedMetaBeanProperty
This MetaBeanProperty will create a pseudo property whose value is bound to an object using weak references.
ThrowsIf
Represents a method's exceptional contract: the method throws the given exception when the given condition holds on entry.
ThrowsIfASTTransformation
Handles a method's `ThrowsIf` arm-set.
ThrowsIfConditions
Container annotation for multiple `ThrowsIf` arms on the same target.
ThrowsIfSupport
Runtime support for `checked` `@ThrowsIf` arm-sets (invoked from generated code; not intended to be called by user code).
ThrowsIfViolation
Thrown whenever a `@ThrowsIf` exceptional-contract violation is detected by a `checked` arm-set: the method returned normally although a must-throw condition held, or threw a matching exception although no arm's condition held (the latter checked only for `exhaustive` arm-sets).
ThrowStatement
Represents a throw statement that raises an exception.
TimeCategory
Deprecated.
Use one of the quirk-free replacements instead: `org.apache.groovy.datetime.TimeCategory` (produces `java.time` types) or `org.apache.groovy.dateutil.TimeCategory` (produces `java.util.Date`).
TimeCategory
A `java.time`-based DSL for convenient date/time manipulation, the modern counterpart to the legacy `groovy.time.TimeCategory`.
TimeCategory
A dequirked, `java.util.Date`-flavored parallel to the legacy `groovy.time.TimeCategory`.
TimeCategory.From
Helper returned by `TimeCategory.getFrom(java.time.Duration)`, supporting the `.now` / `.today` suffix.
Timed<T>
An immutable holder for the outcome of a timed execution: the value produced together with the elapsed time in nanoseconds.
TimeDatumDependentDuration
Deprecated.
Superseded by `org.apache.groovy.dateutil.TimeDatumDependentDuration` (the dequirked `java.util.Date` flavor) or the `java.time` DSL in `org.apache.groovy.datetime.TimeCategory`.
TimeDatumDependentDuration
The result of mixing a `TimeDuration` with a `DatumDependentDuration`.
TimeDuration
Deprecated.
Superseded by `org.apache.groovy.dateutil.TimeDuration` (the dequirked `java.util.Date` flavor) or `java.time.Duration`.
TimeDuration
A time period in hours, minutes, seconds and milliseconds (optionally with days).
Timeout
Overrides the request timeout for a specific method in an `HttpBuilderClient` interface.
Token
A `CSTNode` produced by the Lexer during lexical analysis.
TokenException
Exception thrown when a token-related error is encountered during parsing.
TokenMismatchException
Exception thrown when a parser encounters a token of an unexpected type.
TokenUtil
Utility methods for working with tokens and operators.
TomlBuilder
A builder for creating TOML payloads.
TomlConverter
Converts between TOML and JSON text representations.
TomlRuntimeException
Represents a runtime exception raised while parsing or building TOML.
TomlSlurper
Represents a TOML parser
TooManyValuesException
Thrown when too many values returned by sub-query in the `select` clause
ToString
Class annotation used to assist in the creation of `toString()` methods in classes.
ToStringASTStubber
Joint-compilation stubber for `ToString`.
ToStringASTTransformation
Handles generation of code for the @ToString annotation.
TracingInterceptor
This `Interceptor` traces method calls on the proxied object to a log.
Trait
Used to mark a class as being a trait.
TraitASTTransformation
Handles generation of code for the traits (trait keyword is equivalent to using the @Trait annotation).
TraitComposer
This class contains a static utility method `TraitComposer.doExtendTraits(org.codehaus.groovy.ast.ClassNode, org.codehaus.groovy.control.SourceUnit, org.codehaus.groovy.control.CompilationUnit)` aimed at generating code for a classnode implementing a trait.
Traits
A collection of utility methods used to deal with traits.
Traits.Implemented
Internal annotation used to indicate which methods in a trait interface have a default implementation.
Traits.TraitBridge
Internal annotation used to indicate that a method is a bridge method to a trait default implementation.
TraitTypeCheckingExtension
An extension that handles field, super and static method calls within a trait.
TransformingCodeVisitor
Code visitor that combines depth-first traversal with expression transformation, delegating both to an underlying `ClassCodeExpressionTransformer`.
TransformMetaMethod
A MetaMethod implementation useful for implementing coercion based invocations.
TransformWithPriority
AST transforms may optionally implement this interface and return a priority value.
TreeContext
Holds the current AST node together with its traversal context.
TreeContextAction
Callback invoked when a `TreeContext` is popped.
TriConsumer<A,B,C>
A `Consumer` of three input arguments — the three-argument cousin of `BiConsumer` that `java.util.function` itself does not provide.
TriggerBinding
Creates a `FullBinding` that reacts to changes from a triggering source.
TryCatchBlockGenerator
Creates a try-catch block around a given `AssertStatement` and catches a PowerAssertionError to reuse the generated visual output.
TryCatchStatement
Represents a try { ...
TryWithResourcesASTTransformation
Transform try-with-resources to try-catch-finally Reference JLS "14.20.3.
Tuple<E>
Represents a list of Objects.
Tuple0
Represents a list of 0 typed Object.
Tuple1<T1>
Represents a list of 1 typed Object.
Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
Represents a list of 10 typed Objects.
Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>
Represents a list of 10 typed Objects.
Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>
Represents a list of 12 typed Objects.
Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>
Represents a list of 13 typed Objects.
Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>
Represents a list of 14 typed Objects.
Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>
Represents a list of 15 typed Objects.
Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
Represents a list of 16 typed Objects.
Tuple2<T1,T2>
Represents a list of 2 typed Objects.
Tuple3<T1,T2,T3>
Represents a list of 3 typed Objects.
Tuple4<T1,T2,T3,T4>
Represents a list of 4 typed Objects.
Tuple5<T1,T2,T3,T4,T5>
Represents a list of 5 typed Objects.
Tuple6<T1,T2,T3,T4,T5,T6>
Represents a list of 6 typed Objects.
Tuple7<T1,T2,T3,T4,T5,T6,T7>
Represents a list of 7 typed Objects.
Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>
Represents a list of 8 typed Objects.
Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9>
Represents a list of 9 typed Objects.
TupleConstructor
Class annotation used to assist in the creation of tuple constructors in classes.
TupleConstructorASTStubber
Adds a placeholder tuple-style constructor surface for `TupleConstructor` classes during joint compilation.
TupleConstructorASTTransformation
Handles generation of code for the @TupleConstructor annotation.
TupleConstructorASTTransformation.SelectedTupleProperties
Result of `TupleConstructorASTTransformation.selectTupleProperties(org.codehaus.groovy.transform.AbstractASTTransformation, org.codehaus.groovy.ast.ClassNode, org.codehaus.groovy.ast.AnnotationNode)`: the super-class properties and self properties that pass the annotation's filters (includes / excludes / allNames / includeProperties / includeFields / includeSuperProperties / includeSuperFields / allProperties).
TupleExpression
Represents a tuple or grouped list of expressions, typically used for method arguments, multiple assignment targets, or other contexts requiring multiple values.
Type
Token classifications used by the lazy JSON parser.
TypeChecked
This will let the Groovy compiler use compile time checks in the style of Java.
TypeChecked.TypeCheckingInfo
This annotation is added by @TypeChecked on methods which have type checking turned on.
TypeCheckingContext
Holds mutable state shared across a static type-checking visit.
TypeCheckingContext.EnclosingClosure
Represents the context of an enclosing closure.
TypeCheckingExtension
This interface defines a high-level API for handling type checking errors.
TypeCheckingMode
This enumeration can be used whenever it is preferred to annotate a class as `TypeChecked` in general, but where only one or more methods are "dynamic".
TypeChooser
Interface for modules which are capable of resolving the type of an expression.
TypedOption<T>
Map-backed command-line option metadata with a typed default value.
TypeHelper
This class contains helper methods for converting and comparing types.
Types
Registry of token type constants and type hierarchy definitions for the concrete syntax tree (CST) system.
TypeTransformers
This class contains several transformers for used during method invocation.
TypeUseUtils
Classification of a `ClassNode` as a type use (JLS 4.5, 4.7, 4.8).
TypeUtil
A utility for getting information of types
UberCompileTask
Compiles Java and Groovy source files.
UnaryExpressionHelper
A helper class used to generate bytecode for unary expressions.
UnaryMinusExpression
UnaryPlusExpression
UncheckedThrow
Allows to throw a checked exception unchecked.
Undefined
Java doesn't allow you to have null as an attribute value.
Undefined.CLASS
Sentinel type used when an annotation member has no explicit class value.
Undefined.EXCEPTION
Sentinel exception type used when an annotation member has no explicit exception value.
UnicodeConst
UnlimitedConcurrentCache<K,V>
A cache backed by a ConcurrentHashMap
Unparsed
Indicates that a method or property will contain the remaining arguments.
URLReaderSource
A ReaderSource for source files hosted at a URL.
URLStreams
Utilities for opening URL connections and reading last-modified times with Groovy-specific defaults.
UsedVariableTracker
Tracks replacement variables that are actually used while rewriting expressions.
Utilities
Various utility functions for use in the compiler.
Validate
Internal utility class for in-code assertion checks.
Value
Represents a lazily decoded JSON token or container managed by the index-overlay parser.
Value
A value recorded during evaluation of an assertion, along with the column it is associated with in the assertion's normalized source text.
ValueBound<U extends Comparable<? super U>>
Represents value bounds of window frame
ValueContainer
Simple `Value` wrapper for literals and already-hydrated JSON containers.
ValueConvertable<V1,V2>
To support caches whose values are convertable, e.g.
ValueHolder
A mutable `ValueModel` implementation that stores a local value and optionally emits change events.
ValueList
List implementation that lazily converts overlay `Value` instances on access.
ValueMap<K,V>
Map contract used by the lazy JSON object implementations.
ValueMapImpl
This map is for object serialization mainly.
ValueModel
Represents a typed value that can participate in Swing data binding.
ValueRecorder
Records values produced during evaluation of an assertion statement's truth expression.
Variable
Interface marking an AST node as representing a variable in Groovy/Java scope.
VariableAccessReplacer
Replace all access to variables and args by new variables.
VariableExpression
Represents a local variable reference, the simplest form of expression (e.g., "foo").
VariableExpressionReplacer
Tool for replacing VariableExpression instances in an AST by other VariableExpression instances.
VariableExpressionTransformer
An expression transformer used in the process of replacing the access to variables
VariableReplacedListener
Receives notifications whenever a variable expression is replaced.
VariableScope
Manages variable scope tracking for a given code block, tracking declared and referenced variables to determine variable sharing patterns across closure and method boundaries.
VariableScopeVisitor
Initializes the variable scopes for an AST.
VariableScopeVisitor.InstanceofFlowBindings
Flow-sensitive result for JEP 394 `instanceof` pattern bindings (GROOVY-12242) — the Groovy equivalent of the JLS §6.3.1 “introduced by” sets.
VariableSlotLoader
A bytecode expression that loads a variable from a specific slot index.
VariantSupport
Shared runtime support for `Decreases` termination measures, used by both the loop variant (`@Decreases` on a loop) and the recursion variant (`@Decreases` on a method, via `MethodVariantSupport`).
Verifier
Verifies the AST node and adds any default AST code before bytecode generation occurs.
Verifier.DefaultArgsAction
Strategy invoked for each synthetic method or constructor generated for default arguments.
VerifierCodeVisitor
Performs various checks on code inside methods and constructors including checking for valid field, variables names etc.
VerifyClass
Verify Class files.
Vetoable
Annotates a groovy property or a class.
VetoableASTStubber
Joint-compilation stubber for `Vetoable` (class-level use).
VetoableASTTransformation
Handles generation of code for the `@Vetoable` annotation, and `@Bindable` if also present.
ViolationTracker
A violation tracker is used to keep a list of pre-, post-condition or class-invariant violations in chronological order.
Virtual
Marks a public trait `static` method as virtual: trait-body calls to this method dispatch through the implementing class at runtime, so a same-signature static method declared on the implementing class overrides the trait's default.
Visibility
Indicates the visibility of a node.
VisibilityOptions
Marker annotation used in the context of AST transformations to provide a custom visibility.
VisibilityUtils
Utility methods for resolving visibility customizations from `VisibilityOptions`.
VMPlugin
Interface to access VM version based actions.
VMPluginFactory
Factory class to get functionality based on the VM version.
WarningMessage
A class for warning messages.
Weigher<V>
A class that can determine the weight of a value.
Weighers
A common set of `Weigher` and `EntryWeigher` implementations.
WhereExpression
Represent the where expression
WhileStatement
Represents a while (condition) { ...
WideningCategories
This class provides helper methods to determine the type from a widening operation for example for a plus operation.
WideningCategories.LowestUpperBoundClassNode
This `ClassNode` specialization is used when the lowest upper bound of two types cannot be represented by an existing type.
Window<T>
Represents window which stores elements used by window functions
WindowDefinition<T,U extends Comparable<? super U>>
Represents window definition, which will define the result set to construct the window
WithReadLock
This annotation is used in conjunction with `WithWriteLock` to support read and write synchronization on a method.
WithWriteLock
This annotation is used in conjunction with `WithReadLock` to support read and write synchronization on a method.
Wrapper
Base class for runtime wrappers that expose a value through `GroovyObject` while reporting a constrained type.
Writable
Represents an object which is capable of writing itself to a text stream in a more efficient format than just creating a toString() representation of itself.
WritableFile
A file wrapper implementing the `Writable` interface to support writing file contents.
WritablePath
`Path` wrapper that also implements `Writable`.
WriterController
Central coordinator for Groovy-to-bytecode compilation of a single class.
WriterControllerFactory
A non-static factory to get alternative writer controller to be stored in the metadata
XmlExtensions
This class defines all the new XML-related groovy methods which enhance the normal JDK XML classes when inside the Groovy environment.
XmlNodePrinter
Prints a `groovy.util.Node` (as used with `XmlParser`) including all children in XML format.
XmlNodePrinter.NamespaceContext
Tracks namespace declarations already emitted while printing a subtree.
XmlParser
A helper class for parsing XML into a tree of Node instances for a simple way of processing XML.
XmlRuntimeException
Represents a runtime exception that occurred when parsing or building XML.
XmlSlurper
Parse XML into a document tree that may be traversed similar to XPath expressions.
XmlTemplateEngine
Template engine for use in templating scenarios where both the template source and the expected output are intended to be XML.
XmlUtil
Used for pretty printing XML content and other XML related utilities.
XStreamUtils
Serializes AST structures to XML for debugging.
YamlBuilder
A builder for creating YAML payloads.
YamlConverter
A converter for converting YAML to JSON, vice versa
YamlRuntimeException
Represents a runtime exception raised while parsing or building YAML.
YamlSlurper
Represents a YAML parser
YieldStatement
Represents a `yield` statement that produces the value of an enclosing `SwitchExpression`.