Try fix ObjectCollectedException

Author: adpi2

modules/core/src/main/scala/ch/epfl/scala/debugadapter/internal/evaluator/JdiClass.scala

@@ -28,7 +28,7 @@ private[internal] class JdiClass(
     for {
       _ <- prepareMethod(ctr)
       instance <- Safe(cls.newInstance(thread, ctr, args.map(_.value).asJava, ObjectReference.INVOKE_SINGLE_THREADED))
-        .recoverWith(recoverInvocationException(thread))
+        .recoverWith(wrapInvocationException(thread))
     } yield JdiObject(instance, thread)
 
   // Load the argument types of the method to avoid ClassNotLoadedException
@@ -64,7 +64,7 @@ private[internal] class JdiClass(
   private def invokeStatic(method: Method, args: Seq[JdiValue]): Safe[JdiValue] =
     Safe(cls.invokeMethod(thread, method, args.map(_.value).asJava, ObjectReference.INVOKE_SINGLE_THREADED))
       .map(JdiValue(_, thread))
-      .recoverWith(recoverInvocationException(thread))
+      .recoverWith(wrapInvocationException(thread))
 }
 
 object JdiClass {

modules/core/src/main/scala/ch/epfl/scala/debugadapter/internal/evaluator/JdiObject.scala

@@ -29,22 +29,19 @@ private[internal] class JdiObject(
   protected def invoke(method: Method, args: Seq[JdiValue]): Safe[JdiValue] = {
     Safe(reference.invokeMethod(thread, method, args.map(_.value).asJava, ObjectReference.INVOKE_SINGLE_THREADED))
       .map(JdiValue(_, thread))
-      .recoverWith(recoverInvocationException(thread))
+      .recoverWith(wrapInvocationException(thread))
   }
 
-  protected def recoverInvocationException(thread: ThreadReference): PartialFunction[Throwable, Safe[Nothing]] = {
-    case t: InvocationException =>
-      extractMessage(t, thread).map { message =>
-        throw new MethodInvocationFailed(message, JdiObject(t.exception, thread))
+  protected def wrapInvocationException(thread: ThreadReference): PartialFunction[Throwable, Safe[Nothing]] = {
+    case invocationException: InvocationException =>
+      for {
+        exception <- Safe(invocationException.exception).map(JdiObject(_, thread))
+        message <- exception.invoke("toString", List()).map(_.asString.stringValue).recover { case _ => "" }
+      } yield {
+        throw new MethodInvocationFailed(message, exception)
       }
   }
 
-  private def extractMessage(invocationException: InvocationException, thread: ThreadReference): Safe[String] =
-    JdiObject(invocationException.exception(), thread)
-      .invoke("toString", List())
-      .map(_.asString.stringValue)
-      .recover { case _ => "" }
-
   // we use a Seq instead of a Map because the ScalaEvaluator rely on the order of the fields
   def fields: Seq[(String, JdiValue)] =
     reference.referenceType.fields.asScala.toSeq

modules/core/src/main/scala/ch/epfl/scala/debugadapter/internal/evaluator/ScalaEvaluator.scala

@@ -42,9 +42,9 @@ private[internal] class ScalaEvaluator(
         classLoader <- frame.classLoader()
         (names, values) <- extractValuesAndNames(frame, classLoader)
         localNames = names.map(_.stringValue).toSet
-        _ <- Safe(
-          compiler.compile(outDir, expressionClassName, sourceFile, line, expression, localNames, packageName, testMode)
-        )
+        _ <- compiler
+          .compile(outDir, expressionClassName, sourceFile, line, expression, localNames, packageName, testMode)
+          .toSafe
       } yield CompiledExpression(outDir, expressionFqcn)
     compiledExpression.getResult
   }
@@ -85,7 +85,6 @@ private[internal] class ScalaEvaluator(
       args: List[JdiObject]
   ): Safe[JdiObject] = {
     val expressionClassPath = classDir.toUri.toString
-    getClass()
     for {
       expressionClassLoader <- classLoader.createChildLoader(classDir)
       expressionClass <- expressionClassLoader.loadClass(className)

modules/core/src/main/scala/ch/epfl/scala/debugadapter/internal/evaluator/package.scala

@@ -1,5 +1,7 @@
 package ch.epfl.scala.debugadapter.internal
 
+import scala.util.Try
+
 package object evaluator {
   implicit class SafeSeq[A](seq: Seq[Safe[A]]) {
     def traverse: Safe[Seq[A]] = {
@@ -13,4 +15,8 @@ package object evaluator {
     def traverse: Safe[Option[A]] =
       opt.map(s => s.map(Option.apply)).getOrElse(Safe(None))
   }
+
+  implicit class TryToSafe[A](t: Try[A]) {
+    def toSafe: Safe[A] = Safe(t)
+  }
 }