Reproduce error from scala-exercises/sbt-exercise

build.sbt

@@ -8,9 +8,15 @@ addCommandAlias(
   ";scalafmtCheckAll; scalafmtSbtCheck; +test; +publishLocal; scripted"
 )
 
-// ScalaTest
-libraryDependencies += "org.scalactic" %% "scalactic" % "3.2.9" % Test
-libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.9" % Test
+lazy val root = project.aggregate(compiler, `sbt-source-extract`)
+
+lazy val dependencies = Seq(
+  "org.scalactic" %% "scalactic" % "3.2.9" % Test,
+  "org.scalatest" %% "scalatest" % "3.2.9" % Test,
+  "org.typelevel" %% "cats-core" % "2.4.0"
+)
+
+lazy val compilerClasspath = TaskKey[Classpath]("compiler-classpath")
 
 inThisBuild(
   List(
@@ -23,7 +29,7 @@ inThisBuild(
       Developer(
         "jisantuc",
         "James Santucci",
-        "james.santucci@47deg.com",
+        "james.santucci@47d1eg.com",
         url("https://github.com/jisantuc")
       )
     )
@@ -32,13 +38,33 @@ inThisBuild(
 
 (console / initialCommands) := """import io.github.jisantuc.sbtse._"""
 
-enablePlugins(ScriptedPlugin, SbtPlugin)
-// set up 'scripted; sbt plugin for testing sbt plugins
-scriptedLaunchOpts ++=
-  Seq("-Xmx1024M", "-Dplugin.version=" + version.value)
-
 ThisBuild / githubWorkflowBuild := Seq(
   WorkflowStep.Sbt(List("ci-test"))
 )
 
 ThisBuild / githubWorkflowPublishTargetBranches := Seq.empty
+
+lazy val `sbt-source-extract` = (project in file("sbtse"))
+  .settings(
+    compilerClasspath := { (compiler / Compile / fullClasspath) }.value,
+    buildInfoObject := "Meta",
+    buildInfoPackage := "io.github.jisantuc.sbtse",
+    buildInfoKeys := Seq(
+      version,
+      BuildInfoKey.map(compilerClasspath) { case (_, classFiles) ⇒
+        ("compilerClasspath", classFiles.map(_.data))
+      }
+    ),
+    libraryDependencies ++= dependencies,
+    // set up 'scripted; sbt plugin for testing sbt plugins
+    scriptedLaunchOpts ++=
+      Seq("-Xmx1024M", "-Dplugin.version=" + version.value)
+  )
+  .dependsOn(compiler)
+  .enablePlugins(BuildInfoPlugin, SbtPlugin, ScriptedPlugin)
+
+lazy val compiler = (project in file("compiler"))
+  .settings(
+    libraryDependencies ++= dependencies
+  )
+  .enablePlugins(BuildInfoPlugin, SbtPlugin)

compiler/src/main/scala/io/github/jisantuc/sbtse/Compiler.scala

@@ -0,0 +1,14 @@
+package io.github.jisantuc.sbtse
+
+class CompilerJava {
+  def compile(): Array[String] = {
+    locally(Compiler().test)
+    println("ok!")
+    Array.empty
+  }
+}
+
+final case class Compiler() {
+  lazy val extracter = new Extracter()
+  val test = extracter.testFn()
+}

compiler/src/main/scala/io/github/jisantuc/sbtse/Extracter.scala

@@ -0,0 +1,67 @@
+package io.github.jisantuc.sbtse
+
+import java.io.File
+
+import scala.annotation.tailrec
+import scala.collection.compat._
+import scala.reflect.internal.util.BatchSourceFile
+import scala.tools.nsc._
+import scala.tools.nsc.doc.{Settings => _, _}
+import scala.tools.nsc.doc.base.comment.Comment
+
+class Extracter {
+  private def classPathOfClass(className: String): List[String] = {
+    val resource = className.split('.').mkString("/", "/", ".class")
+    val path = getClass.getResource(resource).getPath
+    if (path.indexOf("file:") >= 0) {
+      val indexOfFile = path.indexOf("file:") + 5
+      val indexOfSeparator = path.lastIndexOf('!')
+      List(path.substring(indexOfFile, indexOfSeparator))
+    } else {
+      require(path.endsWith(resource))
+      List(path.substring(0, path.length - resource.length + 1))
+    }
+  }
+
+  private lazy val compilerPath =
+    try classPathOfClass("scala.tools.nsc.Interpreter")
+    catch {
+      case e: Throwable =>
+        throw new RuntimeException(
+          "Unable to load Scala interpreter from classpath (scala-compiler jar is missing?)",
+          e
+        )
+    }
+
+  private lazy val libPath =
+    try classPathOfClass("scala.AnyVal")
+    catch {
+      case e: Throwable =>
+        throw new RuntimeException(
+          "Unable to load scala base object from classpath (scala-library jar is missing?)",
+          e
+        )
+    }
+
+  lazy val paths: List[String] = compilerPath ::: libPath
+
+  // Same settings as
+  // https://github.com/scala-exercises/sbt-exercise/blob/v0.6.7/compiler/src/main/scala/org/scalaexercises/exercises/compiler/SourceTextExtraction.scal
+  // except usejavacp.value is set to false.
+  // that setting controls whether to "Utilize the java.class.path in classpath resolution."
+  // clearly that was interacting with _something_ poorly (buildinfo plugin? I don't know!)
+  // but it'll probably be a bit before I understand what.
+  val defaultSettings = new Settings {
+    embeddedDefaults[Global.type]
+    Yrangepos.value = true
+    usejavacp.value = false
+
+    bootclasspath.value = paths.mkString(File.pathSeparator)
+    classpath.value = paths.mkString(File.pathSeparator)
+  }
+  val global = new Global(defaultSettings)
+
+  def testFn(): global.Run = {
+    new global.Run()
+  }
+}

compiler/src/test/scala/io/github/jisantuc/sbtse/SourceExtractSpec.scala

@@ -0,0 +1,12 @@
+package io.github.jisantuc.sbtse
+
+import org.scalatest.funspec.AnyFunSpec
+import org.scalatest.matchers.should.Matchers
+
+class SourceExtractTest extends AnyFunSpec with Matchers {
+  describe("run without crashing when initialized without classpath hackery") {
+    it("should do that") {
+      new CompilerJava().compile()
+    }
+  }
+}

project/plugins.sbt

@@ -1,3 +1,4 @@
 libraryDependencies += "org.scala-sbt" %% "scripted-plugin" % sbtVersion.value
 addSbtPlugin("com.codecommit" % "sbt-github-actions" % "0.13.0")
 addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.4.6")
+addSbtPlugin("com.eed3si9n" % "sbt-buildinfo" % "0.10.0")

sbtse/src/main/scala/io/github/jisantuc/sbtse/SourceExtractPlugin.scala

@@ -0,0 +1,62 @@
+package io.github.jisantuc.sbtse
+
+import sbt._
+import sbt.Keys._
+import sbt.plugins.JvmPlugin
+
+import cats.data.Ior
+import cats.syntax.either._
+import cats.syntax.monadError._
+import scala.util.Random
+import sbt.internal.inc.classpath.ClasspathUtil
+import java.nio.file.Paths
+
+object SourceExtractPlugin extends AutoPlugin {
+
+  override def trigger = allRequirements
+  override def requires = JvmPlugin
+
+  object autoImport {
+    val testInit =
+      TaskKey[Unit]("test-init", "run initialization to see if it crashes")
+  }
+
+  import autoImport._
+
+  override lazy val projectSettings = Seq(
+    testInit := locally(testTask.value)
+  )
+
+  override lazy val buildSettings = Seq()
+
+  override lazy val globalSettings = Seq()
+
+  private def catching[A](f: => A)(msg: => String) =
+    Either.catchNonFatal(f).leftMap(e => Ior.both(msg, e))
+
+  private val COMPILER_CLASS = "io.github.jisantuc.sbtse.CompilerJava"
+
+  private type COMPILER = {
+    def compile(): Array[String]
+  }
+
+  def testTask = Def.task {
+    val libraryClasspath = Attributed.data((Compile / fullClasspath).value)
+    val classpath = (Meta.compilerClasspath ++ libraryClasspath).distinct
+    val loader = ClasspathUtil.toLoader(
+      classpath.map(file => Paths.get(file.getAbsolutePath())),
+      null,
+      ClasspathUtil.createClasspathResources(
+        appPaths =
+          Meta.compilerClasspath.map(file => Paths.get(file.getAbsolutePath())),
+        bootPaths = scalaInstance.value.allJars.map(file =>
+          Paths.get(file.getAbsolutePath())
+        )
+      )
+    )
+
+    val compilerClass = loader.loadClass(COMPILER_CLASS)
+    val compiler = compilerClass.newInstance.asInstanceOf[COMPILER]
+    compiler.compile()
+  }
+}

sbtse/src/sbt-test/sbt-source-extract/simple/build.sbt

@@ -0,0 +1,11 @@
+version := "0.1"
+scalaVersion := "2.12.15"
+
+lazy val simple = (project in file("."))
+  .settings(
+    resolvers ++= Seq(
+      Resolver.sonatypeRepo("snapshots"),
+      Resolver.defaultLocal
+    )
+  )
+  .enablePlugins(SourceExtractPlugin)

sbtse/src/sbt-test/sbt-source-extract/simple/test

@@ -0,0 +1,2 @@
+# check whether the test task runs without crashing
+> simple / testInit