Backports to 3.1.x

build.sbt

@@ -49,11 +49,11 @@ lazy val javaDebug = project
     autoScalaLibrary := false,
     compile / javacOptions ++= Seq("-source", "1.8", "-target", "1.8"),
     libraryDependencies ++= Seq(
-      "org.apache.commons" % "commons-lang3" % "3.12.0",
+      "org.apache.commons" % "commons-lang3" % "3.13.0",
       "com.google.code.gson" % "gson" % "2.10.1",
       "io.reactivex.rxjava2" % "rxjava" % "2.2.21",
       "org.reactivestreams" % "reactive-streams" % "1.0.4",
-      "commons-io" % "commons-io" % "2.12.0",
+      "commons-io" % "commons-io" % "2.13.0",
       "junit" % "junit" % "4.13.2" % Test,
       "org.easymock" % "easymock" % "5.1.0" % Test,
       "com.github.sbt" % "junit-interface" % "0.13.3" % Test
@@ -166,10 +166,10 @@ lazy val expressionCompiler = projectMatrix
     crossScalaVersions ++= CrossVersion
       .partialVersion(scalaVersion.value)
       .collect {
-        case (2, 12) => Seq("2.12.17", "2.12.16", "2.12.15", "2.12.14", "2.12.13", "2.12.12", "2.12.11", "2.12.10")
-        case (2, 13) => Seq("2.13.10", "2.13.9", "2.13.8", "2.13.7", "2.13.6", "2.13.5", "2.13.4", "2.13.3")
+        case (2, 12) => Seq("2.12.18", "2.12.17", "2.12.16", "2.12.15", "2.12.14", "2.12.13", "2.12.12", "2.12.11")
+        case (2, 13) => Seq("2.13.11", "2.13.10", "2.13.9", "2.13.8", "2.13.7", "2.13.6", "2.13.5", "2.13.4", "2.13.3")
         case (3, 0) => Seq("3.0.2", "3.0.1", "3.0.0")
-        case (3, _) => Seq("3.2.2", "3.2.1", "3.2.0", "3.1.3", "3.1.2", "3.1.1", "3.1.0")
+        case (3, _) => Seq("3.3.0", "3.2.2", "3.2.1", "3.2.0", "3.1.3", "3.1.2", "3.1.1", "3.1.0")
       }
       .toSeq
       .flatten,
@@ -202,7 +202,7 @@ lazy val scala3StepFilter: Project = project
     scalaVersion := Dependencies.scala31Plus,
     Compile / doc / sources := Seq.empty,
     libraryDependencies ++= Seq(
-      "ch.epfl.scala" %% "tasty-query" % "0.7.9",
+      "ch.epfl.scala" %% "tasty-query" % "0.8.4",
       "org.scala-lang" %% "tasty-core" % scalaVersion.value,
       Dependencies.munit % Test
     ),

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

@@ -162,13 +162,13 @@ private class ClassEntryLookUp(
 
 private object ClassEntryLookUp {
   private[internal] def apply(entry: ClassEntry, logger: Logger): ClassEntryLookUp = {
-    val sourceFiles = entry.sourceEntries.flatMap(SourceEntryLookUp.getAllSourceFiles(_, logger))
-    ClassEntryLookUp(entry, sourceFiles, logger)
+    val sourceLookUps = entry.sourceEntries.flatMap(SourceEntryLookUp(_, logger))
+    ClassEntryLookUp(entry, sourceLookUps, logger)
   }
 
   def apply(
       entry: ClassEntry,
-      sourceFiles: Seq[SourceFile],
+      sourceLookUps: Seq[SourceEntryLookUp],
       logger: Logger
   ): ClassEntryLookUp = {
     val classFiles = entry.classSystems.flatMap { classSystem =>
@@ -181,8 +181,9 @@ private object ClassEntryLookUp {
     val classNameToClassFile =
       classFiles.map(c => (c.fullyQualifiedName, c)).toMap
 
-    val sourceUriToSourceFile = sourceFiles.map(f => (f.uri, f)).toMap
-    val sourceNameToSourceFile = sourceFiles.groupBy(f => f.fileName)
+    val sourceFileToRoot = sourceLookUps.flatMap(l => l.sourceFiles.map(f => (f -> l.root))).toMap
+    val sourceUriToSourceFile = sourceLookUps.flatMap(_.sourceFiles).map(f => (f.uri, f)).toMap
+    val sourceNameToSourceFile = sourceLookUps.flatMap(_.sourceFiles).groupBy(f => f.fileName)
 
     val classNameToSourceFile = mutable.Map[String, SourceFile]()
     val sourceUriToClassFiles = mutable.Map[URI, Seq[ClassFile]]()
@@ -235,11 +236,11 @@ private object ClassEntryLookUp {
                   // so we try to find the right package declaration in each file
                   // it would be very unfortunate that 2 sources file with the same name
                   // declare the same package.
-                  manySourceFiles.filter(s => findPackage(s, classFile.fullPackage, logger)) match {
-                    case sourceFile :: Nil =>
-                      recordSourceFile(sourceFile)
-                    case _ =>
-                      orphanClassFiles.append(classFile)
+                  manySourceFiles.filter { f =>
+                    findPackage(f, sourceFileToRoot(f), classFile.fullPackage, logger)
+                  } match {
+                    case sourceFile :: Nil => recordSourceFile(sourceFile)
+                    case _ => orphanClassFiles.append(classFile)
                   }
               }
           }
@@ -249,6 +250,7 @@ private object ClassEntryLookUp {
     if (orphanClassFiles.size > 0)
       logger.debug(s"Found ${orphanClassFiles.size} orphan class files in ${entry.name}")
 
+    sourceLookUps.foreach(_.close())
     new ClassEntryLookUp(
       entry,
       classNameToClassFile,
@@ -320,17 +322,13 @@ private object ClassEntryLookUp {
     }
   }
 
-  private def findPackage(
-      sourceFile: SourceFile,
-      fullPackage: String,
-      logger: Logger
-  ): Boolean = {
+  private def findPackage(sourceFile: SourceFile, root: Path, fullPackage: String, logger: Logger): Boolean = {
     // for "a.b.c" it returns Seq("a.b.c", "b.c", "c")
     // so that we can match on "package a.b.c" or "package b.c" or "package c"
     val nestedPackages = fullPackage.split('.').foldLeft(Seq.empty[String]) { (nestedParts, newPart) =>
       nestedParts.map(outer => s"$outer.$newPart") :+ newPart
     }
-    val sourceContent = readSourceContent(sourceFile, logger)
+    val sourceContent = readSourceContent(sourceFile, root, logger)
     nestedPackages.exists { `package` =>
       val quotedPackage = Regex.quote(`package`)
       val matcher = s"package\\s+(object\\s+)?$quotedPackage(\\{|:|;|\\s+)".r
@@ -339,7 +337,13 @@ private object ClassEntryLookUp {
   }
 
   private def readSourceContent(sourceFile: SourceFile, logger: Logger): Option[String] = {
-    withinSourceEntry(sourceFile.entry) { root =>
+    withinSourceEntry(sourceFile.entry)(readSourceContent(sourceFile, _, logger))
+      .warnFailure(logger, s"Cannot read content of ${sourceFile.uri}")
+      .flatten
+  }
+
+  private def readSourceContent(sourceFile: SourceFile, root: Path, logger: Logger): Option[String] = {
+    Try {
       val sourcePath = root.resolve(sourceFile.relativePath)
       new String(Files.readAllBytes(sourcePath))
     }

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

@@ -11,11 +11,16 @@ import scala.util.Failure
 import scala.util.Success
 
 private[debugadapter] object IO {
-  def withinJarFile[T](absolutePath: Path)(f: FileSystem => T): Try[T] = try {
+  def withinJarFile[T](absolutePath: Path)(f: FileSystem => T): Try[T] =
+    getJarFileSystem(absolutePath).map { fs =>
+      try f(fs)
+      finally fs.close()
+    }
+
+  def getJarFileSystem(absolutePath: Path): Try[FileSystem] = try {
     val uri = URI.create(s"jar:${absolutePath.toUri}")
     val fileSystem = FileSystems.newFileSystem(uri, new util.HashMap[String, Any])
-    try Success(f(fileSystem))
-    finally fileSystem.close()
+    Success(fileSystem)
   } catch {
     case NonFatal(exception) => Failure(exception)
     case zipError: util.zip.ZipError => Failure(zipError)

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

@@ -12,6 +12,7 @@ import scala.jdk.CollectionConverters.*
 import java.net.URI
 import ch.epfl.scala.debugadapter.Logger
 import ch.epfl.scala.debugadapter.internal.ScalaExtension.*
+import scala.util.control.NonFatal
 
 private case class SourceFile(
     entry: SourceEntry,
@@ -22,20 +23,44 @@ private case class SourceFile(
   def folderPath: String = relativePath.stripSuffix(s"/$fileName")
 }
 
+private case class SourceEntryLookUp(
+    entry: SourceEntry,
+    sourceFiles: Seq[SourceFile],
+    fileSystem: FileSystem,
+    root: Path
+) {
+  def close(): Unit =
+    try
+      entry match {
+        case SourceJar(jar) => fileSystem.close()
+        case SourceDirectory(directory) => ()
+        case StandaloneSourceFile(absolutePath, relativePath) => ()
+      }
+    catch {
+      case NonFatal(_) => ()
+    }
+}
+
 private object SourceEntryLookUp {
-  def getAllSourceFiles(entry: SourceEntry, logger: Logger): Seq[SourceFile] = {
+  def apply(entry: SourceEntry, logger: Logger): Option[SourceEntryLookUp] = {
     entry match {
       case SourceJar(jar) =>
-        IO
-          .withinJarFile(jar) { fileSystem =>
-            getAllSourceFiles(entry, fileSystem, fileSystem.getPath("/")).toVector
+        IO.getJarFileSystem(jar)
+          .map { fs =>
+            val root = fs.getPath("/")
+            val sourceFiles = getAllSourceFiles(entry, fs, root).toVector
+            SourceEntryLookUp(entry, sourceFiles, fs, root)
           }
           .warnFailure(logger, s"Cannot list the source files in ${entry.name}")
-          .getOrElse(Vector.empty)
       case SourceDirectory(directory) =>
-        getAllSourceFiles(entry, FileSystems.getDefault, directory).toSeq
+        val fs = FileSystems.getDefault
+        val sourceFiles = getAllSourceFiles(entry, fs, directory).toVector
+        Some(SourceEntryLookUp(entry, sourceFiles, fs, directory))
       case StandaloneSourceFile(absolutePath, relativePath) =>
-        Seq(SourceFile(entry, relativePath, absolutePath.toUri))
+        val fs = FileSystems.getDefault
+        val sourceFile = SourceFile(entry, relativePath, absolutePath.toUri)
+        val root = fs.getPath(sourceFile.folderPath)
+        Some(SourceEntryLookUp(entry, Seq(sourceFile), FileSystems.getDefault, root))
     }
   }
 

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

@@ -83,13 +83,14 @@ private[debugadapter] object SourceLookUpProvider {
 
   def apply(entries: Seq[ClassEntry], logger: Logger): SourceLookUpProvider = {
     val parrallelEntries = ParVector(entries*)
-    val sourceFilesByEntry = parrallelEntries
-      .flatMap(_.sourceEntries)
-      .distinct
-      .map(entry => entry -> SourceEntryLookUp.getAllSourceFiles(entry, logger))
-      .toMap
+    val sourceLookUps =
+      parrallelEntries
+        .flatMap(_.sourceEntries)
+        .distinct
+        .map(entry => entry -> SourceEntryLookUp(entry, logger))
+        .toMap
     val allLookUps = parrallelEntries
-      .map(entry => ClassEntryLookUp(entry, entry.sourceEntries.flatMap(sourceFilesByEntry.apply), logger))
+      .map(entry => ClassEntryLookUp(entry, entry.sourceEntries.flatMap(sourceLookUps.apply), logger))
       .seq
     val sourceUriToClassPathEntry = allLookUps
       .flatMap(lookup => lookup.sources.map(uri => (uri, lookup)))

modules/core/src/main/scala/ch/epfl/scala/debugadapter/internal/stepfilter/Scala2StepFilter.scala

@@ -1,12 +1,14 @@
 package ch.epfl.scala.debugadapter.internal.stepfilter
 
-import com.sun.jdi
-import ch.epfl.scala.debugadapter.internal.scalasig._
-import ch.epfl.scala.debugadapter.internal.SourceLookUpProvider
-import ch.epfl.scala.debugadapter.internal.scalasig.ScalaSigPrinter
 import ch.epfl.scala.debugadapter.Logger
 import ch.epfl.scala.debugadapter.ScalaVersion
+import ch.epfl.scala.debugadapter.internal.SourceLookUpProvider
+import ch.epfl.scala.debugadapter.internal.scalasig.ScalaSigPrinter
+import ch.epfl.scala.debugadapter.internal.scalasig._
+import com.sun.jdi
+
 import scala.jdk.CollectionConverters.*
+import scala.util.matching.Regex
 
 class Scala2StepFilter(
     sourceLookUp: SourceLookUpProvider,
@@ -122,12 +124,11 @@ class Scala2StepFilter(
     // TODO try use tryEncode
     getOwners(scalaClass)
       .foldRight(Option(javaClass.name)) { (sym, acc) =>
-        for (javaName <- acc if javaName.contains(sym.name)) yield {
-          javaName
-            .split(sym.name)
+        for (javaName <- acc if javaName.contains(sym.name))
+          yield javaName
+            .split(Regex.quote(sym.name))
             .drop(1)
             .mkString(sym.name)
-        }
       }
       .exists { remainder =>
         remainder.forall(c => c.isDigit || c == '$')

modules/expression-compiler/src/main/scala-3/dotty/tools/dotc/evaluation/EvaluationStrategy.scala

@@ -12,6 +12,7 @@ import dotty.tools.dotc.util.Property.*
 enum EvaluationStrategy:
   case This(cls: ClassSymbol)
   case Outer(outerCls: ClassSymbol)
+  case LocalOuter(outerCls: ClassSymbol) // the $outer param in a constructor
   case LocalValue(variable: TermSymbol, isByName: Boolean)
   case LocalValueAssign(variable: TermSymbol)
   case MethodCapture(variable: TermSymbol, method: TermSymbol, isByName: Boolean)