import com.sun.jdi.Type; //导入依赖的package包/类
private static Type boxType(Type t) {
    if (t instanceof ClassType) {
        String name = ((ClassType) t).name();
        if (name.equals("java.lang.Boolean")) {
            t = t.virtualMachine().mirrorOf(true).type();
        } else if (name.equals("java.lang.Byte")) {
            t = t.virtualMachine().mirrorOf((byte) 10).type();
        } else if (name.equals("java.lang.Character")) {
            t = t.virtualMachine().mirrorOf('a').type();
        } else if (name.equals("java.lang.Integer")) {
            t = t.virtualMachine().mirrorOf(10).type();
        } else if (name.equals("java.lang.Long")) {
            t = t.virtualMachine().mirrorOf(10l).type();
        } else if (name.equals("java.lang.Short")) {
            t = t.virtualMachine().mirrorOf((short)10).type();
        } else if (name.equals("java.lang.Float")) {
            t = t.virtualMachine().mirrorOf(10f).type();
        } else if (name.equals("java.lang.Double")) {
            t = t.virtualMachine().mirrorOf(10.0).type();
        }
    }
    return t;
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
public boolean hasAllTypes() {
    if (getInnerValue () == null) {
        return true;
    }
    Type t;
    synchronized (valueTypeLoaded) {
        if (!valueTypeLoaded[0]) {
            return false;
        }
        t = valueType;
    }
    if (t instanceof ClassType) {
        ClassType ct = (ClassType) t;
        if (!getDebugger().hasAllInterfaces(ct)) {
            return false;
        }
        synchronized (superClassLoaded) {
            if (!superClassLoaded[0]) {
                return false;
            }
        }
    }
    return true;
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
public List<JPDAClassType> getAllInterfaces() {
    if (getInnerValue () == null) {
        return null;
    }
    try {
        Type t = getCachedType();
        if (!(t instanceof ClassType)) {
            return null;
        }
        ClassType ct = (ClassType) t;
        return getDebugger().getAllInterfaces(ct);
    } catch (ObjectCollectedExceptionWrapper ocex) {
        return null;
    } catch (InternalExceptionWrapper ex) {
        return null;
    } catch (VMDisconnectedExceptionWrapper e) {
        return null;
    }
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
/**
 * Test whether the value has referenced objects.
 *
 * @param value
 *            the value.
 * @param includeStatic
 *            whether or not the static fields are visible.
 * @return true if this value is reference objects.
 */
public static boolean hasChildren(Value value, boolean includeStatic) {
    if (value == null) {
        return false;
    }
    Type type = value.type();
    if (type instanceof ArrayType) {
        return ((ArrayReference) value).length() > 0;
    }
    return value.type() instanceof ReferenceType && ((ReferenceType) type).allFields().stream()
            .filter(t -> includeStatic || !t.isStatic()).toArray().length > 0;
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
private Value handleSetValueForObject(String name, String belongToClass, String valueString,
        ObjectReference container, Map<String, Object> options) throws InvalidTypeException, ClassNotLoadedException {
    Value newValue;
    if (container instanceof ArrayReference) {
        ArrayReference array = (ArrayReference) container;
        Type eleType = ((ArrayType) array.referenceType()).componentType();
        newValue = setArrayValue(array, eleType, Integer.parseInt(name), valueString, options);
    } else {
        if (StringUtils.isBlank(belongToClass)) {
            Field field = container.referenceType().fieldByName(name);
            if (field != null) {
                if (field.isStatic()) {
                    newValue = this.setStaticFieldValue(container.referenceType(), field, name, valueString, options);
                } else {
                    newValue = this.setObjectFieldValue(container, field, name, valueString, options);
                }
            } else {
                throw new IllegalArgumentException(
                        String.format("SetVariableRequest: Variable %s cannot be found.", name));
            }
        } else {
            newValue = setFieldValueWithConflict(container, container.referenceType().allFields(), name, belongToClass, valueString, options);
        }
    }
    return newValue;
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
private static Type unboxType(Type t) {
    if (t instanceof ClassType) {
        String name = ((ClassType) t).name();
        if (name.equals("java.lang.Boolean")) {
            t = t.virtualMachine().mirrorOf(true).type();
        } else if (name.equals("java.lang.Byte")) {
            t = t.virtualMachine().mirrorOf((byte) 10).type();
        } else if (name.equals("java.lang.Character")) {
            t = t.virtualMachine().mirrorOf('a').type();
        } else if (name.equals("java.lang.Integer")) {
            t = t.virtualMachine().mirrorOf(10).type();
        } else if (name.equals("java.lang.Long")) {
            t = t.virtualMachine().mirrorOf(10l).type();
        } else if (name.equals("java.lang.Short")) {
            t = t.virtualMachine().mirrorOf((short)10).type();
        } else if (name.equals("java.lang.Float")) {
            t = t.virtualMachine().mirrorOf(10f).type();
        } else if (name.equals("java.lang.Double")) {
            t = t.virtualMachine().mirrorOf(10.0).type();
        }
    }
    return t;
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
private ArrayType getArrayType(NewArrayTree arg0, Type type, int depth, EvaluationContext evaluationContext) {
    String arrayClassName;
    if (depth < BRACKETS.length()/2) {
        arrayClassName = type.name() + BRACKETS.substring(0, 2*depth);
    } else {
        arrayClassName = type.name() + BRACKETS;
        for (int i = BRACKETS.length()/2; i < depth; i++) {
            arrayClassName += "[]"; // NOI18N
        }
    }
    ReferenceType rt = getOrLoadClass(type.virtualMachine(), arrayClassName, evaluationContext);
    if (rt == null) {
        Assert.error(arg0, "unknownType", arrayClassName);
    }
    return (ArrayType) rt;
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
private Type getSubArrayType(Tree arg0, Type type, EvaluationContext evaluationContext) {
    String name = type.name();
    if (name.endsWith("[]")) {
        name = name.substring(0, name.length() - 2);
        if (!name.endsWith("[]")) {
            Type pType = getPrimitiveType(name, type.virtualMachine());
            if (pType != null) {
                return pType;
            }
        }
        type = getOrLoadClass(type.virtualMachine(), name, evaluationContext);
        if (type == null) {
            Assert.error(arg0, "unknownType", name);
        }
    }
    return type;
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
@Override
public Mirror visitArrayType(ArrayTypeTree arg0, EvaluationContext evaluationContext) {
    Mirror arrayType = arg0.getType().accept(this, evaluationContext);
    if (!(arrayType instanceof Type)) {
        return arrayType;
    }
    Type type = (Type) arrayType;
    String arrayClassName = type.name()+"[]";
    ReferenceType aType = getOrLoadClass(type.virtualMachine(), arrayClassName, evaluationContext);
    if (aType != null) {
        return aType;
    } else {
        Assert.error(arg0, "unknownType", arrayClassName);
        return null;
    }
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
/**
 * Auto-boxes or un-boxes arguments of a method.
 */
static void autoboxArguments(List<Type> types, List<Value> argVals,
                             ThreadReference evaluationThread,
                             EvaluationContext evaluationContext) throws InvalidTypeException,
                                                                         ClassNotLoadedException,
                                                                         IncompatibleThreadStateException,
                                                                         InvocationException {
    if (types.size() != argVals.size()) {
        return ;
    }
    int n = types.size();
    for (int i = 0; i < n; i++) {
        Type t = types.get(i);
        Value v = argVals.get(i);
        if (v instanceof ObjectReference && t instanceof PrimitiveType) {
            argVals.set(i, unbox((ObjectReference) v, (PrimitiveType) t, evaluationThread, evaluationContext));
        }
        if (v instanceof PrimitiveValue && t instanceof ReferenceType) {
            argVals.set(i, box((PrimitiveValue) v, (ReferenceType) t, evaluationThread, evaluationContext));
        }
    }
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
Type findType(String signature) throws ClassNotLoadedException {
    Type type;
    if (signature.length() == 1) {
        /* OTI FIX: Must be a primitive type or the void type */
        char sig = signature.charAt(0);
        if (sig == 'V') {
            type = vm.theVoidType();
        } else {
            type = vm.primitiveTypeMirror((byte)sig);
        }
    } else {
        // Must be a reference type.
        ClassLoaderReferenceImpl loader =
                   (ClassLoaderReferenceImpl)classLoader();
        if ((loader == null) ||
            (isPrimitiveArray(signature)) //Work around 4450091
            ) {
            // Caller wants type of boot class field
            type = vm.findBootType(signature);
        } else {
            // Caller wants type of non-boot class field
            type = loader.findType(signature);
        }
    }
    return type;
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
Type findComponentType(String signature) throws ClassNotLoadedException {
    byte tag = (byte)signature.charAt(0);
    if (PacketStream.isObjectTag(tag)) {
        // It's a reference type
        JNITypeParser parser = new JNITypeParser(componentSignature());
        List<ReferenceType> list = vm.classesByName(parser.typeName());
        Iterator<ReferenceType> iter = list.iterator();
        while (iter.hasNext()) {
            ReferenceType type = iter.next();
            ClassLoaderReference cl = type.classLoader();
            if ((cl == null)?
                     (classLoader() == null) :
                     (cl.equals(classLoader()))) {
                return type;
            }
        }
        // Component class has not yet been loaded
        throw new ClassNotLoadedException(componentTypeName());
    } else {
        // It's a primitive type
        return vm.primitiveTypeMirror(tag);
    }
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
static boolean isComponentAssignable(Type destination, Type source) {
    if (source instanceof PrimitiveType) {
        // Assignment of primitive arrays requires identical
        // component types.
        return source.equals(destination);
    } else {
        if (destination instanceof PrimitiveType) {
            return false;
        }

        ReferenceTypeImpl refSource = (ReferenceTypeImpl)source;
        ReferenceTypeImpl refDestination = (ReferenceTypeImpl)destination;
        // Assignment of object arrays requires availability
        // of widening conversion of component types
        return refSource.isAssignableTo(refDestination);
    }
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
boolean isAssignableTo(ReferenceType destType) {
    if (destType instanceof ArrayType) {
        try {
            Type destComponentType = ((ArrayType)destType).componentType();
            return isComponentAssignable(destComponentType, componentType());
        } catch (ClassNotLoadedException e) {
            // One or both component types has not yet been
            // loaded => can't assign
            return false;
        }
    } else if (destType instanceof InterfaceType) {
        // Only valid InterfaceType assignee is Cloneable
        return destType.name().equals("java.lang.Cloneable");
    } else {
        // Only valid ClassType assignee is Object
        return destType.name().equals("java.lang.Object");
    }
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
private static IFormatter getFormatter(Map<? extends IFormatter, Integer> formatterMap, Type type,
                                       Map<String, Object> options) {
    List<? extends IFormatter> formatterList =
            formatterMap.keySet().stream().filter(t -> t.acceptType(type, options))
                    .sorted((a, b) ->
                            -Integer.compare(formatterMap.get(a), formatterMap.get(b))).collect(Collectors.toList());
    if (formatterList.isEmpty()) {
        throw new UnsupportedOperationException(String.format("There is no related formatter for type %s.",
                type == null ? "null" : type.name()));
    }
    return formatterList.get(0);
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
private Type getSubExpressionType(Tree t) {
    Type type = subExpressionTypes.get(t);
    if (type != null) {
        return type;
    } else {
        if (t.getKind() == Tree.Kind.PARENTHESIZED) {
            return getSubExpressionType(((ParenthesizedTree) t).getExpression());
        }
        return null;
    }
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
private ReferenceType findEnclosingTypeWithMethod(ReferenceType type,
                                                  String enclosingClass,
                                                  String methodName,
                                                  List<? extends TypeMirror> paramTypes,
                                                  List<? extends Type> argTypes,
                                                  Method[] methodPtr,
                                                  VMCache vmCache) {
    ReferenceType etype = findEnclosingType(type, enclosingClass, vmCache);
    if (etype == null) {
        return null;
    }
    Method method;
    try {
        if (paramTypes != null) {
            method = getConcreteMethod(etype, methodName, null, paramTypes);
        } else {
            method = getConcreteMethod2(etype, methodName, argTypes);
        }
    } catch (UnsuitableArgumentsException uaex) {
        method = null;
    }
    if (method != null) {
        methodPtr[0] = method;
        return etype;
    } else {
        return type;
    }
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
private static Method getConcreteMethod2(ReferenceType type, String methodName, List<? extends Type> typeArguments) throws UnsuitableArgumentsException {
    List<Method> methods = type.methodsByName(methodName);
    List<Method> possibleMethods = new ArrayList<Method>();
    List<Method> methodsWithArgTypesNotLoaded = null;
    boolean constructor = "<init>".equals(methodName);
    for (Method method : methods) {
        if (!method.isAbstract() &&
            (!constructor || type.equals(method.declaringType()))) {
            try {
                if (equalTypes(method.argumentTypes(), typeArguments)) {
                    return method;
                }
                if (acceptTypes(method.argumentTypes(), typeArguments)) {
                    possibleMethods.add(method);
                }
            } catch (ClassNotLoadedException ex) {
                if (method.argumentTypeNames().size() == typeArguments.size()) {
                    if (methodsWithArgTypesNotLoaded == null) {
                        methodsWithArgTypesNotLoaded = new ArrayList<Method>();
                    }
                    methodsWithArgTypesNotLoaded.add(method);
                }
            }
        }
    }
    if (possibleMethods.isEmpty()) {
        if (methods.size() > 0) {
            if (methodsWithArgTypesNotLoaded != null) {
                // Workaround for cases when we're not able to test method types.
                return methodsWithArgTypesNotLoaded.get(0);
            }
            throw new UnsuitableArgumentsException();
        }
        return null;
    }
    return possibleMethods.get(0);
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
private Value setStaticFieldValue(Type declaringType, Field field, String name, String value, Map<String, Object> options)
        throws ClassNotLoadedException, InvalidTypeException {
    if (field.isFinal()) {
        throw new UnsupportedOperationException(
                String.format("SetVariableRequest: Final field %s cannot be changed.", name));
    }
    if (!(declaringType instanceof ClassType)) {
        throw new UnsupportedOperationException(
                String.format("SetVariableRequest: Field %s in interface cannot be changed.", name));
    }
    return setValueProxy(field.type(), value, newValue -> ((ClassType) declaringType).setValue(field, newValue), options);
}
 

import com.sun.jdi.Type; //导入依赖的package包/类
private Type getPrimitiveType(String name, VirtualMachine vm) {
    if (name.equals(Boolean.TYPE.getName())) {
        return vm.mirrorOf(true).type();
    }
    if (name.equals((Byte.TYPE.getName()))) {
        return vm.mirrorOf((byte) 0).type();
    }
    if (name.equals((Character.TYPE.getName()))) {
        return vm.mirrorOf('a').type();
    }
    if (name.equals((Double.TYPE.getName()))) {
        return vm.mirrorOf(0.).type();
    }
    if (name.equals((Float.TYPE.getName()))) {
        return vm.mirrorOf(0f).type();
    }
    if (name.equals((Integer.TYPE.getName()))) {
        return vm.mirrorOf(0).type();
    }
    if (name.equals((Long.TYPE.getName()))) {
        return vm.mirrorOf(0l).type();
    }
    if (name.equals((Short.TYPE.getName()))) {
        return vm.mirrorOf((short) 0).type();
    }
    return null;
}