Class Annotations

src/main/java/org/codehaus/groovy/ast/decompiled/Annotations.java:69–308

Utility class that converts annotation metadata extracted from bytecode into corresponding AST node representations. Handles JSR 175 (annotation) and JSR 308 (type annotation) conversions from ASM-parsed structures to Groovy AST AnnotationNode instances. Key responsibilities: Converti

 * @see AsmReferenceResolver
 */
class Annotations {
    /**
     * Creates an {@link AnnotationNode} from bytecode annotation metadata.
     * Resolves the annotation class using the provided resolver and converts all annotation members
     * to corresponding AST expressions. Returns null if the annotation class cannot be resolved
     * (e.g., not present on classpath).
     *
     * <p>If resolution fails, the annotation is silently skipped to allow compilation with missing
     * annotation types (e.g., runtime-only annotations not in classpath).
     *
     * @param annotation the {@link AnnotationStub} containing bytecode annotation metadata
     * @param resolver the {@link AsmReferenceResolver} used to resolve the annotation class type
     * @return the created {@link AnnotationNode}, or null if the annotation class cannot be resolved
     * @see DecompiledAnnotationNode
     */
    static AnnotationNode createAnnotationNode(AnnotationStub annotation, AsmReferenceResolver resolver) {
        ClassNode classNode = resolver.resolveClassNullable(Type.getType(annotation.className).getClassName());
        if (classNode == null) {
            // there might be annotations not present in the classpath
            // e.g. java.lang.Synthetic (http://forge.ow2.org/tracker/?aid=307392&group_id=23&atid=100023&func=detail)
            // so skip them
            return null;
        }

        AnnotationNode node = new DecompiledAnnotationNode(classNode);
        for (Map.Entry<String, Object> entry : annotation.members.entrySet()) {
            addMemberIfFound(resolver, node, entry);
        }
        return node;
    }

    /**
     * Adds a single annotation member to the given {@link AnnotationNode} if the member value
     * can be successfully converted to an AST expression. Silently skips members with unconvertible values.
     *
     * @param resolver the {@link AsmReferenceResolver} used for type resolution
     * @param node the {@link AnnotationNode} to add the member to
     * @param entry the key-value pair from annotation member map (name → value)
     */
    private static void addMemberIfFound(AsmReferenceResolver resolver, AnnotationNode node, Map.Entry<String, Object> entry) {
        Expression value = annotationValueToExpression(entry.getValue(), resolver);
        if (value != null) {
            node.addMember(entry.getKey(), value);
        }
    }

    /**
     * Converts a bytecode annotation element value to a corresponding AST expression.
     * Handles all annotation value types according to JVMS §4.7.16:
     * <ul>
     *   <li>{@link TypeWrapper} → {@link ClassExpression}</li>
     *   <li>{@link EnumConstantWrapper} → {@link PropertyExpression} for enum constant access</li>
     *   <li>{@link AnnotationStub} → {@link AnnotationConstantExpression} for nested annotations</li>
     *   <li>Arrays (via {@link Array.getLength()}) → {@link ListExpression} with recursive conversion</li>
     *   <li>{@link List} → {@link ListExpression} with recursive conversion</li>
     *   <li>Primitives and strings → {@link ConstantExpression}</li>
     * </ul>
     *