@Override
    public ClassLoaderScope getParent() {
        return this; // should this be null?
    }

    @Override
    public boolean defines(Class<?> clazz) {
        return localClassLoader.equals(clazz.getClassLoader()) || exportClassLoader.equals(clazz.getClassLoader());
    }

    @Override
    public ClassLoaderScope lock() {
        return this;
    }

    @Override
    public boolean isLocked() {

            assert source.exists()
            def clazz = new File(dstDir, "org/test/${className}.class")
            assert clazz.exists()
            assertCompatibleWithJava8(clazz)
        }
    }

    private static void assertCompatibleWithJava8(File clazz) {
        ClassVisitor cv = new ClassVisitor(Opcodes.ASM7) {
            @Override

      if (info.getName().endsWith("_gwt")) {
        Class<?> clazz = info.load();
        // TODO(cpovirk): why does asSubclass() throw? Is it something about ClassLoaders?
        @SuppressWarnings("unchecked")
        Class<? extends GWTTestCase> cast = (Class<? extends GWTTestCase>) clazz;
        suite.addTestSuite(cast);
      }
    }
    return suite;
  }

        assertArgumentNotNull("type", type);
        assertArgumentNotNull("clazz", clazz);

        if (type instanceof Class) {
            return clazz.isAssignableFrom((Class<?>) type);
        }
        if (type instanceof ParameterizedType) {
            final ParameterizedType parameterizedType = ParameterizedType.class.cast(type);
            return isTypeOf(parameterizedType.getRawType(), clazz);
        }

import java.lang.reflect.Modifier;

@GroovyASTTransformation
public class MagicFieldTransform implements ASTTransformation {
    public void visit(ASTNode[] nodes, SourceUnit source) {
        ClassNode clazz = (ClassNode) nodes[1];
        clazz.addField("magicField", Modifier.PUBLIC, ClassHelper.STRING_TYPE, new ConstantExpression("magicValue"));
    }

 */
class JclLoggerAdapter implements LoggerAdapter {

    protected final String sourceClass;

    protected final Log logger;

    public JclLoggerAdapter(final Class<?> clazz) {
        sourceClass = clazz.getName();
        logger = LogFactory.getLog(clazz);
    }

    @Override
    public boolean isFatalEnabled() {
        return logger.isFatalEnabled();
    }

    @Override

        val cleared = readBoolean()
        val updates = readList {
            val clazz = readClass()
            val key = read() as Any
            val value = read()
            when (clazz) {
                ConfigurationCacheEnvironmentChangeTracker.SystemPropertyMutate::class.java ->

    try {
      return subscriberMethodsCache.getUnchecked(clazz);
    } catch (UncheckedExecutionException e) {
      throwIfUnchecked(e.getCause());
      throw e;
    }
  }

  private static ImmutableList<Method> getAnnotatedMethodsNotCached(Class<?> clazz) {
    Set<? extends Class<?>> supertypes = TypeToken.of(clazz).getTypes().rawTypes();

    }

    static synchronized void removeClassFromGlobalClassSet(Class<?> clazz) {
        Iterator<ClassInfo> it = GLOBAL_CLASS_SET_ITEMS.iterator()
        while (it.hasNext()) {
            ClassInfo ci = it.next()
            if (ci.cachedClass.getTheClass().is(clazz)) {
                it.remove()
                break
            }
        }
    }

@GroovyASTTransformation
class GroovyMagicFieldTransform implements ASTTransformation, Opcodes {
    void visit(ASTNode[] nodes, SourceUnit source) {
        def clazz = (ClassNode) nodes[1]
        clazz.addField("magicField", ACC_PUBLIC, ClassHelper.STRING_TYPE, new StringExpressionThroughAsm())
    }

    private class StringExpressionThroughAsm extends BytecodeExpression {