abstract class Symbol extends SymbolTable.SymbolContextApiImpl with HasFlags with SymbolTable.Annotatable[SymbolTable.Symbol] with SymbolTable.Attachable

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Symbol
  2. Attachable
  3. Annotatable
  4. HasFlags
  5. SymbolContextApiImpl
  6. SymbolApi
  7. AnyRef
  8. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Symbol(initOwner: SymbolTable.Symbol, initPos: SymbolTable.Position, initName: SymbolTable.Name)
    Attributes
    protected[Symbols]

Type Members

  1. type AccessBoundaryType = SymbolTable.Symbol
    Definition Classes
    SymbolHasFlags
  2. type AnnotationType = SymbolTable.AnnotationInfo
    Definition Classes
    SymbolHasFlags
  3. abstract type NameType >: Null <: SymbolTable.Name

    The type of the symbol name.

    The type of the symbol name. Can be either TermName or TypeName depending on whether this is a TermSymbol or a TypeSymbol.

    Type name namespaces do not intersect with term name namespaces. This fact is reflected in different types for names of TermSymbol and TypeSymbol.

    Definition Classes
    SymbolApi
  4. abstract type TypeOfClonedSymbol >: Null <: SymbolTable.Symbol { type NameType = Symbol.this.NameType }

Abstract Value Members

  1. abstract def asNameType(n: SymbolTable.Name): NameType
  2. abstract def cloneSymbolImpl(owner: SymbolTable.Symbol, newFlags: Long): TypeOfClonedSymbol

    Internal method to clone a symbol's implementation with the given flags and no info.

  3. abstract def existentialBound: SymbolTable.Type

    If we quantify existentially over this symbol, the bound of the type variable that stands for it pre: symbol is a term, a class, or an abstract type (no alias type allowed)

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def GADT_SKOLEM_FLAGS: Int
    Attributes
    protected[Symbols]
  5. final var _rawname: SymbolTable.Name
    Attributes
    protected[this]
  6. def abbreviatedKindString: String

    String representation of symbol's kind, suitable for the masses.

    String representation of symbol's kind, suitable for the masses.

    Attributes
    protected[scala]
  7. def accessBoundary(base: SymbolTable.Symbol): SymbolTable.Symbol

    The class or term up to which this symbol is accessible, or else enclosingRootClass if it is public.

  8. def accessString: String
    Definition Classes
    HasFlags
  9. final def accessed: SymbolTable.Symbol

    The symbol accessed by this accessor (getter or setter) function.

  10. def accessedOrSelf: SymbolTable.Symbol

    accessed, if this is an accessor that should have an underlying field.

    accessed, if this is an accessor that should have an underlying field. Otherwise, this. Note that a "regular" accessor in a trait does not have a field, as an interface cannot define a field. "non-regular" vals are: early initialized or lazy vals. Eventually, we should delay introducing symbols for all val/vars until the fields (or lazyvals) phase, as they are an implementation detail that's irrelevant to type checking.

  11. final def accurateKindString: String

    Accurate string representation of symbols' kind, suitable for developers.

  12. final def addAnnotation(tp: SymbolTable.Type, args: List[SymbolTable.Tree]): Symbol.this.type
  13. final def addAnnotation(tp: SymbolTable.Type, arg1: SymbolTable.Tree, arg2: SymbolTable.Tree): Symbol.this.type
  14. final def addAnnotation(tp: SymbolTable.Type, arg: SymbolTable.Tree): Symbol.this.type
  15. final def addAnnotation(tp: SymbolTable.Type): Symbol.this.type

    Use that variant if you want to pass (for example) an applied type

  16. final def addAnnotation(sym: SymbolTable.Symbol, args: List[SymbolTable.Tree]): Symbol.this.type
  17. final def addAnnotation(sym: SymbolTable.Symbol, args: SymbolTable.Tree*): Symbol.this.type
  18. final def addAnnotation(sym: SymbolTable.Symbol, arg1: SymbolTable.Tree, arg2: SymbolTable.Tree): Symbol.this.type
  19. final def addAnnotation(sym: SymbolTable.Symbol, arg: SymbolTable.Tree): Symbol.this.type
  20. final def addAnnotation(sym: SymbolTable.Symbol): Symbol.this.type
  21. def addAnnotation(annot: SymbolTable.AnnotationInfo): Symbol.this.type
  22. def addChild(sym: SymbolTable.Symbol): Unit
  23. def addThrowsAnnotation(throwableSym: SymbolTable.Symbol): SymbolTable.Symbol
    Definition Classes
    Annotatable
  24. def alias: SymbolTable.Symbol

    For a paramaccessor: a superclass paramaccessor for which this symbol is an alias, NoSymbol for all others.

  25. final def allOverriddenSymbols: List[SymbolTable.Symbol]

    Returns all symbols overridden by this symbol.

    Returns all symbols overridden by this symbol.

    Definition Classes
    SymbolSymbolApi
  26. def alternatives: List[SymbolTable.Symbol]

    The overloaded alternatives of this symbol.

    The overloaded alternatives of this symbol.

    Definition Classes
    SymbolSymbolApi
  27. def ancestors: List[SymbolTable.Symbol]

    All directly or indirectly inherited classes.

  28. final def andAlso(f: (SymbolTable.Symbol) ⇒ Unit): SymbolTable.Symbol
    Annotations
    @inline()
  29. def annotations: List[SymbolTable.AnnotationInfo]

    After the typer phase (before, look at the definition's Modifiers), contains the annotations attached to member a definition (class, method, type, field).

    After the typer phase (before, look at the definition's Modifiers), contains the annotations attached to member a definition (class, method, type, field).

    Definition Classes
    SymbolAnnotatableHasFlagsSymbolApi
  30. def annotationsString: String
  31. def asClass: SymbolTable.ClassSymbol

    This symbol cast to a ClassSymbol representing a class or trait.

    This symbol cast to a ClassSymbol representing a class or trait.

    Definition Classes
    SymbolApi
    Exceptions thrown

    ScalaReflectionException if isClass is false.

  32. def asFreeTerm: SymbolTable.FreeTermSymbol
    Definition Classes
    SymbolContextApiImpl
  33. def asFreeType: SymbolTable.FreeTypeSymbol
    Definition Classes
    SymbolContextApiImpl
  34. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  35. def asMethod: SymbolTable.MethodSymbol

    This symbol cast to a MethodSymbol.

    This symbol cast to a MethodSymbol.

    Definition Classes
    SymbolApi
    Exceptions thrown

    ScalaReflectionException if isMethod is false.

  36. def asModule: SymbolTable.ModuleSymbol

    This symbol cast to a ModuleSymbol defined by an object definition.

    This symbol cast to a ModuleSymbol defined by an object definition.

    Definition Classes
    SymbolApi
    Exceptions thrown

    ScalaReflectionException if isModule is false.

  37. def asTerm: SymbolTable.TermSymbol

    This symbol cast to a TermSymbol.

    This symbol cast to a TermSymbol.

    Definition Classes
    SymbolApi
    Exceptions thrown

    ScalaReflectionException if isTerm is false.

  38. def asType: SymbolTable.TypeSymbol

    This symbol cast to a TypeSymbol.

    This symbol cast to a TypeSymbol.

    Definition Classes
    SymbolApi
    Exceptions thrown

    ScalaReflectionException if isType is false.

  39. final def assertOwner: SymbolTable.Symbol
  40. def associatedFile: AbstractFile

    Overridden in ModuleSymbols to delegate to the module class.

    Overridden in ModuleSymbols to delegate to the module class. Never null; if there is no associated file, returns NoAbstractFile.

    Definition Classes
    SymbolSymbolApi
  41. def associatedFile_=(f: AbstractFile): Unit
  42. def attachments: Attachments { type Pos = Symbols.this.Position }
    Definition Classes
    Attachable
  43. def baseClasses: List[SymbolTable.Symbol]
    Definition Classes
    SymbolContextApiImpl
  44. def calculateFlagString(basis: Long): String
    Attributes
    protected
    Definition Classes
    HasFlags
  45. final def caseFieldAccessors: List[SymbolTable.Symbol]

    For a case class, the symbols of the accessor methods, one for each argument in the first parameter list of the primary constructor.

    For a case class, the symbols of the accessor methods, one for each argument in the first parameter list of the primary constructor. The empty list for all other classes.

    This list will be sorted to correspond to the declaration order in the constructor parameter

  46. final def caseModule: SymbolTable.Symbol

    The case module corresponding to this case class

  47. def changeNameInOwners(name: SymbolTable.Name): Unit
    Attributes
    protected[this]
  48. def children: Set[SymbolTable.Symbol]

    If this is a sealed or local class, its known direct subclasses.

    If this is a sealed or local class, its known direct subclasses. Otherwise, the empty set.

  49. def classBound: SymbolTable.Type

    The least proper supertype of a class; includes all parent types and refinement where needed.

    The least proper supertype of a class; includes all parent types and refinement where needed. You need to compute that in a situation like this: { class C extends P { ... } new C }

  50. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  51. final def cloneSymbol(newOwner: SymbolTable.Symbol, newFlags: Long, newName: SymbolTable.Name): TypeOfClonedSymbol
  52. final def cloneSymbol(newOwner: SymbolTable.Symbol, newFlags: Long): TypeOfClonedSymbol
  53. final def cloneSymbol(newOwner: SymbolTable.Symbol): TypeOfClonedSymbol

    A clone of this symbol, but with given owner.

  54. final def cloneSymbol: TypeOfClonedSymbol

    A clone of this symbol.

  55. def companion: SymbolTable.Symbol

    For a class: its companion object if exists.

    For a class: its companion object if exists. For a module or a module class: companion class of the module if exists. For a package or a package class: NoSymbol. For all others: NoSymbol.

    Definition Classes
    SymbolContextApiImplSymbolApi
  56. def companionClass: SymbolTable.Symbol

    For a module: the class with the same name in the same package.

    For a module: the class with the same name in the same package. For all others: NoSymbol Note: does not work for classes owned by methods, see Namers.companionClassOf

    object Foo . companionClass --> class Foo

    !!! linkedClassOfClass depends on companionClass on the module class getting to the class. As presently implemented this potentially returns class for any symbol except NoSymbol.

  57. def companionModule: SymbolTable.Symbol

    For a class: the module or case class factory with the same name in the same package.

    For a class: the module or case class factory with the same name in the same package. For all others: NoSymbol Note: does not work for modules owned by methods, see Namers.companionModuleOf

    class Foo . companionModule --> object Foo

  58. def companionSymbol: SymbolTable.Symbol

    For a module: its linked class For a plain class: its linked module or case factory.

    For a module: its linked class For a plain class: its linked module or case factory. Note: does not work for modules owned by methods, see Namers.companionSymbolOf

    class Foo <-- companionSymbol --> object Foo

    Definition Classes
    SymbolSymbolApi
  59. def compileTimeOnlyMessage: Option[String]
  60. final def constrParamAccessors: List[SymbolTable.Symbol]
  61. def cookJavaRawInfo(): Symbol.this.type

    Modify term symbol's type so that a raw type C is converted to an existential C[_]

    Modify term symbol's type so that a raw type C is converted to an existential C[_]

    This is done in checkAccessible and overriding checks in refchecks We can't do this on class loading because it would result in infinite cycles.

  62. def createAbstractTypeSymbol(name: SymbolTable.TypeName, pos: SymbolTable.Position, newFlags: Long): SymbolTable.AbstractTypeSymbol

    Symbol creation implementations.

    Symbol creation implementations.

    Attributes
    protected
  63. def createAliasTypeSymbol(name: SymbolTable.TypeName, pos: SymbolTable.Position, newFlags: Long): SymbolTable.AliasTypeSymbol
    Attributes
    protected
  64. def createClassSymbol(name: SymbolTable.TypeName, pos: SymbolTable.Position, newFlags: Long): SymbolTable.ClassSymbol
    Attributes
    protected
  65. def createMethodSymbol(name: SymbolTable.TermName, pos: SymbolTable.Position, newFlags: Long): SymbolTable.MethodSymbol
    Attributes
    protected
  66. def createModuleClassSymbol(name: SymbolTable.TypeName, pos: SymbolTable.Position, newFlags: Long): SymbolTable.ModuleClassSymbol
    Attributes
    protected
  67. def createModuleSymbol(name: SymbolTable.TermName, pos: SymbolTable.Position, newFlags: Long): SymbolTable.ModuleSymbol
    Attributes
    protected
  68. def createPackageClassSymbol(name: SymbolTable.TypeName, pos: SymbolTable.Position, newFlags: Long): SymbolTable.PackageClassSymbol
    Attributes
    protected
  69. def createPackageObjectClassSymbol(pos: SymbolTable.Position, newFlags: Long): SymbolTable.PackageObjectClassSymbol
    Attributes
    protected
  70. def createPackageSymbol(name: SymbolTable.TermName, pos: SymbolTable.Position, newFlags: Long): SymbolTable.ModuleSymbol
    Attributes
    protected
  71. def createRefinementClassSymbol(pos: SymbolTable.Position, newFlags: Long): SymbolTable.RefinementClassSymbol
    Attributes
    protected
  72. def createTypeSkolemSymbol(name: SymbolTable.TypeName, origin: AnyRef, pos: SymbolTable.Position, newFlags: Long): SymbolTable.TypeSkolem
    Attributes
    protected
  73. def createValueMemberSymbol(name: SymbolTable.TermName, pos: SymbolTable.Position, newFlags: Long): SymbolTable.TermSymbol
    Attributes
    protected
  74. def createValueParameterSymbol(name: SymbolTable.TermName, pos: SymbolTable.Position, newFlags: Long): SymbolTable.TermSymbol
    Attributes
    protected
  75. def deSkolemize: SymbolTable.Symbol

    If this symbol is a type parameter skolem (not an existential skolem!) its corresponding type parameter, otherwise this

  76. def debugFlagString: String
  77. def debugLocationString: String
  78. def decodedName: String

    The decoded name of the symbol, e.g.

    The decoded name of the symbol, e.g. == instead of $eq$eq.

  79. def defString: String

    String representation of symbol's definition.

    String representation of symbol's definition. It uses the symbol's raw info to avoid forcing types.

  80. def defStringSeenAs(info: SymbolTable.Type): String

    String representation of symbol's definition, using the supplied info rather than the symbol's.

  81. def deprecatedInheritanceMessage: Option[String]
  82. def deprecatedInheritanceVersion: Option[String]
  83. def deprecatedOverridingMessage: Option[String]
  84. def deprecatedOverridingVersion: Option[String]
  85. def deprecatedParamName: Option[SymbolTable.TermName]
  86. def deprecatedParamVersion: Option[String]
  87. def deprecationMessage: Option[String]
  88. def deprecationVersion: Option[String]
  89. def derivedValueClassUnbox: SymbolTable.Symbol

    If this is a derived value class, return its unbox method or NoSymbol if it does not exist.

  90. def effectiveOwner: SymbolTable.Symbol

    The owner, skipping package objects.

  91. def elisionLevel: Option[Int]
  92. def enclClass: SymbolTable.Symbol

    The next enclosing class.

  93. def enclClassChain: List[SymbolTable.Symbol]
  94. def enclMethod: SymbolTable.Symbol

    The next enclosing method.

  95. def enclosingPackage: SymbolTable.Symbol

    The package containing this symbol, or NoSymbol if there is not one.

  96. def enclosingPackageClass: SymbolTable.Symbol

    The package class containing this symbol, or NoSymbol if there is not one.

    The package class containing this symbol, or NoSymbol if there is not one. TODO: formulate as enclosingSuchThat, after making sure we can start with current symbol rather than owner. TODO: Also harmonize with enclClass, enclMethod etc.

  97. def enclosingRootClass: SymbolTable.Symbol

    The package class containing this symbol, or NoSymbol if there is not one.

  98. final def enclosingSuchThat(p: (SymbolTable.Symbol) ⇒ Boolean): SymbolTable.Symbol
    Annotations
    @inline()
  99. def enclosingTopLevelClass: SymbolTable.Symbol

    The top-level class containing this symbol, using the current owner chain.

  100. def encodedName: String

    The name of the symbol before decoding, e.g.

    The name of the symbol before decoding, e.g. $eq$eq instead of ==.

  101. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  102. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  103. def existentialToString: String

    String representation of existentially bound variable

  104. def exists: Boolean
  105. def expandName(base: SymbolTable.Symbol): Unit

    change name by appending $$<fully-qualified-name-of-class base> Do the same for any accessed symbols or setters/getters.

    change name by appending $$<fully-qualified-name-of-class base> Do the same for any accessed symbols or setters/getters. Implementation in TermSymbol.

  106. final def extendedOverriddenSymbols: List[SymbolTable.Symbol]

    Returns all symbols overridden by this symbol, plus all matching symbols defined in parents of the selftype.

  107. def failIfStub(): Unit

    Raises a MissingRequirementError if this symbol is a StubSymbol

  108. def filter(cond: (SymbolTable.Symbol) ⇒ Boolean): SymbolTable.Symbol

    Filters the underlying alternatives (or a single-element list composed of the symbol itself if the symbol is not overloaded).

    Filters the underlying alternatives (or a single-element list composed of the symbol itself if the symbol is not overloaded). Returns an overloaded symbol is there are multiple matches. Returns a NoSymbol if there are no matches.

    Definition Classes
    SymbolSymbolApi
  109. def filterAnnotations(p: (SymbolTable.AnnotationInfo) ⇒ Boolean): Symbol.this.type
    Definition Classes
    SymbolAnnotatable
  110. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  111. def firstParam: SymbolTable.Symbol

    The first parameter to the first argument list of this method, or NoSymbol if inapplicable.

  112. def flagBitsToString(bits: Long): String
    Definition Classes
    HasFlags
  113. def flagMask: Long

    The default mask determining which flags to display.

    The default mask determining which flags to display.

    Definition Classes
    SymbolHasFlags
  114. def flagString(mask: Long): String
    Definition Classes
    HasFlags
  115. def flagString: String

    The printable representation of this entity's flags and access boundary, restricted to flags in the given mask.

    The printable representation of this entity's flags and access boundary, restricted to flags in the given mask.

    Definition Classes
    HasFlags
  116. final def flags: Long

    Though both Symbol and Modifiers widen this method to public, it's defined protected here to give us the option in the future to route flag methods through accessors and disallow raw flag manipulation.

    Though both Symbol and Modifiers widen this method to public, it's defined protected here to give us the option in the future to route flag methods through accessors and disallow raw flag manipulation. And after that, perhaps, on some magical day: a typesafe enumeration.

    Definition Classes
    SymbolHasFlags
  117. def flagsExplanationString: String
  118. def flags_=(fs: Long): Unit
  119. final def flatOwnerInfo: SymbolTable.Type

    Returns the rawInfo of the owner.

    Returns the rawInfo of the owner. If the current phase has flat classes, it first applies all pending type maps to this symbol.

    assume this is the ModuleSymbol for B in the following definition: package p { class A { object B { val x = 1 } } }

    The owner after flatten is "package p" (see "def owner"). The flatten type map enters symbol B in the decls of p. So to find a linked symbol ("object B" or "class B") we need to apply flatten to B first. Fixes #2470.

    Attributes
    protected
  120. def flattenedName: NameType
    Attributes
    protected[this]
  121. final def fold[T](none: ⇒ T)(f: (SymbolTable.Symbol) ⇒ T): T
    Annotations
    @inline()
  122. final def freshExistential(suffix: String, id: Int): SymbolTable.TypeSymbol
  123. def fullLocationString: String
  124. final def fullName: String

    The encoded full path name of this symbol, where outer names and inner names are separated by periods.

    The encoded full path name of this symbol, where outer names and inner names are separated by periods.

    Definition Classes
    SymbolSymbolApi
  125. final def fullName(separator: Char): String

    The encoded full path name of this symbol, where outer names and inner names are separated by separator characters.

    The encoded full path name of this symbol, where outer names and inner names are separated by separator characters. Never translates expansions of operators back to operator symbol. Never adds id. Drops package objects.

  126. def fullNameAsName(separator: Char): SymbolTable.Name
  127. def fullNameString: String
  128. def getAndRemoveAttachment[T](implicit arg0: ClassTag[T]): Option[T]
    Definition Classes
    Attachable
  129. def getAnnotation(cls: SymbolTable.Symbol): Option[SymbolTable.AnnotationInfo]
    Definition Classes
    Annotatable
  130. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  131. def getFlag(mask: Long): Long

    In our current architecture, symbols for top-level classes and modules are created as dummies.

    In our current architecture, symbols for top-level classes and modules are created as dummies. Package symbols just call newClass(name) or newModule(name) and consider their job done.

    In order for such a dummy to provide meaningful info (e.g. a list of its members), it needs to go through unpickling. Unpickling is a process of reading Scala metadata from ScalaSignature annotations and assigning it to symbols and types.

    A single unpickling session takes a top-level class or module, parses the ScalaSignature annotation and then reads metadata for the unpicklee, its companion (if any) and all their members recursively (i.e. the pickle not only contains info about directly nested classes/modules, but also about classes/modules nested into those and so on).

    Unpickling is triggered automatically whenever info (info in compiler parlance) is called. This happens because package symbols assign completer thunks to the dummies they create. Therefore metadata loading happens lazily and transparently.

    Almost transparently. Unfortunately metadata isn't limited to just signatures (i.e. lists of members). It also includes flags (which determine e.g. whether a class is sealed or not), annotations and privateWithin. This gives rise to unpleasant effects like in scala/bug#6277, when a flag test called on an uninitialize symbol produces incorrect results.

    One might think that the solution is simple: automatically call the completer whenever one needs flags, annotations and privateWithin - just like it's done for info. Unfortunately, this leads to weird crashes in scalac, and currently we can't attempt to fix the core of the compiler risk stability a few weeks before the final release. upd. Haha, "a few weeks before the final release". This surely sounds familiar :)

    However we do need to fix this for runtime reflection, since this idiosyncrasy is not something we'd like to expose to reflection users. Therefore a proposed solution is to check whether we're in a runtime reflection universe, and if yes and if we've not yet loaded the requested info, then to commence initialization.

  132. def getter: SymbolTable.Symbol
    Definition Classes
    SymbolContextApiImpl
  133. final def getterIn(base: SymbolTable.Symbol): SymbolTable.Symbol

    The getter of this value or setter definition in class base, or NoSymbol if none exists.

  134. def getterName: SymbolTable.TermName
  135. def hasAbstractFlag: Boolean
    Definition Classes
    HasFlags
  136. final def hasAccessBoundary: Boolean

    Does symbol have a private or protected qualifier set?

    Does symbol have a private or protected qualifier set?

    Definition Classes
    SymbolHasFlags
  137. def hasAccessorFlag: Boolean
    Definition Classes
    HasFlags
  138. final def hasAllFlags(mask: Long): Boolean

    Does symbol have ALL the flags in mask set?

    Does symbol have ALL the flags in mask set?

    Definition Classes
    SymbolHasFlags
  139. def hasAnnotation(cls: SymbolTable.Symbol): Boolean

    Tests for, get, or remove an annotation

    Tests for, get, or remove an annotation

    Definition Classes
    Annotatable
  140. def hasAttachment[T](implicit arg0: ClassTag[T]): Boolean
    Definition Classes
    Attachable
  141. def hasBridgeAnnotation: Boolean
  142. def hasCompleteInfo: Boolean
  143. def hasDefault: Boolean
    Definition Classes
    HasFlags
  144. def hasDeprecatedInheritanceAnnotation: Boolean
  145. def hasDeprecatedOverridingAnnotation: Boolean
  146. def hasFlag(mask: Int): Boolean
  147. final def hasFlag(mask: Long): Boolean

    Does symbol have ANY flag in mask set?

    Does symbol have ANY flag in mask set?

    Definition Classes
    SymbolHasFlags
  148. final def hasGetter: Boolean
  149. def hasJavaAnnotationFlag: Boolean
    Definition Classes
    HasFlags
  150. def hasJavaEnumFlag: Boolean
    Definition Classes
    HasFlags
  151. def hasMeaninglessName: Boolean

    If the name of the symbol's owner should be used when you care about seeing an interesting name: in such cases this symbol is e.g.

    If the name of the symbol's owner should be used when you care about seeing an interesting name: in such cases this symbol is e.g. a method parameter with a synthetic name, a constructor named "this", an object "package", etc. The kind string, if non-empty, will be phrased relative to the name of the owner.

  152. def hasMigrationAnnotation: Boolean
  153. def hasModuleFlag: Boolean
    Definition Classes
    HasFlags
  154. def hasNoFlags(mask: Long): Boolean

    Whether this entity has NONE of the flags in the given mask.

    Whether this entity has NONE of the flags in the given mask.

    Definition Classes
    HasFlags
  155. def hasOnlyBottomSubclasses: Boolean

    Can this symbol only be subclassed by bottom classes? This is assessed to be the case if it is final, and any type parameters are invariant.

  156. def hasPackageFlag: Boolean
    Definition Classes
    HasFlags
  157. def hasRawInfo: Boolean
  158. def hasSelfType: Boolean
  159. def hasStableFlag: Boolean
    Definition Classes
    HasFlags
  160. def hasStaticFlag: Boolean
    Definition Classes
    HasFlags
  161. def hasTransOwner(sym: SymbolTable.Symbol): Boolean

    Same as ownerChain contains sym but more efficient, and with a twist for refinement classes (see RefinementClassSymbol.)

  162. final def hasTypeAt(pid: Int): Boolean

    Was symbol's type updated during given phase?

  163. final def hasVolatileType: Boolean
  164. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  165. final val id: Int
  166. final def idString: String

    If settings.uniqid is set, the symbol's id, else ""

  167. def implicitAmbiguousMsg: Option[String]
  168. def implicitNotFoundMsg: Option[String]
  169. def info: SymbolTable.Type

    Get type info associated with symbol at current phase, after ensuring that symbol is initialized (i.e.

    Get type info associated with symbol at current phase, after ensuring that symbol is initialized (i.e. type is completed).

    Definition Classes
    SymbolSymbolApi
  170. def infoIn(site: SymbolTable.Type): SymbolTable.Type

    The type signature of this symbol seen as a member of given type site.

    The type signature of this symbol seen as a member of given type site.

    Definition Classes
    SymbolContextApiImplSymbolApi
  171. final def infoString(tp: SymbolTable.Type): String

    String representation of symbol's definition following its name

  172. def info_=(info: SymbolTable.Type): Unit
  173. def infosString: String
  174. def initFlags(mask: Long): Symbol.this.type

    Set the symbol's flags to the given value, asserting that the previous value was 0.

  175. final def initialize: Symbol.this.type

    Initialize the symbol

  176. def isAbstract: Boolean

    Is this symbol abstract (i.e.

    Is this symbol abstract (i.e. an abstract class, an abstract method, value or type member)?

    Definition Classes
    SymbolContextApiImplSymbolApi
  177. def isAbstractClass: Boolean

    These are all tests for varieties of ClassSymbol, which has these subclasses:

    These are all tests for varieties of ClassSymbol, which has these subclasses:

    • ModuleClassSymbol
    • RefinementClassSymbol
    • PackageClassSymbol (extends ModuleClassSymbol)
  178. def isAbstractOverride: Boolean
    Definition Classes
    HasFlags
  179. def isAbstractType: Boolean
  180. def isAccessor: Boolean

    Qualities of Terms, always false for TypeSymbols.

  181. def isAliasType: Boolean
  182. def isAnonOrRefinementClass: Boolean
  183. def isAnonymousClass: Boolean
  184. final def isAnonymousFunction: Boolean
  185. def isAnyOverride: Boolean
    Definition Classes
    HasFlags
  186. def isArtifact: Boolean
    Definition Classes
    HasFlags
  187. final def isAuxiliaryConstructor: Boolean

    Does this symbol denote an auxiliary constructor of its enclosing class?

  188. def isBottomClass: Boolean

    The bottom classes are Nothing and Null, found in Definitions.

  189. def isBottomSubClass(that: SymbolTable.Symbol): Boolean

    Is this class symbol Null or Nothing, and (if Null) is that inhabited by null? If this is Nothing, of course, it is a subclass of that by definition.

    Is this class symbol Null or Nothing, and (if Null) is that inhabited by null? If this is Nothing, of course, it is a subclass of that by definition.

    TODO - what is implied by the fact that AnyVal now has infinitely many non-bottom subclasses, not only 9?

  190. def isBridge: Boolean
  191. def isByNameParam: Boolean
    Definition Classes
    SymbolContextApiImpl
  192. def isCapturedVariable: Boolean
  193. def isCase: Boolean
    Definition Classes
    HasFlags
  194. def isCaseAccessor: Boolean
    Definition Classes
    HasFlags
  195. def isCaseAccessorMethod: Boolean

    Qualities of MethodSymbols, always false for TypeSymbols and other TermSymbols.

  196. final def isCaseApplyOrUnapply: Boolean

    Is this symbol a synthetic apply or unapply method in a companion object of a case class?

  197. def isCaseClass: Boolean
  198. final def isCaseCopy: Boolean

    Is this symbol a synthetic copy method in a case class?

  199. def isClass: Boolean

    Does this symbol represent the definition of a class or trait? If yes, isType is also guaranteed to be true.

    Does this symbol represent the definition of a class or trait? If yes, isType is also guaranteed to be true.

    Definition Classes
    SymbolApi
  200. def isClassConstructor: Boolean
  201. def isClassLocalToConstructor: Boolean
  202. def isCoDefinedWith(that: SymbolTable.Symbol): Boolean

    Is this symbol defined in the same scope and compilation unit as that symbol?

  203. def isCompileTimeOnly: Boolean
  204. def isConcreteClass: Boolean
  205. final def isConstant: Boolean

    Is this symbol a constant?

  206. def isConstructor: Boolean

    Does this method represent a constructor?

    Does this method represent a constructor?

    If owner is a class, then this is a vanilla JVM constructor. If owner is a trait, then this is a mixin constructor.

    Definition Classes
    SymbolSymbolApi
  207. def isContravariant: Boolean

    Qualities of Types, always false for TermSymbols.

  208. def isCovariant: Boolean
  209. def isDefaultGetter: Boolean
  210. def isDeferred: Boolean
    Definition Classes
    HasFlags
  211. final def isDefinedInPackage: Boolean
  212. final def isDelambdafyFunction: Boolean
  213. final def isDelambdafyTarget: Boolean
  214. def isDeprecated: Boolean
  215. final def isDerivedValueClass: Boolean
  216. def isEarlyInitialized: Boolean
  217. def isEffectiveRoot: Boolean

    Is this symbol an effective root for fullname string?

  218. final def isEffectivelyFinal: Boolean

    Is this symbol effectively final? I.e, it cannot be overridden

  219. final def isEffectivelyFinalOrNotOverridden: Boolean

    Is this symbol effectively final or a concrete term member of sealed class whose children do not override it

  220. def isEmptyPackage: Boolean
  221. def isEmptyPackageClass: Boolean
  222. def isEmptyPrefix: Boolean
  223. final def isErroneous: Boolean
  224. final def isError: Boolean
  225. def isExistential: Boolean
    Definition Classes
    SymbolContextApiImpl
  226. def isExistentialSkolem: Boolean
  227. def isExistentiallyBound: Boolean
  228. def isFBounded: Boolean
  229. def isField: Boolean
    Definition Classes
    SymbolContextApiImpl
  230. def isFinal: Boolean
    Definition Classes
    HasFlags
  231. def isFreeTerm: Boolean
    Definition Classes
    SymbolContextApiImpl
  232. def isFreeType: Boolean
    Definition Classes
    SymbolContextApiImpl
  233. def isGADTSkolem: Boolean
  234. def isGetter: Boolean
  235. def isHigherOrderTypeParameter: Boolean
  236. def isImplementationArtifact: Boolean

    Does this symbol represent an implementation artifact that isn't meant for public use? Examples of such artifacts are erasure bridges and outer fields.

    Does this symbol represent an implementation artifact that isn't meant for public use? Examples of such artifacts are erasure bridges and outer fields.

    Definition Classes
    SymbolContextApiImplSymbolApi
  237. def isImplicit: Boolean
    Definition Classes
    HasFlags
  238. def isInDefaultNamespace: Boolean
  239. final def isIncompleteIn(base: SymbolTable.Symbol): Boolean

    A a member of class base is incomplete if (1) it is declared deferred or (2) it is abstract override and its super symbol in base is nonexistent or incomplete.

  240. final def isInitialized: Boolean
  241. final def isInitializedToDefault: Boolean
  242. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  243. def isInterface: Boolean
    Definition Classes
    HasFlags
  244. final def isInterpreterWrapper: Boolean

    Does this symbol denote a wrapper created by the repl?

  245. def isInvariant: Boolean
  246. def isJava: Boolean

    Is this symbol defined by Java?

    Is this symbol defined by Java?

    Definition Classes
    SymbolContextApiImplSymbolApi
  247. def isJavaAnnotation: Boolean

    Does this symbol represent a java annotation interface?

    Does this symbol represent a java annotation interface?

    Definition Classes
    SymbolContextApiImplSymbolApi
  248. def isJavaDefined: Boolean
    Definition Classes
    HasFlags
  249. def isJavaEnum: Boolean

    Does this symbol represent a java enum class or a java enum value?

    Does this symbol represent a java enum class or a java enum value?

    Definition Classes
    SymbolContextApiImplSymbolApi
  250. def isJavaInterface: Boolean
  251. def isLabel: Boolean
    Definition Classes
    SymbolHasFlags
  252. def isLazy: Boolean
    Definition Classes
    HasFlags
  253. final def isLess(that: SymbolTable.Symbol): Boolean

    A total ordering between symbols that refines the class inheritance graph (i.e.

    A total ordering between symbols that refines the class inheritance graph (i.e. subclass.isLess(superclass) always holds). the ordering is given by: (_.isType, -_.baseTypeSeq.length) for type symbols, followed by id.

  254. def isLessAccessibleThan(other: SymbolTable.Symbol): Boolean
  255. def isLifted: Boolean
    Definition Classes
    HasFlags
  256. def isLiftedMethod: Boolean
  257. def isLocalClass: Boolean

    Is this class locally defined? A class is local, if

    Is this class locally defined? A class is local, if

    • it is anonymous, or
    • its owner is a value
    • it is defined within a local class
  258. def isLocalDummy: Boolean
  259. final def isLocalToBlock: Boolean

    Is this symbol defined in a block?

  260. def isLocalToThis: Boolean
    Definition Classes
    HasFlags
  261. final def isLocatable: Boolean

    Can this symbol be loaded by a reflective mirror?

    Can this symbol be loaded by a reflective mirror?

    Scalac relies on ScalaSignature' annotation to retain symbols across compilation runs. Such annotations (also called "pickles") are applied on top-level classes and include information about all symbols reachable from the annotee. However, local symbols (e.g. classes or definitions local to a block) are typically unreachable and information about them gets lost.

    This method is useful for macro writers who wish to save certain ASTs to be used at runtime. With isLocatable' it's possible to check whether a tree can be retained as is, or it needs special treatment.

  262. def isMacro: Boolean
    Definition Classes
    HasFlags
  263. def isMethod: Boolean

    Does this symbol represent the definition of a method? If yes, isTerm is also guaranteed to be true.

    Does this symbol represent the definition of a method? If yes, isTerm is also guaranteed to be true.

    Definition Classes
    SymbolApi
  264. final def isMethodWithExtension: Boolean
  265. def isMixinConstructor: Boolean
  266. def isModule: Boolean

    Does this symbol represent the definition of a module (i.e.

    Does this symbol represent the definition of a module (i.e. it results from an object definition?). If yes, isTerm is also guaranteed to be true.

    Definition Classes
    SymbolApi
  267. def isModuleClass: Boolean

    Does this symbol represent the definition of a class implicitly associated with an object definition (module class in scala compiler parlance)? If yes, isType is also guaranteed to be true.

    Does this symbol represent the definition of a class implicitly associated with an object definition (module class in scala compiler parlance)? If yes, isType is also guaranteed to be true.

    Definition Classes
    SymbolApi
  268. def isModuleNotMethod: Boolean

    Nested modules with a non-static owner receive the METHOD flag during UnCurry's info transform.

    Nested modules with a non-static owner receive the METHOD flag during UnCurry's info transform. (They are replaced by a ClassDef and DefDef for the module accessor during the fields phase.)

    Note: the METHOD flag is added lazily in the info transformer of the UnCurry phase. This means that forcing the sym.info may change the value of sym.isMethod. Forcing the info is in the responsibility of the caller. Doing it eagerly here was tried (0ccdb151f) but has proven to lead to bugs (scala/bug#8907).

    Here's an example where one can see all four of FF FT TF TT for (isStatic, isMethod) at various phases.

    trait A1 { case class Quux() } object A2 extends A1 { object Flax } // -- namer object Quux in trait A1 // -M flatten object Quux in trait A1 // S- flatten object Flax in object A2 // -M posterasure object Quux in trait A1 // -M jvm object Quux in trait A1 // SM jvm object Quux in object A2

    So "isModuleNotMethod" exists not for its achievement in brevity, but to encapsulate the relevant condition.

  269. def isModuleOrModuleClass: Boolean
  270. final def isModuleVar: Boolean
  271. final def isMonomorphicType: Boolean

    Is symbol a monomorphic type? assumption: if a type starts out as monomorphic, it will not acquire type parameters in later phases.

  272. def isMutable: Boolean
    Definition Classes
    HasFlags
  273. def isMutableVal: Boolean
    Definition Classes
    SymbolContextApiImpl
  274. def isNestedClass: Boolean

    Is this class nested in another class or module (not a package).

    Is this class nested in another class or module (not a package). Includes locally defined classes.

  275. final def isNestedIn(that: SymbolTable.Symbol): Boolean

    A partial ordering between symbols.

    A partial ordering between symbols. (this isNestedIn that) holds iff this symbol is defined within a class or method defining that symbol

  276. def isNonBottomSubClass(that: SymbolTable.Symbol): Boolean

    Is this class symbol a subclass of that symbol, and is this class symbol also different from Null or Nothing?

  277. def isNonClassType: Boolean

    A Type, but not a Class.

  278. final def isNumericSubClass(that: SymbolTable.Symbol): Boolean
  279. def isNumericValueClass: Boolean
  280. final def isOmittablePrefix: Boolean

    Conditions where we omit the prefix when printing a symbol, to avoid unpleasantries like Predef.String, $iw.$iw.Foo and <empty>.Bippy.

  281. def isOnlyRefinementMember: Boolean

    Is this a term symbol only defined in a refinement (so that it needs to be accessed by reflection)?

  282. final def isOuterAccessor: Boolean

    Is this symbol an accessor method for outer?

  283. final def isOuterField: Boolean

    Is this symbol an accessor method for outer?

  284. final def isOuterParam: Boolean

    Is this symbol an outer parameter in a constructor

  285. def isOverloaded: Boolean
  286. def isOverloadedMethod: Boolean

    Used to provide a better error message for asMethod.

    Used to provide a better error message for asMethod.

    Attributes
    protected
    Definition Classes
    SymbolApi
  287. final def isOverridableMember: Boolean
  288. def isOverride: Boolean
    Definition Classes
    HasFlags
  289. final def isOverridingSymbol: Boolean
  290. def isPackageClass: Boolean

    Package/package object tests

    Package/package object tests

    Definition Classes
    SymbolSymbolApi
  291. def isPackageObject: Boolean
  292. def isPackageObjectClass: Boolean
  293. def isPackageObjectOrClass: Boolean
  294. def isParamAccessor: Boolean
    Definition Classes
    HasFlags
  295. def isParamWithDefault: Boolean
    Definition Classes
    SymbolContextApiImpl
  296. def isParameter: Boolean
    Definition Classes
    HasFlags
  297. final def isPatternTypeVariable: Boolean
  298. final def isPossibleInRefinement: Boolean
  299. final def isPrimaryConstructor: Boolean

    Does this symbol denote the primary constructor of its enclosing class?

  300. def isPrimitiveValueClass: Boolean
  301. def isPrivate: Boolean
    Definition Classes
    HasFlags
  302. def isPrivateLocal: Boolean
    Definition Classes
    HasFlags
  303. def isPrivateThis: Boolean

    Does this symbol represent a declaration or definition written in a source file as private[this] or generated in tree/symbol form with the combination of flags LOCAL and PRIVATE? If yes, isPrivate is guaranteed to be true.

    Does this symbol represent a declaration or definition written in a source file as private[this] or generated in tree/symbol form with the combination of flags LOCAL and PRIVATE? If yes, isPrivate is guaranteed to be true.

    Definition Classes
    SymbolContextApiImplSymbolApi
  304. def isProtected: Boolean
    Definition Classes
    HasFlags
  305. def isProtectedLocal: Boolean
    Definition Classes
    HasFlags
  306. def isProtectedThis: Boolean

    Does this symbol represent a declaration or definition written in a source file as protected[this] or generated in tree/symbol form with the combination of flags LOCAL and PROTECTED? If yes, isProtected is guaranteed to be true,

    Does this symbol represent a declaration or definition written in a source file as protected[this] or generated in tree/symbol form with the combination of flags LOCAL and PROTECTED? If yes, isProtected is guaranteed to be true,

    Definition Classes
    SymbolContextApiImplSymbolApi
  307. def isPublic: Boolean
    Definition Classes
    HasFlags
  308. def isRefinementClass: Boolean
  309. def isRoot: Boolean

    Overridden in custom objects in Definitions

  310. def isRootPackage: Boolean
  311. def isRootSymbol: Boolean
  312. def isSealed: Boolean
    Definition Classes
    HasFlags
  313. def isSerializable: Boolean
  314. def isSetter: Boolean
  315. def isSetterParameter: Boolean
  316. def isSingletonExistential: Boolean
  317. def isSkolem: Boolean
  318. def isSourceMethod: Boolean
  319. def isSpecialized: Boolean
    Definition Classes
    HasFlags
  320. final def isStable: Boolean

    Does this symbol denote a stable value, ignoring volatility?

    Does this symbol denote a stable value, ignoring volatility?

    Stability and volatility are checked separately to allow volatile paths in patterns that amount to equality checks. scala/bug#6815

  321. def isStatic: Boolean

    Is this symbol static (i.e.

    Is this symbol static (i.e. with no outer instance)? Q: When exactly is a sym marked as STATIC? A: If it's a member of a toplevel object, or of an object contained in a toplevel object, or any number of levels deep. http://groups.google.com/group/scala-internals/browse_thread/thread/d385bcd60b08faf6

    TODO: should this only be invoked on class / module symbols? because there's also isStaticMember.

    Note: the result of isStatic changes over time.

    • Lambdalift local definitions to the class level, the owner field is modified. object T { def foo { object O } } After lambdalift, the OModule.isStatic is true.
    • After flatten, nested classes are moved to the package level. Invoking owner on a class returns a package class, for which isStaticOwner is true. For example, class C { object O } OModuleClass.isStatic is true after flatten. Using phase travel to get before flatten, method owner returns the class C.

    Why not make a stable version of isStatic? Maybe some parts of the compiler depend on the current implementation.

    Definition Classes
    SymbolSymbolApi
  322. final def isStaticConstructor: Boolean

    Is this symbol a static constructor?

  323. final def isStaticMember: Boolean

    Is this symbol a static member of its class? (i.e.

    Is this symbol a static member of its class? (i.e. needs to be implemented as a Java static?)

  324. def isStaticModule: Boolean
  325. final def isStaticOwner: Boolean

    Does this symbol denote a class that defines static symbols?

  326. def isStrictFP: Boolean
  327. final def isStructuralRefinement: Boolean

    Is this class or type defined as a structural refinement type?

  328. final def isStructuralRefinementMember: Boolean
  329. def isSubClass(that: SymbolTable.Symbol): Boolean

    Overridden in NullClass and NothingClass for custom behavior.

  330. def isSuperAccessor: Boolean
    Definition Classes
    HasFlags
  331. def isSynthetic: Boolean
    Definition Classes
    HasFlags
  332. def isTerm: Boolean

    Does this symbol represent the definition of a term? Note that every symbol is either a term or a type.

    Does this symbol represent the definition of a term? Note that every symbol is either a term or a type. So for every symbol sym (except for NoSymbol), either sym.isTerm is true or sym.isType is true.

    Definition Classes
    SymbolApi
  333. def isTermMacro: Boolean
  334. final def isThisSym: Boolean
  335. def isThreadsafe(purpose: SymbolTable.SymbolOps): Boolean

    We consider a symbol to be thread-safe, when multiple concurrent threads can call its methods (either directly or indirectly via public reflection or internal compiler infrastructure), without any locking and everything works as it should work.

    We consider a symbol to be thread-safe, when multiple concurrent threads can call its methods (either directly or indirectly via public reflection or internal compiler infrastructure), without any locking and everything works as it should work.

    In its basic form, isThreadsafe always returns false. Runtime reflection augments reflection infrastructure with threadsafety-tracking mechanism implemented in SynchronizedSymbol that communicates with underlying completers and can sometimes return true if the symbol has been completed to the point of thread safety.

    The purpose parameter signifies whether we want to just check immutability of certain flags for the given mask. This is necessary to enable robust auto-initialization of Symbol.flags for runtime reflection, and is also quite handy in avoiding unnecessary initializations when requesting for flags that have already been set.

  336. final def isTopLevel: Boolean

    Is this symbol owned by a package?

  337. def isTrait: Boolean
    Definition Classes
    SymbolHasFlags
  338. def isTraitOrInterface: Boolean
    Definition Classes
    HasFlags
  339. def isType: Boolean

    Does this symbol represent the definition of a type? Note that every symbol is either a term or a type.

    Does this symbol represent the definition of a type? Note that every symbol is either a term or a type. So for every symbol sym (except for NoSymbol), either sym.isTerm is true or sym.isType is true.

    Definition Classes
    SymbolApi
  340. def isTypeParameter: Boolean
  341. def isTypeParameterOrSkolem: Boolean
  342. def isTypeSkolem: Boolean
  343. def isVal: Boolean
    Definition Classes
    SymbolContextApiImpl
  344. def isValue: Boolean
  345. def isValueParameter: Boolean
  346. def isVar: Boolean
    Definition Classes
    SymbolContextApiImpl
  347. def isVarargsMethod: Boolean
  348. def isVariable: Boolean
  349. final def isWeakSubClass(that: SymbolTable.Symbol): Boolean
  350. def javaBinaryName: SymbolTable.Name
  351. def javaBinaryNameString: String
  352. def javaClassName: String
  353. def javaSimpleName: SymbolTable.Name

    These should be moved somewhere like JavaPlatform.

  354. final def keyString: String

    String representation of symbol's definition key word

  355. final def kindString: String
  356. def knownDirectSubclasses: Set[SymbolTable.Symbol]
    Definition Classes
    SymbolContextApiImpl
  357. def linkedClassOfClass: SymbolTable.Symbol

    For a module class: its linked class For a plain class: the module class of its linked module.

    For a module class: its linked class For a plain class: the module class of its linked module.

    class Foo <-- linkedClassOfClass --> class Foo$

  358. def localName: SymbolTable.TermName
  359. def locationString: String

    String representation of location, plus a preposition.

    String representation of location, plus a preposition. Doesn't do much, for backward compatibility reasons.

  360. final def logicallyEnclosingMember: SymbolTable.Symbol

    The method or class which logically encloses the current symbol.

    The method or class which logically encloses the current symbol. If the symbol is defined in the initialization part of a template this is the template's primary constructor, otherwise it is the physically enclosing method or class.

    Example 1:

    def f() { val x = { def g() = ...; g() } }

    In this case the owner chain of g is x, followed by f and g.logicallyEnclosingMember == f.

    Example 2:

    class C { def <init> = { ... } val x = { def g() = ...; g() } } }

    In this case the owner chain of g is x, followed by C but g.logicallyEnclosingMember is the primary constructor symbol <init> (or, for traits: $init) of C.

  361. final def makeNotPrivate(base: SymbolTable.Symbol): Unit

    Remove private modifier from symbol syms definition.

    Remove private modifier from symbol syms definition. If sym is a is not a constructor nor a static module rename it by expanding its name to avoid name clashes

    base

    the fully qualified name of this class will be appended if name expansion is needed

  362. def makePublic: SymbolTable.Symbol

    Remove any access boundary and clear flags PROTECTED | PRIVATE.

  363. def makeSerializable(): Unit

    Adds the interface scala.Serializable to the parents of a ClassInfoType.

    Adds the interface scala.Serializable to the parents of a ClassInfoType. Note that the tree also has to be updated accordingly.

  364. final def map(f: (SymbolTable.Symbol) ⇒ SymbolTable.Symbol): SymbolTable.Symbol

    If this is a NoSymbol, returns NoSymbol, otherwise returns the result of applying f to this symbol.

    If this is a NoSymbol, returns NoSymbol, otherwise returns the result of applying f to this symbol.

    Definition Classes
    SymbolSymbolApi
    Annotations
    @inline()
  365. def markAllCompleted(): Symbol.this.type
  366. def markFlagsCompleted(mask: Long): Symbol.this.type
  367. final def matchingSymbol(site: SymbolTable.Type, admit: Long = 0L): SymbolTable.Symbol

    The non-private member of site whose type and name match the type of this symbol.

  368. final def matchingSymbol(ofclazz: SymbolTable.Symbol, site: SymbolTable.Type): SymbolTable.Symbol

    The non-private symbol whose type matches the type of this symbol in in given class.

    The non-private symbol whose type matches the type of this symbol in in given class.

    ofclazz

    The class containing the symbol's definition

    site

    The base type from which member types are computed

  369. def maybeInitialize: Boolean
  370. def migrationMessage: Option[String]
  371. def migrationVersion: Option[String]
  372. def mixinClasses: List[SymbolTable.Symbol]

    The directly or indirectly inherited mixins of this class except for mixin classes inherited by the superclass.

    The directly or indirectly inherited mixins of this class except for mixin classes inherited by the superclass. Mixin classes appear in linearization order.

  373. def modifyInfo(f: (SymbolTable.Type) ⇒ SymbolTable.Type): Symbol.this.type

    Modifies this symbol's info in place.

  374. def module: SymbolTable.Symbol
    Definition Classes
    SymbolContextApiImpl
  375. def moduleClass: SymbolTable.Symbol

    The module class corresponding to this module.

  376. def moduleSuffix: String
  377. final def name: NameType

    The name of the symbol as a member of the Name type.

    The name of the symbol as a member of the Name type.

    Definition Classes
    SymbolSymbolApi
  378. def nameString: String

    String representation of symbol's simple name.

    String representation of symbol's simple name. If !settings.debug translates expansions of operators back to operator symbol. E.g. $eq => =. If settings.uniqid, adds id. If settings.Yshowsymowners, adds owner's id If settings.Yshowsymkinds, adds abbreviated symbol kind.

  379. def name_=(n: SymbolTable.Name): Unit
  380. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  381. def needsExpandedSetterName: Boolean
  382. final def needsFlatClasses: Boolean
  383. def needsModuleSuffix: Boolean

    Whether this symbol needs nme.MODULE_SUFFIX_STRING (aka $) appended on the java platform.

  384. final def newAbstractType(name: SymbolTable.TypeName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.AbstractTypeSymbol

    Symbol of an abstract type type T >: ...

    Symbol of an abstract type type T >: ... <: ...

  385. final def newAliasType(name: SymbolTable.TypeName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.AliasTypeSymbol

    Symbol of a type definition type T = ...

  386. final def newAnonymousFunctionClass(pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.ClassSymbol
  387. final def newAnonymousFunctionValue(pos: SymbolTable.Position, newFlags: Long = 0L): SymbolTable.TermSymbol
  388. final def newClass(name: SymbolTable.TypeName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.ClassSymbol
  389. def newClassConstructor(pos: SymbolTable.Position): SymbolTable.MethodSymbol

    Instance constructor with info set.

  390. final def newClassSymbol(name: SymbolTable.TypeName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.ClassSymbol
  391. def newClassWithInfo(name: SymbolTable.TypeName, parents: List[SymbolTable.Type], scope: SymbolTable.Scope, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.ClassSymbol

    A new class with its info set to a ClassInfoType with given scope and parents.

  392. final def newConstructor(pos: SymbolTable.Position, newFlags: Long = 0L): SymbolTable.MethodSymbol

    Propagates ConstrFlags (JAVA, specifically) from owner to constructor.

  393. final def newErrorClass(name: SymbolTable.TypeName): SymbolTable.ClassSymbol
  394. final def newErrorSymbol(name: SymbolTable.Name): SymbolTable.Symbol
  395. final def newErrorValue(name: SymbolTable.TermName): SymbolTable.TermSymbol
  396. final def newExistential(name: SymbolTable.TypeName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.TypeSymbol

    Symbol of an existential type T forSome { ...

    Symbol of an existential type T forSome { ... }

  397. def newExistentialSkolem(name: SymbolTable.TypeName, info: SymbolTable.Type, flags: Long, pos: SymbolTable.Position, origin: AnyRef): SymbolTable.TypeSkolem

    Create a new existential type skolem with this symbol its owner, and the given other properties.

  398. def newExistentialSkolem(basis: SymbolTable.Symbol, origin: AnyRef): SymbolTable.TypeSkolem

    Create a new existential type skolem with this symbol its owner, based on the given symbol and origin.

  399. def newGADTSkolem(name: SymbolTable.TypeName, origin: SymbolTable.Symbol, info: SymbolTable.Type): SymbolTable.TypeSkolem
  400. final def newImport(pos: SymbolTable.Position): SymbolTable.TermSymbol
  401. final def newLabel(name: SymbolTable.TermName, pos: SymbolTable.Position = NoPosition): SymbolTable.MethodSymbol
  402. def newLinkedModule(moduleClass: SymbolTable.Symbol, newFlags: Long = 0L): SymbolTable.ModuleSymbol
  403. final def newLocalDummy(pos: SymbolTable.Position): SymbolTable.TermSymbol

    Create local dummy for template (owner of local blocks)

  404. final def newMethod(name: SymbolTable.TermName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.MethodSymbol
  405. final def newMethodSymbol(name: SymbolTable.TermName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.MethodSymbol
  406. final def newModule(name: SymbolTable.TermName, pos: SymbolTable.Position = NoPosition, newFlags0: Long = 0L): SymbolTable.ModuleSymbol
  407. final def newModuleAndClassSymbol(name: SymbolTable.Name, pos: SymbolTable.Position, flags0: SymbolTable.FlagSet): (SymbolTable.ModuleSymbol, SymbolTable.ClassSymbol)
  408. final def newModuleClass(name: SymbolTable.TypeName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.ModuleClassSymbol
  409. final def newModuleClassSymbol(name: SymbolTable.TypeName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.ModuleClassSymbol
  410. final def newModuleSymbol(name: SymbolTable.TermName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.ModuleSymbol
  411. def newNestedSymbol(name: SymbolTable.Name, pos: SymbolTable.Position, newFlags: Long, isClass: Boolean): SymbolTable.Symbol
    Definition Classes
    SymbolContextApiImpl
  412. final def newNonClassSymbol(name: SymbolTable.TypeName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.TypeSymbol
  413. final def newOverloaded(pre: SymbolTable.Type, alternatives: List[SymbolTable.Symbol]): SymbolTable.TermSymbol

    pre

    type relative to which alternatives are seen. for instance: class C[T] { def m(x: T): T def m'(): T } val v: C[Int] Then v.m has symbol TermSymbol(flags = {OVERLOADED}, tpe = OverloadedType(C[Int], List(m, m'))) You recover the type of m doing a m.tpe.asSeenFrom(pre, C) (generally, owner of m, which is C here). or: pre.memberType(m)

  414. final def newPackage(name: SymbolTable.TermName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.ModuleSymbol
  415. final def newRefinementClass(pos: SymbolTable.Position): SymbolTable.RefinementClassSymbol

    Refinement types P { val x: String; type T <: Number } also have symbols, they are refinementClasses

  416. def newStaticConstructor(pos: SymbolTable.Position): SymbolTable.MethodSymbol

    Static constructor with info set.

  417. def newStubSymbol(name: SymbolTable.Name, missingMessage: String): SymbolTable.Symbol

    Creates a placeholder symbol for when a name is encountered during unpickling for which there is no corresponding classfile.

    Creates a placeholder symbol for when a name is encountered during unpickling for which there is no corresponding classfile. This defers failure to the point when that name is used for something, which is often to the point of never.

  418. def newSyntheticTypeParam(name: String, newFlags: Long): SymbolTable.TypeSymbol
  419. def newSyntheticTypeParams(num: Int): List[SymbolTable.TypeSymbol]
  420. final def newSyntheticValueParam(argtype: SymbolTable.Type, name: SymbolTable.TermName = nme.syntheticParamName(1)): SymbolTable.TermSymbol

    Synthetic value parameter when parameter symbol is not available.

    Synthetic value parameter when parameter symbol is not available. Calling this method multiple times will re-use the same parameter name.

  421. final def newSyntheticValueParams(argtypes: List[SymbolTable.Type], freshName: () ⇒ SymbolTable.TermName): List[SymbolTable.TermSymbol]
  422. final def newSyntheticValueParams(argtypes: List[SymbolTable.Type]): List[SymbolTable.TermSymbol]

    Synthetic value parameters when parameter symbols are not available.

    Synthetic value parameters when parameter symbols are not available. Calling this method multiple times will re-use the same parameter names.

  423. final def newTermSymbol(name: SymbolTable.TermName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.TermSymbol
  424. final def newThisSym(name: SymbolTable.TermName = nme.this_, pos: SymbolTable.Position = NoPosition): SymbolTable.TermSymbol
  425. final def newTypeParameter(name: SymbolTable.TypeName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.TypeSymbol

    Symbol of a type parameter

  426. final def newTypeSkolem: SymbolTable.TypeSkolem

    Type skolems are type parameters seen from the inside Assuming a polymorphic method m[T], its type is a PolyType which has a TypeParameter with name T in its typeParams list.

    Type skolems are type parameters seen from the inside Assuming a polymorphic method m[T], its type is a PolyType which has a TypeParameter with name T in its typeParams list. While type checking the parameters, result type and body of the method, there's a local copy of T which is a TypeSkolem.

  427. final def newTypeSkolemSymbol(name: SymbolTable.TypeName, origin: AnyRef, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.TypeSkolem
  428. def newTypeSymbol(name: SymbolTable.TypeName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.TypeSymbol
  429. final def newValue(name: SymbolTable.TermName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.TermSymbol
  430. final def newValueParameter(name: SymbolTable.TermName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.TermSymbol
  431. final def newVariable(name: SymbolTable.TermName, pos: SymbolTable.Position = NoPosition, newFlags: Long = 0L): SymbolTable.TermSymbol
  432. def nextOverriddenSymbol: SymbolTable.Symbol

    Equivalent to allOverriddenSymbols.head (or NoSymbol if no overrides) but more efficient.

  433. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  434. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  435. final def orElse(alt: ⇒ SymbolTable.Symbol): SymbolTable.Symbol

    Provides an alternate if symbol is a NoSymbol.

    Provides an alternate if symbol is a NoSymbol.

    Definition Classes
    SymbolSymbolApi
    Annotations
    @inline()
  436. def originalEnclosingTopLevelClassOrDummy: SymbolTable.Symbol

    The top-level class or local dummy symbol containing this symbol, using the original owner chain.

  437. def originalInfo: SymbolTable.Type
  438. def originalOwner: SymbolTable.Symbol

    The initial owner of this symbol.

  439. final def outerClass: SymbolTable.Symbol

    The class that is logically an outer class of given clazz.

    The class that is logically an outer class of given clazz. This is the enclosing class, except for classes defined locally to constructors, where it is the outer class of the enclosing class.

  440. def outerSource: SymbolTable.Symbol

    For an outer accessor: The class from which the outer originates.

    For an outer accessor: The class from which the outer originates. For all other symbols: NoSymbol

  441. final def overriddenSymbol(baseClass: SymbolTable.Symbol): SymbolTable.Symbol

    The symbol, in class baseClass, that is overridden by this symbol.

    The symbol, in class baseClass, that is overridden by this symbol.

    baseClass

    is a base class of this symbol's owner.

  442. def overrideChain: collection.immutable.List[SymbolTable.Symbol]
  443. def overrides: List[SymbolTable.Symbol]

    Returns all symbols overridden by this symbol.

    Returns all symbols overridden by this symbol.

    Definition Classes
    SymbolContextApiImplSymbolApi
  444. final def overridingSymbol(ofclazz: SymbolTable.Symbol): SymbolTable.Symbol

    The symbol overriding this symbol in given subclass ofclazz.

    The symbol overriding this symbol in given subclass ofclazz.

    ofclazz

    is a subclass of this symbol's owner

  445. def owner: SymbolTable.Symbol

    The owner of a symbol.

    The owner of a symbol. Changes over time to adapt to the structure of the trees:

    • Up to lambdalift, the owner is the lexically enclosing definition. For definitions in a local block, the owner is also the next enclosing definition.
    • After lambdalift, all local method and class definitions (those not owned by a class or package class) change their owner to the enclosing class. This is done through a destructive "sym.owner = sym.owner.enclClass". The old owner is saved by saveOriginalOwner.
    • After flatten, all classes are owned by a PackageClass. This is done through a phase check (if after flatten) in the (overridden) method "def owner" in ModuleSymbol / ClassSymbol. The rawowner field is not modified.
    • Owners are also changed in other situations, for example when moving trees into a new lexical context, e.g. in the named/default arguments transformation, or when translating extension method definitions.

    In general when seeking the owner of a symbol, one should call owner. The other possibilities include:

    • call safeOwner if it is expected that the target may be NoSymbol
    • call assertOwner if it is an unrecoverable error if the target is NoSymbol

    owner behaves like safeOwner, but logs NoSymbol.owner calls under -Xdev. assertOwner aborts compilation immediately if called on NoSymbol.

    Definition Classes
    SymbolSymbolApi
  446. def ownerChain: List[SymbolTable.Symbol]
  447. def owner_=(owner: SymbolTable.Symbol): Unit
  448. def ownersIterator: Iterator[SymbolTable.Symbol]
  449. def ownsString: String

    String representation of location.

  450. def packageObject: SymbolTable.Symbol

    The package object symbol corresponding to this package or package class symbol, or NoSymbol otherwise

  451. def paramLists: List[List[SymbolTable.Symbol]]
    Definition Classes
    SymbolContextApiImpl
  452. def paramPos: Int

    The sequence number of this parameter symbol among all type and value parameters of symbol's owner.

    The sequence number of this parameter symbol among all type and value parameters of symbol's owner. -1 if symbol does not appear among the parameters of its owner.

  453. def paramss: List[List[SymbolTable.Symbol]]

    The value parameter sections of this symbol.

  454. def parentSymbols: List[SymbolTable.Symbol]
  455. def parentSymbolsIterator: Iterator[SymbolTable.Symbol]
  456. def pos: SymbolTable.Position
    Definition Classes
    Attachable
  457. def pos_=(pos: SymbolTable.Position): Unit
    Definition Classes
    Attachable
  458. def primaryConstructor: SymbolTable.Symbol

    The primary constructor of a class.

  459. def privateWithin: SymbolTable.Symbol

    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.

    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

    Definition Classes
    SymbolHasFlagsSymbolApi
  460. def privateWithin_=(sym: SymbolTable.Symbol): Unit
  461. def rawFlagString: String
  462. def rawFlagString(mask: Long): String
  463. def rawInfo: SymbolTable.Type

    Return info without checking for initialization or completing

  464. final def rawInfoIsNoType: Boolean
  465. val rawatt: Attachments { type Pos = Symbols.this.Position }
    Attributes
    protected
    Definition Classes
    Attachable
  466. final def rawflags: Long
  467. def rawflags_=(x: Long): Unit
  468. final def rawname: NameType
  469. final def rawowner: SymbolTable.Symbol
  470. def removeAnnotation(cls: SymbolTable.Symbol): SymbolTable.Symbol
    Definition Classes
    Annotatable
  471. def removeAttachment[T](implicit arg0: ClassTag[T]): Symbol.this.type
    Definition Classes
    Attachable
  472. def reset(completer: SymbolTable.Type): Symbol.this.type

    Reset symbol to initial state

  473. def resetFlag(mask: Long): Symbol.this.type
  474. def resetFlags(): Unit
  475. def resolveOverloadedFlag(flag: Long): String

    Default implementation calls the generic string function, which will print overloaded flags as <flag1/flag2/flag3>.

    Default implementation calls the generic string function, which will print overloaded flags as <flag1/flag2/flag3>. Subclasses of Symbol refine.

    Definition Classes
    SymbolHasFlags
  476. final def safeOwner: SymbolTable.Symbol
  477. final def sealedChildren: Set[SymbolTable.Symbol]
  478. final def sealedDescendants: Set[SymbolTable.Symbol]

    Recursively assemble all children of this symbol.

  479. final def sealedSortName: String

    The String used to order otherwise identical sealed symbols.

    The String used to order otherwise identical sealed symbols. This uses data which is stable across runs and variable classpaths (the initial Name) before falling back on id, which varies depending on exactly when a symbol is loaded.

  480. def selfType: SymbolTable.Type
    Definition Classes
    SymbolContextApiImpl
  481. def setAnnotations(annots: List[SymbolTable.AnnotationInfo]): Symbol.this.type
    Definition Classes
    SymbolAnnotatable
  482. def setAnnotations(annots: SymbolTable.AnnotationInfo*): Symbol.this.type
    Definition Classes
    SymbolContextApiImpl
  483. def setAttachments(attachments: Attachments { type Pos = Symbols.this.Position }): Symbol.this.type
    Definition Classes
    Attachable
  484. def setFlag(mask: Long): Symbol.this.type
  485. def setInfo(info: SymbolTable.Type): Symbol.this.type

    Set initial info.

  486. def setInfoAndEnter(info: SymbolTable.Type): Symbol.this.type

    Set the info and enter this symbol into the owner's scope.

  487. def setInfoOwnerAdjusted(info: SymbolTable.Type): Symbol.this.type
  488. def setName(name: SymbolTable.Name): Symbol.this.type
  489. def setPos(newpos: SymbolTable.Position): Symbol.this.type
    Definition Classes
    Attachable
  490. def setPrivateWithin(sym: SymbolTable.Symbol): Symbol.this.type
  491. def setter: SymbolTable.Symbol
    Definition Classes
    SymbolContextApiImpl
  492. final def setterIn(base: SymbolTable.Symbol, hasExpandedName: Boolean = needsExpandedSetterName): SymbolTable.Symbol

    The setter of this value or getter definition, or NoSymbol if none exists.

  493. def setterName: SymbolTable.TermName
  494. def setterNameInBase(base: SymbolTable.Symbol, expanded: Boolean): SymbolTable.TermName
  495. def shortSymbolClass: String
  496. def signatureString: String
  497. final def simpleName: SymbolTable.Name

    The simple name of this Symbol

  498. final def skipConstructor: SymbolTable.Symbol

    If this is a constructor, its owner: otherwise this.

  499. def skipPackageObject: SymbolTable.Symbol

    If this is a package object or its implementing class, its owner: otherwise this.

  500. final def sourceFile: AbstractFile
  501. def sourceModule: SymbolTable.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.

  502. def sourceModule_=(sym: SymbolTable.Symbol): Unit
  503. def staticAnnotations: collection.immutable.List[SymbolTable.AnnotationInfo]
    Definition Classes
    Annotatable
  504. def substInfo(syms0: List[SymbolTable.Symbol], syms1: List[SymbolTable.Symbol]): Symbol.this.type

    Substitute second list of symbols for first in current info.

    Substitute second list of symbols for first in current info.

    NOTE: this discards the type history (uses setInfo)

  505. def suchThat(cond: (SymbolTable.Symbol) ⇒ Boolean): SymbolTable.Symbol

    Does the same as filter, but crashes if there are multiple matches.

    Does the same as filter, but crashes if there are multiple matches.

    Definition Classes
    SymbolSymbolApi
  506. def sugaredSymbolOrSelf: SymbolTable.Symbol

    Given a field, construct a term symbol that represents the source construct that gave rise the field

  507. def superClass: SymbolTable.Symbol

    The superclass of this class.

  508. def superPrefix(supertpe: SymbolTable.Type): SymbolTable.Type
    Definition Classes
    SymbolContextApiImpl
  509. final def superSymbolIn(base: SymbolTable.Symbol): SymbolTable.Symbol

    The symbol accessed by a super in the definition of this symbol when seen from class base.

    The symbol accessed by a super in the definition of this symbol when seen from class base. This symbol is always concrete. pre: this.owner is in the base class sequence of base.

  510. def symbolCreationString: String
  511. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  512. def thisPrefix: SymbolTable.Type
    Definition Classes
    SymbolContextApiImpl
  513. def thisSym: SymbolTable.Symbol

    The self symbol (a TermSymbol) of a class with explicit self type, or else the symbol itself (a TypeSymbol).

    The self symbol (a TermSymbol) of a class with explicit self type, or else the symbol itself (a TypeSymbol).

    WARNING: you're probably better off using typeOfThis, as it's more uniform across classes with and without self variables.

    Example by Paul: scala> trait Foo1 { } scala> trait Foo2 { self => } scala> intp("Foo1").thisSym res0: $r.intp.global.Symbol = trait Foo1

    scala> intp("Foo2").thisSym res1: $r.intp.global.Symbol = value self

    Martin says: The reason thisSym' is this' is so that thisType can be this.thisSym.tpe. It's a trick to shave some cycles off.

    Morale: DO: if (clazz.typeOfThis.typeConstructor ne clazz.typeConstructor) ... DON'T: if (clazz.thisSym ne clazz) ...

  514. def thisType: SymbolTable.Type

    If symbol is a class, the type this.type in this class, otherwise NoPrefix.

    If symbol is a class, the type this.type in this class, otherwise NoPrefix. We always have: thisType <:< typeOfThis

  515. final def toOption: Option[SymbolTable.Symbol]
  516. def toString(): String

    String representation, including symbol's kind e.g., "class Foo", "method Bar".

    String representation, including symbol's kind e.g., "class Foo", "method Bar". If hasMeaninglessName is true, uses the owner's name to disambiguate identity.

    Definition Classes
    Symbol → AnyRef → Any
  517. def toType: SymbolTable.Type
    Definition Classes
    SymbolContextApiImpl
  518. def toTypeConstructor: SymbolTable.Type
    Definition Classes
    SymbolContextApiImpl
  519. def toTypeIn(site: SymbolTable.Type): SymbolTable.Type
    Definition Classes
    SymbolContextApiImpl
  520. final def tpe: SymbolTable.Type

    The "type" of this symbol.

    The "type" of this symbol. The type of a term symbol is its usual type. A TypeSymbol is more complicated; see that class for elaboration. Since tpe forwards to tpe_*, if you call it on a type symbol with unapplied type parameters, the type returned will contain dummies types. These will hide legitimate errors or create spurious ones if used as normal types.

    For type symbols, tpe is different than info. tpe returns a typeRef to the type symbol, info returns the type information of the type symbol, e.g. a ClassInfoType for classes or a TypeBounds for abstract types.

  521. def tpeHK: SymbolTable.Type

    typeConstructor throws an exception when called on term symbols; this is a more forgiving alternative.

    typeConstructor throws an exception when called on term symbols; this is a more forgiving alternative. Calls typeConstructor on TypeSymbols, returns info otherwise.

  522. def tpe_*: SymbolTable.Type

    The type of this symbol, guaranteed to be of kind *.

    The type of this symbol, guaranteed to be of kind *. If there are unapplied type parameters, they will be substituted with dummy type arguments derived from the type parameters. Such types are not valid in a general sense and will cause difficult-to-find bugs if allowed to roam free.

    If you call tpe_* explicitly to obtain these types, you are responsible for them as if it they were your own minor children.

  523. def typeConstructor: SymbolTable.Type

    Only applicable to TypeSymbols, it is the type corresponding to the symbol itself.

    Only applicable to TypeSymbols, it is the type corresponding to the symbol itself. For instance, the type of a List might be List[Int] - the same symbol's typeConstructor is simply List. One might be tempted to write that as List[_], and in some contexts this is possible, but it is discouraged because it is syntactically indistinguishable from and easily confused with the type List[T] forSome { type T; }, which can also be written List[_].

  524. def typeOfThis: SymbolTable.Type

    The type of this in a class, or else the type of the symbol itself.

  525. def typeOfThis_=(tp: SymbolTable.Type): Unit
  526. def typeParams: List[SymbolTable.Symbol]

    The type parameters of this symbol.

    The type parameters of this symbol. assumption: if a type starts out as monomorphic, it will not acquire type parameters later.

  527. def typeSignature: SymbolTable.Type

    Definition Classes
    SymbolContextApiImplSymbolApi
    See also

    info

  528. def typeSignatureIn(site: SymbolTable.Type): SymbolTable.Type

    Definition Classes
    SymbolContextApiImplSymbolApi
    See also

    infoIn

  529. def unexpandedName: SymbolTable.Name

    If this symbol has an expanded name, its original (unexpanded) name, otherwise the name itself.

  530. def unpackLocation: AnyRef

    If this symbol is an existential skolem the location (a Tree or null) where it was unpacked.

    If this symbol is an existential skolem the location (a Tree or null) where it was unpacked. Resulttype is AnyRef because trees are not visible here.

  531. def unsafeTypeParams: List[SymbolTable.Symbol]

    The type parameters of this symbol, without ensuring type completion.

    The type parameters of this symbol, without ensuring type completion. assumption: if a type starts out as monomorphic, it will not acquire type parameters later.

  532. def updateAttachment[T](attachment: T)(implicit arg0: ClassTag[T]): Symbol.this.type
    Definition Classes
    Attachable
  533. def updateInfo(info: SymbolTable.Type): SymbolTable.Symbol

    Set new info valid from start of this phase.

  534. def validTo: Period
  535. def validTo_=(x: Period): Unit
  536. def variance: Variance

    The variance of this symbol.

  537. def varianceString: String

    String representation of symbol's variance

  538. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  539. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  540. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  541. final def withAnnotation(annot: SymbolTable.AnnotationInfo): SymbolTable.Symbol
    Definition Classes
    Annotatable
  542. def withAnnotations(annots: List[SymbolTable.AnnotationInfo]): Symbol.this.type
    Definition Classes
    SymbolAnnotatable
  543. def withoutAnnotations: Symbol.this.type
    Definition Classes
    SymbolAnnotatable

Deprecated Value Members

  1. final def freshExistential(suffix: String): SymbolTable.TypeSymbol
    Annotations
    @deprecated
    Deprecated

    (Since version 2.12.1) Use overload that accepts an id

  2. final def getter(base: SymbolTable.Symbol): SymbolTable.Symbol
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) use getterIn instead

  3. def hasLocalFlag: Boolean
    Definition Classes
    HasFlags
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) use isLocalToThis instead

  4. def isImplClass: Boolean
    Annotations
    @deprecated
    Deprecated

    (Since version 2.12.0) trait implementation classes have been removed in Scala 2.12

  5. final def isLocal: Boolean

    Is this symbol defined in a block?

    Is this symbol defined in a block?

    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) use isLocalToBlock instead

  6. def isPackage: Boolean
    Definition Classes
    HasFlags
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) use hasPackageFlag instead

  7. def lazyAccessor: SymbolTable.Symbol
    Annotations
    @deprecated
    Deprecated

    (Since version 2.12.0) No longer applicable, as lazy vals are not desugared until the fields phase

  8. def lazyAccessorOrSelf: SymbolTable.Symbol
    Annotations
    @deprecated
    Deprecated

    (Since version 2.12.0) No longer applicable, as lazy vals are not desugared until the fields phase

  9. def originalName: SymbolTable.Name
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) use unexpandedName

  10. final def setter(base: SymbolTable.Symbol, hasExpandedName: Boolean = needsExpandedSetterName): SymbolTable.Symbol
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) use setterIn instead

  11. final def superSymbol(base: SymbolTable.Symbol): SymbolTable.Symbol
    Annotations
    @deprecated
    Deprecated

    (Since version 2.11.0) use superSymbolIn instead

Inherited from SymbolTable.Attachable

Inherited from HasFlags

Inherited from SymbolTable.SymbolApi

Inherited from AnyRef

Inherited from Any

Method Symbol Members

Symbol Basic Information

Symbol Type Tests

Symbol Conversions

Iteration Helpers

These methods enable collections-like operations on symbols.

Ungrouped