import jdk.nashorn.internal.codegen.FunctionSignature; //导入依赖的package包/类
private MethodHandle addCode(final FunctionNode fn, final MethodType runtimeType, final MethodHandle guard, final MethodHandle fallback) {
    final MethodType targetType = new FunctionSignature(fn).getMethodType();
    MethodHandle target =
        MH.findStatic(
                LOOKUP,
                fn.getCompileUnit().getCode(),
                fn.getName(),
                targetType);

    /*
     * For any integer argument. a double that is representable as an integer is OK.
     * otherwise the guard would have failed. in that case introduce a filter that
     * casts the double to an integer, which we know will preserve all precision.
     */
    for (int i = 0; i < targetType.parameterCount(); i++) {
        if (targetType.parameterType(i) == int.class) {
            //representable as int
            target = MH.filterArguments(target, i, ENSURE_INT);
        }
    }

    MethodHandle mh = target;
    if (guard != null) {
        mh = MH.guardWithTest(MH.asCollector(guard, Object[].class, target.type().parameterCount()), MH.asType(target, fallback.type()), fallback);
    }

    final CompiledFunction cf = new CompiledFunction(runtimeType == null ? targetType : runtimeType, mh);
    code.add(cf);

    return cf.getInvoker();
}
 

import jdk.nashorn.internal.codegen.FunctionSignature; //导入依赖的package包/类
MethodHandle lookup(final FunctionNode fn) {
    final MethodType type = new FunctionSignature(fn).getMethodType();
    logLookup(true, type);
    return lookupCodeMethod(fn.getCompileUnit().getCode(), type);
}