Add public method to get a local ivy resolver

internal/zinc-ivy-integration/src/main/java/sbt/inc/ZincBridgeProvider.java

@@ -4,6 +4,7 @@ import sbt.internal.inc.ZincComponentCompiler$;
 import sbt.internal.inc.ZincComponentManager;
 import sbt.internal.librarymanagement.IvyConfiguration;
 import sbt.librarymanagement.Resolver;
+import sbt.librarymanagement.ResolversSyntax;
 import scala.None$;
 import xsbti.ComponentProvider;
 import xsbti.GlobalLock;
@@ -13,6 +14,18 @@ import xsbti.compile.CompilerBridgeProvider;
 import java.io.File;
 
 public final class ZincBridgeProvider {
+    /**
+     * Returns an ivy resolver to resolve dependencies locally in the default `.ivy2/local`.
+     * <p>
+     * For those users interested in using Internet resolvers like Maven Central, you can
+     * instantiate them via {@link ResolversSyntax#DefaultMavenRepository()} et al.
+     *
+     * @return A local ivy resolver.
+     */
+    public static Resolver getLocalResolver() {
+        return ZincComponentCompiler$.MODULE$.LocalResolver();
+    }
+
     /**
      * Get the default ivy configuration to retrieve compiler components.
      * <p>
@@ -25,6 +38,8 @@ public final class ZincBridgeProvider {
      * @param baseDirectory The base directory for ivy.
      * @param ivyHome       The home for ivy.
      * @param resolvers     The resolvers to be used (usually local and Maven).
+     *                      See {@link ZincBridgeProvider#getProvider(File, GlobalLock, ComponentProvider, IvyConfiguration, Logger)}
+     *                      and {@link ResolversSyntax}.
      * @return A default ivy configuration ready for fetching Zinc compiler components.
      */
     public static IvyConfiguration getDefaultConfiguration(File baseDirectory, File ivyHome, Resolver[] resolvers, Logger logger) {
@@ -43,10 +58,10 @@ public final class ZincBridgeProvider {
      * @return A compiler bridge provider capable of fetching scala jars and the compiler bridge.
      */
     public static CompilerBridgeProvider getProvider(File scalaJarsTarget,
-                                              GlobalLock lock,
-                                              ComponentProvider componentProvider,
-                                              IvyConfiguration ivyConfiguration,
-                                              Logger logger) {
+                                                     GlobalLock lock,
+                                                     ComponentProvider componentProvider,
+                                                     IvyConfiguration ivyConfiguration,
+                                                     Logger logger) {
         ZincComponentManager manager = new ZincComponentManager(lock, componentProvider, None$.empty(), logger);
         return ZincComponentCompiler$.MODULE$.interfaceProvider(manager, ivyConfiguration, scalaJarsTarget);
     }

internal/zinc-ivy-integration/src/main/scala/sbt/internal/inc/ZincComponentCompiler.scala

@@ -137,6 +137,14 @@ private[sbt] object ZincComponentCompiler {
                         scalaJarsTarget: File): CompilerBridgeProvider =
     new ZincCompilerBridgeProvider(manager, ivyConfiguration, scalaJarsTarget)
 
+  private final val LocalIvy = s"$${user.home}/.ivy2/local/${Resolver.localBasePattern}"
+  final val LocalResolver: Resolver = {
+    val toUse = Vector(LocalIvy)
+    val ivyPatterns = Patterns().withIsMavenCompatible(false)
+    val finalPatterns = ivyPatterns.withIvyPatterns(toUse).withArtifactPatterns(toUse)
+    FileRepository("local", Resolver.defaultFileConfiguration, finalPatterns)
+  }
+
   def getDefaultConfiguration(baseDirectory: File,
                               ivyHome: File,
                               resolvers0: Array[Resolver],

internal/zinc-ivy-integration/src/test/scala/sbt/internal/inc/BridgeProviderSpecification.scala

@@ -20,15 +20,8 @@ import xsbti.{ ComponentProvider, GlobalLock }
  * Base class for test suites that must be able to fetch and compile the compiler bridge.
  */
 abstract class BridgeProviderSpecification extends BaseIvySpecification {
-  def realLocal: Resolver = {
-    val pList = Vector(s"$${user.home}/.ivy2/local/${Resolver.localBasePattern}")
-    FileRepository(
-      "local",
-      Resolver.defaultFileConfiguration,
-      Patterns().withIvyPatterns(pList).withArtifactPatterns(pList).withIsMavenCompatible(false))
-  }
-
-  override def resolvers: Vector[Resolver] = Vector(realLocal, DefaultMavenRepository)
+  override def resolvers: Vector[Resolver] =
+    Vector(ZincComponentCompiler.LocalResolver, DefaultMavenRepository)
   private val ivyConfiguration = mkIvyConfiguration(UpdateOptions())
 
   def secondaryCacheDirectory: File = {