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
|
package scala.reflect
package api
trait Symbols { self: Universe =>
type Symbol >: Null <: AbsSymbol
abstract class AbsSymbol { this: Symbol =>
/** The modifiers of this symbol
*/
def allModifiers: Set[Modifier.Value]
/** Does this symbol have given modifier?
*/
def hasModifier(mod: Modifier.Value): Boolean
/** The owner of this symbol.
*/
def owner: Symbol
/** The name of the symbol as a member of the `Name` type.
*/
def name: Name
/** The name of the symbol before decoding, e.g. `\$eq\$eq` instead of `==`.
*/
def encodedName: String
/** The decoded name of the symbol, e.g. `==` instead of `\$eq\$eq`.
*/
def decodedName: String
/** The encoded full path name of this symbol, where outer names and inner names
* are separated by periods.
*/
def fullName: String
/**
* Set when symbol has a modifier of the form private[X], NoSymbol otherwise.
*
* Access level encoding: there are three scala flags (PRIVATE, PROTECTED,
* and LOCAL) which combine with value privateWithin (the "foo" in private[foo])
* to define from where an entity can be accessed. The meanings are as follows:
*
* PRIVATE access restricted to class only.
* PROTECTED access restricted to class and subclasses only.
* LOCAL can only be set in conjunction with PRIVATE or PROTECTED.
* Further restricts access to the same object instance.
*
* In addition, privateWithin can be used to set a visibility barrier.
* When set, everything contained in the named enclosing package or class
* has access. It is incompatible with PRIVATE or LOCAL, but is additive
* with PROTECTED (i.e. if either the flags or privateWithin allow access,
* then it is allowed.)
*
* The java access levels translate as follows:
*
* java private: hasFlag(PRIVATE) && !hasAccessBoundary
* java package: !hasFlag(PRIVATE | PROTECTED) && (privateWithin == enclosing package)
* java protected: hasFlag(PROTECTED) && (privateWithin == enclosing package)
* java public: !hasFlag(PRIVATE | PROTECTED) && !hasAccessBoundary
*/
def privateWithin: Symbol
/** Whether this symbol has a "privateWithin" visibility barrier attached.
*/
def hasAccessBoundary: Boolean
/** A list of annotations attached to this Symbol.
*/
def annotations: List[self.AnnotationInfo]
/** The type of the symbol
*/
def tpe: Type
/** The info of the symbol. This is like tpe, except for class symbols where the `info`
* describes the contents of the class whereas the `tpe` is a reference to the class.
*/
def info: Type
/** If this symbol is a class or trait, its self type, otherwise the type of the symbol itse;lf
*/
def typeOfThis: Type
/** For a module class its linked class, for a plain class
* the module class of its linked module.
* For instance
* object Foo
* class Foo
*
* Then object Foo has a `moduleClass` (invisible to the user, the backend calls it Foo$
* linkedClassOfClass goes from class Foo$ to class Foo, and back.
*/
def linkedClassOfClass: Symbol
/** The module corresponding to this module class (note that this
* is not updated when a module is cloned), or NoSymbol if this is not a ModuleClass
*/
def sourceModule: Symbol
/** If symbol is an object definition, it's implied associated class,
* otherwise NoSymbol
*/
def moduleClass: Symbol
/** The top-level class containing this symbol. */
def toplevelClass: Symbol
/**
* If symbol is a lazy val, it's lazy accessor
*/
def lazyAccessor: Symbol
/** The next enclosing class */
def enclClass : Symbol
/** The next enclosing method */
def enclMethod : Symbol
def isTerm : Boolean
def isType : Boolean
def isClass : Boolean
def isAliasType : Boolean
def isAbstractType : Boolean
def isAbstractClass: Boolean
def isBridge : Boolean
def isContravariant: Boolean
def isCovariant : Boolean
def isEarlyInitialized : Boolean
def isExistentiallyBound: Boolean
def isImplClass : Boolean
def isLazyAccessor : Boolean
def isMethod : Boolean
def isVarargsMethod: Boolean
def isModule : Boolean
def isModuleClass : Boolean
def isOverloaded : Boolean
def isRefinementClass: Boolean
def isSourceMethod : Boolean
def isTypeParameter: Boolean
/** Package tests */
def isPackage : Boolean
def isPackageClass : Boolean
def isRootPackage : Boolean
def isRoot : Boolean
def isEmptyPackage : Boolean
def isEmptyPackageClass: Boolean
}
val NoSymbol: Symbol
}
|
