import org.codehaus.groovy.transform.AbstractASTTransformation; //导入依赖的package包/类
/**
 * Copies all <tt>candidateAnnotations</tt> with retention policy {@link java.lang.annotation.RetentionPolicy#RUNTIME}
 * and {@link java.lang.annotation.RetentionPolicy#CLASS}.
 * <p>
 * Annotations with {@link org.codehaus.groovy.runtime.GeneratedClosure} members are not supported at present.
 */
public static void copyAnnotatedNodeAnnotations(final AnnotatedNode annotatedNode, final List<AnnotationNode> copied, List<AnnotationNode> notCopied) {
    List<AnnotationNode> annotationList = annotatedNode.getAnnotations();
    for (AnnotationNode annotation : annotationList)  {

        List<AnnotationNode> annotations = annotation.getClassNode().getAnnotations(AbstractASTTransformation.RETENTION_CLASSNODE);
        if (annotations.isEmpty()) continue;

        if (hasClosureMember(annotation)) {
            notCopied.add(annotation);
            continue;
        }

        AnnotationNode retentionPolicyAnnotation = annotations.get(0);
        Expression valueExpression = retentionPolicyAnnotation.getMember("value");
        if (!(valueExpression instanceof PropertyExpression)) continue;

        PropertyExpression propertyExpression = (PropertyExpression) valueExpression;
        boolean processAnnotation =
                propertyExpression.getProperty() instanceof ConstantExpression &&
                        (
                                "RUNTIME".equals(((ConstantExpression) (propertyExpression.getProperty())).getValue()) ||
                                        "CLASS".equals(((ConstantExpression) (propertyExpression.getProperty())).getValue())
                        );

        if (processAnnotation)  {
            AnnotationNode newAnnotation = new AnnotationNode(annotation.getClassNode());
            for (Map.Entry<String, Expression> member : annotation.getMembers().entrySet())  {
                newAnnotation.addMember(member.getKey(), member.getValue());
            }
            newAnnotation.setSourcePosition(annotatedNode);

            copied.add(newAnnotation);
        }
    }
}
 

import org.codehaus.groovy.transform.AbstractASTTransformation; //导入依赖的package包/类
private static List<FieldNode> filterFields(List<FieldNode> fieldNodes, List<String> includes, List<String> excludes, boolean allNames) {
    List<FieldNode> fields = new ArrayList<FieldNode>();
    for (FieldNode fNode : fieldNodes) {
        if (AbstractASTTransformation.shouldSkipUndefinedAware(fNode.getName(), excludes, includes, allNames)) continue;
        fields.add(fNode);
    }
    return fields;
}
 

import org.codehaus.groovy.transform.AbstractASTTransformation; //导入依赖的package包/类
private void checkForSystemProperties(AnnotationNode node) {
    systemProperties = new HashMap<String, String>();
    List<String> nameValueList = AbstractASTTransformation.getMemberStringList(node, SYSTEM_PROPERTIES_SETTING);
    if (nameValueList != null) {
        for (String nameValue : nameValueList) {
            int equalsDelim = nameValue.indexOf('=');
            if (equalsDelim != -1) {
                systemProperties.put(nameValue.substring(0, equalsDelim), nameValue.substring(equalsDelim + 1));
            }
        }
    }
}
 

import org.codehaus.groovy.transform.AbstractASTTransformation; //导入依赖的package包/类
public void build(BuilderASTTransformation transform, AnnotatedNode annotatedNode, AnnotationNode anno) {
    if (!(annotatedNode instanceof ClassNode)) {
        transform.addError("Error during " + BuilderASTTransformation.MY_TYPE_NAME + " processing: building for " +
                annotatedNode.getClass().getSimpleName() + " not supported by " + getClass().getSimpleName(), annotatedNode);
        return;
    }
    ClassNode buildee = (ClassNode) annotatedNode;
    if (unsupportedAttribute(transform, anno, "builderClassName")) return;
    if (unsupportedAttribute(transform, anno, "buildMethodName")) return;
    if (unsupportedAttribute(transform, anno, "builderMethodName")) return;
    if (unsupportedAttribute(transform, anno, "forClass")) return;
    if (unsupportedAttribute(transform, anno, "includeSuperProperties")) return;
    if (unsupportedAttribute(transform, anno, "allProperties")) return;
    boolean useSetters = transform.memberHasValue(anno, "useSetters", true);
    boolean allNames = transform.memberHasValue(anno, "allNames", true);

    List<String> excludes = new ArrayList<String>();
    List<String> includes = new ArrayList<String>();
    includes.add(Undefined.STRING);
    if (!getIncludeExclude(transform, anno, buildee, excludes, includes)) return;
    if (includes.size() == 1 && Undefined.isUndefined(includes.get(0))) includes = null;
    String prefix = getMemberStringValue(anno, "prefix", "set");
    List<FieldNode> fields = getFields(transform, anno, buildee);
    if (includes != null) {
        for (String name : includes) {
            checkKnownField(transform, anno, name, fields);
        }
    }
    for (FieldNode field : fields) {
        String fieldName = field.getName();
        if (!AbstractASTTransformation.shouldSkipUndefinedAware(fieldName, excludes, includes, allNames)) {
            String methodName = getSetterName(prefix, fieldName);
            Parameter parameter = param(field.getType(), fieldName);
            buildee.addMethod(methodName, Opcodes.ACC_PUBLIC, newClass(buildee), params(parameter), NO_EXCEPTIONS, block(
                            stmt(useSetters && !field.isFinal()
                                            ? callThisX(getSetterName("set", fieldName), varX(parameter))
                                            : assignX(fieldX(field), varX(parameter))
                            ),
                            returnS(varX("this")))
            );
        }
    }
}