RuleDecoder: avoid error on Scala 3 & stale class on Scala 2

In scala 3's AbstractFileClassLoader, `loadClass` is routing loadClass
calls to findClass, causing "attempted duplicate class definition"
when loading a rule sharing the same FQN as a previously compiled one.

In scala 2, there is no failure but loaded rules could be the result
of previous compilations, so returning a fresh classloader each time
is probably what we want.

Author: bjaglin

scalafix-reflect/src/main/scala-2/scalafix/internal/reflect/RuleCompiler.scala

@@ -30,8 +30,6 @@ class RuleCompiler(
   settings.classpath.value = classpath
   lazy val reporter = new StoreReporter
   private val global = new Global(settings, reporter)
-  private val classLoader =
-    new AbstractFileClassLoader(output, this.getClass.getClassLoader)
 
   def compile(input: Input): Configured[ClassLoader] = {
     reporter.reset()
@@ -57,6 +55,10 @@ class RuleCompiler(
     ConfError
       .fromResults(errors.toSeq)
       .map(_.notOk)
-      .getOrElse(Configured.Ok(classLoader))
+      .getOrElse {
+        val classLoader: AbstractFileClassLoader =
+          new AbstractFileClassLoader(output, this.getClass.getClassLoader)
+        Configured.Ok(classLoader)
+      }
   }
 }

scalafix-reflect/src/main/scala-3/scalafix/internal/reflect/RuleCompiler.scala

@@ -38,8 +38,6 @@ class RuleCompiler(
     .setSetting(ctx.settings.classpath, classpath)
 
   private val compiler: Compiler = new Compiler()
-  private val classLoader: AbstractFileClassLoader =
-    new AbstractFileClassLoader(output, this.getClass.getClassLoader)
 
   def compile(input: Input): Configured[ClassLoader] = {
     reporter.removeBufferedMessages(using ctx)
@@ -71,6 +69,10 @@ class RuleCompiler(
     ConfError
       .apply(errors)
       .map(_.notOk)
-      .getOrElse(Configured.Ok(classLoader))
+      .getOrElse {
+        val classLoader: AbstractFileClassLoader =
+          new AbstractFileClassLoader(output, this.getClass.getClassLoader)
+        Configured.Ok(classLoader)
+      }
   }
 }

scalafix-tests/unit/src/test/scala/scalafix/tests/reflect/RuleDecoderSuite.scala

@@ -1,5 +1,7 @@
 package scalafix.tests.reflect
 
+import java.nio.file.Files
+
 import scala.meta.io.AbsolutePath
 import scala.meta.io.RelativePath
 
@@ -26,13 +28,42 @@ class RuleDecoderSuite extends AnyFunSuite {
     RuleDecoder.Settings().withCwd(cwd)
   val decoder: ConfDecoder[Rules] = RuleDecoder.decoder(decoderSettings)
   val expectedName = "NoDummy"
-  val expectedDescription = ""
+
   test("absolute path resolves as is", SkipWindows) {
     val rules = decoder.read(Conf.Str(s"file:$abspath")).get
     assert(expectedName == rules.name.value)
   }
+
   test("relative resolves from custom working directory") {
     val rules = decoder.read(Conf.Str(s"file:$relpath")).get
     assert(expectedName == rules.name.value)
   }
+
+  test("resolved classes can be reloaded", SkipWindows) {
+    val tmp = Files.createTempFile("scalafix", "CustomRule.scala")
+
+    val customRuleV1 =
+      """package custom
+        |import scalafix.v1._
+        |class CustomRule extends SyntacticRule("CustomRule") {}
+      """.stripMargin
+    Files.write(tmp, customRuleV1.getBytes)
+    val rules1 =
+      decoder.read(Conf.Str(s"file:${tmp.toFile.getAbsolutePath}")).get
+    val class1 = rules1.rules.head.getClass
+
+    val customRuleV2 =
+      """package custom
+        |import scalafix.v1._
+        |class CustomRule extends SyntacticRule("CustomRule") {
+        |  def foo = 1
+        |}
+      """.stripMargin
+    Files.write(tmp, customRuleV2.getBytes)
+    val rules2 =
+      decoder.read(Conf.Str(s"file:${tmp.toFile.getAbsolutePath}")).get
+    val class2 = rules2.rules.head.getClass
+
+    assert(!class1.isAssignableFrom(class2))
+  }
 }