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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
/* NSC -- new Scala compiler
* Copyright 2005-2007 LAMP/EPFL
* @author
*/
// $Id$
package scala.tools.nsc.transform
import scala.collection.mutable.ListBuffer
import symtab.Flags._
import util.TreeSet
abstract class Constructors extends Transform {
import global._
import definitions._
import posAssigner.atPos
/** the following two members override abstract members in Transform */
val phaseName: String = "constructors"
protected def newTransformer(unit: CompilationUnit): Transformer =
new ConstructorTransformer
class ConstructorTransformer extends Transformer {
def transformClassTemplate(impl: Template): Template = {
val clazz = impl.symbol.owner
val stats = impl.body
val localTyper = typer.atOwner(impl, clazz)
var constr: DefDef = null
var constrParams: List[Symbol] = null
var constrBody: Block = null
// decompose primary constructor into the three entities above.
for (stat <- stats) {
stat match {
case ddef @ DefDef(_, _, _, List(vparams), _, rhs @ Block(_, Literal(_))) =>
if (ddef.symbol.isPrimaryConstructor) {
constr = ddef
constrParams = vparams map (_.symbol)
constrBody = rhs
}
case _ =>
}
}
assert((constr ne null) && (constrBody ne null), impl)
val paramAccessors = clazz.constrParamAccessors
def parameter(acc: Symbol): Symbol =
parameterNamed(nme.getterName(acc.originalName))
def parameterNamed(name: Name): Symbol = {
def matchesName(param: Symbol) =
param.name == name ||
param.name.startsWith(name) && param.name(name.length) == '$'
val ps = constrParams filter matchesName
if (ps.isEmpty) assert(false, "" + name + " not in " + constrParams)
ps.head
}
var thisRefSeen: Boolean = false
val intoConstructorTransformer = new Transformer {
override def transform(tree: Tree): Tree = tree match {
case Apply(Select(This(_), _), List()) =>
if ((tree.symbol hasFlag PARAMACCESSOR) && tree.symbol.owner == clazz)
gen.mkAttributedIdent(parameter(tree.symbol.accessed)) setPos tree.pos
else if (tree.symbol.outerSource == clazz && !clazz.isImplClass)
gen.mkAttributedIdent(parameterNamed(nme.OUTER)) setPos tree.pos
else
super.transform(tree)
case Select(This(_), _)
if ((tree.symbol hasFlag PARAMACCESSOR) && !tree.symbol.isSetter && tree.symbol.owner == clazz) =>
gen.mkAttributedIdent(parameter(tree.symbol)) setPos tree.pos
case Select(_, _) =>
thisRefSeen = true
super.transform(tree)
case This(_) =>
thisRefSeen = true
super.transform(tree)
case Super(_, _) =>
thisRefSeen = true
super.transform(tree)
case _ =>
super.transform(tree)
}
}
def intoConstructor(oldowner: Symbol, tree: Tree) =
intoConstructorTransformer.transform(
new ChangeOwnerTraverser(oldowner, constr.symbol)(tree))
def canBeMoved(tree: Tree) = tree match {
//todo: eliminate thisRefSeen
case ValDef(mods, _, _, _) => (mods hasFlag PRESUPER | PARAMACCESSOR) || !thisRefSeen
case _ => false
}
def mkAssign(to: Symbol, from: Tree): Tree =
atPos(to.pos) {
localTyper.typed {
Assign(Select(This(clazz), to), from)
}
}
def copyParam(to: Symbol, from: Symbol): Tree = {
var result = mkAssign(to, Ident(from))
if (from.name == nme.OUTER)
result =
atPos(to.pos) {
localTyper.typed {
If(Apply(Select(Ident(from), nme.eq), List(Literal(Constant(null)))),
Throw(New(TypeTree(NullPointerExceptionClass.tpe), List(List()))),
result);
}
}
result
}
val defBuf = new ListBuffer[Tree]
val constrStatBuf = new ListBuffer[Tree]
val constrPrefixBuf = new ListBuffer[Tree]
val presupers = treeInfo.preSuperFields(stats)
for (stat <- constrBody.stats) {
constrStatBuf += stat
stat match {
case ValDef(mods, name, _, _) if (mods hasFlag PRESUPER) =>
constrStatBuf +=
localTyper.typed {
atPos(stat.pos) {
val fields = presupers filter (
vdef => nme.localToGetter(vdef.name) == name)
assert(fields.length == 1)
Assign(
gen.mkAttributedRef(clazz.thisType, fields.head.symbol),
Ident(stat.symbol))
}
}
case _ =>
}
}
for (stat <- stats) stat match {
case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
stat.symbol.tpe match {
case MethodType(List(), tp @ ConstantType(c)) =>
defBuf += copy.DefDef(
stat, mods, name, tparams, vparamss, tpt,
Literal(c) setPos rhs.pos setType tp)
case _ =>
if (!stat.symbol.isPrimaryConstructor) defBuf += stat
}
case ValDef(mods, name, tpt, rhs) =>
if (stat.symbol.tpe.isInstanceOf[ConstantType])
assert(stat.symbol.getter(stat.symbol.owner) != NoSymbol, stat)
else {
if (rhs != EmptyTree && !stat.symbol.hasFlag(LAZY)) {
val rhs1 = intoConstructor(stat.symbol, rhs);
(if (canBeMoved(stat)) constrPrefixBuf else constrStatBuf) += mkAssign(
stat.symbol, rhs1)
}
defBuf += copy.ValDef(stat, mods, name, tpt, EmptyTree)
}
case ClassDef(_, _, _, _) =>
defBuf += (new ConstructorTransformer).transform(stat)
case _ =>
constrStatBuf += intoConstructor(impl.symbol, stat)
}
val accessed = new TreeSet[Symbol]((x, y) => x isLess y)
def isAccessed(sym: Symbol) =
sym.owner != clazz ||
!(sym hasFlag PARAMACCESSOR) ||
!sym.isPrivateLocal ||
(accessed contains sym)
val accessTraverser = new Traverser {
override def traverse(tree: Tree) = {
tree match {
case Select(_, _) =>
if (!isAccessed(tree.symbol)) accessed addEntry tree.symbol
case _ =>
}
super.traverse(tree)
}
}
for (stat <- defBuf.elements) accessTraverser.traverse(stat)
val paramInits = for (acc <- paramAccessors if isAccessed(acc))
yield copyParam(acc, parameter(acc))
defBuf += copy.DefDef(
constr, constr.mods, constr.name, constr.tparams, constr.vparamss, constr.tpt,
copy.Block(
constrBody,
paramInits ::: constrPrefixBuf.toList ::: constrStatBuf.toList,
constrBody.expr));
for (sym <- clazz.info.decls.toList)
if (!isAccessed(sym)) clazz.info.decls unlink sym
copy.Template(impl, impl.parents, impl.self,
defBuf.toList filter (stat => isAccessed(stat.symbol)))
}
override def transform(tree: Tree): Tree = {
tree match {
case ClassDef(mods, name, tparams, impl) if !tree.symbol.hasFlag(INTERFACE) =>
copy.ClassDef(tree, mods, name, tparams, transformClassTemplate(impl))
case _ =>
super.transform(tree)
}
}
} // ConstructorTransformer
}
|