Produced a meaningful error message when toolkit is invoked without passing a version

Author: Gedochao

modules/build/src/test/scala/scala/build/tests/DirectiveTests.scala

@@ -9,6 +9,8 @@ import scala.build.tests.util.BloopServer
 import build.Ops.EitherThrowOps
 import dependency.AnyDependency
 
+import scala.build.errors.ToolkitDirectiveMissingVersionError
+
 class DirectiveTests extends munit.FunSuite {
 
   val buildThreads = BuildThreads.create()
@@ -87,11 +89,11 @@ class DirectiveTests extends munit.FunSuite {
     }
   }
 
-  test("resolve toolkit & toolkit-test dependency") {
+  test(s"resolve toolkit & toolkit-test dependency with version passed") {
     val testInputs = TestInputs(
       os.rel / "simple.sc" ->
-        """//> using toolkit latest
-          |""".stripMargin
+        s"""//> using toolkit latest
+           |""".stripMargin
     )
     testInputs.withBuilds(baseOptions, buildThreads, bloopConfigOpt) {
       (_, _, maybeBuilds) =>
@@ -111,6 +113,21 @@ class DirectiveTests extends munit.FunSuite {
         expect(toolkitTestDep.version == expectedVersion)
     }
   }
+
+  for (toolkitDirectiveKey <- Seq("toolkit", "test.toolkit"))
+    test(s"missing $toolkitDirectiveKey version produces an informative error message") {
+      val testInputs = TestInputs(
+        os.rel / "simple.sc" ->
+          s"""//> using $toolkitDirectiveKey
+             |""".stripMargin
+      )
+      testInputs.withBuilds(baseOptions, buildThreads, bloopConfigOpt) {
+        (_, _, maybeBuilds) =>
+          maybeBuilds match
+            case Left(ToolkitDirectiveMissingVersionError(_, errorKey)) =>
+              expect(errorKey == toolkitDirectiveKey)
+      }
+    }
   for (scope <- Scope.all) {
     def withProjectFile[T](projectFileContent: String)(f: (Build, Boolean) => T): T = TestInputs(
       os.rel / "project.scala" -> projectFileContent,

modules/directives/src/main/scala/scala/build/directives/DirectiveValueParser.scala

@@ -7,6 +7,7 @@ import scala.build.errors.{
   BuildException,
   CompositeBuildException,
   MalformedDirectiveError,
+  ToolkitDirectiveMissingVersionError,
   UsingDirectiveValueNumError,
   UsingDirectiveWrongValueTypeError
 }
@@ -53,15 +54,18 @@ object DirectiveValueParser {
       scopePath: ScopePath,
       path: Either[String, os.Path]
     ): Either[BuildException, T] =
-      values.filter(!_.isEmpty) match {
-        case Seq(value) => parseValue(key, value, scopePath, path)
+      values match {
+        case Seq(value) if !value.isEmpty => parseValue(key, value, scopePath, path)
+        case Seq(value) if value.isEmpty && (key == "toolkit" || key == "test.toolkit") =>
+          // FIXME: handle similar parsing errors in the directive declaration instead of hacks like this one
+          Left(ToolkitDirectiveMissingVersionError(maybePath = path, key = key))
         case resultValues @ _ =>
           Left(
             new UsingDirectiveValueNumError(
               maybePath = path,
               key = key,
               expectedValueNum = 1,
-              providedValueNum = resultValues.length
+              providedValueNum = resultValues.count(!_.isEmpty)
             )
           )
       }

modules/directives/src/main/scala/scala/build/errors/UsingDirectiveExpectationError.scala

@@ -28,3 +28,20 @@ final class UsingDirectiveValueNumError(
       s"""Encountered an error when parsing the `$key` using directive$pathString.
          |Expected $expectedValueNum values, but got $providedValueNum values instead.""".stripMargin
     })
+
+final class ToolkitDirectiveMissingVersionError(
+  val maybePath: Either[String, os.Path],
+  val key: String
+) extends UsingDirectiveExpectationError({
+      val pathString = maybePath.map(p => s" at $p").getOrElse("")
+      s"""Encountered an error when parsing the `$key` using directive$pathString.
+         |Expected a version to be passed.
+         |Example: `//> using $key latest`
+         |""".stripMargin
+    })
+object ToolkitDirectiveMissingVersionError {
+  def apply(maybePath: Either[String, os.Path], key: String): ToolkitDirectiveMissingVersionError =
+    new ToolkitDirectiveMissingVersionError(maybePath, key)
+  def unapply(arg: ToolkitDirectiveMissingVersionError): (Either[String, os.Path], String) =
+    arg.maybePath -> arg.key
+}