SingleDenotation

abstract def hasUniqueSym: Boolean

abstract def info(implicit ctx: Context): Type

The type info of the denotation, exists only for non-overloaded denotations

abstract def infoOrCompleter: Type

The type info, or, if this is a SymDenotation where the symbol is not yet completed, the completer

abstract def isType: Boolean

Is this a reference to a type symbol?

abstract def newLikeThis(symbol: Symbol, info: Type): SingleDenotation

final def !=(arg0: Any): Boolean

final def ##(): Int

def &(that: Denotation, pre: Type, safeIntersection: Boolean = false)(implicit ctx: Context): Denotation

Form a denotation by conjoining with denotation that.

final def ==(arg0: Any): Boolean

def accessibleFrom(pre: Type, superAccess: Boolean)(implicit ctx: Context): Denotation

The denotation made up from the alternatives of this denotation that are accessible from prefix pre, or NoDenotation if no accessible alternative exists.

final def alternatives: List[SingleDenotation]

The set of alternative single-denotations making up this denotation

def altsWith(p: (Symbol) ⇒ Boolean): List[SingleDenotation]

The alternatives of this denotation that satisfy the predicate p.

final def asInstanceOf[T0]: T0

final def asSeenFrom(pre: Type)(implicit ctx: Context): AsSeenFromResult

The denotation with info(s) as seen from prefix type

final def asSingleDenotation: SingleDenotation

final def asSymDenotation: SymDenotation

def atSignature(sig: Signature, site: Type, relaxed: Boolean)(implicit ctx: Context): SingleDenotation

Resolve overloaded denotation to pick the ones with the given signature when seen from prefix site.

def checkUnique(implicit ctx: Context): SingleDenotation

If this is a SingleDenotation, return it, otherwise throw a TypeError

def clone(): AnyRef

def computeAsSeenFrom(pre: Type)(implicit ctx: Context): SingleDenotation

final def containsSym(sym: Symbol): Boolean

Group contains a denotation that refers to given symbol

def coveredInterval(implicit ctx: Context): Period

The period (interval of phases) for which there exists a valid denotation in this flock.

def current(implicit ctx: Context): SingleDenotation

Produce a denotation that is valid for the given context.

def definedPeriodsString: String

def derivedSingleDenotation(symbol: Symbol, info: Type)(implicit ctx: Context): SingleDenotation

def disambiguate(p: (Symbol) ⇒ Boolean)(implicit ctx: Context): SingleDenotation

If this denotation is overloaded, filter with given predicate.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists: Boolean

Is this denotation different from NoDenotation or an ErrorDenotation?

def fallbackToText(printer: Printer): Text

A fallback text representation, if the pattern matching in Printers does not have a case for this showable element

final def filterDisjoint(denots: PreDenotation)(implicit ctx: Context): SingleDenotation

Keep only those denotations in this group which have a signature that's not already defined by denots.

final def filterExcluded(excluded: FlagSet)(implicit ctx: Context): SingleDenotation

Keep only those denotations in this group whose flags do not intersect with excluded.

final def filterWithPredicate(p: (SingleDenotation) ⇒ Boolean): SingleDenotation

Keep only those denotations in this group which satisfy predicate p.

def finalize(): Unit

def findMember(name: Name, pre: Type, excluded: FlagSet)(implicit ctx: Context): Denotation

Find member of this denotation with given name and produce a denotation that contains the type of the member as seen from given prefix pre.

final def first: SingleDenotation

First/last denotation in the group

final def getClass(): Class[_]

def hasAltWith(p: (SingleDenotation) ⇒ Boolean): Boolean

Does this denotation have an alternative that satisfies the predicate p?

def hashCode(): Int

def history: List[SingleDenotation]

def initial: SingleDenotation

The version of this SingleDenotation that was valid in the first phase of this run.

def installAfter(phase: DenotTransformer)(implicit ctx: Context): Unit

Install this denotation to be the result of the given denotation transformer.

def invalidateInheritedInfo(): Unit

Invalidate all caches and fields that depend on base classes and their contents

final def isInstanceOf[T0]: Boolean

final def isOverloaded: Boolean

Is this denotation overloaded?

def isTerm: Boolean

Is this a reference to a term symbol?

final def last: SingleDenotation

def mapInfo(f: (Type) ⇒ Type)(implicit ctx: Context): SingleDenotation

A denotation with the info of this denotation transformed using f

def mapInherited(ownDenots: PreDenotation, prevDenots: PreDenotation, pre: Type)(implicit ctx: Context): SingleDenotation

Keep only those inherited members M of this predenotation for which the following is true

final def matches(other: SingleDenotation)(implicit ctx: Context): Boolean

Group contains a denotation with given signature

def matchingDenotation(site: Type, targetType: Type)(implicit ctx: Context): SingleDenotation

The alternative of this denotation that has a type matching targetType when seen as a member of type site, NoDenotation if none exists.

def mergeNames[N <: Name](names1: List[N], names2: List[N], syntheticName: (Int) ⇒ N): List[N]

Merge two lists of names.

def namedType(implicit ctx: Context): NamedType

The NamedType representing this denotation at its original location.

final def ne(arg0: AnyRef): Boolean

var nextInRun: SingleDenotation

The next SingleDenotation in this run, with wrap-around from last to first.

final def notify(): Unit

final def notifyAll(): Unit

def orElse(that: ⇒ SingleDenotation): SingleDenotation

final def orElse(that: ⇒ Denotation): Denotation

If this denotation does not exist, fallback to alternative

def requiredClass(name: PreName)(implicit ctx: Context): ClassSymbol

def requiredMethod(name: PreName, argTypes: List[Type])(implicit ctx: Context): TermSymbol

def requiredMethod(name: PreName)(implicit ctx: Context): TermSymbol

def requiredMethodRef(name: PreName, argTypes: List[Type])(implicit ctx: Context): TermRef

def requiredMethodRef(name: PreName)(implicit ctx: Context): TermRef

def requiredSymbol(p: (Symbol) ⇒ Boolean, source: AbstractFile = null, generateStubs: Boolean = true)(implicit ctx: Context): Symbol

Return symbol in this denotation that satisfies the given predicate.

def requiredValue(name: PreName)(implicit ctx: Context): TermSymbol

def requiredValueRef(name: PreName)(implicit ctx: Context): TermRef

def show(implicit ctx: Context): String

The string representation of this showable element.

def showDcl(implicit ctx: Context): String

Show declaration string; useful for showing declarations as seen from subclasses.

def showSummary(implicit ctx: Context): String

def showSummary(depth: Int)(implicit ctx: Context): String

The summarized string representation of this showable element.

final def signature(implicit ctx: Context): Signature

The signature of the denotation.

def staleSymbolError(implicit ctx: Context): Nothing

def suchThat(p: (Symbol) ⇒ Boolean)(implicit ctx: Context): SingleDenotation

The unique alternative of this denotation that satisfies the predicate p, or NoDenotation if no satisfying alternative exists.

val symbol: Symbol

The referencing symbol, or NoSymbol is none exists

def syncWithParents(implicit ctx: Context): SingleDenotation

For ClassDenotations only: If caches influenced by parent classes are still valid, the denotation itself, otherwise a freshly initialized copy.

final def synchronized[T0](arg0: ⇒ T0): T0

def termRef(implicit ctx: Context): TermRef

The TermRef representing this term denotation at its original location.

def termRefWithSig(implicit ctx: Context): TermRef

The TermRef representing this term denotation at its original location at the denotation's signature.

final def toDenot(pre: Type)(implicit ctx: Context): Denotation

Convert to full denotation by &-ing all elements

def toString(): String

def toText(printer: Printer): Text

The text representation of this showable element.

def transformAfter(phase: DenotTransformer, f: (SymDenotation) ⇒ SymDenotation)(implicit ctx: Context): Unit

Apply a transformation f to all denotations in this group that start at or after given phase.

def typeRef(implicit ctx: Context): TypeRef

The TypeRef representing this type denotation at its original location.

def union(that: PreDenotation): PreDenotation

The union of two groups.

def unsupported(methodName: String): Nothing

Throws an UnsupportedOperationException with the given method name.

def valRef(implicit ctx: Context): TermRef

The TermRef representing this term denotation at its original location and at signature NotAMethod.

def validFor: Period

The period during which this denotation is valid.

def validFor_=(p: Period): Unit

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def |(that: Denotation, pre: Type)(implicit ctx: Context): Denotation

Form a choice between this denotation and that one.