Searches an AST for subtrees matching a given pattern. @since 2.5.0

Common base class providing shared AST helper methods used by both the classic and new parsers. Manages module-level information including the package

Base class for any AST node. This class supports basic information used in all nodes of the AST: <ul> <li> line and column number information. Usually

Holds all constants to be used as AST node metadata keys.

Predicate used to test AST nodes. @since 2.5.0

Base class for every TestCase that uses an AST

This class is instantiated and invoked when an AST transformation is activated. For Global AST Transformations, this interface is called once per Sour

Walks the AST and collects references to annotations that are annotated themselves by {@link GroovyASTTransformation}. Each such annotation is added.

This class handles the invocation of the ASTAnnotationTransformation when it is encountered by a tree walk. One instance of each exists for each phas

Stores state information about global AST transformations applied to a compilation unit.

Abstract base class for AST transformations. <p> Provides utility methods for extracting annotation members, validating properties/fields, and filteri

Represents window frame bounds @param <T1> the type of lower frame bound @param <T2> the type of upper frame bound @since 4.0.0

Base class for builder generation strategies.

Supplies synthetic binding definitions for {@link AbstractButton}. @since Groovy 1.1

Tracks the synthetic {@code selected} property on an {@link AbstractButton}.

Base class for all call sites.

Base class for Groovy comparators. Provides a common implementation where equality is based on object identity.

@since 3.0.0

Base {@link Factory} implementation with default no-op lifecycle hooks.

Base implementation for {@link FullBinding} that handles validation and value conversion. @since Groovy 1.1

Shared bytecode and deserialization support for statically-compiled functional interface implementations, including both lambdas and method references

Represents GINQ expression which could hold metadata @since 4.0.0

A base class dealing with common HTTP servlet API housekeeping aspects. <p> <h4>Resource name mangling (pattern replacement)</h4> <p> Also implements

Base class for AST Transformations which will automatically throw an {@link InterruptedException} when some conditions are met. @since 1.8.0

Base binding for synthetic {@link JComponent} properties driven by component and property-change events.

Because antlr4 does not support generating lexer with specified interface, we have to create a super class for it and implement the interface.

Base iterator implementation for traversing the deque in link order.

Base class for logging strategy implementations.

Base class for logging strategy implementations supporting the v2 logging API.

Because antlr4 does not support generating parser with specified interface, we have to create a super class for it and implement the interface.

Base command object for query operations that manage statement and connection lifecycle.

For ReaderSources that can choose a parent class, a base that provides common functionality.

This is a test specific subclass for AbstractReaderSource.

Unit test for AbstractReaderSource.

Base class for bindings that observe synthetic Swing properties.

<p>Custom type checking extensions may extend this method in order to benefit from a lot of support methods.</p> <p>The methods found in this class a

Encapsulates access rules for code completion. Controls which members are visible during completion.

Benchmark comparing Java and Groovy implementations of the Ackermann function.

Represents the action to deal with the cache @param <K> key type @param <V> value type @param <R> result type @since 3.0.0

Handles the {@link ActiveObject} annotation, transforming {@link ActiveMethod}-annotated methods to route through an internal actor for serialized exe

A lightweight message-passing actor for concurrent state management. <p> Each actor has a dedicated thread that processes messages sequentially from a

Context handle passed to context-aware actor handlers. Provides access to the executing actor itself and to the per-dispatch capabilities needed to ex

Construction-time configuration for an {@link Actor}. <p> Carries the mailbox capacity / overflow policy, the optional stash capacity / overflow polic

An interface for MetaClass instances that "adapt" other MetaClass instances such as a proxy or delegating MetaClass. @since 1.5

Replaces a given {@link ReturnStatement} with the appropriate assertion call statement and returns a result variable expression.

Replaces a given {@link ReturnStatement} with the appropriate assertion call statement and returns a result variable expression.

Nested-element holder populated by Ant introspection for {@code <addStylesheet file="..."/>}. @since 6.0.0

Adds the node to the page replacement policy.

A thread-safe mutable-value container inspired by Clojure's agents and GPars' {@code Agent}. <p> An {@code Agent} wraps a value that can be read by an

An aggregation of multiple bindings @since Groovy 1.6

Replaces XML-disallowed control characters and Unicode noncharacters with {@code U+FFFD}.

AllTestSuite can be used in extension of GroovyTestSuite to execute TestCases written in Groovy from inside a Java IDE. AllTestSuite collects all file

Base class for any AST node which is capable of being annotated

Utility class for working with AnnotatedNodes

Common interface for bytecode stubs that may carry annotations extracted from the class file. Provides access to annotation metadata for classes, meth

Interface for bytecode stubs that may carry type annotations (JSR 308 JVMS 4.7.20, 4.7.21). Type annotations provide fine-grained type information for

Visits interfaces &amp; classes and looks for <tt>@Requires</tt> or <tt>@Ensures</tt> and creates {@link groovy.lang.Closure} classes for the annotati

Conflict resolution modes for {@link AnnotationCollector}. @since 2.0.0

This class is the base for any annotation alias processor. @see AnnotationCollector @see AnnotationCollectorTransform#visit(AnnotationNode, Annotatio

Represents an annotation "constant" that may appear in annotation attributes (mainly used as a marker).

Resolves constants in annotation definitions.

This {@link BaseVisitor} walks up the class hierarchy for the given {@link org.codehaus.groovy.ast.ClassNode} and adds {@link org.apache.groovy.contra

Represents an annotation which can be attached to interfaces, classes, methods, fields, parameters, and other places.

<p>Base class for modifying the internal domain model, starting at {@link Contract}, and adding parts to it.</p> @see org.apache.groovy.contracts.ann

Visits annotations of meta-type {@link ContractElement} and applies the AST transformations of the underlying {@link org.apache.groovy.contracts.commo

Base visitor class for collecting annotation attribute values from bytecode. Handles type conversions, enum constants, nested annotations, and array a

Parsing annotations

Bytecode stub representing an annotation extracted from a class file. Holds the annotation type and its member key-value pairs.

<p>Helper methods for reading/getting {@link org.codehaus.groovy.ast.AnnotationNode} instances.</p>

An Annotation visitor responsible for: <ul> <li>reading annotation metadata (@Retention, @Target, attribute types)</li> <li>verify that an <code>Annot

Utility class that converts annotation metadata extracted from bytecode into corresponding AST node representations. Handles JSR 175 (annotation) and

Allows <a href="https://ant.apache.org/manual/tasklist.html">Ant tasks</a> to be used with a Groovy builder-style markup. Requires that <code>ant.jar<

Would be nice to retrieve location information (from AST?). In a first time, without info

Live {@link Hashtable}-style view over an Ant project's immutable properties. Mutation requests are redirected to Ant where possible and otherwise rej

A parser plugin for the new parser.

A parser plugin factory for the new parser.

Represents one or more arguments being passed into a method

Provides optimized reflection caching for Java arrays. Handles type coercion including conversion of boxed arrays to primitive arrays, and {@link GStr

A {@link GroovyClassDoc} decorator that wraps a component-type class doc for array-type representations. All {@link GroovyClassDoc} method calls are d

Represents an array literal or array construction expression. Supports both fixed-size array construction (e.g., {@code new String[3]} or {@code new I