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
|
/* NSC -- new scala compiler
* Copyright 2005 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)
}
}
}
|
