import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
/**
 * Parses the source to a CST.  You can retrieve it with getCST().
 */
public void parse() throws CompilationFailedException {
    if (this.phase > Phases.PARSING) {
        throw new GroovyBugError("parsing is already complete");
    }

    if (this.phase == Phases.INITIALIZATION) {
        nextPhase();
    }

    //
    // Create a reader on the source and run the parser.

    try (Reader reader = source.getReader()) {
        // let's recreate the parser each time as it tends to keep around state
        parserPlugin = getConfiguration().getPluginFactory().createParserPlugin();

        cst = parserPlugin.parseCST(this, reader);
    } catch (IOException e) {
        getErrorCollector().addFatalError(new SimpleMessage(e.getMessage(), this));
    }
}
 

import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
private void verifyCompilePhase(AnnotationNode annotation, Class<?> klass) {
    GroovyASTTransformation transformationClass = klass.getAnnotation(GroovyASTTransformation.class);
    if (transformationClass != null) {
        CompilePhase specifiedCompilePhase = transformationClass.phase();
        if (specifiedCompilePhase.getPhaseNumber() < CompilePhase.SEMANTIC_ANALYSIS.getPhaseNumber()) {
            source.getErrorCollector().addError(
                    new SimpleMessage(
                            annotation.getClassNode().getName() + " is defined to be run in compile phase " + specifiedCompilePhase + ". Local AST transformations must run in " + CompilePhase.SEMANTIC_ANALYSIS + " or later!",
                            source));
        }

    } else {
        source.getErrorCollector().addError(
                new SimpleMessage("AST transformation implementation classes must be annotated with " + GroovyASTTransformation.class.getName() + ". " + klass.getName() + " lacks this annotation.", source));
    }
}
 

import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
private List<String> getTransformClassNames(AnnotationNode annotation, Annotation transformClassAnnotation) {
    List<String> result = new ArrayList<String>();

    try {
        Method valueMethod = transformClassAnnotation.getClass().getMethod("value");
        String[] names = (String[]) valueMethod.invoke(transformClassAnnotation);
        result.addAll(Arrays.asList(names));

        Method classesMethod = transformClassAnnotation.getClass().getMethod("classes");
        Class[] classes = (Class[]) classesMethod.invoke(transformClassAnnotation);
        for (Class klass : classes) {
            result.add(klass.getName());
        }

        if (names.length > 0 && classes.length > 0) {
            source.getErrorCollector().addError(new SimpleMessage("@GroovyASTTransformationClass in " +
                    annotation.getClassNode().getName() +
                    " should specify transforms only by class names or by classes and not by both", source));
        }
    } catch (Exception e) {
        source.addException(e);
    }

    return result;
}
 

import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
protected static boolean needsTwitter4jContribution(ClassNode declaringClass, SourceUnit sourceUnit) {
    boolean found1 = false, found2 = false, found3 = false;
    ClassNode consideredClass = declaringClass;
    while (consideredClass != null) {
        for (MethodNode method : consideredClass.getMethods()) {
            // just check length, MOP will match it up
            found1 = method.getName().equals(METHOD_WITH_TWITTER) && method.getParameters().length == 2;
            found2 = method.getName().equals(METHOD_SET_TWITTER4j_PROVIDER) && method.getParameters().length == 1;
            found3 = method.getName().equals(METHOD_GET_TWITTER4j_PROVIDER) && method.getParameters().length == 0;
            if (found1 && found2 && found3) {
                return false;
            }
        }
        consideredClass = consideredClass.getSuperClass();
    }
    if (found1 || found2 || found3) {
        sourceUnit.getErrorCollector().addErrorAndContinue(
            new SimpleMessage("@Twitter4jAware cannot be processed on "
                + declaringClass.getName()
                + " because some but not all of methods from " + Twitter4jContributionHandler.class.getName() + " were declared in the current class or super classes.",
                sourceUnit)
        );
        return false;
    }
    return true;
}
 

import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
public void visit(ASTNode[] nodes, SourceUnit source) {
  if (nodes.length == 0 || !(nodes[0] instanceof ModuleNode)) {
    source.getErrorCollector().addError(new SimpleMessage(
      "internal error in DetectorTransform", source));
    return;
  }
  ModuleNode module = (ModuleNode)nodes[0];
  for (ClassNode clazz : (List<ClassNode>)module.getClasses()) {
    FieldNode field = clazz.getField(VERSION_FIELD_NAME);
    if (field != null) {
      field.setInitialValueExpression(new ConstantExpression(ReleaseInfo.getVersion()));
      break;
    }
  }
}
 

import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
public void call(SourceUnit source) throws CompilationFailedException {
    List<ClassNode> classes = source.ast.getClasses();
    for (ClassNode node : classes) {
        CompileUnit cu = node.getCompileUnit();
        for (Iterator iter = cu.iterateClassNodeToCompile(); iter.hasNext();) {
            String name = (String) iter.next();
            SourceUnit su = ast.getScriptSourceLocation(name);
            List<ClassNode> classesInSourceUnit = su.ast.getClasses();
            StringBuilder message = new StringBuilder();
            message
                    .append("Compilation incomplete: expected to find the class ")
                    .append(name)
                    .append(" in ")
                    .append(su.getName());
            if (classesInSourceUnit.isEmpty()) {
                message.append(", but the file seems not to contain any classes");
            } else {
                message.append(", but the file contains the classes: ");
                boolean first = true;
                for (ClassNode cn : classesInSourceUnit) {
                    if (!first) {
                        message.append(", ");
                    } else {
                        first = false;
                    }
                    message.append(cn.getName());
                }
            }

            getErrorCollector().addErrorAndContinue(
                    new SimpleMessage(message.toString(), CompilationUnit.this)
            );
            iter.remove();
        }
    }
}
 

import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
private void addTransformsToClassNode(AnnotationNode annotation, Annotation transformClassAnnotation) {
    List<String> transformClassNames = getTransformClassNames(annotation, transformClassAnnotation);

    if (transformClassNames.isEmpty()) {
        source.getErrorCollector().addError(new SimpleMessage("@GroovyASTTransformationClass in " +
                annotation.getClassNode().getName() + " does not specify any transform class names/classes", source));
    }

    for (String transformClass : transformClassNames) {
        Class klass = loadTransformClass(transformClass, annotation);
        if (klass != null) {
            verifyAndAddTransform(annotation, klass);
        }
    }
}
 

import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
private Class loadTransformClass(String transformClass, AnnotationNode annotation) {
    try {
        return transformLoader.loadClass(transformClass, false, true, false);
    } catch (ClassNotFoundException e) {
        source.getErrorCollector().addErrorAndContinue(
                new SimpleMessage(
                        "Could not find class for Transformation Processor " + transformClass
                                + " declared by " + annotation.getClassNode().getName(),
                        source));
    }
    return null;
}
 

import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
private static void addJavacError(String header, CompilationUnit cu, StringBuilderWriter msg) {
    if (msg != null) {
        header = header + "\n" + msg.getBuilder().toString();
    } else {
        header = header +
                "\nThis javac version does not support compile(String[],PrintWriter), " +
                "so no further details of the error are available. The message error text " +
                "should be found on System.err.\n";
    }
    cu.getErrorCollector().addFatalError(new SimpleMessage(header, cu));
}
 

import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
/**
 * Snoops through the declaring class and all parents looking for methods
 * <code>void addPropertyChangeListener(PropertyChangeListener)</code>,
 * <code>void removePropertyChangeListener(PropertyChangeListener)</code>, and
 * <code>void firePropertyChange(String, Object, Object)</code>. If any are defined all
 * must be defined or a compilation error results.
 *
 * @param declaringClass the class to search
 * @param sourceUnit the source unit, for error reporting. {@code @NotNull}.
 * @return true if property change support should be added
 */
protected boolean needsPropertyChangeSupport(ClassNode declaringClass, SourceUnit sourceUnit) {
    boolean foundAdd = false, foundRemove = false, foundFire = false;
    ClassNode consideredClass = declaringClass;
    while (consideredClass!= null) {
        for (MethodNode method : consideredClass.getMethods()) {
            // just check length, MOP will match it up
            foundAdd = foundAdd || method.getName().equals("addPropertyChangeListener") && method.getParameters().length == 1;
            foundRemove = foundRemove || method.getName().equals("removePropertyChangeListener") && method.getParameters().length == 1;
            foundFire = foundFire || method.getName().equals("firePropertyChange") && method.getParameters().length == 3;
            if (foundAdd && foundRemove && foundFire) {
                return false;
            }
        }
        consideredClass = consideredClass.getSuperClass();
    }
    // check if a super class has @Bindable annotations
    consideredClass = declaringClass.getSuperClass();
    while (consideredClass!=null) {
        if (hasBindableAnnotation(consideredClass)) return false;
        for (FieldNode field : consideredClass.getFields()) {
            if (hasBindableAnnotation(field)) return false;
        }
        consideredClass = consideredClass.getSuperClass();
    }
    if (foundAdd || foundRemove || foundFire) {
        sourceUnit.getErrorCollector().addErrorAndContinue(
            new SimpleMessage("@Bindable cannot be processed on "
                + declaringClass.getName()
                + " because some but not all of addPropertyChangeListener, removePropertyChange, and firePropertyChange were declared in the current or super classes.",
            sourceUnit)
        );
        return false;
    }
    return true;
}
 

import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
/**
 * Snoops through the declaring class and all parents looking for a field
 * of type VetoableChangeSupport.  Remembers the field and returns false
 * if found otherwise returns true to indicate that such support should
 * be added.
 *
 * @param declaringClass the class to search
 * @return true if vetoable change support should be added
 */
protected boolean needsVetoableChangeSupport(ClassNode declaringClass, SourceUnit sourceUnit) {
    boolean foundAdd = false, foundRemove = false, foundFire = false;
    ClassNode consideredClass = declaringClass;
    while (consideredClass!= null) {
        for (MethodNode method : consideredClass.getMethods()) {
            // just check length, MOP will match it up
            foundAdd = foundAdd || method.getName().equals("addVetoableChangeListener") && method.getParameters().length == 1;
            foundRemove = foundRemove || method.getName().equals("removeVetoableChangeListener") && method.getParameters().length == 1;
            foundFire = foundFire || method.getName().equals("fireVetoableChange") && method.getParameters().length == 3;
            if (foundAdd && foundRemove && foundFire) {
                return false;
            }
        }
        consideredClass = consideredClass.getSuperClass();
    }
    // check if a super class has @Vetoable annotations
    consideredClass = declaringClass.getSuperClass();
    while (consideredClass!=null) {
        if (hasVetoableAnnotation(consideredClass)) return false;
        for (FieldNode field : consideredClass.getFields()) {
            if (hasVetoableAnnotation(field)) return false;
        }
        consideredClass = consideredClass.getSuperClass();
    }
    if (foundAdd || foundRemove || foundFire) {
        sourceUnit.getErrorCollector().addErrorAndContinue(
            new SimpleMessage("@Vetoable cannot be processed on "
                + declaringClass.getName()
                + " because some but not all of addVetoableChangeListener, removeVetoableChange, and fireVetoableChange were declared in the current or super classes.",
            sourceUnit)
        );
        return false;
    }
    return true;
}
 

import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
public static boolean needsDelegate(@Nonnull ClassNode classNode, @Nonnull SourceUnit sourceUnit,
                                    @Nonnull MethodDescriptor[] methods, @Nonnull String annotationType,
                                    @Nonnull String delegateType) {
    boolean implemented = false;
    int implementedCount = 0;
    ClassNode consideredClass = classNode;
    while (consideredClass != null) {
        for (MethodNode method : consideredClass.getMethods()) {
            for (MethodDescriptor md : methods) {
                if (method.getName().equals(md.methodName) && method.getParameters().length == md.arguments.length) {
                    implemented |= true;
                    implementedCount++;
                }
                if (implementedCount == methods.length) {
                    return false;
                }
            }
        }

        consideredClass = consideredClass.getSuperClass();
    }
    if (implemented) {
        sourceUnit.getErrorCollector().addErrorAndContinue(
            new SimpleMessage("@" + annotationType + " cannot be processed on "
                + classNode.getName()
                + " because some but not all methods from "
                + delegateType
                + " were declared in the current class or super classes.",
                sourceUnit)
        );
        return false;
    }
    return true;
}
 

import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
protected static boolean needsJdbiContribution(ClassNode declaringClass, SourceUnit sourceUnit) {
    boolean found1 = false, found2 = false, found3 = false, found4 = false;
    ClassNode consideredClass = declaringClass;
    while (consideredClass != null) {
        for (MethodNode method : consideredClass.getMethods()) {
            // just check length, MOP will match it up
            found1 = method.getName().equals(METHOD_WITH_JDBI) && method.getParameters().length == 1;
            found2 = method.getName().equals(METHOD_WITH_JDBI) && method.getParameters().length == 2;
            found3 = method.getName().equals(METHOD_SET_JDBI_PROVIDER) && method.getParameters().length == 1;
            found4 = method.getName().equals(METHOD_GET_JDBI_PROVIDER) && method.getParameters().length == 0;
            if (found1 && found2 && found3 && found4) {
                return false;
            }
        }
        consideredClass = consideredClass.getSuperClass();
    }
    if (found1 || found2 || found3 || found4) {
        sourceUnit.getErrorCollector().addErrorAndContinue(
            new SimpleMessage("@JdbiAware cannot be processed on "
                + declaringClass.getName()
                + " because some but not all of methods from " + JdbiContributionHandler.class.getName() + " were declared in the current class or super classes.",
                sourceUnit)
        );
        return false;
    }
    return true;
}
 

import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
private static void addPhaseOperationsForGlobalTransforms(CompilationUnit compilationUnit,
        Map<String, URL> transformNames, boolean isFirstScan) {
    GroovyClassLoader transformLoader = compilationUnit.getTransformLoader();
    for (Map.Entry<String, URL> entry : transformNames.entrySet()) {
        try {
            Class gTransClass = transformLoader.loadClass(entry.getKey(), false, true, false);
            //no inspection unchecked
            GroovyASTTransformation transformAnnotation = (GroovyASTTransformation) gTransClass.getAnnotation(GroovyASTTransformation.class);
            if (transformAnnotation == null) {
                compilationUnit.getErrorCollector().addWarning(new WarningMessage(
                    WarningMessage.POSSIBLE_ERRORS,
                    "Transform Class " + entry.getKey() + " is specified as a global transform in " + entry.getValue().toExternalForm()
                    + " but it is not annotated by " + GroovyASTTransformation.class.getName()
                    + " the global transform associated with it may fail and cause the compilation to fail.",
                    null,
                    null));
                continue;
            }
            if (ASTTransformation.class.isAssignableFrom(gTransClass)) {
                final ASTTransformation instance = (ASTTransformation)gTransClass.newInstance();
                if (instance instanceof CompilationUnitAware) {
                    ((CompilationUnitAware)instance).setCompilationUnit(compilationUnit);
                }
                CompilationUnit.SourceUnitOperation suOp = new CompilationUnit.SourceUnitOperation() {
                    public void call(SourceUnit source) throws CompilationFailedException {
                        instance.visit(new ASTNode[] {source.getAST()}, source);
                    }
                }; 
                if(isFirstScan) {
                    compilationUnit.addPhaseOperation(suOp, transformAnnotation.phase().getPhaseNumber());
                } else {
                    compilationUnit.addNewPhaseOperation(suOp, transformAnnotation.phase().getPhaseNumber());
                }
            } else {
                compilationUnit.getErrorCollector().addError(new SimpleMessage(
                    "Transform Class " + entry.getKey() + " specified at "
                    + entry.getValue().toExternalForm() + " is not an ASTTransformation.", null));
            }
        } catch (Exception e) {
            compilationUnit.getErrorCollector().addError(new SimpleMessage(
                "Could not instantiate global transform class " + entry.getKey() + " specified at "
                + entry.getValue().toExternalForm() + "  because of exception " + e.toString(), null));
        }
    }
}
 

import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
private void addLoadingError(final CompilerConfiguration config) {
    context.getErrorCollector().addFatalError(
            new SimpleMessage("Static type checking extension '" + scriptPath + "' could not be loaded.",
                    config.getDebug(), typeCheckingVisitor.getSourceUnit())
    );
}
 

import org.codehaus.groovy.control.messages.SimpleMessage; //导入依赖的package包/类
private void verifyClass(AnnotationNode annotation, Class klass) {
    if (!ASTTransformation.class.isAssignableFrom(klass)) {
        source.getErrorCollector().addError(new SimpleMessage("Not an ASTTransformation: " +
                klass.getName() + " declared by " + annotation.getClassNode().getName(), source));
    }
}