Add position to ComputeVersion

Author: MaciejG604

modules/build/src/test/scala/scala/build/options/publish/ComputeVersionTests.scala

@@ -15,7 +15,7 @@ class ComputeVersionTests extends munit.FunSuite {
       os.rel / "version" -> ver
     )
     inputs.fromRoot { root =>
-      val cv = ComputeVersion.Command(Seq("cat", "version"))
+      val cv = ComputeVersion.Command(Nil, Seq("cat", "version"))
       val readVersion = cv.get(root)
         .fold(ex => throw new Exception(ex), identity)
       expect(readVersion == ver)
@@ -31,7 +31,7 @@ class ComputeVersionTests extends munit.FunSuite {
       os.proc("git", "clone", repo)
         .call(cwd = root, stdin = os.Inherit, stdout = os.Inherit)
       val dir = root / "compute-version-test"
-      val cv  = ComputeVersion.GitTag(os.rel, true, "0.0.1-SNAPSHOT")
+      val cv  = ComputeVersion.GitTag(Nil, os.rel, true, "0.0.1-SNAPSHOT")
 
       val commitExpectedVersions = Seq(
         "8ea4e87f202fbcc369bec9615e7ddf2c14b39e9d" -> "0.2.0-1-g8ea4e87-SNAPSHOT",
@@ -56,7 +56,7 @@ class ComputeVersionTests extends munit.FunSuite {
       expect(!hasHead)
 
       val defaultVersion = "0.0.2-SNAPSHOT"
-      val cv             = ComputeVersion.GitTag(os.rel, true, defaultVersion)
+      val cv             = ComputeVersion.GitTag(Nil, os.rel, true, defaultVersion)
 
       val version = cv.get(root)
         .fold(ex => throw new Exception(ex), identity)

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

@@ -382,4 +382,47 @@ class SourceGeneratorTests extends munit.FunSuite {
         )
     }
   }
+
+  test("BuildInfo no git repository error") {
+    val usingPrefix = "//> using computeVersion \""
+    val usingValue  = "git:tag"
+    val usingSuffix = "\""
+
+    val inputs = TestInputs(
+      os.rel / "main.scala" ->
+        s"""
+           |$usingPrefix$usingValue$usingSuffix
+           |//> using buildInfo
+           |
+           |import scala.cli.build.BuildInfo
+           |
+           |object Main extends App {
+           |  println(s"Scala version: $${BuildInfo.projectVersion}")
+           |}
+           |""".stripMargin
+    )
+
+    inputs.withBuild(baseOptions, buildThreads, bloopConfigOpt) {
+      (root, _, maybeBuild) =>
+        maybeBuild match {
+          case Left(buildException) =>
+            expect(buildException.positions.size == 1)
+            val position = buildException.positions.head
+
+            assertEquals(
+              position,
+              scala.build.Position.File(
+                Right(root / "main.scala"),
+                (1, usingPrefix.length),
+                (1, (usingPrefix + usingValue).length)
+              )
+            )
+            assertNoDiff(
+              buildException.message,
+              s"BuildInfo generation error: $root doesn't look like a Git repository"
+            )
+          case _ => fail("Build should fail")
+        }
+    }
+  }
 }

modules/cli/src/main/scala/scala/cli/commands/publish/Publish.scala

@@ -370,7 +370,7 @@ object Publish extends ScalaCommand[PublishOptions] with BuildCommandHelpers {
     name
   }
   def defaultComputeVersion(mayDefaultToGitTag: Boolean): Option[ComputeVersion] =
-    if (mayDefaultToGitTag) Some(ComputeVersion.GitTag(os.rel, dynVer = false))
+    if (mayDefaultToGitTag) Some(ComputeVersion.GitTag(Nil, os.rel, dynVer = false))
     else None
   def defaultVersionError =
     new MissingPublishOptionError("version", "--version", "publish.version")

modules/core/src/main/scala/scala/build/errors/BuildInfoGenerationError.scala

@@ -1,4 +1,10 @@
 package scala.build.errors
 
-final class BuildInfoGenerationError(cause: Exception)
-    extends BuildException(s"BuildInfo generation error: ${cause.getMessage}", cause = cause)
+import scala.build.Position
+
+final class BuildInfoGenerationError(msg: String, positions: Seq[Position], cause: Exception)
+    extends BuildException(
+      s"BuildInfo generation error: $msg",
+      positions = positions,
+      cause = cause
+    )

modules/options/src/main/scala/scala/build/info/BuildInfo.scala

@@ -100,19 +100,23 @@ object BuildInfo {
   def apply(
     options: BuildOptions,
     workspace: os.Path
-  ): Either[BuildException, BuildInfo] = either {
+  ): Either[BuildException, BuildInfo] = either[Exception] {
     Seq(
       BuildInfo(
         mainClass = options.mainClass,
         projectVersion = options.sourceGeneratorOptions.computeVersion
           .map(cv => value(cv.get(workspace)))
-          .orElse(ComputeVersion.GitTag(os.rel, dynVer = false).get(workspace).toOption)
+          .orElse(ComputeVersion.GitTag(Nil, os.rel, dynVer = false).get(workspace).toOption)
       ),
       scalaVersionSettings(options),
       platformSettings(options)
     )
       .reduceLeft(_ + _)
-  }.left.map(BuildInfoGenerationError(_))
+  }.left.map {
+    case e: BuildException =>
+      BuildInfoGenerationError(e.message, positions = e.positions, cause = e)
+    case e => BuildInfoGenerationError(e.getMessage, Nil, e)
+  }
 
   def escapeBackslashes(s: String): String =
     s.replace("\\", "\\\\")

modules/options/src/main/scala/scala/build/options/ComputeVersion.scala

@@ -5,26 +5,29 @@ import com.github.plokhotnyuk.jsoniter_scala.macros.*
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.lib.{Constants, Ref}
 
-import scala.build.Positioned
+import scala.build.{Position, Positioned}
 import scala.build.errors.{BuildException, MalformedInputError}
 import scala.io.Codec
 import scala.jdk.CollectionConverters.*
 import scala.util.{Success, Try, Using}
 
 sealed abstract class ComputeVersion extends Product with Serializable {
   def get(workspace: os.Path): Either[BuildException, String]
+
+  val positions: Seq[Position]
 }
 
 object ComputeVersion {
 
-  final case class Command(command: Seq[String]) extends ComputeVersion {
+  final case class Command(positions: Seq[Position], command: Seq[String]) extends ComputeVersion {
     def get(workspace: os.Path): Either[BuildException, String] = {
       val maybeRes = Try(os.proc(command).call(stdin = os.Inherit, cwd = workspace, check = false))
       maybeRes match {
         case Success(res) if res.exitCode == 0 =>
           Right(res.out.trim(Codec.default))
         case _ =>
           Left(new Command.ComputeVersionCommandError(
+            positions,
             command,
             maybeRes.map(_.exitCode).getOrElse(1)
           ))
@@ -33,13 +36,18 @@ object ComputeVersion {
   }
 
   object Command {
-    final class ComputeVersionCommandError(command: Seq[String], exitCode: Int)
-        extends BuildException(
-          s"Error running command ${command.mkString(" ")} (exit code: $exitCode)"
+    final class ComputeVersionCommandError(
+      positions: Seq[Position],
+      command: Seq[String],
+      exitCode: Int
+    ) extends BuildException(
+          s"Error running command ${command.mkString(" ")} (exit code: $exitCode)",
+          positions = positions
         )
   }
 
   final case class GitTag(
+    positions: Seq[Position],
     repo: os.FilePath,
     dynVer: Boolean,
     defaultFirstVersion: String = "0.1.0-SNAPSHOT"
@@ -115,17 +123,19 @@ object ComputeVersion {
               Option(tagOrNull) match {
                 case None =>
                   Left(new GitTagError(
+                    positions,
                     s"Unexpected error when running git describe from Git repository $repo0 (git describe doesn't find back tag $tag)"
                   ))
                 case Some(tag) =>
                   versionOf(tag).map(_ + "-SNAPSHOT").toRight(
                     new GitTagError(
+                      positions,
                       s"Unexpected error when running git describe from Git repository $repo0 (git describe-provided tag $tag doesn't have the expected shape)"
                     )
                   )
               }
             case (Some(_), None) =>
-              Left(new GitTagError(s"No stable tag found in Git repository $repo0"))
+              Left(new GitTagError(positions, s"No stable tag found in Git repository $repo0"))
             case (_, Some((tag, name))) =>
               val idx = name.lastIndexOf('.')
               if (
@@ -134,6 +144,7 @@ object ComputeVersion {
                 Right(name.take(idx + 1) + (name.drop(idx + 1).toInt + 1).toString + "-SNAPSHOT")
               else
                 Left(new GitTagError(
+                  positions,
                   s"Don't know how to bump version in tag $tag in Git repository $repo0"
                 ))
           }
@@ -142,32 +153,38 @@ object ComputeVersion {
           Right(defaultFirstVersion)
       }
       else
-        Left(new GitTagError(s"$repo0 doesn't look like a Git repository"))
+        Left(new GitTagError(positions, s"$repo0 doesn't look like a Git repository"))
     }
   }
   object GitTag {
-    final class GitTagError(message: String) extends BuildException(message)
+    final class GitTagError(positions: Seq[Position], message: String)
+        extends BuildException(message, positions)
   }
 
   private lazy val commandCodec: JsonValueCodec[List[String]] =
     JsonCodecMaker.make
 
   def parse(input: Positioned[String]): Either[BuildException, ComputeVersion] =
     if (input.value == "git" || input.value == "git:tag")
-      Right(ComputeVersion.GitTag(os.rel, dynVer = false))
+      Right(ComputeVersion.GitTag(input.positions, os.rel, dynVer = false))
     else if (input.value.startsWith("git:tag:"))
-      Right(ComputeVersion.GitTag(os.FilePath(input.value.stripPrefix("git:tag:")), dynVer = false))
+      Right(ComputeVersion.GitTag(
+        input.positions,
+        os.FilePath(input.value.stripPrefix("git:tag:")),
+        dynVer = false
+      ))
     else if (input.value == "git:dynver")
-      Right(ComputeVersion.GitTag(os.rel, dynVer = true))
+      Right(ComputeVersion.GitTag(input.positions, os.rel, dynVer = true))
     else if (input.value.startsWith("git:dynver:"))
       Right(ComputeVersion.GitTag(
+        input.positions,
         os.FilePath(input.value.stripPrefix("git:dynver:")),
         dynVer = true
       ))
     else if (input.value.startsWith("command:["))
       try {
         val command = readFromString(input.value.stripPrefix("command:"))(commandCodec)
-        Right(ComputeVersion.Command(command))
+        Right(ComputeVersion.Command(input.positions, command))
       }
       catch {
         case e: JsonReaderException =>
@@ -183,7 +200,7 @@ object ComputeVersion {
       }
     else if (input.value.startsWith("command:")) {
       val command = input.value.stripPrefix("command:").split("\\s+").toSeq
-      Right(ComputeVersion.Command(command))
+      Right(ComputeVersion.Command(input.positions, command))
     }
     else
       Left(