Apply suggested changes

Author: adpi2

modules/core/src/main/scala/ch/epfl/scala/debugadapter/internal/EvaluationProvider.scala

@@ -97,15 +97,15 @@ private[internal] class EvaluationProvider(
       thisContext: ObjectReference,
       methodName: String,
       methodSignature: String,
-      rawArgs: Array[Value],
+      args: Array[Value],
       thread: ThreadReference,
       invokeSuper: Boolean
   ): CompletableFuture[Value] = {
     val obj = JdiObject(thisContext, thread)
-    val args = if (rawArgs == null) Seq.empty else rawArgs.toSeq.map(JdiValue(_, thread))
+    val wrappedArgs = if (args == null) Seq.empty else args.toSeq.map(JdiValue(_, thread))
     val invocation = evaluationBlock {
       obj
-        .invoke(methodName, methodSignature, args)
+        .invoke(methodName, methodSignature, wrappedArgs)
         .recover {
           // if invocation throws an exception, we return that exception as the result
           case MethodInvocationFailed(msg, exception) => exception

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

@@ -6,16 +6,16 @@ import com.sun.jdi.Value
 
 import scala.jdk.CollectionConverters.*
 
-class JdiArray(reference: ArrayReference, thread: ThreadReference) extends JdiObject(reference, thread) {
+class JdiArray(arrayRef: ArrayReference, thread: ThreadReference) extends JdiObject(arrayRef, thread) {
   def setValue(index: Int, value: Value): Unit =
-    reference.setValue(index, value)
+    arrayRef.setValue(index, value)
 
-  def setValues(values: Seq[JdiValue]): Unit = reference.setValues(values.map(_.value).asJava)
+  def setValues(values: Seq[JdiValue]): Unit = arrayRef.setValues(values.map(_.value).asJava)
 
-  def getValues: Seq[JdiValue] = reference.getValues.asScala.toSeq.map(JdiValue(_, thread))
+  def getValues: Seq[JdiValue] = arrayRef.getValues.asScala.toSeq.map(JdiValue(_, thread))
 }
 
 object JdiArray {
-  def apply(value: Value, thread: ThreadReference): JdiArray =
-    new JdiArray(value.asInstanceOf[ArrayReference], thread)
+  def apply(arrayValue: Value, thread: ThreadReference): JdiArray =
+    new JdiArray(arrayValue.asInstanceOf[ArrayReference], thread)
 }

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

@@ -52,7 +52,6 @@ private[internal] class JdiClass(
     Safe(cls.getValue(cls.fieldByName(fieldName))).map(JdiValue(_, thread))
 
   def invokeStatic(methodName: String, args: Seq[JdiValue]): Safe[JdiValue] = {
-    cls.methodsByName(methodName).forEach(m => println(m.signature))
     val method = cls.methodsByName(methodName).asScala.head
     invokeStatic(method, args)
   }
@@ -62,16 +61,16 @@ private[internal] class JdiClass(
     invokeStatic(method, args)
   }
 
-  protected def invokeStatic(method: Method, args: Seq[JdiValue]): Safe[JdiValue] =
+  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))
 }
 
 object JdiClass {
-  def apply(classType: ReferenceType, thread: ThreadReference): JdiClass =
+  def apply(classType: Type, thread: ThreadReference): JdiClass =
     new JdiClass(classType.asInstanceOf[ClassType], thread)
 
-  def apply(classObject: ClassObjectReference, thread: ThreadReference): JdiClass =
-    new JdiClass(classObject.reflectedType.asInstanceOf[ClassType], thread)
+  def apply(classObject: Value, thread: ThreadReference): JdiClass =
+    JdiClass(classObject.asInstanceOf[ClassObjectReference].reflectedType, thread)
 }

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

@@ -90,6 +90,6 @@ private[internal] class JdiClassLoader(
 }
 
 private[internal] object JdiClassLoader {
-  def apply(ref: ClassLoaderReference, thread: ThreadReference): JdiClassLoader =
-    new JdiClassLoader(ref, thread)
+  def apply(ref: Value, thread: ThreadReference): JdiClassLoader =
+    new JdiClassLoader(ref.asInstanceOf[ClassLoaderReference], thread)
 }

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

@@ -11,17 +11,19 @@ final case class JdiFrame(thread: ThreadReference, depth: Int) {
   def current(): StackFrame = thread.frame(depth)
 
   // it's a Safe because it can fail, but it could also be a Try
-  def classLoader(): Safe[JdiClassLoader] = Safe {
+  def classLoader(): Safe[JdiClassLoader] = {
     def getClassLoaderRecursively(depth: Int): Option[ClassLoaderReference] =
       if (depth == thread.frameCount) None
       else {
         Option(thread.frame(depth).location.method.declaringType.classLoader)
           .orElse(getClassLoaderRecursively(depth + 1))
       }
 
-    val classLoader = getClassLoaderRecursively(depth)
-      .getOrElse(throw new Exception("Cannot find any classloader in the stack trace"))
-    JdiClassLoader(classLoader, thread)
+    Safe {
+      val classLoader = getClassLoaderRecursively(depth)
+        .getOrElse(throw new Exception("Cannot find any classloader in the stack trace"))
+      JdiClassLoader(classLoader, thread)
+    }
   }
 
   // this object can be null

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

@@ -45,6 +45,7 @@ private[internal] class JdiObject(
       .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
       .map(f => (f.name, JdiValue(reference.getValue(f), thread)))

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

@@ -3,10 +3,10 @@ package ch.epfl.scala.debugadapter.internal.evaluator
 import com.sun.jdi._
 
 private[internal] class JdiValue(val value: Value, val thread: ThreadReference) {
-  def asObject: JdiObject = JdiObject(value.asInstanceOf[ObjectReference], thread)
-  def asClass: JdiClass = JdiClass(value.asInstanceOf[ClassObjectReference], thread)
-  def asClassLoader: JdiClassLoader = JdiClassLoader(value.asInstanceOf[ClassLoaderReference], thread)
-  def asArray: JdiArray = JdiArray(value.asInstanceOf[ArrayReference], thread)
+  def asObject: JdiObject = JdiObject(value, thread)
+  def asClass: JdiClass = JdiClass(value, thread)
+  def asClassLoader: JdiClassLoader = JdiClassLoader(value, thread)
+  def asArray: JdiArray = JdiArray(value, thread)
   def asString: JdiString = new JdiString(value.asInstanceOf[StringReference], thread)
 
   def unboxIfPrimitive: Safe[JdiValue] = {
@@ -15,12 +15,13 @@ private[internal] class JdiValue(val value: Value, val thread: ThreadReference)
         val typeName = ref.referenceType.name
         JdiValue.unboxMethods
           .get(typeName)
-          .map(methodName => asObject.invoke(methodName, Nil))
+          .map(methodName => JdiObject(ref, thread).invoke(methodName, Nil))
           .getOrElse(Safe(this))
       case _ => Safe(this)
     }
   }
 
+  // The ref types are used by the compiler to mutate local vars in nested methods
   def derefIfRef: JdiValue =
     value match {
       case ref: ObjectReference if JdiValue.refTypes.contains(ref.referenceType.name) =>

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

@@ -106,6 +106,8 @@ private[internal] class ScalaEvaluator(
   ): Safe[(Seq[JdiString], Seq[JdiValue])] = {
     def extractVariablesFromFrame(): Safe[(Seq[JdiString], Seq[JdiValue])] = {
       val localVariables = frameRef.variablesAndValues().map { case (variable, value) => (variable.name, value) }
+      // Exclude the this object if there already is a local $this variable
+      // The Scala compiler uses `$this` in the extension methods of AnyVal classes
       val thisObject = frameRef.thisObject().filter(_ => !localVariables.contains("$this")).map("$this".->)
       (localVariables ++ thisObject)
         .map { case (name, value) =>
@@ -148,17 +150,19 @@ private[internal] class ScalaEvaluator(
   }
 
   private def updateVariables(variableArray: JdiArray, frame: JdiFrame): Safe[Unit] = {
-    val unboxedValues = frame
+    frame
       .variables()
       .zip(variableArray.getValues)
-      .map { case (variable, value) =>
-        if (variable.`type`.isInstanceOf[PrimitiveType]) value.unboxIfPrimitive
-        else Safe(value)
+      .map {
+        case (variable, value) if variable.`type`.isInstanceOf[PrimitiveType] => value.unboxIfPrimitive
+        case (_, value) => Safe(value)
       }
       .traverse
-
-    for (values <- unboxedValues)
-      yield for ((variable, value) <- frame.variables().zip(values))
-        frame.setVariable(variable, value)
+      .map { values =>
+        frame
+          .variables()
+          .zip(values)
+          .foreach { case (variable, value) => frame.setVariable(variable, value) }
+      }
   }
 }