1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
package forge
import ammonite.ops.{ls, mkdir}
import forge.util.{Args, PathRef}
import play.api.libs.json.{Format, JsValue, Json}
import scala.annotation.compileTimeOnly
import language.experimental.macros
import reflect.macros.blackbox.Context
import scala.collection.mutable
abstract class Target[T] extends Target.Ops[T]{
/**
* What other Targets does this Target depend on?
*/
val inputs: Seq[Target[_]]
/**
* Evaluate this target
*/
def evaluate(args: Args): T
/**
* Even if this target's inputs did not change, does it need to re-evaluate
* anyway?
*/
def sideHash: Int = 0
@compileTimeOnly("Target#apply() can only be used with a T{...} block")
def apply(): T = ???
}
object Target{
trait Cacher{
private[this] val cacherLazyMap = mutable.Map.empty[sourcecode.Enclosing, Target[_]]
protected[this] def cachedTarget[T](t: => Target[T])
(implicit c: sourcecode.Enclosing): Target[T] = {
cacherLazyMap.getOrElseUpdate(c, t).asInstanceOf[Target[T]]
}
}
class Target0[T](t: T) extends Target[T]{
lazy val t0 = t
val inputs = Nil
def evaluate(args: Args) = t0
}
def apply[T](t: Target[T]): Target[T] = macro impl0[T]
def apply[T](t: T): Target[T] = macro impl[T]
def impl0[T: c.WeakTypeTag](c: Context)(t: c.Expr[Target[T]]): c.Expr[Target[T]] = {
wrapCached(c)(t.tree)
}
def impl[T: c.WeakTypeTag](c: Context)(t: c.Expr[T]): c.Expr[Target[T]] = {
import c.universe._
def rec(t: Tree): Iterator[c.Tree] = Iterator(t) ++ t.children.flatMap(rec(_))
val bound = collection.mutable.Buffer.empty[(c.Tree, Symbol)]
val targetApplySym = c.universe.typeOf[Target[_]].member(TermName("apply"))
// Derived from @olafurpg's
// https://gist.github.com/olafurpg/596d62f87bf3360a29488b725fbc7608
val (startPos, endPos) = rec(t.tree)
.map(t => (t.pos.start, t.pos.end))
.reduce[(Int, Int)]{ case ((s1, e1), (s2, e2)) => (math.min(s1, s2), math.max(e1, e2))}
val macroSource = t.tree.pos.source
val transformed = c.internal.typingTransform(t.tree) {
case (t @ q"$fun.apply()", api) if t.symbol == targetApplySym =>
val used = rec(t)
val banned = used.filter(x =>
x.symbol.pos.source == macroSource &&
x.symbol.pos.start >= startPos &&
x.symbol.pos.end <= endPos
)
if (banned.hasNext){
val banned0 = banned.next()
c.abort(
banned0.pos,
"Target#apply() call cannot use `" + banned0.symbol + "` defined within the T{...} block"
)
}
val tempName = c.freshName(TermName("tmp"))
val tempSym = c.internal.newTermSymbol(api.currentOwner, tempName)
c.internal.setInfo(tempSym, t.tpe)
val tempIdent = Ident(tempSym)
c.internal.setType(tempIdent, t.tpe)
bound.append((fun, tempSym))
tempIdent
case (t, api) => api.default(t)
}
val (exprs, symbols) = bound.unzip
val bindings = symbols.map(c.internal.valDef(_))
wrapCached(c)(q"forge.zipMap(..$exprs){ (..$bindings) => $transformed }")
}
def wrapCached[T](c: Context)(t: c.Tree) = {
import c.universe._
val owner = c.internal.enclosingOwner
val ownerIsCacherClass = owner.owner.isClass && owner.owner.asClass.baseClasses.exists(_.fullName == "forge.Target.Cacher")
if (ownerIsCacherClass && !owner.isMethod){
c.abort(
c.enclosingPosition,
"T{} members defined in a Cacher class/trait/object body must be defs"
)
}else{
val embedded =
if (!ownerIsCacherClass) t
else q"this.cachedTarget($t)"
c.Expr[Target[T]](embedded)
}
}
abstract class Ops[T]{ this: Target[T] =>
def map[V](f: T => V) = new Target.Mapped(this, f)
def filter(f: T => Boolean) = this
def withFilter(f: T => Boolean) = this
def zip[V](other: Target[V]) = new Target.Zipped(this, other)
}
def traverse[T](source: Seq[Target[T]]) = {
new Traverse[T](source)
}
class Traverse[T](val inputs: Seq[Target[T]]) extends Target[Seq[T]]{
def evaluate(args: Args) = {
for (i <- 0 until args.length)
yield args(i).asInstanceOf[T]
}
}
class Mapped[T, V](source: Target[T], f: T => V) extends Target[V]{
def evaluate(args: Args) = f(args(0))
val inputs = List(source)
}
class Zipped[T, V](source1: Target[T],
source2: Target[V]) extends Target[(T, V)]{
def evaluate(args: Args) = (args(0), args(1))
val inputs = List(source1, source2)
}
def path(path: ammonite.ops.Path) = new Path(path)
class Path(path: ammonite.ops.Path) extends Target[PathRef]{
def handle = PathRef(path)
def evaluate(args: Args) = handle
override def sideHash = handle.hashCode()
val inputs = Nil
}
class Subprocess(val inputs: Seq[Target[_]],
command: Args => Seq[String]) extends Target[Subprocess.Result] {
def evaluate(args: Args) = {
mkdir(args.dest)
import ammonite.ops._
implicit val path = ammonite.ops.Path(args.dest, pwd)
val toTarget = () // Shadow the implicit conversion :/
val output = %%(command(args))
assert(output.exitCode == 0)
Subprocess.Result(output, PathRef(args.dest))
}
}
object Subprocess{
case class Result(result: ammonite.ops.CommandResult, dest: PathRef)
object Result{
implicit val tsFormat: Format[Target.Subprocess.Result] = Json.format
}
}
}
|
