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
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
|
/* NSC -- new Scala compiler
* Copyright 2005-2010 LAMP/EPFL
* @author Martin Odersky
*/
package scala.tools.nsc
package transform
import symtab._
import Flags.{ CASE => _, _ }
import scala.collection.mutable.ListBuffer
import matching.{ TransMatcher, Patterns, ParallelMatching }
/** This class ...
*
* @author Martin Odersky
* @version 1.0
*/
abstract class ExplicitOuter extends InfoTransform
with TransMatcher
with Patterns
with ParallelMatching
with TypingTransformers
with ast.TreeDSL
{
import global._
import definitions._
import CODE._
/** The following flags may be set by this phase: */
override def phaseNewFlags: Long = notPRIVATE | notPROTECTED | lateFINAL
/** the name of the phase: */
val phaseName: String = "explicitouter"
/** This class does not change linearization */
override def changesBaseClasses = false
protected def newTransformer(unit: CompilationUnit): Transformer =
new ExplicitOuterTransformer(unit)
/** Is given <code>clazz</code> an inner class? */
private def isInner(clazz: Symbol) =
!clazz.isPackageClass && !clazz.outerClass.isStaticOwner
/** Does given <code>clazz</code> define an outer field? */
def hasOuterField(clazz: Symbol) = {
def hasSameOuter(parent: Type) =
parent.typeSymbol.isClass &&
clazz.owner.isClass &&
clazz.owner == parent.typeSymbol.owner &&
parent.prefix =:= clazz.owner.thisType
isInner(clazz) && !clazz.isTrait &&
!(clazz.info.parents.headOption exists hasSameOuter)
}
private def outerField(clazz: Symbol): Symbol = {
val result = clazz.info.member(nme.OUTER_LOCAL)
assert(result != NoSymbol, "no outer field in "+clazz+clazz.info.decls+" at "+phase)
result
}
/** Issue a migration warning for instance checks which might be on an Array and
* for which the type parameter conforms to Seq, because these answers changed in 2.8.
*/
def isArraySeqTest(lhs: Type, rhs: Type) =
ArrayClass.tpe <:< lhs.widen && rhs.widen.matchesPattern(SeqClass.tpe)
def outerAccessor(clazz: Symbol): Symbol = {
val firstTry = clazz.info.decl(nme.expandedName(nme.OUTER, clazz))
if (firstTry != NoSymbol && firstTry.outerSource == clazz) firstTry
else clazz.info.decls find (_.outerSource == clazz) getOrElse NoSymbol
}
/** <p>
* The type transformation method:
* </p>
* <ol>
* <li>
* Add an outer parameter to the formal parameters of a constructor
* in a inner non-trait class;
* </li>
* <li>
* Add a protected <code>$outer</code> field to an inner class which is
* not a trait.
* </li>
* <li>
* <p>
* Add an outer accessor <code>$outer$$C</code> to every inner class
* with fully qualified name <code>C</code> that is not an interface.
* The outer accessor is abstract for traits, concrete for other
* classes.
* </p>
* <p>
* 3a. Also add overriding accessor defs to every class that inherits
* mixin classes with outer accessor defs (unless the superclass
* already inherits the same mixin).
* </p>
* </li>
* <li>
* Make all super accessors and modules in traits non-private, mangling
* their names.
* </li>
* <li>
* Remove protected flag from all members of traits.
* </li>
* </ol>
*/
def transformInfo(sym: Symbol, tp: Type): Type = tp match {
case MethodType(params, restpe1) =>
val restpe = transformInfo(sym, restpe1)
if (sym.owner.isTrait && ((sym hasFlag (ACCESSOR | SUPERACCESSOR)) || sym.isModule)) { // 5
sym.makeNotPrivate(sym.owner)
}
if (sym.owner.isTrait && sym.isProtected) sym setFlag notPROTECTED // 6
if (sym.isClassConstructor && isInner(sym.owner)) { // 1
val p = sym.newValueParameter(sym.pos, "arg" + nme.OUTER)
.setInfo(sym.owner.outerClass.thisType)
MethodType(p :: params, restpe)
} else if (restpe ne restpe1)
MethodType(params, restpe)
else tp
case ClassInfoType(parents, decls, clazz) =>
var decls1 = decls
if (isInner(clazz) && !clazz.isInterface) {
decls1 = decls.cloneScope
val outerAcc = clazz.newMethod(clazz.pos, nme.OUTER) // 3
outerAcc expandName clazz
val restpe = if (clazz.isTrait) clazz.outerClass.tpe else clazz.outerClass.thisType
decls1 enter (clazz.newOuterAccessor(clazz.pos) setInfo MethodType(Nil, restpe))
if (hasOuterField(clazz)) { //2
val access = if (clazz.isFinal) PRIVATE | LOCAL else PROTECTED
decls1 enter (
clazz.newValue(clazz.pos, nme.OUTER_LOCAL)
setFlag (SYNTHETIC | PARAMACCESSOR | access)
setInfo clazz.outerClass.thisType
)
}
}
if (!clazz.isTrait && !parents.isEmpty) {
for (mc <- clazz.mixinClasses) {
val mixinOuterAcc: Symbol = atPhase(phase.next)(outerAccessor(mc))
if (mixinOuterAcc != NoSymbol) {
if (decls1 eq decls) decls1 = decls.cloneScope
val newAcc = mixinOuterAcc.cloneSymbol(clazz)
newAcc resetFlag DEFERRED setInfo (clazz.thisType memberType mixinOuterAcc)
decls1 enter newAcc
}
}
}
if (decls1 eq decls) tp else ClassInfoType(parents, decls1, clazz)
case PolyType(tparams, restp) =>
val restp1 = transformInfo(sym, restp)
if (restp eq restp1) tp else PolyType(tparams, restp1)
case _ =>
// Local fields of traits need to be unconditionally unprivatized.
// Reason: Those fields might need to be unprivatized if referenced by an inner class.
// On the other hand, mixing in the trait into a separately compiled
// class needs to have a common naming scheme, independently of whether
// the field was accessed from an inner class or not. See #2946
if (sym.owner.isTrait && (sym hasFlag LOCAL) &&
((sym.getter(sym.owner.toInterface) == NoSymbol) && (!sym.isLazy || (sym.lazyAccessor == NoSymbol))))
sym.makeNotPrivate(sym.owner)
tp
}
/** A base class for transformers that maintain <code>outerParam</code>
* values for outer parameters of constructors.
* The class provides methods for referencing via outer.
*/
abstract class OuterPathTransformer(unit: CompilationUnit) extends TypingTransformer(unit) {
/** The directly enclosing outer parameter, if we are in a constructor */
protected var outerParam: Symbol = NoSymbol
/** The first outer selection from currently transformed tree.
* The result is typed but not positioned.
*/
protected def outerValue: Tree =
if (outerParam != NoSymbol) ID(outerParam)
else outerSelect(THIS(currentClass))
/** Select and apply outer accessor from 'base'
* The result is typed but not positioned.
* If the outer access is from current class and current class is final
* take outer field instead of accessor
*/
private def outerSelect(base: Tree): Tree = {
val outerAcc = outerAccessor(base.tpe.typeSymbol.toInterface)
val currentClass = this.currentClass //todo: !!! if this line is removed, we get a build failure that protected$currentClass need an override modifier
// outerFld is the $outer field of the current class, if the reference can
// use it (i.e. reference is allowed to be of the form this.$outer),
// otherwise it is NoSymbol
val outerFld =
if (outerAcc.owner == currentClass &&
base.tpe =:= currentClass.thisType &&
outerAcc.owner.isFinal)
outerField(currentClass) suchThat (_.owner == currentClass)
else
NoSymbol
val path =
if (outerFld != NoSymbol) Select(base, outerFld)
else Apply(Select(base, outerAcc), Nil)
localTyper typed path
}
/** The path
* <blockquote><pre>`base'.$outer$$C1 ... .$outer$$Cn</pre></blockquote>
* which refers to the outer instance of class <code>to</code> of
* value <code>base</code>. The result is typed but not positioned.
*
* @param base ...
* @param from ...
* @param to ...
* @return ...
*/
protected def outerPath(base: Tree, from: Symbol, to: Symbol): Tree = {
//Console.println("outerPath from "+from+" to "+to+" at "+base+":"+base.tpe)
//assert(base.tpe.widen.baseType(from.toInterface) != NoType, ""+base.tpe.widen+" "+from.toInterface)//DEBUG
if (from == to || from.isImplClass && from.toInterface == to) base
else outerPath(outerSelect(base), from.outerClass, to)
}
override def transform(tree: Tree): Tree = {
val savedOuterParam = outerParam
try {
tree match {
case Template(_, _, _) =>
outerParam = NoSymbol
case DefDef(_, _, _, vparamss, _, _) =>
if (tree.symbol.isClassConstructor && isInner(tree.symbol.owner)) {
outerParam = vparamss.head.head.symbol
assert(outerParam.name startsWith nme.OUTER, outerParam.name)
}
case _ =>
}
super.transform(tree)
}
finally outerParam = savedOuterParam
}
}
/** <p>
* The phase performs the following transformations on terms:
* </p>
* <ol>
* <li> <!-- 1 -->
* <p>
* An class which is not an interface and is not static gets an outer
* accessor (@see outerDefs).
* </p>
* <p>
* 1a. A class which is not a trait gets an outer field.
* </p>
* </li>
* <li> <!-- 4 -->
* A constructor of a non-trait inner class gets an outer parameter.
* </li>
* <li> <!-- 5 -->
* A reference <code>C.this</code> where <code>C</code> refers to an
* outer class is replaced by a selection
* <code>this.$outer$$C1</code> ... <code>.$outer$$Cn</code> (@see outerPath)
* </li>
* <li>
* </li>
* <li> <!-- 7 -->
* A call to a constructor Q.<init>(args) or Q.$init$(args) where Q != this and
* the constructor belongs to a non-static class is augmented by an outer argument.
* E.g. <code>Q.<init>(OUTER, args)</code> where <code>OUTER</code>
* is the qualifier corresponding to the singleton type <code>Q</code>.
* </li>
* <li>
* A call to a constructor <code>this.<init>(args)</code> in a
* secondary constructor is augmented to <code>this.<init>(OUTER, args)</code>
* where <code>OUTER</code> is the last parameter of the secondary constructor.
* </li>
* <li> <!-- 9 -->
* Remove <code>private</code> modifier from class members <code>M</code>
* that are accessed from an inner class.
* </li>
* <li> <!-- 10 -->
* Remove <code>protected</code> modifier from class members <code>M</code>
* that are accessed without a super qualifier accessed from an inner
* class or trait.
* </li>
* <li> <!-- 11 -->
* Remove <code>private</code> and <code>protected</code> modifiers
* from type symbols
* </li>
* <li> <!-- 12 -->
* Remove <code>private</code> modifiers from members of traits
* </li>
* </ol>
* <p>
* Note: The whole transform is run in phase <code>explicitOuter.next</code>.
* </p>
*/
class ExplicitOuterTransformer(unit: CompilationUnit) extends OuterPathTransformer(unit) {
transformer =>
/** The definition tree of the outer accessor of current class
*/
def outerFieldDef: Tree = VAL(outerField(currentClass)) === EmptyTree
/** The definition tree of the outer accessor of current class
*/
def outerAccessorDef: Tree = {
val outerAcc = outerAccessor(currentClass)
var rhs: Tree =
if (outerAcc.isDeferred) EmptyTree
else This(currentClass) DOT outerField(currentClass)
/** If we don't re-type the tree, we see self-type related crashes like #266.
*/
localTyper typed {
(DEF(outerAcc) withPos currentClass.pos withType null) === rhs
}
}
/** The definition tree of the outer accessor for class mixinClass.
*
* @param mixinClass The mixin class which defines the abstract outer
* accessor which is implemented by the generated one.
* @pre mixinClass is an inner class
*/
def mixinOuterAccessorDef(mixinClass: Symbol): Tree = {
val outerAcc = outerAccessor(mixinClass) overridingSymbol currentClass
assert(outerAcc != NoSymbol)
val path =
if (mixinClass.owner.isTerm) THIS(mixinClass.owner.enclClass)
else gen.mkAttributedQualifier(currentClass.thisType baseType mixinClass prefix)
localTyper typed {
(DEF(outerAcc) withPos currentClass.pos) === {
// Need to cast for nested outer refs in presence of self-types. See ticket #3274.
transformer.transform(path) AS_ANY outerAcc.info.resultType
}
}
}
/** If FLAG is set on symbol, sets notFLAG (this exists in anticipation of generalizing). */
def setNotFlags(sym: Symbol, flags: Int*) {
val notMap = Map(
PRIVATE -> notPRIVATE,
PROTECTED -> notPROTECTED
)
for (f <- flags ; notFlag <- notMap get f ; if sym hasFlag f)
sym setFlag notFlag
}
def matchTranslation(tree: Match) = {
val Match(selector, cases) = tree
var nselector = transform(selector)
def makeGuardDef(vs: List[Symbol], guard: Tree) = {
val gdname = newName(guard.pos, "gd")
val method = currentOwner.newMethod(tree.pos, gdname) setFlag SYNTHETIC
val fmls = vs map (_.tpe)
val tpe = new MethodType(method newSyntheticValueParams fmls, BooleanClass.tpe)
method setInfo tpe
localTyper typed (DEF(method) === {
new ChangeOwnerTraverser(currentOwner, method) traverse guard
new TreeSymSubstituter(vs, method.paramss.head) transform (guard)
})
}
val nguard = new ListBuffer[Tree]
val ncases =
for (CaseDef(p, guard, b) <- cases) yield {
val gdcall =
if (guard == EmptyTree) EmptyTree
else {
val vs = Pattern(p).deepBoundVariables
val guardDef = makeGuardDef(vs, guard)
nguard += transform(guardDef) // building up list of guards
localTyper typed (Ident(guardDef.symbol) APPLY (vs map Ident))
}
(CASE(transform(p)) IF gdcall) ==> transform(b)
}
def isUncheckedAnnotation(tpe: Type) = tpe hasAnnotation UncheckedClass
def isSwitchAnnotation(tpe: Type) = tpe hasAnnotation SwitchClass
val (checkExhaustive, requireSwitch) = nselector match {
case Typed(nselector1, tpt) =>
val unchecked = isUncheckedAnnotation(tpt.tpe)
if (unchecked)
nselector = nselector1
(!unchecked, isSwitchAnnotation(tpt.tpe))
case _ =>
(true, false)
}
val t = atPos(tree.pos) {
val context = MatrixContext(transform, localTyper, currentOwner, tree.tpe)
val t_untyped = handlePattern(nselector, ncases, checkExhaustive, context)
/* if @switch annotation is present, verify the resulting tree is a Match */
if (requireSwitch) t_untyped match {
case Block(_, Match(_, _)) => // ok
case _ =>
unit.error(tree.pos, "could not emit switch for @switch annotated match")
}
localTyper.typed(t_untyped, context.matchResultType)
}
if (nguard.isEmpty) t
else Block(nguard.toList, t) setType t.tpe
}
/** The main transformation method */
override def transform(tree: Tree): Tree = {
val sym = tree.symbol
if (sym != null && sym.isType) //(9)
setNotFlags(sym, PRIVATE, PROTECTED)
tree match {
case Template(parents, self, decls) =>
val newDefs = new ListBuffer[Tree]
atOwner(tree, currentOwner) {
if (!currentClass.isInterface || (currentClass hasFlag lateINTERFACE)) {
if (isInner(currentClass)) {
if (hasOuterField(currentClass))
newDefs += outerFieldDef // (1a)
newDefs += outerAccessorDef // (1)
}
if (!currentClass.isTrait)
for (mc <- currentClass.mixinClasses)
if (outerAccessor(mc) != NoSymbol)
newDefs += mixinOuterAccessorDef(mc)
}
}
super.transform(
treeCopy.Template(tree, parents, self,
if (newDefs.isEmpty) decls else decls ::: newDefs.toList)
)
case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
if (sym.isClassConstructor) {
rhs match {
case Literal(_) =>
Predef.error("unexpected case") //todo: remove
case _ =>
val clazz = sym.owner
val vparamss1 =
if (isInner(clazz)) { // (4)
val outerParam =
sym.newValueParameter(sym.pos, nme.OUTER) setInfo outerField(clazz).info
((ValDef(outerParam) setType NoType) :: vparamss.head) :: vparamss.tail
} else vparamss
super.transform(treeCopy.DefDef(tree, mods, name, tparams, vparamss1, tpt, rhs))
}
} else
super.transform(tree)
case This(qual) =>
if (sym == currentClass || (sym hasFlag MODULE) && sym.isStatic) tree
else atPos(tree.pos)(outerPath(outerValue, currentClass.outerClass, sym)) // (5)
case Select(qual, name) =>
if (currentClass != sym.owner/* && currentClass != sym.moduleClass*/) // (3)
sym.makeNotPrivate(sym.owner)
val qsym = qual.tpe.widen.typeSymbol
if (sym.isProtected && //(4)
(qsym.isTrait || !(qual.isInstanceOf[Super] || (qsym isSubClass currentClass))))
sym setFlag notPROTECTED
super.transform(tree)
case Apply(sel @ Select(qual, nme.CONSTRUCTOR), args) if isInner(sel.symbol.owner) =>
val outerVal = atPos(tree.pos)(qual match {
// it's a call between constructors of same class
case _: This =>
assert(outerParam != NoSymbol)
outerValue
case _ =>
gen.mkAttributedQualifier(qual.tpe.prefix match {
case NoPrefix => sym.owner.outerClass.thisType
case x => x
})
})
super.transform(treeCopy.Apply(tree, sel, outerVal :: args))
// TransMatch hook
case mch: Match =>
matchTranslation(mch)
case _ =>
if (settings.Xmigration28.value) tree match {
case TypeApply(fn @ Select(qual, _), args) if fn.symbol == Object_isInstanceOf || fn.symbol == Any_isInstanceOf =>
if (isArraySeqTest(qual.tpe, args.head.tpe))
unit.warning(tree.pos, "An Array will no longer match as Seq[_].")
case _ => ()
}
val x = super.transform(tree)
if (x.tpe eq null) x
else x setType transformInfo(currentOwner, x.tpe)
}
}
/** The transformation method for whole compilation units */
override def transformUnit(unit: CompilationUnit) {
cunit = unit
atPhase(phase.next) { super.transformUnit(unit) }
cunit = null
}
}
override def newPhase(prev: scala.tools.nsc.Phase): StdPhase =
new Phase(prev)
class Phase(prev: scala.tools.nsc.Phase) extends super.Phase(prev) {
override val checkable = false
}
}
|