Merge pull request #1026 from alexarchambault/publish-fixes

Publish fixes

Author: alexarchambault

modules/build/src/main/scala/scala/build/bsp/BuildServerForwardStubs.scala

@@ -28,60 +28,60 @@ trait BuildServerForwardStubs extends b.BuildServer {
   }
 
   override def buildShutdown(): CompletableFuture[Object] =
-    forwardTo.buildShutdown().handleAsync(fatalExceptionHandler("buildShutdown"))
+    forwardTo.buildShutdown().handle(fatalExceptionHandler("buildShutdown"))
 
   override def buildTargetCleanCache(
     params: b.CleanCacheParams
   ): CompletableFuture[b.CleanCacheResult] =
     forwardTo.buildTargetCleanCache(params)
-      .handleAsync(fatalExceptionHandler("buildTargetCleanCache", params))
+      .handle(fatalExceptionHandler("buildTargetCleanCache", params))
 
   override def buildTargetCompile(params: b.CompileParams): CompletableFuture[b.CompileResult] =
     forwardTo.buildTargetCompile(params)
-      .handleAsync(fatalExceptionHandler("buildTargetCompile", params))
+      .handle(fatalExceptionHandler("buildTargetCompile", params))
 
   override def buildTargetDependencySources(
     params: b.DependencySourcesParams
   ): CompletableFuture[b.DependencySourcesResult] =
     forwardTo.buildTargetDependencySources(params)
-      .handleAsync(fatalExceptionHandler("buildTargetDependencySources", params))
+      .handle(fatalExceptionHandler("buildTargetDependencySources", params))
 
   override def buildTargetInverseSources(
     params: b.InverseSourcesParams
   ): CompletableFuture[b.InverseSourcesResult] =
     forwardTo.buildTargetInverseSources(params)
-      .handleAsync(fatalExceptionHandler("buildTargetInverseSources", params))
+      .handle(fatalExceptionHandler("buildTargetInverseSources", params))
 
   override def buildTargetResources(
     params: b.ResourcesParams
   ): CompletableFuture[b.ResourcesResult] =
     forwardTo.buildTargetResources(params)
-      .handleAsync(fatalExceptionHandler("buildTargetResources", params))
+      .handle(fatalExceptionHandler("buildTargetResources", params))
 
   override def buildTargetRun(params: b.RunParams): CompletableFuture[b.RunResult] =
     forwardTo.buildTargetRun(params)
-      .handleAsync(fatalExceptionHandler("buildTargetRun", params))
+      .handle(fatalExceptionHandler("buildTargetRun", params))
 
   override def buildTargetSources(params: b.SourcesParams): CompletableFuture[b.SourcesResult] =
     forwardTo.buildTargetSources(params)
-      .handleAsync(fatalExceptionHandler("buildTargetSources", params))
+      .handle(fatalExceptionHandler("buildTargetSources", params))
 
   override def buildTargetTest(params: b.TestParams): CompletableFuture[b.TestResult] =
     forwardTo.buildTargetTest(params)
-      .handleAsync(fatalExceptionHandler("buildTargetTest", params))
+      .handle(fatalExceptionHandler("buildTargetTest", params))
 
   override def workspaceBuildTargets(): CompletableFuture[b.WorkspaceBuildTargetsResult] =
     forwardTo.workspaceBuildTargets()
-      .handleAsync(fatalExceptionHandler("workspaceBuildTargets"))
+      .handle(fatalExceptionHandler("workspaceBuildTargets"))
 
   override def workspaceReload(): CompletableFuture[Object] =
     CompletableFuture.completedFuture(new Object)
   // Bloop does not support workspaceReload and Intellij calls it at the start
   // forwardTo.workspaceReload()
-  //   .handleAsync(fatalExceptionHandler("workspaceReload"))
+  //   .handle(fatalExceptionHandler("workspaceReload"))
 
   override def buildTargetDependencyModules(params: DependencyModulesParams)
     : CompletableFuture[DependencyModulesResult] =
     forwardTo.buildTargetDependencyModules(params)
-      .handleAsync(fatalExceptionHandler("buildTargetDependencyModules", params))
+      .handle(fatalExceptionHandler("buildTargetDependencyModules", params))
 }

modules/cli-options/src/main/scala/scala/cli/commands/publish/SharedPublishOptions.scala

@@ -52,7 +52,11 @@ final case class SharedPublishOptions(
   @Group("Publishing")
   @HelpMessage("Set Ivy 2 home directory")
   @ValueDescription("path")
-    ivy2Home: Option[String] = None
+    ivy2Home: Option[String] = None,
+
+  @Group("Publishing")
+  @Hidden
+    forceSigningBinary: Boolean = false
 
 )
 // format: on

modules/cli/src/main/java/scala/cli/internal/BouncycastleSignerMakerSubst.java

@@ -12,10 +12,10 @@
 import scala.cli.signing.shared.PasswordOption;
 
 @TargetClass(className = "scala.cli.publish.BouncycastleSignerMaker")
-final class BouncycastleSignerMakerSubst {
+public final class BouncycastleSignerMakerSubst {
 
   @Substitute
-  Signer get(PasswordOption passwordOrNull, PasswordOption secretKey, Supplier<Path> launcher, Logger logger) {
+  public Signer get(PasswordOption passwordOrNull, PasswordOption secretKey, Supplier<Path> launcher, Logger logger) {
     return BouncycastleExternalSigner$.MODULE$.apply(secretKey, passwordOrNull, launcher.get(), logger);
   }
 

modules/cli/src/main/scala/scala/cli/commands/Bsp.scala

@@ -66,7 +66,7 @@ object Bsp extends ScalaCommand[BspOptions] {
   }
 
   private def buildOptions(sharedOptions: SharedOptions): BuildOptions = {
-    val baseOptions = sharedOptions.buildOptions(enableJmh = false, jmhVersion = None)
+    val baseOptions = sharedOptions.buildOptions()
     baseOptions.copy(
       classPathOptions = baseOptions.classPathOptions.copy(
         fetchSources = baseOptions.classPathOptions.fetchSources.orElse(Some(true))

modules/cli/src/main/scala/scala/cli/commands/Compile.scala

@@ -73,7 +73,7 @@ object Compile extends ScalaCommand[CompileOptions] {
       }
     }
 
-    val buildOptions = options.shared.buildOptions(enableJmh = false, jmhVersion = None)
+    val buildOptions = options.shared.buildOptions()
     val threads      = BuildThreads.create()
 
     val compilerMaker = options.shared.compilerMaker(threads)

modules/cli/src/main/scala/scala/cli/commands/Export.scala

@@ -98,7 +98,7 @@ object Export extends ScalaCommand[ExportOptions] {
     val inputs = options.shared.inputsOrExit(args)
     CurrentParams.workspaceOpt = Some(inputs.workspace)
     val baseOptions =
-      options.shared.buildOptions(enableJmh = false, None)
+      options.shared.buildOptions()
         .copy(mainClass = options.mainClass.mainClass.filter(_.nonEmpty))
 
     val (sourcesMain, optionsMain0) =

modules/cli/src/main/scala/scala/cli/commands/Fmt.scala

@@ -89,7 +89,7 @@ object Fmt extends ScalaCommand[FmtOptions] {
     }
 
     def buildOptions: BuildOptions =
-      shared.buildOptions(enableJmh = false, jmhVersion = None, ignoreErrors = false)
+      shared.buildOptions(ignoreErrors = false)
 
     def scalafmtCliOptions: List[String] =
       scalafmtArg ::: (if (check) List("--check") else Nil)
@@ -113,7 +113,7 @@ object Fmt extends ScalaCommand[FmtOptions] {
       }
     CurrentParams.workspaceOpt = Some(workspace)
     val (versionMaybe, confExists) = readVersionFromFile(workspace, logger)
-    val cache                      = options.shared.buildOptions(false, None).archiveCache
+    val cache                      = options.shared.buildOptions().archiveCache
 
     val version = versionMaybe.getOrElse {
       System.err.println(

modules/cli/src/main/scala/scala/cli/commands/Metabrowse.scala

@@ -44,7 +44,7 @@ object Metabrowse extends ScalaCommand[MetabrowseOptions] {
 
     val logger = options.shared.logger
 
-    val baseOptions = options.shared.buildOptions(enableJmh = false, jmhVersion = None)
+    val baseOptions = options.shared.buildOptions()
     val initialBuildOptions = baseOptions.copy(
       classPathOptions = baseOptions.classPathOptions.copy(
         fetchSources = Some(true)

modules/cli/src/main/scala/scala/cli/commands/Repl.scala

@@ -25,7 +25,7 @@ object Repl extends ScalaCommand[ReplOptions] {
     import ops._
     def ammoniteVersionOpt = ammoniteVersion.map(_.trim).filter(_.nonEmpty)
 
-    val baseOptions = shared.buildOptions(enableJmh = false, jmhVersion = None)
+    val baseOptions = shared.buildOptions()
     baseOptions.copy(
       javaOptions = baseOptions.javaOptions.copy(
         javaOpts =

modules/cli/src/main/scala/scala/cli/commands/ScalaCommand.scala

@@ -8,6 +8,7 @@ import caseapp.core.parser.Parser
 import caseapp.core.util.Formatter
 import caseapp.core.{Arg, Error}
 
+import scala.build.internal.Constants
 import scala.cli.commands.util.CommandHelpers
 import scala.cli.commands.util.SharedOptionsUtil._
 import scala.util.{Properties, Try}
@@ -62,9 +63,16 @@ abstract class ScalaCommand[T](implicit parser: Parser[T], help: Help[T])
           case "dependency" =>
             state.flatMap(sharedOptions).toList.flatMap { sharedOptions =>
               val cache = sharedOptions.coursierCache
+              val sv = sharedOptions.buildOptions()
+                .scalaParams
+                .toOption
+                .flatten
+                .map(_.scalaVersion)
+                .getOrElse(Constants.defaultScalaVersion)
               val (fromIndex, completions) = cache.logger.use {
                 coursier.complete.Complete(cache)
                   .withInput(prefix)
+                  .withScalaVersion(sv)
                   .complete()
                   .unsafeRun()(cache.ec)
               }