Make InterruptInstrumentation typesafe by using enum

Author: WojciechMazur

repl/src/dotty/tools/repl/AbstractFileClassLoader.scala

@@ -22,10 +22,30 @@ import io.AbstractFile
 import java.net.{URL, URLConnection, URLStreamHandler}
 import java.util.Collections
 
-class AbstractFileClassLoader(root: AbstractFile, parent: ClassLoader, interruptInstrumentation: String)
+import AbstractFileClassLoader.InterruptInstrumentation
+
+
+object AbstractFileClassLoader:
+  enum InterruptInstrumentation(val stringValue: String):
+    case Disabled extends InterruptInstrumentation("false")
+    case Enabled extends InterruptInstrumentation("true")
+    case Local extends InterruptInstrumentation("local")
+
+    def is(value: InterruptInstrumentation): Boolean = this == value
+    def isOneOf(others: InterruptInstrumentation*): Boolean = others.contains(this)
+
+  object InterruptInstrumentation:
+    def fromString(string: String): InterruptInstrumentation = string match {
+      case "false" => Disabled
+      case "true" => Enabled
+      case "local" => Local
+      case _ => throw new IllegalArgumentException(s"Invalid interrupt instrumentation value: $string")
+    }
+
+class AbstractFileClassLoader(root: AbstractFile, parent: ClassLoader, interruptInstrumentation: InterruptInstrumentation)
   extends io.AbstractFileClassLoader(root, parent):
 
-  def this(root: AbstractFile, parent: ClassLoader) = this(root, parent, ScalaSettings.XreplInterruptInstrumentation.default)
+  def this(root: AbstractFile, parent: ClassLoader) = this(root, parent, InterruptInstrumentation.fromString(ScalaSettings.XreplInterruptInstrumentation.default))
 
   override def findClass(name: String): Class[?] = {
     var file: AbstractFile | Null = root
@@ -39,7 +59,7 @@ class AbstractFileClassLoader(root: AbstractFile, parent: ClassLoader, interrupt
 
     val bytes = file.toByteArray
 
-    if interruptInstrumentation != "false" then defineClassInstrumented(name, bytes)
+    if !interruptInstrumentation.is(InterruptInstrumentation.Enabled) then defineClassInstrumented(name, bytes)
     else defineClass(name, bytes, 0, bytes.length)
   }
 
@@ -49,8 +69,8 @@ class AbstractFileClassLoader(root: AbstractFile, parent: ClassLoader, interrupt
   }
 
   override def loadClass(name: String): Class[?] =
-    if interruptInstrumentation == "false" || interruptInstrumentation == "local"
-    then return super.loadClass(name)
+    if interruptInstrumentation.isOneOf(InterruptInstrumentation.Disabled, InterruptInstrumentation.Local) then
+      return super.loadClass(name)
 
     val loaded = findLoadedClass(name) // Check if already loaded
     if loaded != null then return loaded

repl/src/dotty/tools/repl/DependencyResolver.scala

@@ -7,6 +7,8 @@ import java.net.{URL, URLClassLoader}
 import scala.jdk.CollectionConverters.*
 import scala.util.control.NonFatal
 
+import dotty.tools.repl.AbstractFileClassLoader
+
 import coursierapi.{Repository, Dependency, MavenRepository}
 import com.virtuslab.using_directives.UsingDirectivesProcessor
 import com.virtuslab.using_directives.custom.model.{Path, StringValue, Value}
@@ -90,7 +92,7 @@ object DependencyResolver:
     import dotty.tools.dotc.classpath.ClassPathFactory
     import dotty.tools.dotc.core.SymbolLoaders
     import dotty.tools.dotc.core.Symbols.defn
-    import dotty.tools.io.*
+    import dotty.tools.io.{AbstractFile, ClassPath}
     import dotty.tools.repl.ScalaClassLoader.fromURLsParallelCapable
 
     // Create a classloader with all the resolved JAR files
@@ -106,10 +108,10 @@ object DependencyResolver:
         SymbolLoaders.mergeNewEntries(defn.RootClass, ClassPath.RootPackage, jarClassPath, ctx.platform.classPath)
 
     // Create new classloader with previous output dir and resolved dependencies
-    new dotty.tools.repl.AbstractFileClassLoader(
+    new AbstractFileClassLoader(
       prevOutputDir,
       depsClassLoader,
-      ctx.settings.XreplInterruptInstrumentation.value
+      AbstractFileClassLoader.InterruptInstrumentation.fromString(ctx.settings.XreplInterruptInstrumentation.value)
     )
 
 end DependencyResolver

repl/src/dotty/tools/repl/Rendering.scala

@@ -86,7 +86,7 @@ private[repl] class Rendering(parentClassLoader: Option[ClassLoader] = None):
       myClassLoader = new AbstractFileClassLoader(
         ctx.settings.outputDir.value,
         parent,
-        ctx.settings.XreplInterruptInstrumentation.value
+        AbstractFileClassLoader.InterruptInstrumentation.fromString(ctx.settings.XreplInterruptInstrumentation.value)
       )
       myClassLoader
     }

repl/src/dotty/tools/repl/ReplDriver.scala

@@ -607,7 +607,7 @@ class ReplDriver(settings: Array[String],
             rendering.myClassLoader = new AbstractFileClassLoader(
               prevOutputDir,
               jarClassLoader,
-              ctx.settings.XreplInterruptInstrumentation.value
+              AbstractFileClassLoader.InterruptInstrumentation.fromString(ctx.settings.XreplInterruptInstrumentation.value)
             )
 
             out.println(s"Added '$path' to classpath.")