-
Notifications
You must be signed in to change notification settings - Fork 12
/
AcolytePlugin.scala
167 lines (136 loc) · 5.55 KB
/
AcolytePlugin.scala
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
package acolyte
import scala.tools.nsc.Global
import scala.tools.nsc.plugins.{ Plugin, PluginComponent }
import scala.tools.nsc.transform.Transform
import scala.reflect.internal.util.BatchSourceFile
class AcolytePlugin(val global: Global) extends Plugin {
val name = "acolyte"
val description = "Syntax extensions: Extractors with arguments"
val components = List[PluginComponent](ExtractorComponent)
var debug: Boolean = false
override def processOptions(options: List[String], error: String ⇒ Unit) {
for (o ← options) {
if (o == "debug") debug = true
}
}
override val optionsHelp: Option[String] = Some(
" -P:acolyte:debug Enable debug")
@inline private def withSource(pos: global.Position)(f: BatchSourceFile, shift: Int) = CompilerUtility.withSource(global)(pos, f, shift)
private object ExtractorComponent extends PluginComponent with Transform {
val global: AcolytePlugin.this.global.type = AcolytePlugin.this.global
override val runsRightAfter = Some("parser")
override val runsAfter = runsRightAfter.toList
override val runsBefore = List[String]("typer")
val phaseName = "rich-patmat"
def newTransformer(unit: global.CompilationUnit) =
new MatchTransformer(unit)
class MatchTransformer(
unit: global.CompilationUnit) extends global.Transformer {
import scala.collection.mutable.ListBuffer
import global.{
//abort,
reporter,
Apply,
Block,
Bind,
CaseDef,
Constant,
DefDef,
Ident,
Literal,
Match,
Position,
Select,
Tree,
ValDef
}
import scala.reflect.io.VirtualFile
override def transform(tree: Tree): Tree = refactor(tree)
private def refactor(tree: Tree): Tree = tree match {
case m @ Match(_, _) ⇒ {
val richMatch = refactorMatch(m)
if (debug) reporter.info(m.pos,
s"Rich Match refactored: ${global show richMatch}", true)
richMatch
}
case _ ⇒ super.transform(tree)
}
val tildeTerm = global.newTermName("$tilde")
val scalaTerm = global.newTermName("scala")
@inline private def refactorMatch(orig: Match): Tree = orig match {
case Match(t, cs) ⇒ {
val vds = ListBuffer[ValDef]()
val tx = caseDefTransformer(vds)
val cds = cs map {
case ocd @ CaseDef(pat, g, by) ⇒ {
val ocp = ocd.pos // g, by
val of = ocp.source.file
val file = new VirtualFile(of.name,
s"${of.path}#refactored-match-${ocp.line}")
val nc = CaseDef(tx.transform(pat), g, refactor(by))
val cdc = s"${global show nc} // generated from ln ${ocp.line}, col ${ocp.column - 5}"
val cdp = withSource(ocp.withPoint(0))(
new BatchSourceFile(file, cdc), 0)
global.atPos(cdp)(nc)
}
case cd ⇒ cd
}
if (vds.isEmpty) Match(t, cds)
else Block(vds.toList, Match(t, cds).setPos(orig.pos))
}
case _ ⇒
reporter.error(orig.pos, "Invalid Match")
//abort("Invalid Match")
orig
}
private def caseDefTransformer(vds: ListBuffer[ValDef]) =
new global.Transformer {
override def transform(tree: Tree): Tree = tree match {
case oa @ Apply(Ident(it), x) if (it == tildeTerm) ⇒ {
(x.headOption, x.tail) match {
case (Some(xt @ Apply(ex, xa)), bs) ⇒ {
val xpo: Option[List[Tree]] = bs.headOption match {
case Some(Apply(Select(Ident(scalaTerm), st), ua)) if (
st.toString startsWith "Tuple") ⇒ Some(ua)
case Some(ap @ Apply(_, _)) ⇒ Some(ap :: Nil)
case Some(bn @ Bind(_, _)) ⇒ Some(bn :: Nil)
case Some(id @ Ident(_)) ⇒ Some(id :: Nil)
case Some(li @ Literal(Constant(_))) ⇒ Some(li :: Nil)
case None ⇒ Some(Nil)
case _ ⇒ None
}
xpo.fold({
reporter.error(oa.pos, s"""Invalid ~ pattern: ${bs.headOption.fold("None")(global.showRaw(_))}""")
//abort("Invalid ~ pattern")
oa
}) { xp ⇒
val (vd, rp) = refactorPattern(xt.pos, ex, xa, xp)
vds += vd
rp
}
}
case _ ⇒
reporter.error(oa.pos, "Invalid ~ pattern")
//abort("Invalid ~ pattern")
oa
}
}
case _ ⇒ super.transform(tree)
}
}
@inline private def refactorPattern[T](xp: Position, ex: Tree, xa: List[Tree], ua: List[Tree]): (ValDef, Apply) = {
import global.{ atPos, show, newTermName, Ident, Modifiers }
val of = xp.source.file
val file = new VirtualFile(of.name,
s"${of.path}#refactored-match-${xp.line}")
// ValDef
val xn = unit.freshTermName("Xtr")
val vd = ValDef(Modifiers(), xn, global.TypeTree(), Apply(ex, xa))
val vdc =
s"${show(vd)} // generated from ln ${xp.line}, col ${xp.column - 1}"
val vdp = withSource(xp.withPoint(0))(new BatchSourceFile(file, vdc), 0)
(atPos(vdp)(vd), Apply(Ident(xn), ua))
}
}
}
}