runtime/linker/JavaAdapterBytecodeGenerator.java

/*
 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package jdk.nashorn.internal.runtime.linker;

import static jdk.internal.org.objectweb.asm.Opcodes.ACC_FINAL;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PRIVATE;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PUBLIC;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_STATIC;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_SUPER;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_VARARGS;
import static jdk.internal.org.objectweb.asm.Opcodes.ALOAD;
import static jdk.internal.org.objectweb.asm.Opcodes.ASTORE;
import static jdk.internal.org.objectweb.asm.Opcodes.D2F;
import static jdk.internal.org.objectweb.asm.Opcodes.H_INVOKESTATIC;
import static jdk.internal.org.objectweb.asm.Opcodes.I2B;
import static jdk.internal.org.objectweb.asm.Opcodes.I2S;
import static jdk.internal.org.objectweb.asm.Opcodes.RETURN;
import static jdk.nashorn.internal.codegen.CompilerConstants.interfaceCallNoLookup;
import static jdk.nashorn.internal.codegen.CompilerConstants.staticCallNoLookup;
import static jdk.nashorn.internal.lookup.Lookup.MH;
import static jdk.nashorn.internal.runtime.linker.AdaptationResult.Outcome.ERROR_NO_ACCESSIBLE_CONSTRUCTOR;

import java.lang.invoke.CallSite;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles.Lookup;
import java.lang.invoke.MethodType;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Module;
import java.security.AccessControlContext;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import jdk.internal.org.objectweb.asm.ClassWriter;
import jdk.internal.org.objectweb.asm.Handle;
import jdk.internal.org.objectweb.asm.Label;
import jdk.internal.org.objectweb.asm.Opcodes;
import jdk.internal.org.objectweb.asm.Type;
import jdk.internal.org.objectweb.asm.commons.InstructionAdapter;
import jdk.nashorn.api.scripting.ScriptUtils;
import jdk.nashorn.internal.codegen.CompilerConstants.Call;
import jdk.nashorn.internal.runtime.ScriptFunction;
import jdk.nashorn.internal.runtime.ScriptObject;
import jdk.nashorn.internal.runtime.linker.AdaptationResult.Outcome;
import sun.reflect.CallerSensitive;

/**
 * Generates bytecode for a Java adapter class. Used by the {@link JavaAdapterFactory}.
 * </p><p>
 * For every protected or public constructor in the extended class, the adapter class will have either one or two
 * public constructors (visibility of protected constructors in the extended class is promoted to public).
 * <li>
 * <li>For adapter classes with instance-level overrides, a constructor taking a trailing ScriptObject argument preceded
 * by original constructor arguments is always created on the adapter class. When such a constructor is invoked, the
 * passed ScriptObject's member functions are used to implement and/or override methods on the original class,
 * dispatched by name. A single JavaScript function will act as the implementation for all overloaded methods of the
 * same name. When methods on an adapter instance are invoked, the functions are invoked having the ScriptObject passed
 * in the instance constructor as their "this". Subsequent changes to the ScriptObject (reassignment or removal of its
 * functions) will be reflected in the adapter instance as it is live dispatching to its members on every method invocation.
 * {@code java.lang.Object} methods {@code equals}, {@code hashCode}, and {@code toString} can also be overridden. The
 * only restriction is that since every JavaScript object already has a {@code toString} function through the
 * {@code Object.prototype}, the {@code toString} in the adapter is only overridden if the passed ScriptObject has a
 * {@code toString} function as its own property, and not inherited from a prototype. All other adapter methods can be
 * implemented or overridden through a prototype-inherited function of the ScriptObject passed to the constructor too.
 * </li>
 * <li>
 * If the original types collectively have only one abstract method, or have several of them, but all share the
 * same name, an additional constructor for instance-level override adapter is provided for every original constructor;
 * this one takes a ScriptFunction as its last argument preceded by original constructor arguments. This constructor
 * will use the passed function as the implementation for all abstract methods. For consistency, any concrete methods
 * sharing the single abstract method name will also be overridden by the function. When methods on the adapter instance
 * are invoked, the ScriptFunction is invoked with UNDEFINED or Global as its "this" depending whether the function is
 * strict or not.
 * </li>
 * <li>
 * If the adapter being generated has class-level overrides, constructors taking same arguments as the superclass
 * constructors are created. These constructors simply delegate to the superclass constructor. They are simply used to
 * create instances of the adapter class, with no instance-level overrides, as they don't have them. If the original
 * class' constructor was variable arity, the adapter constructor will also be variable arity. Protected constructors
 * are exposed as public.
 * </li>
 * </ul>
 * </p><p>
 * For adapter methods that return values, all the JavaScript-to-Java conversions supported by Nashorn will be in effect
 * to coerce the JavaScript function return value to the expected Java return type.
 * </p><p>
 * Since we are adding a trailing argument to the generated constructors in the adapter class with instance-level overrides, they will never be
 * declared as variable arity, even if the original constructor in the superclass was declared as variable arity. The
 * reason we are passing the additional argument at the end of the argument list instead at the front is that the
 * source-level script expression <code>new X(a, b) { ... }</code> (which is a proprietary syntax extension Nashorn uses
 * to resemble Java anonymous classes) is actually equivalent to <code>new X(a, b, { ... })</code>.
 * </p><p>
 * It is possible to create two different adapter classes: those that can have class-level overrides, and those that can
 * have instance-level overrides. When {@link JavaAdapterFactory#getAdapterClassFor(Class[], ScriptObject)} is invoked
 * with non-null {@code classOverrides} parameter, an adapter class is created that can have class-level overrides, and
 * the passed script object will be used as the implementations for its methods, just as in the above case of the
 * constructor taking a script object. Note that in the case of class-level overrides, a new adapter class is created on
 * every invocation, and the implementation object is bound to the class, not to any instance. All created instances
 * will share these functions. If it is required to have both class-level overrides and instance-level overrides, the
 * class-level override adapter class should be subclassed with an instance-override adapter. Since adapters delegate to
 * super class when an overriding method handle is not specified, this will behave as expected. It is not possible to
 * have both class-level and instance-level overrides in the same class for security reasons: adapter classes are
 * defined with a protection domain of their creator code, and an adapter class that has both class and instance level
 * overrides would need to have two potentially different protection domains: one for class-based behavior and one for
 * instance-based behavior; since Java classes can only belong to a single protection domain, this could not be
 * implemented securely.
 */
final class JavaAdapterBytecodeGenerator {
    // Field names in adapters
    private static final String GLOBAL_FIELD_NAME = "global";
    private static final String DELEGATE_FIELD_NAME = "delegate";
    private static final String IS_FUNCTION_FIELD_NAME = "isFunction";
    private static final String CALL_THIS_FIELD_NAME = "callThis";

    // Initializer names
    private static final String INIT = "<init>";
    private static final String CLASS_INIT = "<clinit>";

    // Types often used in generated bytecode
    private static final Type OBJECT_TYPE = Type.getType(Object.class);
    private static final Type SCRIPT_OBJECT_TYPE = Type.getType(ScriptObject.class);
    private static final Type SCRIPT_FUNCTION_TYPE = Type.getType(ScriptFunction.class);

    // JavaAdapterServices methods used in generated bytecode
    private static final Call CHECK_FUNCTION = lookupServiceMethod("checkFunction", ScriptFunction.class, Object.class, String.class);
    private static final Call EXPORT_RETURN_VALUE = lookupServiceMethod("exportReturnValue", Object.class, Object.class);
    private static final Call GET_CALL_THIS = lookupServiceMethod("getCallThis", Object.class, ScriptFunction.class, Object.class);
    private static final Call GET_CLASS_OVERRIDES = lookupServiceMethod("getClassOverrides", ScriptObject.class);
    private static final Call GET_NON_NULL_GLOBAL = lookupServiceMethod("getNonNullGlobal", ScriptObject.class);
    private static final Call HAS_OWN_TO_STRING = lookupServiceMethod("hasOwnToString", boolean.class, ScriptObject.class);
    private static final Call INVOKE_NO_PERMISSIONS = lookupServiceMethod("invokeNoPermissions", void.class, MethodHandle.class, Object.class);
    private static final Call NOT_AN_OBJECT = lookupServiceMethod("notAnObject", void.class, Object.class);
    private static final Call SET_GLOBAL = lookupServiceMethod("setGlobal", Runnable.class, ScriptObject.class);
    private static final Call TO_CHAR_PRIMITIVE = lookupServiceMethod("toCharPrimitive", char.class, Object.class);
    private static final Call UNSUPPORTED = lookupServiceMethod("unsupported", UnsupportedOperationException.class);
    private static final Call WRAP_THROWABLE = lookupServiceMethod("wrapThrowable", RuntimeException.class, Throwable.class);

    // Other methods invoked by the generated bytecode
    private static final Call UNWRAP = staticCallNoLookup(ScriptUtils.class, "unwrap", Object.class, Object.class);
    private static final Call CHAR_VALUE_OF = staticCallNoLookup(Character.class, "valueOf", Character.class, char.class);
    private static final Call DOUBLE_VALUE_OF = staticCallNoLookup(Double.class, "valueOf", Double.class, double.class);
    private static final Call LONG_VALUE_OF = staticCallNoLookup(Long.class, "valueOf", Long.class, long.class);
    private static final Call RUN = interfaceCallNoLookup(Runnable.class, "run", void.class);

    // ASM handle to the bootstrap method
    private static final Handle BOOTSTRAP_HANDLE = new Handle(H_INVOKESTATIC,
            Type.getInternalName(JavaAdapterServices.class), "bootstrap",
            MethodType.methodType(CallSite.class, Lookup.class, String.class,
                    MethodType.class, int.class).toMethodDescriptorString());

    // ASM handle to the bootstrap method for array populator
    private static final Handle CREATE_ARRAY_BOOTSTRAP_HANDLE = new Handle(H_INVOKESTATIC,
            Type.getInternalName(JavaAdapterServices.class), "createArrayBootstrap",
            MethodType.methodType(CallSite.class, Lookup.class, String.class,
                    MethodType.class).toMethodDescriptorString());

    // Field type names used in the generated bytecode
    private static final String SCRIPT_OBJECT_TYPE_DESCRIPTOR = SCRIPT_OBJECT_TYPE.getDescriptor();
    private static final String OBJECT_TYPE_DESCRIPTOR = OBJECT_TYPE.getDescriptor();
    private static final String BOOLEAN_TYPE_DESCRIPTOR = Type.BOOLEAN_TYPE.getDescriptor();

    // Throwable names used in the generated bytecode
    private static final String RUNTIME_EXCEPTION_TYPE_NAME = Type.getInternalName(RuntimeException.class);
    private static final String ERROR_TYPE_NAME = Type.getInternalName(Error.class);
    private static final String THROWABLE_TYPE_NAME = Type.getInternalName(Throwable.class);

    // Some more frequently used method descriptors
    private static final String GET_METHOD_PROPERTY_METHOD_DESCRIPTOR = Type.getMethodDescriptor(OBJECT_TYPE, SCRIPT_OBJECT_TYPE);
    private static final String VOID_METHOD_DESCRIPTOR = Type.getMethodDescriptor(Type.VOID_TYPE);

    static final String ADAPTER_PACKAGE_INTERNAL = "jdk/nashorn/javaadapters/";
    static final String ADAPTER_PACKAGE = "jdk.nashorn.javaadapters";
    private static final int MAX_GENERATED_TYPE_NAME_LENGTH = 255;

    // Method name prefix for invoking super-methods
    static final String SUPER_PREFIX = "super$";

    // Method name and type for the no-privilege finalizer delegate
    private static final String FINALIZER_DELEGATE_NAME = "$$nashornFinalizerDelegate";
    private static final String FINALIZER_DELEGATE_METHOD_DESCRIPTOR = Type.getMethodDescriptor(Type.VOID_TYPE, OBJECT_TYPE);

    /**
     * Collection of methods we never override: Object.clone(), Object.finalize().
     */
    private static final Collection<MethodInfo> EXCLUDED = getExcludedMethods();

    // This is the superclass for our generated adapter.
    private final Class<?> superClass;
    // Interfaces implemented by our generated adapter.
    private final List<Class<?>> interfaces;
    // Class loader used as the parent for the class loader we'll create to load the generated class. It will be a class
    // loader that has the visibility of all original types (class to extend and interfaces to implement) and of the
    // Nashorn classes.
    private final ClassLoader commonLoader;
    // Is this a generator for the version of the class that can have overrides on the class level?
    private final boolean classOverride;
    // Binary name of the superClass
    private final String superClassName;
    // Binary name of the generated class.
    private final String generatedClassName;
    private final Set<String> abstractMethodNames = new HashSet<>();
    private final String samName;
    private final Set<MethodInfo> finalMethods = new HashSet<>(EXCLUDED);
    private final Set<MethodInfo> methodInfos = new HashSet<>();
    private final boolean autoConvertibleFromFunction;
    private boolean hasExplicitFinalizer = false;
    private final Set<Module> accessedModules = new HashSet<>();

    private final ClassWriter cw;

    /**
     * Creates a generator for the bytecode for the adapter for the specified superclass and interfaces.
     * @param superClass the superclass the adapter will extend.
     * @param interfaces the interfaces the adapter will implement.
     * @param commonLoader the class loader that can see all of superClass, interfaces, and Nashorn classes.
     * @param classOverride true to generate the bytecode for the adapter that has class-level overrides, false to
     * generate the bytecode for the adapter that has instance-level overrides.
     * @throws AdaptationException if the adapter can not be generated for some reason.
     */
    JavaAdapterBytecodeGenerator(final Class<?> superClass, final List<Class<?>> interfaces,
            final ClassLoader commonLoader, final boolean classOverride) throws AdaptationException {
        assert superClass != null && !superClass.isInterface();
        assert interfaces != null;

        this.superClass = superClass;
        this.interfaces = interfaces;
        this.classOverride = classOverride;
        this.commonLoader = commonLoader;
        cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS) {
            @Override
            protected String getCommonSuperClass(final String type1, final String type2) {
                // We need to override ClassWriter.getCommonSuperClass to use this factory's commonLoader as a class
                // loader to find the common superclass of two types when needed.
                return JavaAdapterBytecodeGenerator.this.getCommonSuperClass(type1, type2);
            }
        };
        superClassName = Type.getInternalName(superClass);
        generatedClassName = getGeneratedClassName(superClass, interfaces);

        cw.visit(Opcodes.V1_7, ACC_PUBLIC | ACC_SUPER, generatedClassName, null, superClassName, getInternalTypeNames(interfaces));
        generateField(GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
        generateField(DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);

        gatherMethods(superClass);
        gatherMethods(interfaces);
        if (abstractMethodNames.size() == 1) {
            samName = abstractMethodNames.iterator().next();
            generateField(CALL_THIS_FIELD_NAME, OBJECT_TYPE_DESCRIPTOR);
            generateField(IS_FUNCTION_FIELD_NAME, BOOLEAN_TYPE_DESCRIPTOR);
        } else {
            samName = null;
        }
        if(classOverride) {
            generateClassInit();
        }
        autoConvertibleFromFunction = generateConstructors();
        generateMethods();
        generateSuperMethods();
        if (hasExplicitFinalizer) {
            generateFinalizerMethods();
        }
        // }
        cw.visitEnd();
    }

    private void generateField(final String name, final String fieldDesc) {
        cw.visitField(ACC_PRIVATE | ACC_FINAL | (classOverride ? ACC_STATIC : 0), name, fieldDesc, null, null).visitEnd();
    }

    JavaAdapterClassLoader createAdapterClassLoader() {
        return new JavaAdapterClassLoader(generatedClassName, cw.toByteArray(), accessedModules);
    }

    boolean isAutoConvertibleFromFunction() {
        return autoConvertibleFromFunction;
    }

    private static String getGeneratedClassName(final Class<?> superType, final List<Class<?>> interfaces) {
        // The class we use to primarily name our adapter is either the superclass, or if it is Object (meaning we're
        // just implementing interfaces or extending Object), then the first implemented interface or Object.
        final Class<?> namingType = superType == Object.class ? (interfaces.isEmpty()? Object.class : interfaces.get(0)) : superType;
        final Package pkg = namingType.getPackage();
        final String namingTypeName = Type.getInternalName(namingType);
        final StringBuilder buf = new StringBuilder();
        buf.append(ADAPTER_PACKAGE_INTERNAL).append(namingTypeName.replace('/', '_'));
        final Iterator<Class<?>> it = interfaces.iterator();
        if(superType == Object.class && it.hasNext()) {
            it.next(); // Skip first interface, it was used to primarily name the adapter
        }
        // Append interface names to the adapter name
        while(it.hasNext()) {
            buf.append("$$").append(it.next().getSimpleName());
        }
        return buf.toString().substring(0, Math.min(MAX_GENERATED_TYPE_NAME_LENGTH, buf.length()));
    }

    /**
     * Given a list of class objects, return an array with their binary names. Used to generate the array of interface
     * names to implement.
     * @param classes the classes
     * @return an array of names
     */
    private static String[] getInternalTypeNames(final List<Class<?>> classes) {
        final int interfaceCount = classes.size();
        final String[] interfaceNames = new String[interfaceCount];
        for(int i = 0; i < interfaceCount; ++i) {
            interfaceNames[i] = Type.getInternalName(classes.get(i));
        }
        return interfaceNames;
    }

    private void generateClassInit() {
        final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(ACC_STATIC, CLASS_INIT,
                VOID_METHOD_DESCRIPTOR, null, null));

        // Assign "global = Context.getGlobal()"
        GET_NON_NULL_GLOBAL.invoke(mv);
        mv.putstatic(generatedClassName, GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);

        GET_CLASS_OVERRIDES.invoke(mv);
        if(samName != null) {
            // If the class is a SAM, allow having ScriptFunction passed as class overrides
            mv.dup();
            mv.instanceOf(SCRIPT_FUNCTION_TYPE);
                    mv.dup();
            mv.putstatic(generatedClassName, IS_FUNCTION_FIELD_NAME, BOOLEAN_TYPE_DESCRIPTOR);
            final Label notFunction = new Label();
            mv.ifeq(notFunction);
            mv.dup();
            mv.checkcast(SCRIPT_FUNCTION_TYPE);
            emitInitCallThis(mv);
            mv.visitLabel(notFunction);
        }
        mv.putstatic(generatedClassName, DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);

        endInitMethod(mv);
    }

    /**
     * Emit bytecode for initializing the "callThis" field.
     */
    private void emitInitCallThis(final InstructionAdapter mv) {
        loadField(mv, GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
        GET_CALL_THIS.invoke(mv);
            if(classOverride) {
            mv.putstatic(generatedClassName, CALL_THIS_FIELD_NAME, OBJECT_TYPE_DESCRIPTOR);
            } else {
            // It is presumed ALOAD 0 was already executed
            mv.putfield(generatedClassName, CALL_THIS_FIELD_NAME, OBJECT_TYPE_DESCRIPTOR);
        }
    }

    private boolean generateConstructors() throws AdaptationException {
        boolean gotCtor = false;
        boolean canBeAutoConverted = false;
        for (final Constructor<?> ctor: superClass.getDeclaredConstructors()) {
            final int modifier = ctor.getModifiers();
            if((modifier & (Modifier.PUBLIC | Modifier.PROTECTED)) != 0 && !isCallerSensitive(ctor)) {
                canBeAutoConverted = generateConstructors(ctor) | canBeAutoConverted;
                gotCtor = true;
            }
        }
        if(!gotCtor) {
            throw new AdaptationException(ERROR_NO_ACCESSIBLE_CONSTRUCTOR, superClass.getCanonicalName());
        }
        return canBeAutoConverted;
    }

    private boolean generateConstructors(final Constructor<?> ctor) {
        for (final Class<?> pt : ctor.getParameterTypes()) {
            if (pt.isPrimitive()) continue;
            final Module ptMod = pt.getModule();
            if (ptMod != null) {
                accessedModules.add(ptMod);
            }
        }

        if(classOverride) {
            // Generate a constructor that just delegates to ctor. This is used with class-level overrides, when we want
            // to create instances without further per-instance overrides.
            generateDelegatingConstructor(ctor);
            return false;
        }

            // Generate a constructor that delegates to ctor, but takes an additional ScriptObject parameter at the
            // beginning of its parameter list.
            generateOverridingConstructor(ctor, false);

        if (samName == null) {
            return false;
                }
                // If all our abstract methods have a single name, generate an additional constructor, one that takes a
                // ScriptFunction as its first parameter and assigns it as the implementation for all abstract methods.
                generateOverridingConstructor(ctor, true);
        // If the original type only has a single abstract method name, as well as a default ctor, then it can
        // be automatically converted from JS function.
        return ctor.getParameterTypes().length == 0;
    }

    private void generateDelegatingConstructor(final Constructor<?> ctor) {
        final Type originalCtorType = Type.getType(ctor);
        final Type[] argTypes = originalCtorType.getArgumentTypes();

        // All constructors must be public, even if in the superclass they were protected.
        final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(ACC_PUBLIC |
                (ctor.isVarArgs() ? ACC_VARARGS : 0), INIT,
                Type.getMethodDescriptor(originalCtorType.getReturnType(), argTypes), null, null));

        mv.visitCode();
        emitSuperConstructorCall(mv, originalCtorType.getDescriptor());

        endInitMethod(mv);
    }

    /**
     * Generates a constructor for the instance adapter class. This constructor will take the same arguments as the supertype
     * constructor passed as the argument here, and delegate to it. However, it will take an additional argument of
     * either ScriptObject or ScriptFunction type (based on the value of the "fromFunction" parameter), and initialize
     * all the method handle fields of the adapter instance with functions from the script object (or the script
     * function itself, if that's what's passed). There is one method handle field in the adapter class for every method
     * that can be implemented or overridden; the name of every field is same as the name of the method, with a number
     * suffix that makes it unique in case of overloaded methods. The generated constructor will invoke
     * {@link #getHandle(ScriptFunction, MethodType, boolean)} or {@link #getHandle(Object, String, MethodType,
     * boolean)} to obtain the method handles; these methods make sure to add the necessary conversions and arity
     * adjustments so that the resulting method handles can be invoked from generated methods using {@code invokeExact}.
     * The constructor that takes a script function will only initialize the methods with the same name as the single
     * abstract method. The constructor will also store the Nashorn global that was current at the constructor
     * invocation time in a field named "global". The generated constructor will be public, regardless of whether the
     * supertype constructor was public or protected. The generated constructor will not be variable arity, even if the
     * supertype constructor was.
     * @param ctor the supertype constructor that is serving as the base for the generated constructor.
     * @param fromFunction true if we're generating a constructor that initializes SAM types from a single
     * ScriptFunction passed to it, false if we're generating a constructor that initializes an arbitrary type from a
     * ScriptObject passed to it.
     */
    private void generateOverridingConstructor(final Constructor<?> ctor, final boolean fromFunction) {
        final Type originalCtorType = Type.getType(ctor);
        final Type[] originalArgTypes = originalCtorType.getArgumentTypes();
        final int argLen = originalArgTypes.length;
        final Type[] newArgTypes = new Type[argLen + 1];

        // Insert ScriptFunction|ScriptObject as the last argument to the constructor
        final Type extraArgumentType = fromFunction ? SCRIPT_FUNCTION_TYPE : SCRIPT_OBJECT_TYPE;
        newArgTypes[argLen] = extraArgumentType;
        System.arraycopy(originalArgTypes, 0, newArgTypes, 0, argLen);

        // All constructors must be public, even if in the superclass they were protected.
        // Existing super constructor <init>(this, args...) triggers generating <init>(this, args..., delegate).
        // Any variable arity constructors become fixed-arity with explicit array arguments.
        final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(ACC_PUBLIC, INIT,
                Type.getMethodDescriptor(originalCtorType.getReturnType(), newArgTypes), null, null));

        mv.visitCode();
        // First, invoke super constructor with original arguments.
        final int extraArgOffset = emitSuperConstructorCall(mv, originalCtorType.getDescriptor());

        // Assign "this.global = Context.getGlobal()"
        mv.visitVarInsn(ALOAD, 0);
        GET_NON_NULL_GLOBAL.invoke(mv);
        mv.putfield(generatedClassName, GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);

        // Assign "this.delegate = delegate"
        mv.visitVarInsn(ALOAD, 0);
        mv.visitVarInsn(ALOAD, extraArgOffset);
        mv.putfield(generatedClassName, DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);

        if (fromFunction) {
            // Assign "isFunction = true"
            mv.visitVarInsn(ALOAD, 0);
            mv.iconst(1);
            mv.putfield(generatedClassName, IS_FUNCTION_FIELD_NAME, BOOLEAN_TYPE_DESCRIPTOR);

        mv.visitVarInsn(ALOAD, 0);
            mv.visitVarInsn(ALOAD, extraArgOffset);
            emitInitCallThis(mv);
        }

        endInitMethod(mv);

        if (! fromFunction) {
            newArgTypes[argLen] = OBJECT_TYPE;
            final InstructionAdapter mv2 = new InstructionAdapter(cw.visitMethod(ACC_PUBLIC, INIT,
                    Type.getMethodDescriptor(originalCtorType.getReturnType(), newArgTypes), null, null));
            generateOverridingConstructorWithObjectParam(mv2, originalCtorType.getDescriptor());
        }
    }

    // Object additional param accepting constructor - generated to handle null and undefined value
    // for script adapters. This is effectively to throw TypeError on such script adapters. See
    // JavaAdapterServices.getHandle as well.
    private void generateOverridingConstructorWithObjectParam(final InstructionAdapter mv, final String ctorDescriptor) {
        mv.visitCode();
        final int extraArgOffset = emitSuperConstructorCall(mv, ctorDescriptor);
        mv.visitVarInsn(ALOAD, extraArgOffset);
        NOT_AN_OBJECT.invoke(mv);
        endInitMethod(mv);
    }

    private static void endInitMethod(final InstructionAdapter mv) {
        mv.visitInsn(RETURN);
        endMethod(mv);
    }

    private static void endMethod(final InstructionAdapter mv) {
        mv.visitMaxs(0, 0);
        mv.visitEnd();
    }

    /**
     * Encapsulation of the information used to generate methods in the adapter classes. Basically, a wrapper around the
     * reflective Method object, a cached MethodType, and the name of the field in the adapter class that will hold the
     * method handle serving as the implementation of this method in adapter instances.
     *
     */
    private static class MethodInfo {
        private final Method method;
        private final MethodType type;

        private MethodInfo(final Class<?> clazz, final String name, final Class<?>... argTypes) throws NoSuchMethodException {
            this(clazz.getDeclaredMethod(name, argTypes));
        }

        private MethodInfo(final Method method) {
            this.method = method;
            this.type   = MH.type(method.getReturnType(), method.getParameterTypes());
        }

        @Override
        public boolean equals(final Object obj) {
            return obj instanceof MethodInfo && equals((MethodInfo)obj);
        }

        private boolean equals(final MethodInfo other) {
            // Only method name and type are used for comparison; method handle field name is not.
            return getName().equals(other.getName()) && type.equals(other.type);
        }

        String getName() {
            return method.getName();
        }

        @Override
        public int hashCode() {
            return getName().hashCode() ^ type.hashCode();
        }
    }

    private void generateMethods() {
        for(final MethodInfo mi: methodInfos) {
            generateMethod(mi);
        }
    }

    /**
     * Generates a method in the adapter class that adapts a method from the
     * original class. The generated method will either invoke the delegate
     * using a CALL dynamic operation call site (if it is a SAM method and the
     * delegate is a ScriptFunction), or invoke GET_METHOD_PROPERTY dynamic
     * operation with the method name as the argument and then invoke the
     * returned ScriptFunction using the CALL dynamic operation. If
     * GET_METHOD_PROPERTY returns null or undefined (that is, the JS object
     * doesn't provide an implementation for the method) then the method will
     * either do a super invocation to base class, or if the method is abstract,
     * throw an {@link UnsupportedOperationException}. Finally, if
     * GET_METHOD_PROPERTY returns something other than a ScriptFunction, null,
     * or undefined, a TypeError is thrown. The current Global is checked before
     * the dynamic operations, and if it is different  than the Global used to
     * create the adapter, the creating Global is set to be the current Global.
     * In this case, the previously current Global is restored after the
     * invocation. If CALL results in a Throwable that is not one of the
     * method's declared exceptions, and is not an unchecked throwable, then it
     * is wrapped into a {@link RuntimeException} and the runtime exception is
     * thrown.
     * @param mi the method info describing the method to be generated.
     */
    private void generateMethod(final MethodInfo mi) {
        final Method method = mi.method;
        final Class<?>[] exceptions = method.getExceptionTypes();
        final String[] exceptionNames = getExceptionNames(exceptions);
        final MethodType type = mi.type;
        final String methodDesc = type.toMethodDescriptorString();
        final String name = mi.getName();

        final Type asmType = Type.getMethodType(methodDesc);
        final Type[] asmArgTypes = asmType.getArgumentTypes();

        final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(getAccessModifiers(method), name,
                methodDesc, null, exceptionNames));
        mv.visitCode();

        final Class<?> returnType = type.returnType();
        final Type asmReturnType = Type.getType(returnType);

        // Determine the first index for a local variable
        int nextLocalVar = 1; // "this" is at 0
        for(final Type t: asmArgTypes) {
            nextLocalVar += t.getSize();
        }
        // Set our local variable index
        final int globalRestoringRunnableVar = nextLocalVar++;

        // Load the creatingGlobal object
        loadField(mv, GLOBAL_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);

        // stack: [creatingGlobal]
        SET_GLOBAL.invoke(mv);
        // stack: [runnable]
        mv.visitVarInsn(ASTORE, globalRestoringRunnableVar);
        // stack: []

        final Label tryBlockStart = new Label();
        mv.visitLabel(tryBlockStart);

        final Label callCallee = new Label();
        final Label defaultBehavior = new Label();
        // If this is a SAM type...
        if (samName != null) {
            // ...every method will be checking whether we're initialized with a
            // function.
            loadField(mv, IS_FUNCTION_FIELD_NAME, BOOLEAN_TYPE_DESCRIPTOR);
            // stack: [isFunction]
            if (name.equals(samName)) {
                final Label notFunction = new Label();
                mv.ifeq(notFunction);
                // stack: []
                // If it's a SAM method, it'll load delegate as the "callee" and
                // "callThis" as "this" for the call if delegate is a function.
                loadField(mv, DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
                // NOTE: if we added "mv.checkcast(SCRIPT_FUNCTION_TYPE);" here
                // we could emit the invokedynamic CALL instruction with signature
                // (ScriptFunction, Object, ...) instead of (Object, Object, ...).
                // We could combine this with an optimization in
                // ScriptFunction.findCallMethod where it could link a call with a
                // thinner guard when the call site statically guarantees that the
                // callee argument is a ScriptFunction. Additionally, we could use
                // a "ScriptFunction function" field in generated classes instead
                // of a "boolean isFunction" field to avoid the checkcast.
                loadField(mv, CALL_THIS_FIELD_NAME, OBJECT_TYPE_DESCRIPTOR);
                // stack: [callThis, delegate]
                mv.goTo(callCallee);
                mv.visitLabel(notFunction);
        } else {
                // If it's not a SAM method, and the delegate is a function,
                // it'll fall back to default behavior
                mv.ifne(defaultBehavior);
                // stack: []
            }
        }

        // At this point, this is either not a SAM method or the delegate is
        // not a ScriptFunction. We need to emit a GET_METHOD_PROPERTY Nashorn
        // invokedynamic.

        if(name.equals("toString")) {
            // Since every JS Object has a toString, we only override
            // "String toString()" it if it's explicitly specified on the object.
            loadField(mv, DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
            // stack: [delegate]
            HAS_OWN_TO_STRING.invoke(mv);
            // stack: [hasOwnToString]
            mv.ifeq(defaultBehavior);
        }

        loadField(mv, DELEGATE_FIELD_NAME, SCRIPT_OBJECT_TYPE_DESCRIPTOR);
        mv.dup();
        // stack: [delegate, delegate]
        final String encodedName = NameCodec.encode(name);
        mv.visitInvokeDynamicInsn(encodedName,
                GET_METHOD_PROPERTY_METHOD_DESCRIPTOR, BOOTSTRAP_HANDLE,
                NashornCallSiteDescriptor.GET_METHOD_PROPERTY);
        // stack: [callee, delegate]
        mv.visitLdcInsn(name);
        // stack: [name, callee, delegate]
        CHECK_FUNCTION.invoke(mv);
        // stack: [fnCalleeOrNull, delegate]
        final Label hasFunction = new Label();
        mv.dup();
        // stack: [fnCalleeOrNull, fnCalleeOrNull, delegate]
        mv.ifnonnull(hasFunction);
        // stack: [null, delegate]
        // If it's null or undefined, clear stack and fall back to default
        // behavior.
        mv.pop2();
        // stack: []

        // We can also arrive here from check for "delegate instanceof ScriptFunction"
        // in a non-SAM method as well as from a check for "hasOwnToString(delegate)"
        // for a toString delegate.
        mv.visitLabel(defaultBehavior);
        final Runnable emitFinally = ()->emitFinally(mv, globalRestoringRunnableVar);
        final Label normalFinally = new Label();
        if(Modifier.isAbstract(method.getModifiers())) {
            // If the super method is abstract, throw UnsupportedOperationException
            UNSUPPORTED.invoke(mv);
            // NOTE: no need to invoke emitFinally.run() as we're inside the
            // tryBlockStart/tryBlockEnd range, so throwing this exception will
            // transfer control to the rethrow handler and the finally block in it
            // will execute.
            mv.athrow();
        } else {
            // If the super method is not abstract, delegate to it.
            emitSuperCall(mv, method.getDeclaringClass(), name, methodDesc);
            mv.goTo(normalFinally);
        }

        mv.visitLabel(hasFunction);
        // stack: [callee, delegate]
        mv.swap();
        // stack [delegate, callee]
        mv.visitLabel(callCallee);


        // Load all parameters back on stack for dynamic invocation.

        int varOffset = 1;
        // If the param list length is more than 253 slots, we can't invoke it
        // directly as with (callee, this) it'll exceed 255.
        final boolean isVarArgCall = getParamListLengthInSlots(asmArgTypes) > 253;
        for (final Type t : asmArgTypes) {
            mv.load(varOffset, t);
            convertParam(mv, t, isVarArgCall);
            varOffset += t.getSize();
        }
        // stack: [args..., callee, delegate]

        // If the resulting parameter list length is too long...
        if (isVarArgCall) {
            // ... we pack the parameters (except callee and this) into an array
            // and use Nashorn vararg invocation.
            mv.visitInvokeDynamicInsn(NameCodec.EMPTY_NAME,
                    getArrayCreatorMethodType(type).toMethodDescriptorString(),
                    CREATE_ARRAY_BOOTSTRAP_HANDLE);
        }

        // Invoke the target method handle
        mv.visitInvokeDynamicInsn(encodedName,
                getCallMethodType(isVarArgCall, type).toMethodDescriptorString(),
                BOOTSTRAP_HANDLE, NashornCallSiteDescriptor.CALL);
        // stack: [returnValue]
        convertReturnValue(mv, returnType);
        mv.visitLabel(normalFinally);
        emitFinally.run();
        mv.areturn(asmReturnType);

        // If Throwable is not declared, we need an adapter from Throwable to RuntimeException
        final boolean throwableDeclared = isThrowableDeclared(exceptions);
        final Label throwableHandler;
        if (!throwableDeclared) {
            // Add "throw new RuntimeException(Throwable)" handler for Throwable
            throwableHandler = new Label();
            mv.visitLabel(throwableHandler);
            WRAP_THROWABLE.invoke(mv);
            // Fall through to rethrow handler
        } else {
            throwableHandler = null;
        }
        final Label rethrowHandler = new Label();
        mv.visitLabel(rethrowHandler);
        // Rethrow handler for RuntimeException, Error, and all declared exception types
        emitFinally.run();
        mv.athrow();

        if(throwableDeclared) {
            mv.visitTryCatchBlock(tryBlockStart, normalFinally, rethrowHandler, THROWABLE_TYPE_NAME);
            assert throwableHandler == null;
        } else {
            mv.visitTryCatchBlock(tryBlockStart, normalFinally, rethrowHandler, RUNTIME_EXCEPTION_TYPE_NAME);
            mv.visitTryCatchBlock(tryBlockStart, normalFinally, rethrowHandler, ERROR_TYPE_NAME);
            for(final String excName: exceptionNames) {
                mv.visitTryCatchBlock(tryBlockStart, normalFinally, rethrowHandler, excName);
            }
            mv.visitTryCatchBlock(tryBlockStart, normalFinally, throwableHandler, THROWABLE_TYPE_NAME);
        }
        endMethod(mv);
    }

    private static MethodType getCallMethodType(final boolean isVarArgCall, final MethodType type) {
        final Class<?>[] callParamTypes;
        if (isVarArgCall) {
            // Variable arity calls are always (Object callee, Object this, Object[] params)
            callParamTypes = new Class<?>[] { Object.class, Object.class, Object[].class };
            } else {
            // Adjust invocation type signature for conversions we instituted in
            // convertParam; also, byte and short get passed as ints.
            final Class<?>[] origParamTypes = type.parameterArray();
            callParamTypes = new Class<?>[origParamTypes.length + 2];
            callParamTypes[0] = Object.class; // callee; could be ScriptFunction.class ostensibly
            callParamTypes[1] = Object.class; // this
            for(int i = 0; i < origParamTypes.length; ++i) {
                callParamTypes[i + 2] = getNashornParamType(origParamTypes[i], false);
            }
        }
        return MethodType.methodType(getNashornReturnType(type.returnType()), callParamTypes);
    }

    private static MethodType getArrayCreatorMethodType(final MethodType type) {
        final Class<?>[] callParamTypes = type.parameterArray();
        for(int i = 0; i < callParamTypes.length; ++i) {
            callParamTypes[i] = getNashornParamType(callParamTypes[i], true);
        }
        return MethodType.methodType(Object[].class, callParamTypes);
    }

    private static Class<?> getNashornParamType(final Class<?> clazz, final boolean varArg) {
        if (clazz == byte.class || clazz == short.class) {
            return int.class;
        } else if (clazz == float.class) {
            // If using variable arity, we'll pass a Double instead of double
            // so that floats don't extend the length of the parameter list.
            // We return Object.class instead of Double.class though as the
            // array collector will anyway operate on Object.
            return varArg ? Object.class : double.class;
        } else if (!clazz.isPrimitive() || clazz == long.class || clazz == char.class) {
            return Object.class;
        }
        return clazz;
    }

    private static Class<?> getNashornReturnType(final Class<?> clazz) {
        if (clazz == byte.class || clazz == short.class) {
            return int.class;
        } else if (clazz == float.class) {
            return double.class;
        } else if (clazz == void.class || clazz == char.class) {
            return Object.class;
        }
        return clazz;
    }


    private void loadField(final InstructionAdapter mv, final String name, final String desc) {
                if(classOverride) {
            mv.getstatic(generatedClassName, name, desc);
                } else {
                    mv.visitVarInsn(ALOAD, 0);
            mv.getfield(generatedClassName, name, desc);
                }
            }

    private static void convertReturnValue(final InstructionAdapter mv, final Class<?> origReturnType) {
        if (origReturnType == void.class) {
            mv.pop();
        } else if (origReturnType == Object.class) {
            // Must hide ConsString (and potentially other internal Nashorn types) from callers
            EXPORT_RETURN_VALUE.invoke(mv);
        } else if (origReturnType == byte.class) {
            mv.visitInsn(I2B);
        } else if (origReturnType == short.class) {
            mv.visitInsn(I2S);
        } else if (origReturnType == float.class) {
            mv.visitInsn(D2F);
        } else if (origReturnType == char.class) {
            TO_CHAR_PRIMITIVE.invoke(mv);
        }
    }

    /**
     * Emits instruction for converting a parameter on the top of the stack to
     * a type that is understood by Nashorn.
     * @param mv the current method visitor
     * @param t the type on the top of the stack
     * @param varArg if the invocation will be variable arity
     */
    private static void convertParam(final InstructionAdapter mv, final Type t, final boolean varArg) {
        // We perform conversions of some primitives to accommodate types that
        // Nashorn can handle.
        switch(t.getSort()) {
        case Type.CHAR:
            // Chars are boxed, as we don't know if the JS code wants to treat
            // them as an effective "unsigned short" or as a single-char string.
            CHAR_VALUE_OF.invoke(mv);
            break;
        case Type.FLOAT:
            // Floats are widened to double.
            mv.visitInsn(Opcodes.F2D);
            if (varArg) {
                // We'll be boxing everything anyway for the vararg invocation,
                // so we might as well do it proactively here and thus not cause
                // a widening in the number of slots, as that could even make
                // the array creation invocation go over 255 param slots.
                DOUBLE_VALUE_OF.invoke(mv);
            }
            break;
        case Type.LONG:
            // Longs are boxed as Nashorn can't represent them precisely as a
            // primitive number.
            LONG_VALUE_OF.invoke(mv);
            break;
        case Type.OBJECT:
            if(t.equals(OBJECT_TYPE)) {
                // Object can carry a ScriptObjectMirror and needs to be unwrapped
                // before passing into a Nashorn function.
                UNWRAP.invoke(mv);
            }
            break;
        }
    }

    private static int getParamListLengthInSlots(final Type[] paramTypes) {
        int len = paramTypes.length;
        for(final Type t: paramTypes) {
            final int sort = t.getSort();
            if (sort == Type.FLOAT || sort == Type.DOUBLE) {
                // Floats are widened to double, so they'll take up two slots.
                // Longs on the other hand are always boxed, so their width
                // becomes 1 and thus they don't contribute an extra slot here.
                ++len;
            }
        }
        return len;
    }
    /**
     * Emit code to restore the previous Nashorn Context when needed.
     * @param mv the instruction adapter
     * @param globalRestoringRunnableVar index of the local variable holding the reference to the global restoring Runnable
     */
    private static void emitFinally(final InstructionAdapter mv, final int globalRestoringRunnableVar) {
        mv.visitVarInsn(ALOAD, globalRestoringRunnableVar);
        RUN.invoke(mv);
    }

    private static boolean isThrowableDeclared(final Class<?>[] exceptions) {
        for (final Class<?> exception : exceptions) {
            if (exception == Throwable.class) {
                return true;
            }
        }
        return false;
    }

    private void generateSuperMethods() {
        for(final MethodInfo mi: methodInfos) {
            if(!Modifier.isAbstract(mi.method.getModifiers())) {
                generateSuperMethod(mi);
            }
        }
    }

    private void generateSuperMethod(final MethodInfo mi) {
        final Method method = mi.method;

        final String methodDesc = mi.type.toMethodDescriptorString();
        final String name = mi.getName();

        final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(getAccessModifiers(method),
                SUPER_PREFIX + name, methodDesc, null, getExceptionNames(method.getExceptionTypes())));
        mv.visitCode();

        emitSuperCall(mv, method.getDeclaringClass(), name, methodDesc);
        mv.areturn(Type.getType(mi.type.returnType()));
        endMethod(mv);
    }

    // find the appropriate super type to use for invokespecial on the given interface
    private Class<?> findInvokespecialOwnerFor(final Class<?> cl) {
        assert Modifier.isInterface(cl.getModifiers()) : cl + " is not an interface";

        if (cl.isAssignableFrom(superClass)) {
            return superClass;
        }

        for (final Class<?> iface : interfaces) {
             if (cl.isAssignableFrom(iface)) {
                 return iface;
             }
        }

        // we better that interface that extends the given interface!
        throw new AssertionError("can't find the class/interface that extends " + cl);
    }

    private int emitSuperConstructorCall(final InstructionAdapter mv, final String methodDesc) {
        return emitSuperCall(mv, null, INIT, methodDesc, true);
    }

    private int emitSuperCall(final InstructionAdapter mv, final Class<?> owner, final String name, final String methodDesc) {
        return emitSuperCall(mv, owner, name, methodDesc, false);
    }

    private int emitSuperCall(final InstructionAdapter mv, final Class<?> owner, final String name, final String methodDesc, final boolean constructor) {
        mv.visitVarInsn(ALOAD, 0);
        int nextParam = 1;
        final Type methodType = Type.getMethodType(methodDesc);
        for(final Type t: methodType.getArgumentTypes()) {
            mv.load(nextParam, t);
            nextParam += t.getSize();
        }

        // default method - non-abstract, interface method
        if (!constructor && Modifier.isInterface(owner.getModifiers())) {
            // we should call default method on the immediate "super" type - not on (possibly)
            // the indirectly inherited interface class!
            mv.invokespecial(Type.getInternalName(findInvokespecialOwnerFor(owner)), name, methodDesc, false);
        } else {
            mv.invokespecial(superClassName, name, methodDesc, false);
        }
        return nextParam;
    }

    private void generateFinalizerMethods() {
        generateFinalizerDelegate();
        generateFinalizerOverride();
    }

    private void generateFinalizerDelegate() {
        // Generate a delegate that will be invoked from the no-permission trampoline. Note it can be private, as we'll
        // refer to it with a MethodHandle constant pool entry in the overridden finalize() method (see
        // generateFinalizerOverride()).
        final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(ACC_PRIVATE | ACC_STATIC,
                FINALIZER_DELEGATE_NAME, FINALIZER_DELEGATE_METHOD_DESCRIPTOR, null, null));

        // Simply invoke super.finalize()
        mv.visitVarInsn(ALOAD, 0);
        mv.checkcast(Type.getType(generatedClassName));
        mv.invokespecial(superClassName, "finalize", VOID_METHOD_DESCRIPTOR, false);

        mv.visitInsn(RETURN);
        endMethod(mv);
    }

    private void generateFinalizerOverride() {
        final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(ACC_PUBLIC, "finalize",
                VOID_METHOD_DESCRIPTOR, null, null));
        // Overridden finalizer will take a MethodHandle to the finalizer delegating method, ...
        mv.aconst(new Handle(Opcodes.H_INVOKESTATIC, generatedClassName, FINALIZER_DELEGATE_NAME,
                FINALIZER_DELEGATE_METHOD_DESCRIPTOR));
        mv.visitVarInsn(ALOAD, 0);
        // ...and invoke it through JavaAdapterServices.invokeNoPermissions
        INVOKE_NO_PERMISSIONS.invoke(mv);
        mv.visitInsn(RETURN);
        endMethod(mv);
    }

    private static String[] getExceptionNames(final Class<?>[] exceptions) {
        final String[] exceptionNames = new String[exceptions.length];
        for (int i = 0; i < exceptions.length; ++i) {
            exceptionNames[i] = Type.getInternalName(exceptions[i]);
        }
        return exceptionNames;
    }

    private static int getAccessModifiers(final Method method) {
        return ACC_PUBLIC | (method.isVarArgs() ? ACC_VARARGS : 0);
    }

    /**
     * Gathers methods that can be implemented or overridden from the specified type into this factory's
     * {@link #methodInfos} set. It will add all non-final, non-static methods that are either public or protected from
     * the type if the type itself is public. If the type is a class, the method will recursively invoke itself for its
     * superclass and the interfaces it implements, and add further methods that were not directly declared on the
     * class.
     * @param type the type defining the methods.
     */
    private void gatherMethods(final Class<?> type) throws AdaptationException {
        if (Modifier.isPublic(type.getModifiers())) {
            final Module module = type.getModule();
            if (module != null) {
                accessedModules.add(module);
            }

            final Method[] typeMethods = type.isInterface() ? type.getMethods() : type.getDeclaredMethods();

            for (final Method typeMethod: typeMethods) {
                final String name = typeMethod.getName();
                if(name.startsWith(SUPER_PREFIX)) {
                    continue;
                }
                final int m = typeMethod.getModifiers();
                if (Modifier.isStatic(m)) {
                    continue;
                }
                if (Modifier.isPublic(m) || Modifier.isProtected(m)) {
                    // Is it a "finalize()"?
                    if(name.equals("finalize") && typeMethod.getParameterCount() == 0) {
                        if(type != Object.class) {
                            hasExplicitFinalizer = true;
                            if(Modifier.isFinal(m)) {
                                // Must be able to override an explicit finalizer
                                throw new AdaptationException(Outcome.ERROR_FINAL_FINALIZER, type.getCanonicalName());
                            }
                        }
                        continue;
                    }

                    for (final Class<?> pt : typeMethod.getParameterTypes()) {
                        if (pt.isPrimitive()) continue;
                        final Module ptMod = pt.getModule();
                        if (ptMod != null) {
                            accessedModules.add(ptMod);
                        }
                    }

                    final Class<?> rt = typeMethod.getReturnType();
                    if (!rt.isPrimitive()) {
                        final Module rtMod = rt.getModule();
                        if (rtMod != null) accessedModules.add(rtMod);
                    }

                    final MethodInfo mi = new MethodInfo(typeMethod);
                    if (Modifier.isFinal(m) || isCallerSensitive(typeMethod)) {
                        finalMethods.add(mi);
                    } else if (!finalMethods.contains(mi) && methodInfos.add(mi) && Modifier.isAbstract(m)) {
                            abstractMethodNames.add(mi.getName());
                        }
                }
            }
        }
        // If the type is a class, visit its superclasses and declared interfaces. If it's an interface, we're done.
        // Needing to invoke the method recursively for a non-interface Class object is the consequence of needing to
        // see all declared protected methods, and Class.getDeclaredMethods() doesn't provide those declared in a
        // superclass. For interfaces, we used Class.getMethods(), as we're only interested in public ones there, and
        // getMethods() does provide those declared in a superinterface.
        if (!type.isInterface()) {
            final Class<?> superType = type.getSuperclass();
            if (superType != null) {
                gatherMethods(superType);
            }
            for (final Class<?> itf: type.getInterfaces()) {
                gatherMethods(itf);
            }
        }
    }

    private void gatherMethods(final List<Class<?>> classes) throws AdaptationException {
        for(final Class<?> c: classes) {
            gatherMethods(c);
        }
    }

    private static final AccessControlContext GET_DECLARED_MEMBERS_ACC_CTXT = ClassAndLoader.createPermAccCtxt("accessDeclaredMembers");

    /**
     * Creates a collection of methods that are not final, but we still never allow them to be overridden in adapters,
     * as explicitly declaring them automatically is a bad idea. Currently, this means {@code Object.finalize()} and
     * {@code Object.clone()}.
     * @return a collection of method infos representing those methods that we never override in adapter classes.
     */
    private static Collection<MethodInfo> getExcludedMethods() {
        return AccessController.doPrivileged(new PrivilegedAction<Collection<MethodInfo>>() {
            @Override
            public Collection<MethodInfo> run() {
                try {
                    return Arrays.asList(
                            new MethodInfo(Object.class, "finalize"),
                            new MethodInfo(Object.class, "clone"));
                } catch (final NoSuchMethodException e) {
                    throw new AssertionError(e);
                }
            }
        }, GET_DECLARED_MEMBERS_ACC_CTXT);
    }

    private String getCommonSuperClass(final String type1, final String type2) {
        try {
            final Class<?> c1 = Class.forName(type1.replace('/', '.'), false, commonLoader);
            final Class<?> c2 = Class.forName(type2.replace('/', '.'), false, commonLoader);
            if (c1.isAssignableFrom(c2)) {
                return type1;
            }
            if (c2.isAssignableFrom(c1)) {
                return type2;
            }
            if (c1.isInterface() || c2.isInterface()) {
                return OBJECT_TYPE.getInternalName();
            }
            return assignableSuperClass(c1, c2).getName().replace('.', '/');
        } catch(final ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

    private static Class<?> assignableSuperClass(final Class<?> c1, final Class<?> c2) {
        final Class<?> superClass = c1.getSuperclass();
        return superClass.isAssignableFrom(c2) ? superClass : assignableSuperClass(superClass, c2);
    }

    private static boolean isCallerSensitive(final AccessibleObject e) {
        return e.isAnnotationPresent(CallerSensitive.class);
    }

    private static final Call lookupServiceMethod(final String name, final Class<?> rtype, final Class<?>... ptypes) {
        return staticCallNoLookup(JavaAdapterServices.class, name, rtype, ptypes);
    }
}