private void makeInterfaceTypes(CompileUnit cu, ClassNode classNode, Class<?> clazz) {
    Type[] interfaceTypes = clazz.getGenericInterfaces();
    if (interfaceTypes.length == 0) {
        classNode.setInterfaces(ClassNode.EMPTY_ARRAY);
    } else {
        ClassNode[] ret = new ClassNode[interfaceTypes.length];
        for (int i = 0; i < interfaceTypes.length; i++) {
            Type type = interfaceTypes[i];
            while (!(type instanceof Class)) {
                ParameterizedType pt = (ParameterizedType) type;
                Type t2 = pt.getRawType();
                if (t2==type) {
                    throw new GroovyBugError("Cannot transform generic signature of "+clazz+
                            " with generic interface "+interfaceTypes[i]+" to a class.");
                }
                type = t2;
            }
            ret[i] = makeClassNode(cu, interfaceTypes[i], (Class<?>) type);
        }
        classNode.setInterfaces(ret);
    }
}
 

protected ClassVisitor createClassVisitor() {
    CompilerConfiguration config = getConfiguration();
    int computeMaxStackAndFrames = ClassWriter.COMPUTE_MAXS;
    if (CompilerConfiguration.isPostJDK7(config.getTargetBytecode()) || config.isIndyEnabled()) {
        computeMaxStackAndFrames += ClassWriter.COMPUTE_FRAMES;
    }
    return new ClassWriter(computeMaxStackAndFrames) {
        private ClassNode getClassNode(String name) {
            // try classes under compilation
            CompileUnit cu = getAST();
            ClassNode cn = cu.getClass(name);
            if (cn != null) return cn;
            // try inner classes
            cn = cu.getGeneratedInnerClass(name);
            if (cn != null) return cn;
            ClassNodeResolver.LookupResult lookupResult = getClassNodeResolver().resolveName(name, CompilationUnit.this);
            return lookupResult == null ? null : lookupResult.getClassNode();
        }
        private ClassNode getCommonSuperClassNode(ClassNode c, ClassNode d) {
            // adapted from ClassWriter code
            if (c.isDerivedFrom(d)) return d;
            if (d.isDerivedFrom(c)) return c;
            if (c.isInterface() || d.isInterface()) return ClassHelper.OBJECT_TYPE;
            do {
                c = c.getSuperClass();
            } while (c != null && !d.isDerivedFrom(c));
            if (c == null) return ClassHelper.OBJECT_TYPE;
            return c;
        }
        @Override
        protected String getCommonSuperClass(String arg1, String arg2) {
            ClassNode a = getClassNode(arg1.replace('/', '.'));
            ClassNode b = getClassNode(arg2.replace('/', '.'));
            return getCommonSuperClassNode(a,b).getName().replace('.','/');
        }
    };
}
 

private ConstructedOuterNestedClassNode tryToConstructOuterNestedClassNodeViaStaticImport(final CompileUnit compileUnit, final ImportNode importNode, final String typeName, final BiConsumer<ConstructedOuterNestedClassNode, ClassNode> setRedirectListener) {
    String importClassName = importNode.getClassName();
    ClassNode outerClassNode = compileUnit.getClass(importClassName);

    if (null == outerClassNode) return null;

    String outerNestedClassName = importClassName + "$" + typeName.replace('.', '$');
    ConstructedOuterNestedClassNode constructedOuterNestedClassNode = new ConstructedOuterNestedClassNode(outerClassNode, outerNestedClassName);
    constructedOuterNestedClassNode.addSetRedirectListener(setRedirectListener);
    return constructedOuterNestedClassNode;
}
 

private ConstructedOuterNestedClassNode tryToConstructOuterNestedClassNodeForBaseType(final CompileUnit compileUnit, final String typeName, final ClassNode cn, final BiConsumer<ConstructedOuterNestedClassNode, ClassNode> setRedirectListener) {
    if (!compileUnit.getClassesToCompile().containsValue(cn)) return null;

    String outerNestedClassName = cn.getName() + "$" + typeName;
    ConstructedOuterNestedClassNode constructedOuterNestedClassNode = new ConstructedOuterNestedClassNode(cn, outerNestedClassName);
    constructedOuterNestedClassNode.addSetRedirectListener(setRedirectListener);
    return constructedOuterNestedClassNode;
}
 

protected boolean resolveFromCompileUnit(final ClassNode type) {
    // look into the compile unit if there is a class with that name
    CompileUnit compileUnit = currentClass.getCompileUnit();
    if (compileUnit == null) return false;
    ClassNode cuClass = compileUnit.getClass(type.getName());
    if (cuClass != null) {
        if (type != cuClass) type.setRedirect(cuClass);
        return true;
    }
    return false;
}
 

protected CompileUnit getCompileUnit() {
    CompileUnit answer = classNode.getCompileUnit();
    if (answer == null) {
        answer = context.getCompileUnit();
    }
    return answer;
}
 

protected Parameter[] processParameters(CompileUnit compileUnit, Method m) {
    java.lang.reflect.Parameter[] parameters = m.getParameters();
    Type[] types = m.getGenericParameterTypes();
    Parameter[] params = Parameter.EMPTY_ARRAY;
    if (types.length > 0) {
        params = new Parameter[types.length];
        for (int i = 0; i < params.length; i++) {
            java.lang.reflect.Parameter p = parameters[i];
            String name = p.isNamePresent() ? p.getName() : "param" + i;
            params[i] = makeParameter(compileUnit, types[i], m.getParameterTypes()[i], m.getParameterAnnotations()[i], name);
        }
    }
    return params;
}
 

private ClassNode[] makeClassNodes(CompileUnit cu, Type[] types, Class<?>[] cls) {
    ClassNode[] nodes = new ClassNode[types.length];
    for (int i = 0; i < nodes.length; i++) {
        nodes[i] = makeClassNode(cu, types[i], cls[i]);
    }
    return nodes;
}
 

private ClassNode makeClassNode(CompileUnit cu, Type t, Class<?> c) {
    ClassNode back = null;
    if (cu != null) back = cu.getClass(c.getName());
    if (back == null) back = ClassHelper.make(c);
    if (!(t instanceof Class)) {
        ClassNode front = configureType(t);
        front.setRedirect(back);
        return front;
    }
    return back.getPlainNodeReference();
}
 

/**
 * Returns the CompileUnit that roots our AST.
 */
public CompileUnit getAST() {
    return this.ast;
}
 

public GeneratorContext(CompileUnit compileUnit) {
    this.compileUnit = compileUnit;
}
 

public GeneratorContext(CompileUnit compileUnit, int innerClassOffset) {
    this.compileUnit = compileUnit;
    this.innerClassIdx = innerClassOffset;
}
 

public CompileUnit getCompileUnit() {
    return compileUnit;
}
 

protected Parameter makeParameter(CompileUnit cu, Type type, Class<?> cl, Annotation[] annotations, String name) {
    ClassNode cn = makeClassNode(cu, type, cl);
    Parameter parameter = new Parameter(cn, name);
    setAnnotationMetaData(annotations, parameter);
    return parameter;
}
 

/**
 * Initializes the CompilationUnit with a CodeSource for controlling
 * security stuff, a class loader for loading classes, and a class
 * loader for loading AST transformations.
 * <p>
 * <b>Note</b>: The transform loader must be able to load compiler classes.
 * That means {@link #classLoader} must be at last a parent to {@code transformLoader}.
 * The other loader has no such constraint.
 *
 * @param transformLoader - the loader for transforms
 * @param loader          - loader used to resolve classes against during compilation
 * @param codeSource      - security setting for the compilation
 * @param configuration   - compilation configuration
 */
public CompilationUnit(final CompilerConfiguration configuration, final CodeSource codeSource,
                       final GroovyClassLoader loader, final GroovyClassLoader transformLoader) {
    super(configuration, loader, null);

    this.astTransformationsContext = new ASTTransformationsContext(this, transformLoader);
    this.ast = new CompileUnit(getClassLoader(), codeSource, getConfiguration());

    addPhaseOperations();
    applyCompilationCustomizers();
}
 

/**
 * Returns true if the two classes share the same compilation unit.
 * @param a class a
 * @param b class b
 * @return true if both classes share the same compilation unit
 */
public static boolean isSameCompilationUnit(ClassNode a, ClassNode b) {
    CompileUnit cu1 = a.getCompileUnit();
    CompileUnit cu2 = b.getCompileUnit();
    return cu1 != null && cu1 == cu2;
}
 

void configureClassNode(CompileUnit compileUnit, ClassNode classNode);