@Override
public Value evaluate(final EvaluationContext evaluationContext) throws EvaluateException {
DebugProcess process = evaluationContext.getDebugProcess();
ClassLoaderReference classLoader;
try {
classLoader = getClassLoader(evaluationContext, process);
} catch (Exception e) {
throw new EvaluateException("Error creating evaluation class loader: " + e, e);
}
String version = ((VirtualMachineProxyImpl) process.getVirtualMachineProxy()).version();
JavaSdkVersion sdkVersion = JdkVersionUtil.getVersion(version);
Collection<OutputFileObject> classes =
compile(sdkVersion != null ? sdkVersion.getDescription() : null);
try {
defineClasses(classes, evaluationContext, process, classLoader);
} catch (Exception e) {
throw new EvaluateException("Error during classes definition " + e, e);
}
try {
// invoke base evaluator on call code
final Project project =
ApplicationManager.getApplication()
.runReadAction(
new Computable<Project>() {
@Override
public Project compute() {
return myPsiContext.getProject();
}
});
ExpressionEvaluator evaluator =
DebuggerInvocationUtil.commitAndRunReadAction(
project,
new EvaluatingComputable<ExpressionEvaluator>() {
@Override
public ExpressionEvaluator compute() throws EvaluateException {
final TextWithImports callCode = getCallCode();
PsiElement copyContext = myData.getAnchor();
final CodeFragmentFactory factory =
DebuggerUtilsEx.findAppropriateCodeFragmentFactory(callCode, copyContext);
return factory
.getEvaluatorBuilder()
.build(
factory.createCodeFragment(callCode, copyContext, project),
ContextUtil.getSourcePosition(evaluationContext));
}
});
((EvaluationContextImpl) evaluationContext).setClassLoader(classLoader);
return evaluator.evaluate(evaluationContext);
} catch (Exception e) {
throw new EvaluateException("Error during generated code invocation " + e, e);
}
}
private static ClassLoaderReference getClassLoader(
EvaluationContext context, DebugProcess process)
throws EvaluateException, InvocationException, InvalidTypeException, ClassNotLoadedException,
IncompatibleThreadStateException {
// TODO: cache
ClassType loaderClass =
(ClassType) process.findClass(context, "java.net.URLClassLoader", context.getClassLoader());
Method ctorMethod =
loaderClass.concreteMethodByName("<init>", "([Ljava/net/URL;Ljava/lang/ClassLoader;)V");
ClassLoaderReference reference =
(ClassLoaderReference)
process.newInstance(
context,
loaderClass,
ctorMethod,
Arrays.asList(createURLArray(context), context.getClassLoader()));
keep(reference, context);
return reference;
}
private static ArrayReference mirrorOf(
byte[] bytes, EvaluationContext context, DebugProcess process)
throws EvaluateException, InvalidTypeException, ClassNotLoadedException {
ArrayType arrayClass =
(ArrayType) process.findClass(context, "byte[]", context.getClassLoader());
ArrayReference reference = process.newInstance(arrayClass, bytes.length);
keep(reference, context);
for (int i = 0; i < bytes.length; i++) {
reference.setValue(
i, ((VirtualMachineProxyImpl) process.getVirtualMachineProxy()).mirrorOf(bytes[i]));
}
return reference;
}
private static ArrayReference createURLArray(EvaluationContext context)
throws EvaluateException, InvocationException, InvalidTypeException, ClassNotLoadedException,
IncompatibleThreadStateException {
DebugProcess process = context.getDebugProcess();
ArrayType arrayType =
(ArrayType) process.findClass(context, "java.net.URL[]", context.getClassLoader());
ArrayReference arrayRef = arrayType.newInstance(1);
keep(arrayRef, context);
ClassType classType =
(ClassType) process.findClass(context, "java.net.URL", context.getClassLoader());
VirtualMachineProxyImpl proxy = (VirtualMachineProxyImpl) process.getVirtualMachineProxy();
StringReference url = proxy.mirrorOf("file:a");
keep(url, context);
ObjectReference reference =
process.newInstance(
context,
classType,
classType.concreteMethodByName("<init>", "(Ljava/lang/String;)V"),
Collections.singletonList(url));
keep(reference, context);
arrayRef.setValues(Collections.singletonList(reference));
return arrayRef;
}
private static void keep(ObjectReference reference, EvaluationContext context) {
((SuspendContextImpl) context.getSuspendContext()).keep(reference);
}