Merge pull request #349 from bryljaku/logpoint-opt

Dont evaluate expression if there's no interpolation

Author: adpi2

modules/core/src/main/scala/ch/epfl/scala/debugadapter/DebugConfig.scala

@@ -18,15 +18,19 @@ object DebugConfig {
   )
 
   sealed trait EvaluationMode {
-    def canUseCompiler: Boolean = true
-    def canBypassCompiler: Boolean = true
+    def allowScalaEvaluation: Boolean = false
+    def allowSimpleEvaluation: Boolean = false
   }
 
-  case object ExpressionCompilerOnly extends EvaluationMode {
-    override def canBypassCompiler: Boolean = false
+  case object ScalaEvaluationOnly extends EvaluationMode {
+    override def allowScalaEvaluation: Boolean = true
   }
-  case object AlwaysBypassCompiler extends EvaluationMode {
-    override def canUseCompiler: Boolean = false
+  case object SimpleEvaluationOnly extends EvaluationMode {
+    override def allowSimpleEvaluation: Boolean = true
+  }
+  case object NoEvaluation extends EvaluationMode
+  case object MixedEvaluation extends EvaluationMode {
+    override def allowScalaEvaluation: Boolean = true
+    override def allowSimpleEvaluation: Boolean = true
   }
-  case object MixedEvaluation extends EvaluationMode
 }

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

@@ -10,7 +10,9 @@ import ch.epfl.scala.debugadapter.internal.evaluator.CompiledExpression
 import ch.epfl.scala.debugadapter.internal.evaluator.FrameReference
 import ch.epfl.scala.debugadapter.internal.evaluator.JdiObject
 import ch.epfl.scala.debugadapter.internal.evaluator.LocalValue
+import ch.epfl.scala.debugadapter.internal.evaluator.MessageLogger
 import ch.epfl.scala.debugadapter.internal.evaluator.MethodInvocationFailed
+import ch.epfl.scala.debugadapter.internal.evaluator.PlainLogMessage
 import ch.epfl.scala.debugadapter.internal.evaluator.PreparedExpression
 import ch.epfl.scala.debugadapter.internal.evaluator.ScalaEvaluator
 import ch.epfl.scala.debugadapter.internal.evaluator.SimpleEvaluator
@@ -32,6 +34,7 @@ import ScalaExtension.*
 private[internal] class EvaluationProvider(
     sourceLookUp: SourceLookUpProvider,
     simpleEvaluator: SimpleEvaluator,
+    messageLogger: MessageLogger,
     scalaEvaluators: Map[ClassEntry, ScalaEvaluator],
     mode: DebugConfig.EvaluationMode,
     logger: Logger
@@ -69,13 +72,11 @@ private[internal] class EvaluationProvider(
     val locationCode = (location.method.name, location.codeIndex).hashCode
     val expression =
       if (breakpoint.getCompiledExpression(locationCode) != null) {
-        breakpoint.getCompiledExpression(locationCode).asInstanceOf[Try[CompiledExpression]]
+        breakpoint.getCompiledExpression(locationCode).asInstanceOf[Try[PreparedExpression]]
       } else if (breakpoint.containsConditionalExpression) {
         prepare(breakpoint.getCondition, frame)
       } else if (breakpoint.containsLogpointExpression) {
-        val tripleQuote = "\"\"\""
-        val expression = s"""println(s$tripleQuote${breakpoint.getLogMessage}$tripleQuote)"""
-        prepare(expression, frame)
+        prepareLogMessage(breakpoint.getLogMessage, frame)
       } else {
         Failure(new Exception("Missing expression"))
       }
@@ -113,11 +114,21 @@ private[internal] class EvaluationProvider(
       evaluator <- scalaEvaluators.get(entry).toTry(s"Missing expression compiler for entry ${entry.name}")
     } yield evaluator
 
+  private def prepareLogMessage(message: String, frame: FrameReference): Try[PreparedExpression] = {
+    if (!message.contains("$")) {
+      Success(PlainLogMessage(message))
+    } else {
+      val tripleQuote = "\"\"\""
+      val expression = s"""println(s$tripleQuote$message$tripleQuote)"""
+      prepare(expression, frame)
+    }
+  }
+
   private def prepare(expression: String, frame: FrameReference): Try[PreparedExpression] = {
     lazy val simpleExpression = simpleEvaluator.prepare(expression, frame)
-    if (mode.canBypassCompiler && simpleExpression.isDefined) {
+    if (mode.allowSimpleEvaluation && simpleExpression.isDefined) {
       Success(simpleExpression.get)
-    } else if (mode.canUseCompiler) {
+    } else if (mode.allowScalaEvaluation) {
       val fqcn = frame.current().location.declaringType.name
       for {
         evaluator <- getScalaEvaluator(fqcn)
@@ -133,6 +144,7 @@ private[internal] class EvaluationProvider(
 
   private def evaluate(expression: PreparedExpression, frame: FrameReference): Try[Value] = {
     expression match {
+      case logMessage: PlainLogMessage => messageLogger.log(logMessage, frame)
       case localValue: LocalValue => simpleEvaluator.evaluate(localValue, frame)
       case expression: CompiledExpression =>
         val fqcn = frame.current().location.declaringType.name
@@ -174,6 +186,14 @@ private[internal] object EvaluationProvider {
     val scalaEvaluators = debugTools.expressionCompilers.view.map { case (entry, compiler) =>
       (entry, new ScalaEvaluator(entry, compiler, logger, config.testMode))
     }.toMap
-    new EvaluationProvider(sourceLookUp, simpleEvaluator, scalaEvaluators, config.evaluationMode, logger)
+    val messageLogger = new MessageLogger()
+    new EvaluationProvider(
+      sourceLookUp,
+      simpleEvaluator,
+      messageLogger,
+      scalaEvaluators,
+      config.evaluationMode,
+      logger
+    )
   }
 }

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

@@ -1,15 +1,14 @@
 package ch.epfl.scala.debugadapter.internal.evaluator
 
-import com.sun.jdi.{ArrayReference, ObjectReference, ThreadReference, Value}
+import com.sun.jdi.{ArrayReference, ThreadReference, Value}
 
 import scala.jdk.CollectionConverters.*
 
 object JdiArray {
-  def apply(
-      arrayType: String,
-      arraySize: Int,
-      classLoader: JdiClassLoader
-  ): Safe[JdiArray] = {
+  def apply(value: Value, thread: ThreadReference): JdiArray =
+    new JdiArray(value.asInstanceOf[ArrayReference], thread)
+
+  def apply(arrayType: String, arraySize: Int, classLoader: JdiClassLoader): Safe[JdiArray] = {
     val thread = classLoader.thread
     for {
       classClass <- classLoader.loadClass("java.lang.Class")
@@ -18,23 +17,14 @@ object JdiArray {
         classClass.invoke("getPrimitiveClass", List(intValue))
       arrayClass <- classLoader.loadClass("java.lang.reflect.Array")
       newInstanceValue <- classLoader.mirrorOf("newInstance")
-      newInstanceMethod <-
-        arrayClass
-          .invoke(
-            "getMethod",
-            List(newInstanceValue, classClass.reference, intClass)
-          )
-          .map(_.asInstanceOf[ObjectReference])
-          .map(new JdiObject(_, thread))
+      newInstanceMethod <- arrayClass
+        .invoke("getMethod", List(newInstanceValue, classClass.reference, intClass))
+        .map(JdiObject(_, thread))
       arrayTypeClass <- classLoader.loadClass(arrayType)
       integerRef <- JdiPrimitive.box(arraySize, classLoader, thread)
       array <- newInstanceMethod
-        .invoke(
-          "invoke",
-          List(null, arrayTypeClass.reference, integerRef)
-        )
-        .map(_.asInstanceOf[ArrayReference])
-        .map(new JdiArray(_, thread))
+        .invoke("invoke", List(null, arrayTypeClass.reference, integerRef))
+        .map(JdiArray(_, thread))
     } yield array
   }
 }

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

@@ -1,8 +1,23 @@
 package ch.epfl.scala.debugadapter.internal.evaluator
 
 import com.sun.jdi._
+import scala.collection.JavaConverters.*
+
+private[internal] object JdiClassLoader {
+  def fromFrame(frame: FrameReference): Safe[JdiClassLoader] = Safe {
+    val scalaLibClassLoader =
+      for {
+        scalaLibClass <- frame.thread.virtualMachine.allClasses.asScala
+          .find(c => c.name.startsWith("scala.runtime"))
+        classLoader <- Option(scalaLibClass.classLoader)
+      } yield classLoader
+
+    val classLoader = Option(frame.current().location.method.declaringType.classLoader)
+      .orElse(scalaLibClassLoader)
+      .getOrElse(throw new Exception("Cannot find the classloader of the Scala library"))
+    JdiClassLoader(classLoader, frame.thread)
+  }
 
-private[evaluator] object JdiClassLoader {
   def apply(
       classLoader: ClassLoaderReference,
       thread: ThreadReference
@@ -17,11 +32,12 @@ private[evaluator] object JdiClassLoader {
   }
 }
 
-private[evaluator] case class JdiClassLoader(
+private[internal] case class JdiClassLoader(
     classLoaderRef: ClassLoaderReference,
     loadClassMethod: Method,
     thread: ThreadReference
 ) {
+
   def loadClass(name: String): Safe[JdiClassObject] = {
     for {
       nameValue <- mirrorOf(name)

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

@@ -14,12 +14,10 @@ class JdiClassObject(
       objects <- JdiArray("java.lang.Object", args.size, classLoader)
       _ = objects.setValues(args)
       constructor <- invoke("getConstructor", parameterTypes)
-        .map(_.asInstanceOf[ObjectReference])
-        .map(new JdiObject(_, thread))
+        .map(JdiObject(_, thread))
       jdiObject <- constructor
         .invoke("newInstance", List(objects.reference))
-        .map(_.asInstanceOf[ObjectReference])
-        .map(new JdiObject(_, thread))
+        .map(JdiObject(_, thread))
     } yield jdiObject
   }
 
@@ -30,12 +28,8 @@ class JdiClassObject(
     val parameterTypes = args.map(_.referenceType.classObject())
     for {
       methodNameValue <- classLoader.mirrorOf(methodName)
-      method <- invoke(
-        "getMethod",
-        methodNameValue :: parameterTypes
-      )
-        .map(_.asInstanceOf[ObjectReference])
-        .map(new JdiObject(_, thread))
+      method <- invoke("getMethod", methodNameValue :: parameterTypes)
+        .map(JdiObject(_, thread))
       result <- method.invoke("invoke", List(null) ++ args)
     } yield result
   }

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

@@ -21,3 +21,8 @@ private[internal] class JdiObject(
     invokeMethod(reference, m, args, thread)
   }
 }
+
+private[internal] object JdiObject {
+  def apply(value: Value, thread: ThreadReference): JdiObject =
+    new JdiObject(value.asInstanceOf[ObjectReference], thread)
+}

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

@@ -20,9 +20,7 @@ object JdiPrimitive {
         case _: Long => classLoader.loadClass("java.lang.Long")
         case _: Short => classLoader.loadClass("java.lang.Short")
       }
-      objectRef <- clazz
-        .invokeStatic("valueOf", List(jdiValue))
-        .map(_.asInstanceOf[ObjectReference])
-    } yield objectRef
+      objectRef <- clazz.invokeStatic("valueOf", List(jdiValue))
+    } yield objectRef.asInstanceOf[ObjectReference]
   }
 }

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

@@ -0,0 +1,21 @@
+package ch.epfl.scala.debugadapter.internal.evaluator
+
+import com.sun.jdi.*
+import scala.util.Try
+
+private[internal] class MessageLogger() {
+  def log(logMessage: PlainLogMessage, frame: FrameReference): Try[Value] = {
+    val result = for {
+      classLoader <- JdiClassLoader.fromFrame(frame)
+      vm = frame.thread.virtualMachine()
+      arg <- Safe(vm.mirrorOf(logMessage.message))
+      predefClass <- classLoader.loadClass("scala.Predef$")
+      moduleField <- predefClass
+        .invoke("getDeclaredField", List(vm.mirrorOf("MODULE$")))
+        .map(JdiObject(_, frame.thread))
+      predef <- moduleField.invoke("get", List(null)).map(JdiObject(_, frame.thread))
+      res <- predef.invoke("println", "(Ljava/lang/Object;)V", List(arg))
+    } yield res
+    result.getResult
+  }
+}

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

@@ -5,3 +5,4 @@ import java.nio.file.Path
 sealed trait PreparedExpression
 final case class CompiledExpression(classDir: Path, className: String) extends PreparedExpression
 final case class LocalValue(name: String) extends PreparedExpression
+final case class PlainLogMessage(message: String) extends PreparedExpression

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

@@ -38,9 +38,9 @@ private[internal] class ScalaEvaluator(
     Files.write(sourceFile, sourceContent.getBytes(StandardCharsets.UTF_8))
 
     val expressionFqcn = if (packageName.isEmpty) expressionClassName else s"$packageName.$expressionClassName"
-    val classLoader = findClassLoader(frame)
     val compiledExpression =
       for {
+        classLoader <- JdiClassLoader.fromFrame(frame)
         (names, values) <- extractValuesAndNames(frame, classLoader)
         localNames = names.map(_.value()).toSet
         _ <- Safe(
@@ -51,8 +51,8 @@ private[internal] class ScalaEvaluator(
   }
 
   private def evaluate(classDir: Path, className: String, frame: FrameReference): Try[Value] = {
-    val classLoader = findClassLoader(frame)
     val evaluatedValue = for {
+      classLoader <- JdiClassLoader.fromFrame(frame)
       (names, values) <- extractValuesAndNames(frame, classLoader)
       namesArray <- JdiArray("java.lang.String", names.size, classLoader)
       valuesArray <- JdiArray("java.lang.Object", values.size, classLoader)
@@ -67,20 +67,6 @@ private[internal] class ScalaEvaluator(
     evaluatedValue.getResult
   }
 
-  private def findClassLoader(frame: FrameReference): JdiClassLoader = {
-    val scalaLibClassLoader =
-      for {
-        scalaLibClass <- frame.thread.virtualMachine.allClasses.asScala
-          .find(c => c.name.startsWith("scala.runtime"))
-        classLoader <- Option(scalaLibClass.classLoader)
-      } yield classLoader
-
-    val classLoader = Option(frame.current().location.method.declaringType.classLoader)
-      .orElse(scalaLibClassLoader)
-      .getOrElse(throw new Exception("Cannot find the classloader of the Scala library"))
-    JdiClassLoader(classLoader, frame.thread)
-  }
-
   private def evaluateExpression(expressionInstance: JdiObject): Safe[Value] = {
     expressionInstance
       .invoke("evaluate", List())