1 files changed, 15 insertions, 17 deletions

diff --git a/src/main/scala/hbt/Target.scala b/src/main/scala/hbt/Target.scala
index fa2fbbe5..7b1c5166 100644
--- a/src/main/scala/hbt/Target.scala
+++ b/src/main/scala/hbt/Target.scala
@@ -1,33 +1,31 @@
 package hbt
 
-import java.io.InputStreamReader
 import java.nio.{file => jnio}
 
-import sourcecode.Enclosing
-
 trait Target[T]{
-  val label: String
+  val defCtx: DefCtx
+
   val inputs: Seq[Target[_]]
   def evaluate(args: Args): T
 
-  def map[V](f: T => V)(implicit path: Enclosing) = {
-    Target.Mapped(this, f, path.value)
+  def map[V](f: T => V)(implicit defCtx: DefCtx) = {
+    Target.Mapped(this, f, defCtx)
   }
-  def zip[V](other: Target[V])(implicit path: Enclosing) = {
-    Target.Zipped(this, other, path.value)
+  def zip[V](other: Target[V])(implicit defCtx: DefCtx) = {
+    Target.Zipped(this, other, defCtx)
   }
   def ~[V, R](other: Target[V])
-             (implicit s: Implicits.Sequencer[T, V, R]): Target[R] = {
+             (implicit s: Implicits.Sequencer[T, V, R], defCtx: DefCtx): Target[R] = {
     this.zip(other).map(s.apply _ tupled)
   }
 
 }
 
 object Target{
-  def traverse[T](source: Seq[Target[T]])(implicit path: Enclosing) = {
-    Traverse[T](source, path.value)
+  def traverse[T](source: Seq[Target[T]])(implicit defCtx: DefCtx) = {
+    Traverse[T](source, defCtx)
   }
-  case class Traverse[T](inputs: Seq[Target[T]], label: String) extends Target[Seq[T]]{
+  case class Traverse[T](inputs: Seq[Target[T]], defCtx: DefCtx) extends Target[Seq[T]]{
     def evaluate(args: Args) = {
       for (i <- 0 until args.length)
       yield args(i).asInstanceOf[T]
@@ -35,25 +33,25 @@ object Target{
 
   }
   case class Mapped[T, V](source: Target[T], f: T => V,
-                          label: String) extends Target[V]{
+                          defCtx: DefCtx) extends Target[V]{
     def evaluate(args: Args) = f(args(0))
     val inputs = List(source)
   }
   case class Zipped[T, V](source1: Target[T],
                           source2: Target[V],
-                          label: String) extends Target[(T, V)]{
+                          defCtx: DefCtx) extends Target[(T, V)]{
     def evaluate(args: Args) = (args(0), args(0))
     val inputs = List(source1, source1)
   }
 
-  def path(path: jnio.Path)(implicit label: Enclosing) = Path(path, label.value)
-  case class Path(path: jnio.Path, label: String) extends Target[jnio.Path]{
+  def path(path: jnio.Path)(implicit defCtx: DefCtx) = Path(path, defCtx)
+  case class Path(path: jnio.Path, defCtx: DefCtx) extends Target[jnio.Path]{
     def evaluate(args: Args) = path
     val inputs = Nil
   }
   case class Subprocess(inputs: Seq[Target[_]],
                         command: Args => Seq[String],
-                        label: String) extends Target[Subprocess.Result] {
+                        defCtx: DefCtx) extends Target[Subprocess.Result] {
 
     def evaluate(args: Args) = {
       jnio.Files.createDirectories(args.dest)