Split up forge into `scalaplugin` an `core` subprojects, to allow us to use the `T#apply` macro in the implementation of `scalaplugin.Subproject`

Also needed to implement inter-`Subproject` dependencies so the `MetacircularTests` can continue to support the new layout

28 files changed, 99 insertions, 181 deletions

diff --git a/Test.scala b/Test.scala
deleted file mode 100644
index 37065c70..00000000
--- a/Test.scala
+++ /dev/null
@@ -1,11 +0,0 @@
-import play.api.libs.json.Json
-
-object Test{
-  def main(args: Array[String]): Unit = {
-    println(
-      Json.prettyPrint(
-        Json.toJson(Seq("Hello", "World", "Cow"))
-      )
-    )
-  }
-}
diff --git a/build.sbt b/build.sbt
index cf9b2aad..ea2db92e 100644
--- a/build.sbt
+++ b/build.sbt
@@ -1,29 +1,38 @@
-scalaVersion := "2.12.4"
+val sharedSettings = Seq(
+  scalaVersion := "2.12.4",
+  organization := "com.lihaoyi",
+  libraryDependencies += "com.lihaoyi" %% "utest" % "0.6.0" % "test",
 
-name := "forge"
+  testFrameworks += new TestFramework("forge.UTestFramework"),
 
-organization := "com.lihaoyi"
+  parallelExecution in Test := false,
+  test in assembly := {},
 
-libraryDependencies += "com.lihaoyi" %% "utest" % "0.6.0" % "test"
-
-testFrameworks += new TestFramework("forge.Framework")
-
-parallelExecution in Test := false
-
-libraryDependencies ++= Seq(
-  "org.scala-lang" % "scala-reflect" % scalaVersion.value % "provided",
-  "com.lihaoyi" %% "sourcecode" % "0.1.4",
-  "com.lihaoyi" %% "pprint" % "0.5.3",
-  "com.lihaoyi" % "ammonite" % "1.0.3" cross CrossVersion.full,
-  "com.typesafe.play" %% "play-json" % "2.6.6",
-  "org.scala-sbt" %% "zinc" % "1.0.3"
+  assemblyOption in assembly := (assemblyOption in assembly).value.copy(
+    prependShellScript = Some(
+      // G1 Garbage Collector is awesome https://github.com/lihaoyi/Ammonite/issues/216
+      Seq("#!/usr/bin/env sh", """exec java -jar -Xmx500m -XX:+UseG1GC $JAVA_OPTS "$0" "$@"""")
+    )
+  )
 )
 
-test in assembly := {}
-
-assemblyOption in assembly := (assemblyOption in assembly).value.copy(
-  prependShellScript = Some(
-    // G1 Garbage Collector is awesome https://github.com/lihaoyi/Ammonite/issues/216
-    Seq("#!/usr/bin/env sh", """exec java -jar -Xmx500m -XX:+UseG1GC $JAVA_OPTS "$0" "$@"""")
+lazy val core = project
+  .settings(
+    sharedSettings,
+    name := "forge-core",
+    libraryDependencies ++= Seq(
+      "org.scala-lang" % "scala-reflect" % scalaVersion.value % "provided",
+      "com.lihaoyi" %% "sourcecode" % "0.1.4",
+      "com.lihaoyi" %% "pprint" % "0.5.3",
+      "com.lihaoyi" % "ammonite" % "1.0.3" cross CrossVersion.full,
+      "com.typesafe.play" %% "play-json" % "2.6.6",
+      "org.scala-sbt" %% "zinc" % "1.0.3"
+    )
   )
-)
\ No newline at end of file
+
+lazy val scalaplugin = project
+  .dependsOn(core % "compile->compile;test->test")
+  .settings(
+    sharedSettings,
+    name := "forge-scalaplugin"
+  )
\ No newline at end of file
diff --git a/src/main/scala/forge/Discovered.scala b/core/src/main/scala/forge/Discovered.scala
index a1a9aa65..03577b1f 100644
--- a/src/main/scala/forge/Discovered.scala
+++ b/core/src/main/scala/forge/Discovered.scala
@@ -18,7 +18,7 @@ object Discovered {
 
   def mapping[T: Discovered](t: T): Map[Target[_], Labelled[_]] = {
     implicitly[Discovered[T]].apply(t)
-      .map(x => x._3 -> Labelled(x._3, x._2.asInstanceOf[Format[Any]], x._1))
+      .map(x => x._3 -> Labelled(x._3.asInstanceOf[Target[Any]], x._2.asInstanceOf[Format[Any]], x._1))
       .toMap
   }
 
diff --git a/src/main/scala/forge/Evaluator.scala b/core/src/main/scala/forge/Evaluator.scala
index 50dc46d4..50dc46d4 100644
--- a/src/main/scala/forge/Evaluator.scala
+++ b/core/src/main/scala/forge/Evaluator.scala
diff --git a/src/main/scala/forge/Main.scala b/core/src/main/scala/forge/Main.scala
index d919d0e2..d919d0e2 100644
--- a/src/main/scala/forge/Main.scala
+++ b/core/src/main/scala/forge/Main.scala
diff --git a/src/main/scala/forge/Target.scala b/core/src/main/scala/forge/Target.scala
index 6a465a92..0e84a9b4 100644
--- a/src/main/scala/forge/Target.scala
+++ b/core/src/main/scala/forge/Target.scala
@@ -42,9 +42,8 @@ object Target{
     lazy val inputs = t0.inputs
     def evaluate(args: Args)  = t0.evaluate(args)
   }
-  implicit def toTarget[T](t: T): Target[T] = new Target0(t)
   implicit def apply[T](t: => Target[T]): Target[T] = new Target1(t)
-  def raw[T](t: T): Target[T] = macro impl[T]
+  def apply[T](t: T): Target[T] = macro impl[T]
   def impl[T: c.WeakTypeTag](c: Context)(t: c.Expr[T]): c.Expr[Target[T]] = {
     import c.universe._
     val bound = collection.mutable.Buffer.empty[(c.Tree, Symbol)]
@@ -69,7 +68,7 @@ object Target{
 
     val bindings = symbols.map(c.internal.valDef(_))
 
-    val embedded = q"forge.zipMap(..$exprs){ (..$bindings) => $transformed }"
+    val embedded = q"new forge.Target.Target1(forge.zipMap(..$exprs){ (..$bindings) => $transformed })"
 
     c.Expr[Target[T]](embedded)
   }
diff --git a/src/main/scala/forge/Tarjans.scala b/core/src/main/scala/forge/Tarjans.scala
index 9831fe7f..9831fe7f 100644
--- a/src/main/scala/forge/Tarjans.scala
+++ b/core/src/main/scala/forge/Tarjans.scala
diff --git a/src/main/scala/forge/package.scala b/core/src/main/scala/forge/package.scala
index 6a52d1a1..8c24bde6 100644
--- a/src/main/scala/forge/package.scala
+++ b/core/src/main/scala/forge/package.scala
@@ -6,13 +6,13 @@ package object forge {
 
   val T = Target
   type T[T] = Target[T]
-  def zipMap[R]()(f: () => R) = T(f())
+  def zipMap[R]()(f: () => R) = new Target.Target0(f())
   def zipMap[A, R](a: T[A])(f: A => R) = a.map(f)
   def zipMap[A, B, R](a: T[A], b: T[B])(f: (A, B) => R) = zip(a, b).map(f.tupled)
   def zipMap[A, B, C, R](a: T[A], b: T[B], c: T[C])(f: (A, B, C) => R) = zip(a, b, c).map(f.tupled)
   def zipMap[A, B, C, D, R](a: T[A], b: T[B], c: T[C], d: T[D])(f: (A, B, C, D) => R) = zip(a, b, c, d).map(f.tupled)
   def zipMap[A, B, C, D, E, R](a: T[A], b: T[B], c: T[C], d: T[D], e: T[E])(f: (A, B, C, D, E) => R) = zip(a, b, c, d, e).map(f.tupled)
-  def zip() = T(())
+  def zip() =  new Target.Target0(())
   def zip[A](a: T[A]) = a.map(Tuple1(_))
   def zip[A, B](a: T[A], b: T[B]) = a.zip(b)
   def zip[A, B, C](a: T[A], b: T[B], c: T[C]) = new T[(A, B, C)]{
diff --git a/src/main/scala/forge/util/Args.scala b/core/src/main/scala/forge/util/Args.scala
index 23102572..23102572 100644
--- a/src/main/scala/forge/util/Args.scala
+++ b/core/src/main/scala/forge/util/Args.scala
diff --git a/src/main/scala/forge/util/Labelled.scala b/core/src/main/scala/forge/util/Labelled.scala
index a79d2d93..a79d2d93 100644
--- a/src/main/scala/forge/util/Labelled.scala
+++ b/core/src/main/scala/forge/util/Labelled.scala
diff --git a/src/main/scala/forge/util/MultiBiMap.scala b/core/src/main/scala/forge/util/MultiBiMap.scala
index cb6ff280..cb6ff280 100644
--- a/src/main/scala/forge/util/MultiBiMap.scala
+++ b/core/src/main/scala/forge/util/MultiBiMap.scala
diff --git a/src/main/scala/forge/util/OSet.scala b/core/src/main/scala/forge/util/OSet.scala
index 43743cdc..43743cdc 100644
--- a/src/main/scala/forge/util/OSet.scala
+++ b/core/src/main/scala/forge/util/OSet.scala
diff --git a/src/main/scala/forge/util/PathRef.scala b/core/src/main/scala/forge/util/PathRef.scala
index dbe1ebbd..dbe1ebbd 100644
--- a/src/main/scala/forge/util/PathRef.scala
+++ b/core/src/main/scala/forge/util/PathRef.scala
diff --git a/src/test/examples/javac/build.sc b/core/src/test/examples/javac/build.sc
index dfbe5271..dfbe5271 100644
--- a/src/test/examples/javac/build.sc
+++ b/core/src/test/examples/javac/build.sc
diff --git a/src/test/examples/javac/resources/hello.txt b/core/src/test/examples/javac/resources/hello.txt
index 5e1c309d..5e1c309d 100644
--- a/src/test/examples/javac/resources/hello.txt
+++ b/core/src/test/examples/javac/resources/hello.txt
diff --git a/src/test/examples/javac/src/Bar.java b/core/src/test/examples/javac/src/Bar.java
index 4e30c89b..4e30c89b 100644
--- a/src/test/examples/javac/src/Bar.java
+++ b/core/src/test/examples/javac/src/Bar.java
diff --git a/src/test/examples/javac/src/Foo.java b/core/src/test/examples/javac/src/Foo.java
index e694f9fa..e694f9fa 100644
--- a/src/test/examples/javac/src/Foo.java
+++ b/core/src/test/examples/javac/src/Foo.java
diff --git a/src/test/scala/forge/EvaluationTests.scala b/core/src/test/scala/forge/EvaluationTests.scala
index 2b7315a2..b58d5ccc 100644
--- a/src/test/scala/forge/EvaluationTests.scala
+++ b/core/src/test/scala/forge/EvaluationTests.scala
@@ -59,11 +59,9 @@ object EvaluationTests extends TestSuite{
         val check = new Checker(pair)
         check(down, expValue = 0, expEvaled = OSet(up, down))
 
-        println("=" * 20 + "incrementing down.counter" + "=" * 20)
         down.counter += 1
         check(down, expValue = 1, expEvaled = OSet(down))
 
-        println("=" * 20 + "incrementing up.counter" + "=" * 20)
         up.counter += 1
         check(down, expValue = 2, expEvaled = OSet(up, down))
       }
diff --git a/src/test/scala/forge/GraphTests.scala b/core/src/test/scala/forge/GraphTests.scala
index 572e459e..572e459e 100644
--- a/src/test/scala/forge/GraphTests.scala
+++ b/core/src/test/scala/forge/GraphTests.scala
diff --git a/src/test/scala/forge/IntegrationTests.scala b/core/src/test/scala/forge/IntegrationTests.scala
index 08e7d132..03173eac 100644
--- a/src/test/scala/forge/IntegrationTests.scala
+++ b/core/src/test/scala/forge/IntegrationTests.scala
@@ -47,7 +47,7 @@ object IntegrationTests extends TestSuite{
   val tests = Tests{
     'javac {
       val workspacePath = pwd / 'target / 'workspace / 'javac
-      val javacSrcPath = pwd / 'src / 'test / 'examples / 'javac
+      val javacSrcPath = pwd / 'core / 'src / 'test / 'examples / 'javac
       val javacDestPath = workspacePath / 'src
 
       mkdir(pwd / 'target / 'workspace / 'javac)
diff --git a/src/test/scala/forge/TarjanTests.scala b/core/src/test/scala/forge/TarjanTests.scala
index 5b118368..5b118368 100644
--- a/src/test/scala/forge/TarjanTests.scala
+++ b/core/src/test/scala/forge/TarjanTests.scala
diff --git a/src/test/scala/forge/TestGraphs.scala b/core/src/test/scala/forge/TestGraphs.scala
index 0ee48a18..0ee48a18 100644
--- a/src/test/scala/forge/TestGraphs.scala
+++ b/core/src/test/scala/forge/TestGraphs.scala
diff --git a/src/test/scala/forge/TestMain.scala b/core/src/test/scala/forge/TestMain.scala
index c94e13f0..c94e13f0 100644
--- a/src/test/scala/forge/TestMain.scala
+++ b/core/src/test/scala/forge/TestMain.scala
diff --git a/src/test/scala/forge/TestUtil.scala b/core/src/test/scala/forge/TestUtil.scala
index 9337fbe0..9337fbe0 100644
--- a/src/test/scala/forge/TestUtil.scala
+++ b/core/src/test/scala/forge/TestUtil.scala
diff --git a/src/test/scala/forge/Framework.scala b/core/src/test/scala/forge/UTestFramework.scala
index d1aa7434..3435e9c0 100644
--- a/src/test/scala/forge/Framework.scala
+++ b/core/src/test/scala/forge/UTestFramework.scala
@@ -1,6 +1,6 @@
 package forge
 
-class Framework extends utest.runner.Framework {
+class UTestFramework extends utest.runner.Framework {
   override def exceptionStackFrameHighlighter(s: StackTraceElement) = {
     s.getClassName.startsWith("forge.")
   }
diff --git a/src/main/scala/forge/scalaplugin/Subproject.scala b/scalaplugin/src/main/scala/forge/scalaplugin/Subproject.scala
index 93532ec9..7fad28c9 100644
--- a/src/main/scala/forge/scalaplugin/Subproject.scala
+++ b/scalaplugin/src/main/scala/forge/scalaplugin/Subproject.scala
@@ -84,28 +84,26 @@ object Subproject{
     }
   }
   def createJar(sourceDirs: T[Seq[PathRef]]) = ???
-  def resolveDependencies(repositories: T[Seq[Repository]],
-                          deps: T[Seq[coursier.Dependency]]): T[Seq[PathRef]] = {
-    for((repositories, deps) <- zip(repositories, deps)) yield {
-      val start = Resolution(deps.toSet)
-      val fetch = Fetch.from(repositories, Cache.fetch())
-      val resolution = start.process.run(fetch).unsafePerformSync
-      val localArtifacts: Seq[File] = Task.gatherUnordered(
-        resolution.artifacts.map(Cache.file(_).run)
-      ).unsafePerformSync.flatMap(_.toOption)
+  def resolveDependencies(repositories: Seq[Repository],
+                          deps: Seq[coursier.Dependency]): Seq[PathRef] = {
+    val start = Resolution(deps.toSet)
+    val fetch = Fetch.from(repositories, Cache.fetch())
+    val resolution = start.process.run(fetch).unsafePerformSync
+    val localArtifacts: Seq[File] = Task.gatherUnordered(
+      resolution.artifacts.map(Cache.file(_).run)
+    ).unsafePerformSync.flatMap(_.toOption)
 
-      localArtifacts.map(p => PathRef(Path(p)))
-    }
+    localArtifacts.map(p => PathRef(Path(p)))
   }
 }
 import Subproject._
 abstract class Subproject {
   val scalaVersion: T[String]
 
-  val scalaBinaryVersion = T{ scalaVersion.map(_.split('.').dropRight(1).mkString(".")) }
-  val deps = T{ Seq[coursier.Dependency]() }
-  val compileDeps = T{ Seq[coursier.Dependency]() }
-  val runDeps = T{ Seq[coursier.Dependency]() }
+  val scalaBinaryVersion = T{ scalaVersion().split('.').dropRight(1).mkString(".") }
+  val ivyDeps = T{ Seq[coursier.Dependency]() }
+  val compileIvyDeps = T{ Seq[coursier.Dependency]() }
+  val runIvyDeps = T{ Seq[coursier.Dependency]() }
   val basePath: T[Path]
 
   val repositories: Seq[Repository] = Seq(
@@ -113,34 +111,33 @@ abstract class Subproject {
     MavenRepository("https://repo1.maven.org/maven2")
   )
 
-  val compileDepClasspath: T[Seq[PathRef]] = T(
-    resolveDependencies(
+  val depClasspath = T{ Seq.empty[PathRef] }
+  val compileDepClasspath = T[Seq[PathRef]] {
+    depClasspath() ++ resolveDependencies(
       repositories,
-      for((scalaVersion, scalaBinaryVersion, compileDeps, deps) <- zip(scalaVersion, scalaBinaryVersion, compileDeps, deps))
-      yield deps ++ compileDeps ++ Seq(
-        Dependency(Module("org.scala-lang", "scala-compiler"), scalaVersion),
-        Dependency(Module("org.scala-sbt", s"compiler-bridge_$scalaBinaryVersion"), "1.0.3")
+      ivyDeps() ++ compileIvyDeps() ++ Seq(
+        Dependency(Module("org.scala-lang", "scala-compiler"), scalaVersion()),
+        Dependency(Module("org.scala-sbt", s"compiler-bridge_${scalaBinaryVersion()}"), "1.0.3")
       )
     )
-  )
-  val runDepClasspath: T[Seq[PathRef]] = T(
-    resolveDependencies(
+  }
+  val runDepClasspath =  T[Seq[PathRef]] {
+    depClasspath() ++ resolveDependencies(
       repositories,
-      for((scalaVersion, runDeps, deps) <- zip(scalaVersion, runDeps, deps))
-      yield deps ++ runDeps ++ Seq(
-        Dependency(Module("org.scala-lang", "scala-library"), scalaVersion)
+      ivyDeps() ++ runIvyDeps() ++ Seq(
+        Dependency(Module("org.scala-lang", "scala-library"), scalaVersion())
       )
     )
-  )
+  }
 
-  val sources = T{ basePath.map(p => PathRef(p / 'src)) }
-  val outputPath = T{ basePath.map(p => p / 'out) }
-  val resources = T{ basePath.map(p => PathRef(p / 'resources)) }
-  val compiledPath = T{ outputPath.map(p => p / 'classpath) }
+  val sources = T{ PathRef(basePath() / 'src) }
+  val outputPath = T{ basePath() / 'out }
+  val resources = T{ PathRef(basePath() / 'resources) }
+  val compiledPath = T{ outputPath() / 'classpath }
   val compiled = T{
     compileScala(scalaVersion, sources, compileDepClasspath, outputPath)
   }
 
-  val classpath = T{ for((r, c) <- resources.zip(compiled)) yield Seq(r, c) }
+  val classpath = T{ Seq(resources(), compiled()) }
 //  val jar = T{ createJar(classpath) }
 }
diff --git a/src/test/scala/forge/MetacircularTests.scala b/scalaplugin/src/test/scala/forge/scalaplugin/MetacircularTests.scala
index 7d0a4c1a..05dd0dbd 100644
--- a/src/test/scala/forge/MetacircularTests.scala
+++ b/scalaplugin/src/test/scala/forge/scalaplugin/MetacircularTests.scala
@@ -1,4 +1,5 @@
 package forge
+package scalaplugin
 
 import ammonite.ops.pwd
 import coursier.{Dependency => Dep, Module => Mod}
@@ -6,15 +7,15 @@ import forge.util.{OSet, PathRef}
 import utest._
 
 object MetacircularTests extends TestSuite{
-  object Self extends scalaplugin.Subproject {
+  object Core extends Subproject {
     val scalaVersion = T{ "2.12.4" }
-    override val compileDeps = T.raw{
+    override val compileIvyDeps = T{
       Seq(
         Dep(Mod("org.scala-lang", "scala-reflect"), scalaVersion(), configuration = "provided")
       )
     }
 
-    override val deps = T.raw{
+    override val ivyDeps = T{
       Seq(
         Dep(Mod("com.lihaoyi", "sourcecode_" + scalaBinaryVersion()), "0.1.4"),
         Dep(Mod("com.lihaoyi", "pprint_" + scalaBinaryVersion()), "0.5.3"),
@@ -25,20 +26,41 @@ object MetacircularTests extends TestSuite{
     }
 
 
-    val basePath = T{ pwd }
-    override val sources = T{ PathRef(pwd/'src/'main/'scala) }
-    override val resources = T{ PathRef(pwd/'src/'main/'resources) }
+    val basePath = T{ pwd / 'core }
+    override val sources = T{ PathRef(pwd/'core/'src/'main/'scala) }
+    override val resources = T{ sources }
   }
+  object ScalaPlugin extends Subproject {
+    val scalaVersion = T.apply{ "2.12.4" }
+
+    override val ivyDeps = T{
+      Seq(
+        Dep(Mod("com.lihaoyi", "sourcecode_" + scalaBinaryVersion()), "0.1.4"),
+        Dep(Mod("com.lihaoyi", "pprint_" + scalaBinaryVersion()), "0.5.3"),
+        Dep(Mod("com.lihaoyi", "ammonite_" + scalaVersion()), "1.0.3"),
+        Dep(Mod("com.typesafe.play", "play-json_" + scalaBinaryVersion()), "2.6.6"),
+        Dep(Mod("org.scala-sbt", "zinc_" + scalaBinaryVersion()), "1.0.3")
+      )
+    }
+
+
+    override val depClasspath = T{ Seq(Core.compiled()) }
+    val basePath = T{ pwd / 'scalaplugin }
+    override val sources = T{ PathRef(pwd/'scalaplugin/'src/'main/'scala) }
+    override val resources = T{ sources }
+  }
+
   val tests = Tests{
     'scalac {
       val workspacePath = pwd / 'target / 'workspace / 'meta
-      val mapping = Discovered.mapping(Self)
+      val mapping = Discovered.mapping(MetacircularTests)
       val evaluator = new Evaluator(workspacePath, mapping)
 //      val evaluated1 = evaluator.evaluate(OSet(Self.scalaVersion)).evaluated.collect(mapping)
 //      val evaluated2 = evaluator.evaluate(OSet(Self.scalaBinaryVersion)).evaluated.collect(mapping)
 //      val evaluated3 = evaluator.evaluate(OSet(Self.compileDeps)).evaluated.collect(mapping)
 //      val evaluated4 = evaluator.evaluate(OSet(Self.deps)).evaluated.collect(mapping)
-      val evaluated5 = evaluator.evaluate(OSet(Self.compiled)).evaluated.collect(mapping)
+      val evaluated5 = evaluator.evaluate(OSet(Core.compiled)).evaluated.collect(mapping)
+      val evaluated6 = evaluator.evaluate(OSet(ScalaPlugin.compiled)).evaluated.collect(mapping)
 //      evaluated3
     }
   }
diff --git a/zinc.sc b/zinc.sc
deleted file mode 100644
index 42c7929a..00000000
--- a/zinc.sc
+++ /dev/null
@@ -1,96 +0,0 @@
-import $ivy.`org.scala-sbt::zinc:1.0.3`
-
-import ammonite.ops._
-import java.io.File
-
-import coursier._
-import sbt.internal.inc.{FreshCompilerCache, ScalaInstance, ZincUtil}
-import sbt.internal.util.{ConsoleOut, MainAppender}
-import sbt.util.LogExchange
-import xsbti.api.{ClassLike, DependencyContext}
-import xsbti.compile._
-
-import scalaz.concurrent.Task
-
-val scalaVersion = scala.util.Properties.versionNumberString
-val binaryScalaVersion = scalaVersion.split('.').dropRight(1).mkString(".")
-val start = Resolution(
-  Set(
-    Dependency(Module("org.scala-lang", "scala-compiler"), scalaVersion),
-    Dependency(Module("org.scala-lang", "scala-library"), scalaVersion),
-    Dependency(Module("org.scala-sbt", s"compiler-bridge_$binaryScalaVersion"), "1.0.3"),
-    Dependency(Module("com.typesafe.play", s"play-json_$binaryScalaVersion"), "2.6.6")
-  )
-)
-val repositories = Seq(
-  Cache.ivy2Local,
-  MavenRepository("https://repo1.maven.org/maven2")
-)
-
-val fetch = Fetch.from(repositories, Cache.fetch())
-val resolution = start.process.run(fetch).unsafePerformSync
-
-
-val localArtifacts: Seq[File] = Task.gatherUnordered(
-  resolution.artifacts.map(Cache.file(_).run)
-).unsafePerformSync.flatMap(_.toOption)
-
-pprint.log(localArtifacts)
-def grepJar(s: String) = localArtifacts.find(_.toString.endsWith(s)).get
-
-val scalac = ZincUtil.scalaCompiler(
-  new ScalaInstance(
-    version = scalaVersion,
-    loader = getClass.getClassLoader,
-    libraryJar = grepJar(s"scala-library-$scalaVersion.jar"),
-    compilerJar = grepJar(s"scala-compiler-$scalaVersion.jar"),
-    allJars = localArtifacts.toArray,
-    explicitActual = None
-  ),
-  grepJar(s"compiler-bridge_$binaryScalaVersion-1.0.3.jar")
-)
-
-val outputDir = pwd/'target/'zinc
-mkdir(outputDir)
-
-val scalaFiles = Array(pwd/"Test.scala")
-
-
-scalac.apply(
-  sources = scalaFiles.map(_.toIO),
-  changes = new DependencyChanges {
-    def isEmpty = true
-    def modifiedBinaries() = Array[File]()
-    def modifiedClasses() = Array[String]()
-  },
-  classpath = localArtifacts.toArray,
-  singleOutput = outputDir.toIO,
-  options = Array(),
-  callback = new xsbti.AnalysisCallback {
-    def startSource(source: File) = ()
-    def apiPhaseCompleted() = ()
-    def enabled() = true
-    def binaryDependency(onBinaryEntry: File, onBinaryClassName: String, fromClassName: String, fromSourceFile: File, context: DependencyContext) = ()
-    def generatedNonLocalClass(source: File, classFile: File, binaryClassName: String, srcClassName: String) = ()
-    def problem(what: String, pos: xsbti.Position, msg: String, severity: xsbti.Severity, reported: Boolean) = ()
-    def dependencyPhaseCompleted() = ()
-    def classDependency(onClassName: String, sourceClassName: String, context: DependencyContext) = ()
-    def generatedLocalClass(source: File, classFile: File) = ()
-    def api(sourceFile: File, classApi: ClassLike) = ()
-
-    def mainClass(sourceFile: File, className: String) = ()
-    def usedName(className: String, name: String, useScopes: java.util.EnumSet[xsbti.UseScope]) = ()
-  },
-  maximumErrors = 10,
-  cache = new FreshCompilerCache(),
-  log = {
-    val console = ConsoleOut.systemOut
-    val consoleAppender = MainAppender.defaultScreen(console)
-    val l = LogExchange.logger("Hello")
-    LogExchange.unbindLoggerAppenders("Hello")
-    LogExchange.bindLoggerAppenders("Hello", (consoleAppender -> sbt.util.Level.Warn) :: Nil)
-    l
-  }
-)
-
-%('java,"-cp", localArtifacts.mkString(":") + ":.", "Test")(pwd/'target/'zinc)
\ No newline at end of file