Merge pull request #656 from adpi2/rename-decoder

Rename unpickler to decoder

Author: adpi2

.scalafmt.conf

@@ -13,7 +13,7 @@ rewrite.redundantBraces.generalExpressions = true
 rewrite.redundantBraces.stringInterpolation = true
 rewrite.redundantBraces.defnBodies = none
 fileOverride {
-  "glob:**/modules/unpickler/**.scala" {
+  "glob:**/modules/decoder/**.scala" {
     rewrite.scala3.convertToNewSyntax = yes
     rewrite.scala3.removeOptionalBraces = yes
   }

build.sbt

@@ -37,7 +37,7 @@ lazy val root = project
     expressionCompiler30,
     expressionCompiler33,
     expressionCompiler34,
-    unpickler3
+    decoder3
   )
   .settings(
     publish / skip := true
@@ -93,7 +93,7 @@ lazy val core = projectMatrix
       BuildInfoKey.action("organization")(organization.value),
       BuildInfoKey.action("version")(version.value),
       BuildInfoKey.action("expressionCompilerName")((LocalProject("expressionCompiler2_12") / name).value),
-      BuildInfoKey.action("unpicklerName")((LocalProject("unpickler3") / name).value),
+      BuildInfoKey.action("decoderName")((LocalProject("decoder3") / name).value),
       BuildInfoKey.action("scala212")(Dependencies.scala212),
       BuildInfoKey.action("scala213")(Dependencies.scala213),
       BuildInfoKey.action("scala30")(Dependencies.scala30),
@@ -194,12 +194,12 @@ lazy val expressionCompiler = projectMatrix
     scalacOptionsSettings
   )
 
-lazy val unpickler3: Project = project
-  .in(file("modules/unpickler"))
+lazy val decoder3: Project = project
+  .in(file("modules/decoder"))
   .disablePlugins(SbtJdiTools)
   .dependsOn(tests3 % Test)
   .settings(
-    name := "scala-debug-unpickler",
+    name := "scala-debug-decoder",
     scalaVersion := Dependencies.scala33,
     Compile / doc / sources := Seq.empty,
     libraryDependencies ++= Seq(
@@ -222,7 +222,7 @@ lazy val testOptionsSettings = Def.settings(
       LocalProject("expressionCompiler2_13") / publishLocal,
       LocalProject("expressionCompiler3_3") / publishLocal,
       LocalProject("expressionCompiler3_4") / publishLocal,
-      LocalProject("unpickler3") / publishLocal
+      LocalProject("decoder3") / publishLocal
     )
     .value
 )

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

@@ -4,5 +4,5 @@ import scala.util.Try
 
 trait DebugToolsResolver {
   def resolveExpressionCompiler(scalaVersion: ScalaVersion): Try[ClassLoader]
-  def resolveUnpickler(scalaVersion: ScalaVersion): Try[ClassLoader]
+  def resolveDecoder(scalaVersion: ScalaVersion): Try[ClassLoader]
 }

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

@@ -8,7 +8,7 @@ import scala.reflect.io.File
 
 private[debugadapter] final class DebugTools(
     val expressionCompilers: Map[ClassEntry, ExpressionCompiler],
-    val unpickler: Option[ClassLoader],
+    val decoder: Option[ClassLoader],
     val sourceLookUp: SourceLookUpProvider
 )
 
@@ -28,12 +28,12 @@ object DebugTools {
       loadExpressionCompiler(debuggee, resolver, logger)
     }
 
-    val unpickler =
+    val decoder =
       if (debuggee.scalaVersion.isScala3) {
         TimeUtils.logTime(logger, "Loaded step filter") {
           resolver
-            .resolveUnpickler(debuggee.scalaVersion)
-            .warnFailure(logger, s"Cannot fetch unpickler of Scala ${debuggee.scalaVersion}")
+            .resolveDecoder(debuggee.scalaVersion)
+            .warnFailure(logger, s"Cannot fetch decoder of Scala ${debuggee.scalaVersion}")
         }
       } else None
 
@@ -49,7 +49,7 @@ object DebugTools {
       SourceLookUpProvider(distinctEntries, logger)
     }
 
-    new DebugTools(allCompilers, unpickler, sourceLookUp)
+    new DebugTools(allCompilers, decoder, sourceLookUp)
   }
 
   /* At most 2 expression compilers are resolved, one for Scala 2 and one for Scala 3

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

@@ -11,17 +11,17 @@ import java.util.Optional
 
 class StackTraceProvider(
     runtimeFilter: RuntimeStepFilter,
-    scalaUnpickler: ScalaUnpickler,
+    decoder: ScalaDecoder,
     logger: Logger,
     testMode: Boolean
 ) extends JavaStackTraceProvider() {
 
-  private val stepFilters: Seq[StepFilter] = Seq(ClassLoadingFilter, runtimeFilter, scalaUnpickler)
+  private val stepFilters: Seq[StepFilter] = Seq(ClassLoadingFilter, runtimeFilter, decoder)
 
-  def reload(): Unit = scalaUnpickler.reload()
+  def reload(): Unit = decoder.reload()
 
   override def formatMethod(method: Method): Optional[String] = {
-    scalaUnpickler.format(method) match {
+    decoder.format(method) match {
       case None => Optional.empty()
       case Some(s) => Optional.of(s)
     }
@@ -62,11 +62,11 @@ object StackTraceProvider {
       logger: Logger,
       testMode: Boolean
   ): StackTraceProvider = {
-    val scalaUnpickler: ScalaUnpickler = ScalaUnpickler(debuggee, tools, logger, testMode)
+    val decoder: ScalaDecoder = ScalaDecoder(debuggee, tools, logger, testMode)
     val runtimeStepFilter = RuntimeStepFilter(debuggee.scalaVersion)
     new StackTraceProvider(
       runtimeStepFilter,
-      scalaUnpickler,
+      decoder,
       logger,
       testMode
     )

modules/core/src/main/scala/ch/epfl/scala/debugadapter/internal/stacktrace/Scala2Unpickler.scala renamed to modules/core/src/main/scala/ch/epfl/scala/debugadapter/internal/stacktrace/Scala2Decoder.scala

@@ -10,12 +10,12 @@ import com.sun.jdi
 import scala.jdk.CollectionConverters.*
 import scala.util.matching.Regex
 
-class Scala2Unpickler(
+class Scala2Decoder(
     sourceLookUp: SourceLookUpProvider,
     scalaVersion: ScalaVersion,
     logger: Logger,
     testMode: Boolean
-) extends ScalaUnpickler(scalaVersion, testMode) {
+) extends ScalaDecoder(scalaVersion, testMode) {
   override protected def skipScala(method: jdi.Method): Boolean = {
     if (isLazyInitializer(method)) {
       skipLazyInitializer(method)

modules/core/src/main/scala/ch/epfl/scala/debugadapter/internal/stacktrace/Scala3UnpicklerBridge.scala renamed to modules/core/src/main/scala/ch/epfl/scala/debugadapter/internal/stacktrace/Scala3DecoderBridge.scala

@@ -16,18 +16,18 @@ import scala.jdk.CollectionConverters._
 import scala.jdk.OptionConverters._
 import scala.util.Try
 
-class Scala3UnpicklerBridge(
+class Scala3DecoderBridge(
     debuggee: Debuggee,
     cls: Class[?],
     var bridge: Any,
     skipMethod: Method,
     formatMethod: Method,
     testMode: Boolean,
     logger: Logger
-) extends ScalaUnpickler(debuggee.scalaVersion, testMode) {
+) extends ScalaDecoder(debuggee.scalaVersion, testMode) {
 
   override def reload(): Unit =
-    bridge = Scala3UnpicklerBridge.load(debuggee, cls, logger, testMode)
+    bridge = Scala3DecoderBridge.load(debuggee, cls, logger, testMode)
 
   override protected def skipScala(method: jdi.Method): Boolean = {
     try skipMethod.invoke(bridge, method).asInstanceOf[Boolean]
@@ -46,8 +46,8 @@ class Scala3UnpicklerBridge(
   }
 }
 
-object Scala3UnpicklerBridge {
-  def load(debuggee: Debuggee, unpicklerClass: Class[?], logger: Logger, testMode: Boolean) = {
+object Scala3DecoderBridge {
+  def load(debuggee: Debuggee, decoderClass: Class[?], logger: Logger, testMode: Boolean) = {
     val javaRuntimeJars = debuggee.javaRuntime.toSeq.flatMap {
       case Java8(_, classJars, _) => classJars
       case java9OrAbove: Java9OrAbove =>
@@ -57,7 +57,7 @@ object Scala3UnpicklerBridge {
     }
     val debuggeeClasspath = debuggee.classPath.toArray ++ javaRuntimeJars
     val warnLogger: Consumer[String] = msg => logger.warn(msg)
-    val ctr = unpicklerClass.getConstructor(classOf[Array[Path]], classOf[Consumer[String]], classOf[Boolean])
+    val ctr = decoderClass.getConstructor(classOf[Array[Path]], classOf[Consumer[String]], classOf[Boolean])
 
     ctr.newInstance(debuggeeClasspath, warnLogger, testMode: java.lang.Boolean)
   }
@@ -67,16 +67,16 @@ object Scala3UnpicklerBridge {
       classLoader: ClassLoader,
       logger: Logger,
       testMode: Boolean
-  ): Try[Scala3UnpicklerBridge] = {
+  ): Try[Scala3DecoderBridge] = {
     Try {
-      val className = "ch.epfl.scala.debugadapter.internal.stacktrace.Scala3UnpicklerBridge"
+      val className = "ch.epfl.scala.debugadapter.internal.stacktrace.Scala3DecoderBridge"
       val cls = classLoader.loadClass(className)
 
       val bridge = load(debuggee, cls, logger, testMode)
       val skipMethod = cls.getMethod("skipMethod", classOf[Any])
       val formatMethod = cls.getMethod("formatMethod", classOf[Any])
 
-      new Scala3UnpicklerBridge(debuggee, cls, bridge, skipMethod, formatMethod, testMode, logger)
+      new Scala3DecoderBridge(debuggee, cls, bridge, skipMethod, formatMethod, testMode, logger)
     }
   }
 }

modules/core/src/main/scala/ch/epfl/scala/debugadapter/internal/stacktrace/ScalaUnpickler.scala renamed to modules/core/src/main/scala/ch/epfl/scala/debugadapter/internal/stacktrace/ScalaDecoder.scala

@@ -12,7 +12,7 @@ import com.sun.jdi.ReferenceType
 import scala.jdk.CollectionConverters.*
 import scala.util.control.NonFatal
 
-abstract class ScalaUnpickler(scalaVersion: ScalaVersion, testMode: Boolean) extends StepFilter {
+abstract class ScalaDecoder(scalaVersion: ScalaVersion, testMode: Boolean) extends StepFilter {
   protected def skipScala(method: Method): Boolean
   protected def formatScala(method: Method): Option[String] = Some(formatJava(method))
 
@@ -145,27 +145,27 @@ abstract class ScalaUnpickler(scalaVersion: ScalaVersion, testMode: Boolean) ext
     method.name.matches(""".+\$access\$\d+""")
 }
 
-object ScalaUnpickler {
+object ScalaDecoder {
   def apply(
       debuggee: Debuggee,
       tools: DebugTools,
       logger: Logger,
       testMode: Boolean
-  ): ScalaUnpickler = {
+  ): ScalaDecoder = {
     if (debuggee.scalaVersion.isScala2)
-      new Scala2Unpickler(tools.sourceLookUp, debuggee.scalaVersion, logger, testMode)
+      new Scala2Decoder(tools.sourceLookUp, debuggee.scalaVersion, logger, testMode)
     else
-      tools.unpickler
+      tools.decoder
         .flatMap { classLoader =>
-          Scala3UnpicklerBridge
+          Scala3DecoderBridge
             .tryLoad(debuggee, classLoader, logger, testMode)
             .warnFailure(logger, s"Cannot load step filter for Scala ${debuggee.scalaVersion}")
         }
         .getOrElse(fallback(debuggee.scalaVersion, testMode))
   }
 
-  private def fallback(scalaVersion: ScalaVersion, testMode: Boolean): ScalaUnpickler =
-    new ScalaUnpickler(scalaVersion, testMode) {
+  private def fallback(scalaVersion: ScalaVersion, testMode: Boolean): ScalaDecoder =
+    new ScalaDecoder(scalaVersion, testMode) {
       override protected def skipScala(method: Method): Boolean = false
     }
 }