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
|
/* NSC -- new Scala compiler
* Copyright 2005-2006 LAMP/EPFL
* @author
*/
// $Id$
package scala.tools.nsc.transform
import symtab._
import Flags._
import scala.collection.mutable.ListBuffer
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 (val 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 _ =>
}
}
val paramAccessors = clazz.constrParamAccessors
def parameter(acc: Symbol) = {
val accname = nme.getterName(acc.originalName)
val ps = constrParams.filter { param => accname == param.name }
if (ps.isEmpty) assert(false, "" + accname + " 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.Ident(parameter(tree.symbol.accessed)) setPos tree.pos;
case Select(This(_), _)
if ((tree.symbol hasFlag PARAMACCESSOR) && tree.symbol.owner == clazz) =>
gen.Ident(parameter(tree.symbol)) setPos tree.pos;
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 {
case ValDef(_, _, _, _) => !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]
constrBody.stats foreach (constrStatBuf +=)
for (val 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) {
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 hasFlag LOCAL) ||
(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 (val stat <- defBuf.elements) accessTraverser.traverse(stat);
val paramInits = for (val acc <- paramAccessors; 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));
copy.Template(impl, impl.parents, defBuf.toList filter (stat => isAccessed(stat.symbol)))
}
override def transform(tree: Tree): Tree = {
tree match {
case ClassDef(mods, name, tparams, tpt, impl) if !tree.symbol.hasFlag(INTERFACE) =>
copy.ClassDef(tree, mods, name, tparams, tpt, transformClassTemplate(impl))
case _ =>
super.transform(tree)
}
}
} // ConstructorTransformer
}
|
