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 ->

    }

    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 {

    }

    /**
     * <code>abstract</code>かどうか返します。
     *
     * @param clazz
     *            クラス。{@literal null}であってはいけません
     * @return <code>abstract</code>なら{@literal true}
     */
    public static boolean isAbstract(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        return isAbstract(clazz.getModifiers());
    }

    /**
     * <code>abstract</code>かどうか返します。
     *

     */
    static <T> Key<T> key(Class<T> clazz) {
        return new Key<>(clazz, clazz);
    }

    /**
     * Create a key using the given class and id.
     */
    static <T> Key<T> key(Class<T> clazz, Object id) {
        return new Key<>(clazz, id);
    }

    /**
     * Key used to query the session data

                    format(type)
                )
            );
        }

        return match;
    }

    private static boolean isInnerClass(Class<?> clazz) {
        return clazz.isMemberClass() && !Modifier.isStatic(clazz.getModifiers());
    }

    private static boolean isPublicOrPackageScoped(Constructor<?> constructor) {

    }

    private void shutdownCommonsHttpClient() { // from Tomcat7ConfigServlet (old class)
        try {
            final Class<?> clazz = Class.forName("org.apache.commons.httpclient.MultiThreadedHttpConnectionManager");
            final Method method = clazz.getMethod("shutdownAll", (Class<?>[]) null);
            method.invoke(null, (Object[]) null);
        } catch (final ClassNotFoundException e) {
            // ignore