blob: 02d27ea3389e74e3e0252b9aadd4375ea072daa9 (
plain) (
blame)
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
|
package dotty.tools.dotc
package core
import Periods._
import SymDenotations._
import Contexts._
import Types._
import Symbols._
import Denotations._
import Phases._
import java.lang.AssertionError
import dotty.tools.dotc.util.DotClass
object DenotTransformers {
/** A transformer group contains a sequence of transformers,
* ordered by the phase where they apply. Transformers are added
* to a group via `install`.
*/
/** A transformer transforms denotations at a given phase */
trait DenotTransformer extends Phase {
/** The last phase during which the transformed denotations are valid */
def lastPhaseId(implicit ctx: Context) = ctx.nextDenotTransformerId(id + 1)
/** The validity period of the transformer in the given context */
def validFor(implicit ctx: Context): Period =
Period(ctx.runId, id, lastPhaseId)
/** The transformation method */
def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation
}
/** A transformer that only transforms the info field of denotations */
trait InfoTransformer extends DenotTransformer {
def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type
def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = {
val sym = ref.symbol
if (sym.exists && !mayChange(sym)) ref
else {
val info1 = transformInfo(ref.info, ref.symbol)
if (info1 eq ref.info) ref
else ref match {
case ref: SymDenotation => ref.copySymDenotation(info = info1)
case _ => ref.derivedSingleDenotation(ref.symbol, info1)
}
}
}
/** Denotations with a symbol where `mayChange` is false are guaranteed to be
* unaffected by this transform, so `transformInfo` need not be run. This
* can save time, and more importantly, can help avoid forcing symbol completers.
*/
protected def mayChange(sym: Symbol)(implicit ctx: Context): Boolean = true
}
/** A transformer that only transforms SymDenotations */
trait SymTransformer extends DenotTransformer {
def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation
def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = ref match {
case ref: SymDenotation => transformSym(ref)
case _ => ref
}
}
/** A `DenotTransformer` trait that has the identity as its `transform` method.
* You might want to inherit from this trait so that new denotations can be
* installed using `installAfter` and `enteredAfter` at the end of the phase.
*/
trait IdentityDenotTransformer extends DenotTransformer {
def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = ref
}
}
|
