blob: 1b3018d9b083daee458ea0e82167b2b23641afa8 (
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
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
|
package dotty.tools.dotc
package transform
import core._
import Types._
import Contexts._
import Symbols._
import SymDenotations._
import Decorators._
import Names._
import StdNames._
import NameOps._
import NameExtractors._
import Flags._
import Annotations._
import language.implicitConversions
import scala.annotation.tailrec
object SymUtils {
implicit def decorateSymbol(sym: Symbol): SymUtils = new SymUtils(sym)
implicit def decorateSymDenot(d: SymDenotation): SymUtils = new SymUtils(d.symbol)
}
/** A decorator that provides methods on symbols
* that are needed in the transformer pipeline.
*/
class SymUtils(val self: Symbol) extends AnyVal {
import SymUtils._
/** All traits implemented by a class or trait except for those inherited through the superclass. */
def directlyInheritedTraits(implicit ctx: Context) = {
val superCls = self.asClass.superClass
val baseClasses = self.asClass.baseClasses
if (baseClasses.isEmpty) Nil
else baseClasses.tail.takeWhile(_ ne superCls).reverse
}
/** All traits implemented by a class, except for those inherited through the superclass.
* The empty list if `self` is a trait.
*/
def mixins(implicit ctx: Context) = {
if (self is Trait) Nil
else directlyInheritedTraits
}
def isTypeTestOrCast(implicit ctx: Context): Boolean =
self == defn.Any_asInstanceOf || self == defn.Any_isInstanceOf
def isVolatile(implicit ctx: Context) = self.hasAnnotation(defn.VolatileAnnot)
def isAnyOverride(implicit ctx: Context) = self.is(Override) || self.is(AbsOverride)
// careful: AbsOverride is a term only flag. combining with Override would catch only terms.
def isAliasPreferred(implicit ctx: Context) =
self.is(AliasPreferred) || self.name.is(ExpandedName)
def isSuperAccessor(implicit ctx: Context) = self.name.is(SuperAccessorName)
/** If this is a constructor, its owner: otherwise this. */
final def skipConstructor(implicit ctx: Context): Symbol =
if (self.isConstructor) self.owner else self
/** The closest properly enclosing method or class of this symbol. */
final def enclosure(implicit ctx: Context) = {
self.owner.enclosingMethodOrClass
}
/** The closest enclosing method or class of this symbol */
@tailrec final def enclosingMethodOrClass(implicit ctx: Context): Symbol =
if (self.is(Method, butNot = Label) || self.isClass) self
else if (self.exists) self.owner.enclosingMethodOrClass
else NoSymbol
/** Apply symbol/symbol substitution to this symbol */
def subst(from: List[Symbol], to: List[Symbol]): Symbol = {
@tailrec def loop(from: List[Symbol], to: List[Symbol]): Symbol =
if (from.isEmpty) self
else if (self eq from.head) to.head
else loop(from.tail, to.tail)
loop(from, to)
}
def accessorNamed(name: TermName)(implicit ctx: Context): Symbol =
self.owner.info.decl(name).suchThat(_ is Accessor).symbol
def termParamAccessors(implicit ctx: Context): List[Symbol] =
self.info.decls.filter(_ is TermParamAccessor).toList
def caseAccessors(implicit ctx:Context) =
self.info.decls.filter(_ is CaseAccessor).toList
def getter(implicit ctx: Context): Symbol =
if (self.isGetter) self else accessorNamed(self.asTerm.name.getterName)
def setter(implicit ctx: Context): Symbol =
if (self.isSetter) self
else accessorNamed(self.asTerm.name.setterName)
def field(implicit ctx: Context): Symbol =
self.owner.info.decl(self.asTerm.name.fieldName).suchThat(!_.is(Method)).symbol
def isField(implicit ctx: Context): Boolean =
self.isTerm && !self.is(Method)
def implClass(implicit ctx: Context): Symbol =
self.owner.info.decl(self.name.implClassName).symbol
def annotationsCarrying(meta: ClassSymbol)(implicit ctx: Context): List[Annotation] =
self.annotations.filter(_.symbol.hasAnnotation(meta))
def withAnnotationsCarrying(from: Symbol, meta: ClassSymbol)(implicit ctx: Context): self.type = {
self.addAnnotations(from.annotationsCarrying(meta))
self
}
def registerCompanionMethod(name: Name, target: Symbol)(implicit ctx: Context) = {
if (!self.unforcedDecls.lookup(name).exists) {
val companionMethod = ctx.synthesizeCompanionMethod(name, target, self)
if (companionMethod.exists) {
companionMethod.entered
}
}
}
}
|
