Fix breakpoint in local object

adpi2 · adpi2 · commit 585d612552b6 · 2023-05-22T13:27:18.000+02:00
diff --git a/modules/core/src/main/scala/ch/epfl/scala/debugadapter/internal/stepfilter/ScalaStepFilter.scala b/modules/core/src/main/scala/ch/epfl/scala/debugadapter/internal/stepfilter/ScalaStepFilter.scala
@@ -88,8 +88,9 @@ abstract class ScalaStepFilter(scalaVersion: ScalaVersion) extends StepFilter {
   private def isAnonClass(tpe: ReferenceType): Boolean =
     tpe.name.contains("$anon$")
 
+  /** is local class or local object */
   private def isLocalClass(tpe: ReferenceType): Boolean =
-    tpe.name.matches(".+\\$\\d+")
+    tpe.name.matches(".+\\$\\d+\\$?")
 
   private def isNestedClass(tpe: ReferenceType): Boolean =
     tpe.name.matches(".+\\$\\.+")
diff --git a/modules/scala-3-step-filter/src/main/scala/ch/epfl/scala/debugadapter/internal/jdi/Method.scala b/modules/scala-3-step-filter/src/main/scala/ch/epfl/scala/debugadapter/internal/jdi/Method.scala
@@ -19,4 +19,7 @@ class Method(val obj: Any) extends JavaReflection(obj, "com.sun.jdi.Method"):
       case e: InvocationTargetException if e.getCause.getClass.getName == "com.sun.jdi.ClassNotLoadedException" =>
         None
 
+  def isExtensionMethod: Boolean =
+    name.endsWith("$extension")
+
   override def toString: String = invokeMethod("toString")
diff --git a/modules/scala-3-step-filter/src/main/scala/ch/epfl/scala/debugadapter/internal/stepfilter/ScalaStepFilterBridge.scala b/modules/scala-3-step-filter/src/main/scala/ch/epfl/scala/debugadapter/internal/stepfilter/ScalaStepFilterBridge.scala
@@ -1,19 +1,22 @@
 package ch.epfl.scala.debugadapter.internal.stepfilter
 
-import tastyquery.Contexts.Context
+import ch.epfl.scala.debugadapter.internal.jdi
 import tastyquery.Contexts
-import tastyquery.jdk.ClasspathLoaders
-import tastyquery.jdk.ClasspathLoaders.FileKind
+import tastyquery.Contexts.Context
+import tastyquery.Flags
 import tastyquery.Names.*
+import tastyquery.Signatures.*
 import tastyquery.Symbols.*
-import java.util.function.Consumer
+import tastyquery.Types.*
+import tastyquery.jdk.ClasspathLoaders
+import tastyquery.jdk.ClasspathLoaders.FileKind
+
 import java.nio.file.Path
-import ch.epfl.scala.debugadapter.internal.jdi
-import tastyquery.Flags
-import scala.util.matching.Regex
+import java.util.function.Consumer
+import scala.util.Failure
+import scala.util.Success
 import scala.util.Try
-import tastyquery.Types.*
-import tastyquery.Signatures.*
+import scala.util.matching.Regex
 
 class ScalaStepFilterBridge(
     classpaths: Array[Path],
@@ -25,36 +28,40 @@ class ScalaStepFilterBridge(
 
   private def warn(msg: String): Unit = warnLogger.accept(msg)
 
-  private def throwOrWarn(msg: String): Unit =
-    if (testMode) throw new Exception(msg)
-    else warn(msg)
+  private def throwOrWarn(exception: Throwable): Unit =
+    if (testMode) throw exception
+    else exception.getMessage
 
   def skipMethod(obj: Any): Boolean =
-    findSymbol(obj).forall(skip)
+    findSymbolImpl(obj) match
+      case Failure(exception) => throwOrWarn(exception); false
+      case Success(Some(symbol)) => skip(symbol)
+      case Success(None) => true
 
   private[stepfilter] def findSymbol(obj: Any): Option[TermSymbol] =
+    findSymbolImpl(obj).get
+
+  private def findSymbolImpl(obj: Any): Try[Option[TermSymbol]] =
     val method = jdi.Method(obj)
-    val isExtensionMethod = method.name.endsWith("$extension")
     val fqcn = method.declaringType.name
-    findDeclaringType(fqcn, isExtensionMethod) match
+    findDeclaringType(fqcn, method.isExtensionMethod) match
       case None =>
-        throwOrWarn(s"Cannot find Scala symbol of $fqcn")
-        None
+        Failure(Exception(s"Cannot find Scala symbol of $fqcn"))
       case Some(declaringType) =>
         val matchingSymbols =
           declaringType.declarations
             .collect { case sym: TermSymbol if sym.isTerm => sym }
-            .filter(matchSymbol(method, _, isExtensionMethod))
+            .filter(matchSymbol(method, _))
 
         if matchingSymbols.size > 1 then
           val builder = new java.lang.StringBuilder
           builder.append(
             s"Found ${matchingSymbols.size} matching symbols for $method:"
           )
           matchingSymbols.foreach(sym => builder.append(s"\n$sym"))
-          throwOrWarn(builder.toString)
+          Failure(Exception(builder.toString))
 
-        matchingSymbols.headOption
+        Success(matchingSymbols.headOption)
 
   private[stepfilter] def extractScalaTerms(
       fqcn: String,
@@ -94,34 +101,25 @@ class ScalaStepFilterBridge(
           case _ => None
       }
 
-  private def matchSymbol(method: jdi.Method, symbol: TermSymbol, isExtensionMethod: Boolean): Boolean =
-    matchTargetName(method, symbol, isExtensionMethod) &&
-      matchSignature(method, symbol, isExtensionMethod)
+  private def matchSymbol(method: jdi.Method, symbol: TermSymbol): Boolean =
+    matchTargetName(method, symbol) && matchSignature(method, symbol)
 
-  def matchTargetName(
-      method: jdi.Method,
-      symbol: TermSymbol,
-      isExtensionMethod: Boolean
-  ): Boolean =
+  def matchTargetName(method: jdi.Method, symbol: TermSymbol): Boolean =
     val javaPrefix = method.declaringType.name.replace('.', '$') + "$$"
     // if an inner accesses a private method, the backend makes the method public
     // and prefixes its name with the full class name.
     // Example: method foo in class example.Inner becomes example$Inner$$foo
     val expectedName = method.name.stripPrefix(javaPrefix)
     val encodedScalaName = NameTransformer.encode(symbol.targetName.toString)
-    if isExtensionMethod then encodedScalaName == expectedName.stripSuffix("$extension")
+    if method.isExtensionMethod then encodedScalaName == expectedName.stripSuffix("$extension")
     else encodedScalaName == expectedName
 
-  def matchSignature(
-      method: jdi.Method,
-      symbol: TermSymbol,
-      isExtensionMethod: Boolean
-  ): Boolean =
+  def matchSignature(method: jdi.Method, symbol: TermSymbol): Boolean =
     try {
       symbol.signedName match
         case SignedName(_, sig, _) =>
           val javaArgs = method.arguments.headOption.map(_.name) match
-            case Some("$this") if isExtensionMethod => method.arguments.tail
+            case Some("$this") if method.isExtensionMethod => method.arguments.tail
             case _ => method.arguments
           matchArguments(sig.paramsSig, javaArgs) &&
           method.returnType.forall(matchType(sig.resSig, _))
diff --git a/modules/scala-3-step-filter/src/test/scala/ch/epfl/scala/debugadapter/internal/stepfilter/ScalaStepFilterBridgeTests.scala b/modules/scala-3-step-filter/src/test/scala/ch/epfl/scala/debugadapter/internal/stepfilter/ScalaStepFilterBridgeTests.scala
@@ -70,9 +70,34 @@ abstract class ScalaStepFilterBridgeTests(scalaVersion: ScalaVersion) extends Fu
     assert(findM("example.F$").isEmpty)
     assert(findM("example.Main$G").isDefined)
     assert(findM("example.Main$H").isEmpty)
-    assert(findM("example.Main$$anon$1").isEmpty)
+    intercept[Exception](findM("example.Main$$anon$1"))
     // TODO fix: we could find it by traversing the tree of `Main`
-    assert(findM("example.Main$$anon$2").isEmpty)
+    intercept[Exception](findM("example.Main$$anon$2"))
+  }
+
+  test("local classes or local objects") {
+    val source =
+      """|package example
+         |
+         |object Main {
+         |  def main(args: Array[String]) = {
+         |    class A {
+         |      def m(): Unit = {
+         |        println("A.m")
+         |      }
+         |    }
+         |    object B {
+         |      def m(): Unit = {
+         |        println("B.m")
+         |      }
+         |    }
+         |  }
+         |}
+         |""".stripMargin
+    val debuggee = TestingDebuggee.mainClass(source, "example.Main", scalaVersion)
+    val stepFilter = getStepFilter(debuggee)
+    intercept[Exception](stepFilter.findSymbol(FakeJdiMethod("example.Main$A$1", "m")()("void")))
+    intercept[Exception](stepFilter.findSymbol(FakeJdiMethod("example.Main$B$2$", "m")()("void")))
   }
 
   test("getters and setters") {
@@ -268,7 +293,7 @@ abstract class ScalaStepFilterBridgeTests(scalaVersion: ScalaVersion) extends Fu
          |""".stripMargin
     val debuggee = TestingDebuggee.mainClass(source, "example.Main", scalaVersion)
     val stepFilter = getStepFilter(debuggee)
-    val anonymousfun = FakeJdiMethod("Main$", "$anonfun$1")("x" -> "int")("int")
+    val anonymousfun = FakeJdiMethod("example.Main$", "$anonfun$1")("x" -> "int")("int")
     // TODO fix: it should find the symbol f by traversing the tree of object Main
     assert(stepFilter.findSymbol(anonymousfun).isEmpty)
   }
diff --git a/modules/tests/src/test/scala/ch/epfl/scala/debugadapter/StepFilterTests.scala b/modules/tests/src/test/scala/ch/epfl/scala/debugadapter/StepFilterTests.scala
@@ -137,6 +137,37 @@ abstract class StepFilterTests(protected val scalaVersion: ScalaVersion) extends
     )
   }
 
+  test("step into local class or local object") {
+    val source =
+      """|package example
+         |
+         |object Main {
+         |  def main(args: Array[String]) = {
+         |    class A {
+         |      def m(): Unit = {
+         |        println("A.m")
+         |      }
+         |    }
+         |    object B {
+         |      def m(): Unit = {
+         |        println("B.m")
+         |      }
+         |    }
+         |    val a = new A
+         |    a.m()
+         |    B.m()
+         |  }
+         |}
+         |""".stripMargin
+    implicit val debuggee: TestingDebuggee = TestingDebuggee.mainClass(source, "example.Main", scalaVersion)
+    check(
+      Breakpoint(16),
+      StepIn.line(7),
+      // object B becomes a lazy ref at runtime, to avoid all the steps, it just breaks in B.m()
+      Breakpoint(12)
+    )
+  }
+
   test("should not step into getters") {
     val source =
       """|package example
