Java Code Examples for java.lang.invoke.MethodType#parameterCount()

@Override
boolean isApplicable(final MethodType callSiteType, final SingleDynamicMethod method) {
    final MethodType methodType = method.getMethodType();
    final int methodArity = methodType.parameterCount();
    if(methodArity != callSiteType.parameterCount()) {
        return false;
    }
    // 0th arg is receiver; it doesn't matter for overload
    // resolution.
    for(int i = 1; i < methodArity; ++i) {
        if(!TypeUtilities.isSubtype(callSiteType.parameterType(i), methodType.parameterType(i))) {
            return false;
        }
    }
    return true;
}
 

private static MethodHandle spreadGuardArguments(final MethodHandle guard, final MethodType descType) {
    final MethodType guardType = guard.type();
    final int guardParamCount = guardType.parameterCount();
    final int descParamCount = descType.parameterCount();
    final int spreadCount = guardParamCount - descParamCount + 1;
    if (spreadCount <= 0) {
        // Guard doesn't dip into the varargs
        return guard;
    }

    final MethodHandle arrayConvertingGuard;
    // If the last parameter type of the guard is an array, then it is already itself a guard for a vararg apply
    // invocation. We must filter the last argument with toApplyArgs otherwise deeper levels of nesting will fail
    // with ClassCastException of NativeArray to Object[].
    if (guardType.parameterType(guardParamCount - 1).isArray()) {
        arrayConvertingGuard = MH.filterArguments(guard, guardParamCount - 1, NativeFunction.TO_APPLY_ARGS);
    } else {
        arrayConvertingGuard = guard;
    }

    return ScriptObject.adaptHandleToVarArgCallSite(arrayConvertingGuard, descParamCount);
}
 

@Override
boolean isApplicable(final MethodType callSiteType, final SingleDynamicMethod method) {
    final MethodType methodType = method.getMethodType();
    final int methodArity = methodType.parameterCount();
    if(methodArity != callSiteType.parameterCount()) {
        return false;
    }
    // 0th arg is receiver; it doesn't matter for overload
    // resolution.
    for(int i = 1; i < methodArity; ++i) {
        if(!TypeUtilities.isSubtype(callSiteType.parameterType(i), methodType.parameterType(i))) {
            return false;
        }
    }
    return true;
}
 

private static MethodHandle spreadGuardArguments(final MethodHandle guard, final MethodType descType) {
    final MethodType guardType = guard.type();
    final int guardParamCount = guardType.parameterCount();
    final int descParamCount = descType.parameterCount();
    final int spreadCount = guardParamCount - descParamCount + 1;
    if (spreadCount <= 0) {
        // Guard doesn't dip into the varargs
        return guard;
    }

    final MethodHandle arrayConvertingGuard;
    // If the last parameter type of the guard is an array, then it is already itself a guard for a vararg apply
    // invocation. We must filter the last argument with toApplyArgs otherwise deeper levels of nesting will fail
    // with ClassCastException of NativeArray to Object[].
    if (guardType.parameterType(guardParamCount - 1).isArray()) {
        arrayConvertingGuard = MH.filterArguments(guard, guardParamCount - 1, NativeFunction.TO_APPLY_ARGS);
    } else {
        arrayConvertingGuard = guard;
    }

    return ScriptObject.adaptHandleToVarArgCallSite(arrayConvertingGuard, descParamCount);
}
 

OverloadedMethod(List<MethodHandle> methodHandles, OverloadedDynamicMethod parent, MethodType callSiteType,
        LinkerServices linkerServices) {
    this.parent = parent;
    this.callSiteType = callSiteType;
    this.linkerServices = linkerServices;

    fixArgMethods = new ArrayList<>(methodHandles.size());
    varArgMethods = new ArrayList<>(methodHandles.size());
    final int argNum = callSiteType.parameterCount();
    for(MethodHandle mh: methodHandles) {
        if(mh.isVarargsCollector()) {
            final MethodHandle asFixed = mh.asFixedArity();
            if(argNum == asFixed.type().parameterCount()) {
                fixArgMethods.add(asFixed);
            }
            varArgMethods.add(mh);
        } else {
            fixArgMethods.add(mh);
        }
    }
    fixArgMethods.trimToSize();
    varArgMethods.trimToSize();

    final MethodHandle bound = SELECT_METHOD.bindTo(this);
    final MethodHandle collecting = SingleDynamicMethod.collectArguments(bound, argNum).asType(
            callSiteType.changeReturnType(MethodHandle.class));
    invoker = MethodHandles.foldArguments(MethodHandles.exactInvoker(callSiteType), collecting);
}
 

private static MethodHandle getComputedValueMethodHandle(Lookup lookup, Method method)
        throws IllegalAccessException {
    // check: (ExecutionContext) -> Object
    MethodHandle handle = lookup.unreflect(method);
    MethodType type = handle.type();
    if (type.parameterCount() != 1 || !ExecutionContext.class.equals(type.parameterType(0))) {
        throw new IllegalArgumentException(handle.toString());
    }
    if (!Object.class.equals(type.returnType())) {
        throw new IllegalArgumentException(handle.toString());
    }
    return handle;
}
 

/**
 * Constructor
 * @param functionNodeId function node id
 * @param type           method type found at runtime corresponding to parameter guess
 * @param needsCallee    does the function using this type map need a callee
 */
public TypeMap(final int functionNodeId, final MethodType type, final boolean needsCallee) {
    final Type[] types = new Type[type.parameterCount()];
    int pos = 0;
    for (final Class<?> p : type.parameterArray()) {
        types[pos++] = Type.typeFor(p);
    }

    this.functionNodeId = functionNodeId;
    this.paramTypes = types;
    this.returnType = Type.typeFor(type.returnType());
    this.needsCallee = needsCallee;
}
 

/**
 * Constructor
 * @param functionNodeId function node id
 * @param type           method type found at runtime corresponding to parameter guess
 * @param needsCallee    does the function using this type map need a callee
 */
public TypeMap(final int functionNodeId, final MethodType type, final boolean needsCallee) {
    final Type[] types = new Type[type.parameterCount()];
    int pos = 0;
    for (final Class<?> p : type.parameterArray()) {
        types[pos++] = Type.typeFor(p);
    }

    this.functionNodeId = functionNodeId;
    this.paramTypes = types;
    this.returnType = Type.typeFor(type.returnType());
    this.needsCallee = needsCallee;
}
 

/**
 * Test of parameterCount method, of class MethodType.
 */
@Test
public void testParameterCount() {
    System.out.println("parameterCount");
    MethodType instance = mt_viS;
    int expResult = 2;
    int result = instance.parameterCount();
    assertEquals(expResult, result);
}
 

/**
 * Constructor
 * @param functionNodeId function node id
 * @param type           method type found at runtime corresponding to parameter guess
 * @param needsCallee    does the function using this type map need a callee
 */
public TypeMap(final int functionNodeId, final MethodType type, final boolean needsCallee) {
    final Type[] types = new Type[type.parameterCount()];
    int pos = 0;
    for (final Class<?> p : type.parameterArray()) {
        types[pos++] = Type.typeFor(p);
    }

    this.functionNodeId = functionNodeId;
    this.paramTypes = types;
    this.returnType = Type.typeFor(type.returnType());
    this.needsCallee = needsCallee;
}
 

/**
 * Test of parameterCount method, of class MethodType.
 */
@Test
public void testParameterCount() {
    System.out.println("parameterCount");
    MethodType instance = mt_viS;
    int expResult = 2;
    int result = instance.parameterCount();
    assertEquals(expResult, result);
}
 

static boolean needsCallee(final MethodType type) {
    final int length = type.parameterCount();

    if (length == 0) {
        return false;
    }

    final Class<?> param0 = type.parameterType(0);
    return param0 == ScriptFunction.class || param0 == boolean.class && length > 1 && type.parameterType(1) == ScriptFunction.class;
}
 

/**
 * Constructor
 * @param functionNodeId function node id
 * @param type           method type found at runtime corresponding to parameter guess
 * @param needsCallee    does the function using this type map need a callee
 */
public TypeMap(final int functionNodeId, final MethodType type, final boolean needsCallee) {
    final Type[] types = new Type[type.parameterCount()];
    int pos = 0;
    for (final Class<?> p : type.parameterArray()) {
        types[pos++] = Type.typeFor(p);
    }

    this.functionNodeId = functionNodeId;
    this.paramTypes = types;
    this.returnType = Type.typeFor(type.returnType());
    this.needsCallee = needsCallee;
}
 

static boolean needsCallee(final MethodType type) {
    final int length = type.parameterCount();

    if (length == 0) {
        return false;
    }

    final Class<?> param0 = type.parameterType(0);
    return param0 == ScriptFunction.class || param0 == boolean.class && length > 1 && type.parameterType(1) == ScriptFunction.class;
}
 

private static boolean typeMatchesDescription(String paramTypes, MethodType type) {
    final StringTokenizer tok = new StringTokenizer(paramTypes, ", ");
    for(int i = 1; i < type.parameterCount(); ++i) { // i = 1 as we ignore the receiver
        if(!(tok.hasMoreTokens() && typeNameMatches(tok.nextToken(), type.parameterType(i)))) {
            return false;
        }
    }
    return !tok.hasMoreTokens();
}
 

/**
 * Test of parameterCount method, of class MethodType.
 */
@Test
public void testParameterCount() {
    System.out.println("parameterCount");
    MethodType instance = mt_viS;
    int expResult = 2;
    int result = instance.parameterCount();
    assertEquals(expResult, result);
}
 

private static boolean typeMatchesDescription(final String paramTypes, final MethodType type) {
    final StringTokenizer tok = new StringTokenizer(paramTypes, ", ");
    for(int i = 1; i < type.parameterCount(); ++i) { // i = 1 as we ignore the receiver
        if(!(tok.hasMoreTokens() && typeNameMatches(tok.nextToken(), type.parameterType(i)))) {
            return false;
        }
    }
    return !tok.hasMoreTokens();
}
 

private static boolean typeMatchesDescription(final String paramTypes, final MethodType type) {
    final StringTokenizer tok = new StringTokenizer(paramTypes, ", ");
    for(int i = 1; i < type.parameterCount(); ++i) { // i = 1 as we ignore the receiver
        if(!(tok.hasMoreTokens() && typeNameMatches(tok.nextToken(), type.parameterType(i)))) {
            return false;
        }
    }
    return !tok.hasMoreTokens();
}
 

private static boolean isApplicableDynamically(final LinkerServices linkerServices, final MethodType callSiteType,
        final SingleDynamicMethod m) {
    final MethodType methodType = m.getMethodType();
    final boolean varArgs = m.isVarArgs();
    final int fixedArgLen = methodType.parameterCount() - (varArgs ? 1 : 0);
    final int callSiteArgLen = callSiteType.parameterCount();

    // Arity checks
    if(varArgs) {
        if(callSiteArgLen < fixedArgLen) {
            return false;
        }
    } else if(callSiteArgLen != fixedArgLen) {
        return false;
    }

    // Fixed arguments type checks, starting from 1, as receiver type doesn't participate
    for(int i = 1; i < fixedArgLen; ++i) {
        if(!isApplicableDynamically(linkerServices, callSiteType.parameterType(i), methodType.parameterType(i))) {
            return false;
        }
    }
    if(!varArgs) {
        // Not vararg; both arity and types matched.
        return true;
    }

    final Class<?> varArgArrayType = methodType.parameterType(fixedArgLen);
    final Class<?> varArgType = varArgArrayType.getComponentType();

    if(fixedArgLen == callSiteArgLen - 1) {
        // Exactly one vararg; check both array type matching and array component type matching.
        final Class<?> callSiteArgType = callSiteType.parameterType(fixedArgLen);
        return isApplicableDynamically(linkerServices, callSiteArgType, varArgArrayType)
                || isApplicableDynamically(linkerServices, callSiteArgType, varArgType);
    }

    // Either zero, or more than one vararg; check if all actual vararg types match the vararg array component type.
    for(int i = fixedArgLen; i < callSiteArgLen; ++i) {
        if(!isApplicableDynamically(linkerServices, callSiteType.parameterType(i), varArgType)) {
            return false;
        }
    }

    return true;
}
 

/**
 * Heuristic to figure out if the method handle has a callee argument. If it's type is
 * {@code (ScriptFunction, ...)}, then we'll assume it has a callee argument. We need this as
 * the constructor above is not passed this information, and can't just blindly assume it's false
 * (notably, it's being invoked for creation of new scripts, and scripts have scopes, therefore
 * they also always receive a callee).
 *
 * @param mh the examined method handle
 *
 * @return true if the method handle expects a callee, false otherwise
 */
protected static boolean needsCallee(final MethodHandle mh) {
    final MethodType type = mh.type();
    return (type.parameterCount() > 0 && type.parameterType(0) == ScriptFunction.class);
}