Java Type.widest方法代码示例

import jdk.nashorn.internal.codegen.types.Type; //导入方法依赖的package包/类
private static Type computeElementType(final Expression[] value) {
    Type widestElementType = Type.INT;

    for (final Expression elem : value) {
        if (elem == null) {
            widestElementType = widestElementType.widest(Type.OBJECT); //no way to represent undefined as number
            break;
        }

        final Type type = elem.getType().isUnknown() ? Type.OBJECT : elem.getType();
        if (type.isBoolean()) {
            //TODO fix this with explicit boolean types
            widestElementType = widestElementType.widest(Type.OBJECT);
            break;
        }

        widestElementType = widestElementType.widest(type);
        if (widestElementType.isObject()) {
            break;
        }
    }
    return widestElementType;
}
 

import jdk.nashorn.internal.codegen.types.Type; //导入方法依赖的package包/类
private static Type decideType(final Type lhsType, final Type rhsType) {
    // Compare this to getWidestOperationType() for ADD and ASSIGN_ADD cases. There's some similar logic, but these
    // are optimistic decisions, meaning that we don't have to treat boolean addition separately (as it'll become
    // int addition in the general case anyway), and that we also don't conservatively widen sums of ints to
    // longs, or sums of longs to doubles.
    if(isString(lhsType) || isString(rhsType)) {
        return Type.CHARSEQUENCE;
    }
    // NOTE: We don't have optimistic object-to-(int, long) conversions. Therefore, if any operand is an Object, we
    // bail out of optimism here and presume a conservative Object return value, as the object's ToPrimitive() can
    // end up returning either a number or a string, and their common supertype is Object, for better or worse.
    final Type widest = Type.widest(undefinedToNumber(booleanToInt(lhsType)), undefinedToNumber(booleanToInt(rhsType)));
    return widest.isObject() ? Type.OBJECT : widest;
}
 

import jdk.nashorn.internal.codegen.types.Type; //导入方法依赖的package包/类
/**
 * The first type to try to use for this generated runtime node
 *
 * @return a type
 */
public Type firstTypeGuess() {
    Type widest = Type.UNKNOWN;
    for (final Type type : parameterTypes) {
        if (type.isObject()) {
            continue;
        }
        widest = Type.widest(type, widest);
    }
    widest = Type.widest(widest, firstTypeGuessForObject(request));

    return widest;
}
 

import jdk.nashorn.internal.codegen.types.Type; //导入方法依赖的package包/类
private static boolean comparisonOperandsArePrimitive(final BinaryNode binaryNode) {
    final Type widest = Type.widest(binaryNode.lhs().getType(), binaryNode.rhs().getType());
    return widest.isNumeric() || widest.isBoolean();
}
 

import jdk.nashorn.internal.codegen.types.Type; //导入方法依赖的package包/类
/**
 * Get the widest element type of two arrays. This can be done faster in subclasses, but
 * this works for all ContinuousArrayDatas and for where more optimal checks haven't been
 * implemented.
 *
 * @param otherData another ContinuousArrayData
 * @return the widest boxed element type
 */
public ContinuousArrayData widest(final ContinuousArrayData otherData) {
    final Class<?> elementType = getElementType();
    return Type.widest(elementType, otherData.getElementType()) == elementType ? this : otherData;
}