ClassfileLoader

Instance Constructors

new ClassfileLoader(classfile: AbstractFile)

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def &(that: Type)(implicit ctx: Context): Type

Definition Classes
Type
final def <:<(that: Type)(implicit ctx: Context): Boolean

Is this type a subtype of that type?
Is this type a subtype of that type?

Definition Classes
Type
final def =:=(that: Type)(implicit ctx: Context): Boolean

Is this type the same as that type? This is the case iff this <:< that and that <:< this.
Is this type the same as that type? This is the case iff this <:< that and that <:< this.

Definition Classes
Type
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def abstractTermMembers(implicit ctx: Context): Seq[SingleDenotation]

The set of abstract term members of this type.
The set of abstract term members of this type.

Definition Classes
Type
final def abstractTypeMembers(implicit ctx: Context): Seq[SingleDenotation]

The set of abstract type members of this type.
The set of abstract type members of this type.

Definition Classes
Type
final def addDelta(elemHash: Int, delta: Int): Int

Attributes
protected
Definition Classes
Hashable
def andThen[A](g: (LazyType) ⇒ A): (Symbol) ⇒ A

Definition Classes
Function1
Annotations
@unspecialized()
def apply(module: TermSymbol, modcls: ClassSymbol): LazyType

Definition Classes
LazyType → Function2
def apply(sym: Symbol): LazyType

Definition Classes
LazyType → Function1
final def asInstanceOf[T0]: T0

Definition Classes
Any
final def asSeenFrom(pre: Type, cls: Symbol)(implicit ctx: Context): Type

This type seen as if it were the type of a member of prefix type pre declared in class cls.
This type seen as if it were the type of a member of prefix type pre declared in class cls.

Definition Classes
Type
final def baseClasses(implicit ctx: Context): List[ClassSymbol]

The base classes of this type as determined by ClassDenotation in linearization order, with the class itself as first element.
The base classes of this type as determined by ClassDenotation in linearization order, with the class itself as first element. For AndTypes/OrTypes, the union/intersection of the operands' baseclasses. Inherited by all type proxies. Nil for all other types.

Definition Classes
Type
final def baseTypeRef(base: Symbol)(implicit ctx: Context): Type

The basetype TypeRef of this type with given class symbol, but without including any type arguments
The basetype TypeRef of this type with given class symbol, but without including any type arguments

Definition Classes
Type
final def bounds(implicit ctx: Context): TypeBounds

This type seen as a TypeBounds
This type seen as a TypeBounds

Definition Classes
Type
final def classSymbol(implicit ctx: Context): Symbol

The least class or trait of which this type is a subtype or parameterized instance, or NoSymbol if none exists (either because this type is not a value type, or because superclasses are ambiguous).
The least class or trait of which this type is a subtype or parameterized instance, or NoSymbol if none exists (either because this type is not a value type, or because superclasses are ambiguous).

Definition Classes
Type
final def classSymbols(implicit ctx: Context): List[ClassSymbol]

The least (wrt <:<) set of class symbols of which this type is a subtype
The least (wrt <:<) set of class symbols of which this type is a subtype

Definition Classes
Type
val classfile: AbstractFile
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def complete(root: SymDenotation)(implicit ctx: Context): Unit

Sets all missing fields of given denotation
Sets all missing fields of given denotation

Definition Classes
SymbolLoader → LazyType
def compose[A](g: (A) ⇒ Symbol): (A) ⇒ LazyType

Definition Classes
Function1
Annotations
@unspecialized()
def curried: (TermSymbol) ⇒ (ClassSymbol) ⇒ LazyType

Definition Classes
Function2
Annotations
@unspecialized()
final def deAnonymize(implicit ctx: Context): Type

Eliminate anonymous classes
Eliminate anonymous classes

Definition Classes
Type
final def dealias(implicit ctx: Context): Type

Follow aliases and dereferences LazyRefs, annotated types and instantiated TypeVars until type is no longer alias type, annotated type, LazyRef, or instantiated type variable.
Follow aliases and dereferences LazyRefs, annotated types and instantiated TypeVars until type is no longer alias type, annotated type, LazyRef, or instantiated type variable.

Definition Classes
Type
final def dealiasKeepAnnots(implicit ctx: Context): Type

Follow aliases and dereferences LazyRefs and instantiated TypeVars until type is no longer alias type, LazyRef, or instantiated type variable.
Follow aliases and dereferences LazyRefs and instantiated TypeVars until type is no longer alias type, LazyRef, or instantiated type variable. Goes through annotated types and rewraps annotations on the result.

Definition Classes
Type
final def decl(name: Name)(implicit ctx: Context): Denotation

A denotation containing the declaration(s) in this type with the given name.
A denotation containing the declaration(s) in this type with the given name. The result is either a SymDenotation or a MultiDenotation of SymDenotations. The info(s) are the original symbol infos, no translation takes place.

Definition Classes
Type
def decls: Scope

Definition Classes
LazyType
final def decls(implicit ctx: Context): Scope

The scope of all declarations of this type.
The scope of all declarations of this type. Defined by ClassInfo, inherited by type proxies. Empty scope for all other types.

Definition Classes
Type
final def deconst(implicit ctx: Context): Type

Widen from constant type to its underlying non-constant base type.
Widen from constant type to its underlying non-constant base type.

Definition Classes
Type
def deepenProto(implicit ctx: Context): Type

If this is a prototype with some ignored component, reveal one more layer of it.
If this is a prototype with some ignored component, reveal one more layer of it. Otherwise the type itself.

Definition Classes
Type
final def derivesFrom(cls: Symbol)(implicit ctx: Context): Boolean

Is this type an instance of a non-bottom subclass of the given class cls?
Is this type an instance of a non-bottom subclass of the given class cls?

Definition Classes
Type
def description: String

Description of the resource (ClassPath, AbstractFile) being processed by this loader
Description of the resource (ClassPath, AbstractFile) being processed by this loader

Definition Classes
ClassfileLoader → SymbolLoader
def doComplete(root: SymDenotation)(implicit ctx: Context): Unit

Load source or class file for root, return
Load source or class file for root, return

Definition Classes
ClassfileLoader → SymbolLoader
final def doHash(x1: Int, x2: Int): Int

Attributes
protected
Definition Classes
Hashable
final def doHash(x1: Any, tp2: Type, tps3: List[Type]): Int

Attributes
protected
Definition Classes
Hashable
final def doHash(tp1: Type, tps2: List[Type]): Int

Attributes
protected
Definition Classes
Hashable
final def doHash(x1: Any, tp2: Type, tp3: Type): Int

Attributes
protected
Definition Classes
Hashable
final def doHash(tp1: Type, tp2: Type): Int

Attributes
protected
Definition Classes
Hashable
final def doHash(x1: Any, tp2: Type): Int

Attributes
protected
Definition Classes
Hashable
final def doHash(tp: Type): Int

Attributes
protected
Definition Classes
Hashable
final def doHash(x: Any): Int

Attributes
protected
Definition Classes
Hashable
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exists: Boolean

Is this type different from NoType?
Is this type different from NoType?

Definition Classes
Type
final def existsPart(p: (Type) ⇒ Boolean, forceLazy: Boolean = true)(implicit ctx: Context): Boolean

Returns true if there is a part of this type that satisfies predicate p.
Returns true if there is a part of this type that satisfies predicate p.

Definition Classes
Type
def fallbackToText(printer: Printer): Text

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

Definition Classes
Showable
final def fields(implicit ctx: Context): Seq[SingleDenotation]

Definition Classes
Type
def finalResultType(implicit ctx: Context): Type

The final result type of a PolyType, MethodType, or ExprType, after skipping all parameter sections, the type itself for all others.
The final result type of a PolyType, MethodType, or ExprType, after skipping all parameter sections, the type itself for all others.

Definition Classes
Type
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def findDecl(name: Name, excluded: FlagSet)(implicit ctx: Context): Denotation

A denotation containing the declaration(s) in this type with the given name, as seen from prefix type pre.
A denotation containing the declaration(s) in this type with the given name, as seen from prefix type pre. Declarations that have a flag in excluded are omitted.

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

Find member of this type with given name and produce a denotation that contains the type of the member as seen from given prefix pre.
Find member of this type with given name and produce a denotation that contains the type of the member as seen from given prefix pre. Exclude all members that have flags in excluded from consideration.

Definition Classes
Type
def finishHash(seed: Int, arity: Int, tp: Type, tps: List[Type]): Int

Attributes
protected
Definition Classes
Hashable
def finishHash(seed: Int, arity: Int, tps: List[Type]): Int

Attributes
protected
Definition Classes
Hashable
def finishHash(seed: Int, arity: Int, tp1: Type, tp2: Type): Int

Attributes
protected
Definition Classes
Hashable
def finishHash(seed: Int, arity: Int, tp: Type): Int

Attributes
protected
Definition Classes
Hashable
final def finishHash(hashCode: Int, arity: Int): Int

Attributes
protected
Definition Classes
Hashable
final def firstParamTypes(implicit ctx: Context): List[Type]

The parameter types in the first parameter section of a generic type or MethodType, Empty list for others
The parameter types in the first parameter section of a generic type or MethodType, Empty list for others

Definition Classes
Type
def firstParent(implicit ctx: Context): TypeRef

The first parent of this type, AnyRef if list of parents is empty
The first parent of this type, AnyRef if list of parents is empty

Definition Classes
Type
final def forallParts(p: (Type) ⇒ Boolean)(implicit ctx: Context): Boolean

Returns true if all parts of this type satisfy predicate p.
Returns true if all parts of this type satisfy predicate p.

Definition Classes
Type
final def foreachPart(p: (Type) ⇒ Unit, stopAtStatic: Boolean = false)(implicit ctx: Context): Unit

Performs operation on all parts of this type
Performs operation on all parts of this type

Definition Classes
Type
final def frozen_<:<(that: Type)(implicit ctx: Context): Boolean

Is this type a subtype of that type?
Is this type a subtype of that type?

Definition Classes
Type
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def givenSelfType(implicit ctx: Context): Type

the self type of the underlying classtype
the self type of the underlying classtype

Definition Classes
Type
final def hasAnnotation(cls: ClassSymbol)(implicit ctx: Context): Boolean

Does the type carry an annotation that is an instance of cls?
Does the type carry an annotation that is an instance of cls?

Definition Classes
Type
final def hasUnsafeNonvariant(implicit ctx: Context): Boolean

Does this type have an UnsafeNonvariant annotation on one of its parts?
Does this type have an UnsafeNonvariant annotation on one of its parts?

Definition Classes
Type
final def hash: Int

customized hash code of this type.
customized hash code of this type. NotCached for uncached types. Cached types compute hash and use it as the type's hashCode.

Definition Classes
UncachedGroundType → Type
def hashCode(): Int

Definition Classes
AnyRef → Any
def hashSeed: Int

Attributes
protected
Definition Classes
Hashable
final def identityHash: Int

Definition Classes
Hashable
final def implicitMembers(implicit ctx: Context): List[TermRef]

The set of implicit members of this type
The set of implicit members of this type

Definition Classes
Type
def isAlias: Boolean

Is this an alias TypeBounds?
Is this an alias TypeBounds?

Definition Classes
Type
def isDirectRef(sym: Symbol)(implicit ctx: Context): Boolean

Is this type a (neither aliased nor applied) reference to class sym?
Is this type a (neither aliased nor applied) reference to class sym?

Definition Classes
Type
final def isErroneous(implicit ctx: Context): Boolean

Is some part of this type produced as a repair for an error?
Is some part of this type produced as a repair for an error?

Definition Classes
Type
final def isError(implicit ctx: Context): Boolean

Is this type produced as a repair for an error?
Is this type produced as a repair for an error?

Definition Classes
Type
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def isNotNull(implicit ctx: Context): Boolean

Is this type guaranteed not to have null as a value? For the moment this is only true for modules, but it could be refined later.
Is this type guaranteed not to have null as a value? For the moment this is only true for modules, but it could be refined later.

Definition Classes
Type
final def isParameterless(implicit ctx: Context): Boolean

Is this either not a method at all, or a parameterless method?
Is this either not a method at all, or a parameterless method?

Definition Classes
Type
def isRef(sym: Symbol)(implicit ctx: Context): Boolean

Is this type a (possibly refined or applied or aliased) type reference to the given type symbol?
Is this type a (possibly refined or applied or aliased) type reference to the given type symbol?

Definition Classes
Type
def isRepeatedParam(implicit ctx: Context): Boolean

Is this a type of a repeated parameter?
Is this a type of a repeated parameter?

Definition Classes
Type
final def isStable(implicit ctx: Context): Boolean

Does this type denote a stable reference (i.e.
Does this type denote a stable reference (i.e. singleton type)?

Definition Classes
Type
final def isUnsafeNonvariant(implicit ctx: Context): Boolean

Does this type carry an UnsafeNonvariant annotation?
Does this type carry an UnsafeNonvariant annotation?

Definition Classes
Type
def isValueSubType(that: Type)(implicit ctx: Context): Boolean

Is this type a primitive value type which can be widened to the primitive value type that?
Is this type a primitive value type which can be widened to the primitive value type that?

Definition Classes
Type
final def isValueType: Boolean

Is this type a value type?
Is this type a value type?

Definition Classes
Type
final def isValueTypeOrLambda: Boolean

Is the is value type or type lambda?
Is the is value type or type lambda?

Definition Classes
Type
def isVarArgsMethod(implicit ctx: Context): Boolean

Is this the type of a method that has a repeated parameter type as last parameter type?
Is this the type of a method that has a repeated parameter type as last parameter type?

Definition Classes
Type
def load(root: SymDenotation)(implicit ctx: Context): Option[Embedded]
def lookupRefined(name: Name)(implicit ctx: Context): Type

If this normalizes* to a refinement type that has a refinement for name (which might be followed by other refinements), and the refined info is a type alias, return the alias, otherwise return NoType.
If this normalizes* to a refinement type that has a refinement for name (which might be followed by other refinements), and the refined info is a type alias, return the alias, otherwise return NoType. Used to reduce types of the form
P { ... type T = / += / -= U ... } # T
to just U. Does not perform the reduction if the resulting type would contain a reference to the "this" of the current refined type, except in the following situation
(1) The "this" reference can be avoided by following an alias. Example:
P { type T = String, type R = P{...}.T } # R --> String
(*) normalizes means: follow instantiated typevars and aliases.

Definition Classes
Type
def mapReduceAnd[T](f: (Type) ⇒ T)(g: (T, T) ⇒ T)(implicit ctx: Context): T

Map function f over elements of an AndType, rebuilding with function g
Map function f over elements of an AndType, rebuilding with function g

Definition Classes
Type
final def mapReduceOr[T](f: (Type) ⇒ T)(g: (T, T) ⇒ T)(implicit ctx: Context): T

Map function f over elements of an OrType, rebuilding with function g
Map function f over elements of an OrType, rebuilding with function g

Definition Classes
Type
def matches(that: Type)(implicit ctx: Context): Boolean

Is this type close enough to that type so that members with the two types would override each other? This means:
Is this type close enough to that type so that members with the two types would override each other? This means:
- Either both types are polytypes with the same number of type parameters and their result types match after renaming corresponding type parameters
- Or both types are method types with =:=-equivalent(*) parameter types and matching result types after renaming corresponding parameter types if the method types are dependent.
- Or both types are =:=-equivalent
- Or phase.erasedTypes is false, and neither type takes term or type parameters.
(*) when matching with a Java method, we also regard Any and Object as equivalent parameter types.
Definition Classes
Type
def matchesLoosely(that: Type)(implicit ctx: Context): Boolean

This is the same as matches except that it also matches => T with T and vice versa.
This is the same as matches except that it also matches => T with T and vice versa.

Definition Classes
Type
final def member(name: Name)(implicit ctx: Context): Denotation

The member of this type with the given name
The member of this type with the given name

Definition Classes
Type
final def memberClasses(implicit ctx: Context): Seq[SingleDenotation]

The set of member classes of this type
The set of member classes of this type

Definition Classes
Type
def memberDenots(keepOnly: NameFilter, f: (Name, Buffer[SingleDenotation]) ⇒ Unit)(implicit ctx: Context): Seq[SingleDenotation]

Definition Classes
Type
final def memberExcluding(name: Name, excluding: FlagSet)(implicit ctx: Context): Denotation

Definition Classes
Type
final def memberInfo(sym: Symbol)(implicit ctx: Context): Type

The info of sym, seen as a member of this type.
The info of sym, seen as a member of this type.

Definition Classes
Type
final def memberNames(keepOnly: NameFilter, pre: Type = this)(implicit ctx: Context): Set[Name]

The set of names of members of this type that pass the given name filter when seen as members of pre.
The set of names of members of this type that pass the given name filter when seen as members of pre. More precisely, these are all of members name such that keepOnly(pre, name) is true.

Definition Classes
Type
final def membersBasedOnFlags(requiredFlags: FlagSet, excludedFlags: FlagSet)(implicit ctx: Context): Seq[SingleDenotation]

The set of members of this type having at least one of requiredFlags but none of excludedFlags set
The set of members of this type having at least one of requiredFlags but none of excludedFlags set

Definition Classes
Type
def moduleClass(implicit ctx: Context): Symbol

Definition Classes
LazyType
final def namedParts(implicit ctx: Context): Set[NamedType]

The parts of this type which are type or term refs
The parts of this type which are type or term refs

Definition Classes
Type
def namedPartsWith(p: (NamedType) ⇒ Boolean, excludeLowerBounds: Boolean = false)(implicit ctx: Context): Set[NamedType]

The parts of this type which are type or term refs and which satisfy predicate p.
The parts of this type which are type or term refs and which satisfy predicate p.
p
The predicate to satisfy
excludeLowerBounds
If set to true, the lower bounds of abstract types will be ignored.

Definition Classes
Type
def narrow(implicit ctx: Context): TermRef

A prefix-less refined this or a termRef to a new skolem symbol that has the given type as info.
A prefix-less refined this or a termRef to a new skolem symbol that has the given type as info.

Definition Classes
Type
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def nonClassTypeMembers(implicit ctx: Context): Seq[SingleDenotation]

The set of abstract type members of this type.
The set of abstract type members of this type.

Definition Classes
Type
final def nonPrivateDecl(name: Name)(implicit ctx: Context): Denotation

A denotation containing the non-private declaration(s) in this type with the given name
A denotation containing the non-private declaration(s) in this type with the given name

Definition Classes
Type
final def nonPrivateMember(name: Name)(implicit ctx: Context): Denotation

The non-private member of this type with the given name.
The non-private member of this type with the given name.

Definition Classes
Type
final def normalizedPrefix(implicit ctx: Context): Type

The normalized prefix of this type is: For an alias type, the normalized prefix of its alias For all other named type and class infos: the prefix.
The normalized prefix of this type is: For an alias type, the normalized prefix of its alias For all other named type and class infos: the prefix. Inherited by all other type proxies. NoType for all other types.

Definition Classes
Type
def notApplied: Type

If this is a FunProto or PolyProto, WildcardType, otherwise this.
If this is a FunProto or PolyProto, WildcardType, otherwise this.

Definition Classes
Type
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def occursIn(that: Type)(implicit ctx: Context): Boolean

Does this type occur as a part of type that?
Does this type occur as a part of type that?

Definition Classes
Type
def orElse(that: ⇒ Type): Type

This type, if it exists, otherwise that type
This type, if it exists, otherwise that type

Definition Classes
Type
final def overrides(that: Type)(implicit ctx: Context): Boolean

Is this type a legal type for a member that overrides another member of type that? This is the same as <:<, except that the types ()T and => T are identified, and T is seen as overriding either type.
Is this type a legal type for a member that overrides another member of type that? This is the same as <:<, except that the types ()T and => T are identified, and T is seen as overriding either type.

Definition Classes
Type
final def paramNamess(implicit ctx: Context): List[List[TermName]]

The parameter names of a PolyType or MethodType, Empty list for others
The parameter names of a PolyType or MethodType, Empty list for others

Definition Classes
Type
final def paramTypess(implicit ctx: Context): List[List[Type]]

The parameter types of a PolyType or MethodType, Empty list for others
The parameter types of a PolyType or MethodType, Empty list for others

Definition Classes
Type
def parents(implicit ctx: Context): List[TypeRef]

For a ClassInfo type, its parents, Inherited by all type proxies.
For a ClassInfo type, its parents, Inherited by all type proxies. Empty for all other types. Overwritten in ClassInfo, where parents is cached.

Definition Classes
Type
def parentsWithArgs(implicit ctx: Context): List[Type]

The full parent types, including all type arguments
The full parent types, including all type arguments

Definition Classes
Type
def proxy: LazyType

A proxy to this lazy type that keeps the complete operation but provides fresh slots for scope/sourceModule/moduleClass
A proxy to this lazy type that keeps the complete operation but provides fresh slots for scope/sourceModule/moduleClass

Definition Classes
LazyType
def relaxed_<:<(that: Type)(implicit ctx: Context): Boolean

Definition Classes
Type
def resultType(implicit ctx: Context): Type

The resultType of a PolyType, MethodType, or ExprType, the type itself for others
The resultType of a PolyType, MethodType, or ExprType, the type itself for others

Definition Classes
Type
def rootDenots(rootDenot: ClassDenotation)(implicit ctx: Context): (ClassDenotation, ClassDenotation)
def safe_&(that: Type)(implicit ctx: Context): Type

Safer version of &.
Safer version of &.
This version does not simplify the upper bound of the intersection of two TypeBounds. The simplification done by & requires subtyping checks which may end up calling & again, in most cases this should be safe but because of F-bounded types, this can result in an infinite loop (which will be masked unless -Yno-deep-subtypes is enabled).

Definition Classes
Type
def select(sym: Symbol)(implicit ctx: Context): Type

The type <this .
The type <this . name> with given symbol, reduced if possible

Definition Classes
Type
def select(name: Name, denot: Denotation)(implicit ctx: Context): Type

The type <this .
The type <this . name> , reduced if possible, with given denotation if unreduced

Definition Classes
Type
def select(name: Name)(implicit ctx: Context): Type

The type <this .
The type <this . name> , reduced if possible

Definition Classes
Type
def show(implicit ctx: Context): String

The string representation of this showable element.
The string representation of this showable element.

Definition Classes
Showable
def showSummary(implicit ctx: Context): String

Definition Classes
Showable
def showSummary(depth: Int)(implicit ctx: Context): String

The summarized string representation of this showable element.
The summarized string representation of this showable element. Recursion depth is limited to some smallish value. Default is Config.summarizeDepth.

Definition Classes
Showable
def showWithUnderlying(n: Int = 1)(implicit ctx: Context): String

Utility method to show the underlying type of a TypeProxy chain together with the proxy type itself.
Utility method to show the underlying type of a TypeProxy chain together with the proxy type itself.

Definition Classes
Type
def signature(implicit ctx: Context): Signature

The signature of this type.
The signature of this type. This is by default NotAMethod, but is overridden for PolyTypes, MethodTypes, and TermRefWithSignature types. (the reason why we deviate from the "final-method-with-pattern-match-in-base-class" pattern is that method signatures use caching, so encapsulation is improved using an OO scheme).

Definition Classes
Type
def simplified(implicit ctx: Context): Type

A simplified version of this type which is equivalent wrt =:= to this type.
A simplified version of this type which is equivalent wrt =:= to this type. This applies a typemap to the type which (as all typemaps) follows type variable instances and reduces typerefs over refined types. It also re-evaluates all occurrences of And/OrType with &/| because what was a union or intersection of type variables might be a simpler type after the type variables are instantiated. Finally, it maps poly params in the current constraint set back to their type vars.

Definition Classes
Type
def sourceFileOrNull: AbstractFile

Definition Classes
ClassfileLoader → SymbolLoader
def sourceModule(implicit ctx: Context): Symbol

Definition Classes
LazyType
def stripAnnots(implicit ctx: Context): Type

Remove all AnnotatedTypes wrapping this type.
Remove all AnnotatedTypes wrapping this type.

Definition Classes
Type
def stripTypeVar(implicit ctx: Context): Type

Map a TypeVar to either its instance if it is instantiated, or its origin, if not, until the result is no longer a TypeVar.
Map a TypeVar to either its instance if it is instantiated, or its origin, if not, until the result is no longer a TypeVar. Identity on all other types.

Definition Classes
Type
final def subst(from: BindingType, to: BindingType)(implicit ctx: Context): Type

Substitute all types of the form PolyParam(from, N) by PolyParam(to, N).
Substitute all types of the form PolyParam(from, N) by PolyParam(to, N).

Definition Classes
Type
final def subst(from: List[Symbol], to: List[Type])(implicit ctx: Context): Type

Substitute all types that refer in their symbol attribute to one of the symbols in from by the corresponding types in to.
Substitute all types that refer in their symbol attribute to one of the symbols in from by the corresponding types in to.

Definition Classes
Type
final def substDealias(from: List[Symbol], to: List[Type])(implicit ctx: Context): Type

Same as subst but follows aliases as a fallback.
Same as subst but follows aliases as a fallback. When faced with a reference to an alias type, where normal substitution does not yield a new type, the substitution is instead applied to the alias. If that yields a new type, this type is returned, otherwise the original type (not the alias) is returned. A use case for this method is if one wants to substitute the type parameters of a class and also wants to substitute any parameter accessors that alias the type parameters.

Definition Classes
Type
final def substParam(from: ParamType, to: Type)(implicit ctx: Context): Type

Substitute a bound type by some other type
Substitute a bound type by some other type

Definition Classes
Type
final def substParams(from: BindingType, to: List[Type])(implicit ctx: Context): Type

Substitute bound types by some other types
Substitute bound types by some other types

Definition Classes
Type
final def substRecThis(binder: RecType, tp: Type)(implicit ctx: Context): Type

Substitute all occurrences of RecThis(binder) by tp
Substitute all occurrences of RecThis(binder) by tp

Definition Classes
Type
final def substSym(from: List[Symbol], to: List[Symbol])(implicit ctx: Context): Type

Substitute all occurrences of symbols in from by references to corresponding symbols in to
Substitute all occurrences of symbols in from by references to corresponding symbols in to

Definition Classes
Type
final def substThis(cls: ClassSymbol, tp: Type)(implicit ctx: Context): Type

Substitute all occurrences of This(cls) by tp
Substitute all occurrences of This(cls) by tp

Definition Classes
Type
final def substThisUnlessStatic(cls: ClassSymbol, tp: Type)(implicit ctx: Context): Type

As substThis, but only is class is a static owner (i.e.
As substThis, but only is class is a static owner (i.e. a globally accessible object)

Definition Classes
Type
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
final def termSymbol(implicit ctx: Context): Symbol

The term symbol associated with the type
The term symbol associated with the type

Definition Classes
Type
def toFunctionType(dropLast: Int = 0)(implicit ctx: Context): Type

Turn type into a function type.
Turn type into a function type.
dropLast
The number of trailing parameters that should be dropped when forming the function type.

Definition Classes
Type
def toString(): String

Definition Classes
Function2 → AnyRef → Any
def toText(printer: Printer): Text

Convert to text
Convert to text

Definition Classes
Type → Showable
def tupled: ((TermSymbol, ClassSymbol)) ⇒ LazyType

Definition Classes
Function2
Annotations
@unspecialized()
final def typeMembers(implicit ctx: Context): Seq[SingleDenotation]

The set of type members of this type
The set of type members of this type

Definition Classes
Type
def typeParamNamed(name: TypeName)(implicit ctx: Context): Symbol

The type parameter with given name.
The type parameter with given name. This tries first decls in order not to provoke a cycle by forcing the info. If that yields no symbol it tries member as an alternative.

Definition Classes
Type
final def typeSymbol(implicit ctx: Context): Symbol

The type symbol associated with the type
The type symbol associated with the type

Definition Classes
Type
def underlyingClassRef(refinementOK: Boolean)(implicit ctx: Context): Type

If this is a (possibly aliased, annotated, and/or parameterized) reference to a class, the class type ref, otherwise NoType.
If this is a (possibly aliased, annotated, and/or parameterized) reference to a class, the class type ref, otherwise NoType.
refinementOK
If true we also skip non-parameter refinements.

Definition Classes
Type
def underlyingIfProxy(implicit ctx: Context): Type

Useful for diagnostics: The underlying type if this type is a type proxy, otherwise NoType
Useful for diagnostics: The underlying type if this type is a type proxy, otherwise NoType

Definition Classes
Type
def underlyingIterator(implicit ctx: Context): Iterator[Type]

The iterator of underlying types as long as type is a TypeProxy.
The iterator of underlying types as long as type is a TypeProxy. Useful for diagnostics

Definition Classes
Type
val uniqId: Int

Definition Classes
Type
def unsupported(methodName: String): Nothing

Throws an UnsupportedOperationException with the given method name.
Throws an UnsupportedOperationException with the given method name.

Definition Classes
DotClass
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def widen(implicit ctx: Context): Type

Widen from singleton type to its underlying non-singleton base type by applying one or more underlying dereferences, Also go from => T to T.
Widen from singleton type to its underlying non-singleton base type by applying one or more underlying dereferences, Also go from => T to T. Identity for all other types. Example:
class Outer { class C ; val x: C } def o: Outer <o.x.type>.widen = o.C

Definition Classes
Type
final def widenDealias(implicit ctx: Context): Type

Perform successive widenings and dealiasings until none can be applied anymore
Perform successive widenings and dealiasings until none can be applied anymore

Definition Classes
Type
final def widenExpr: Type

Widen from ExprType type to its result type.
Widen from ExprType type to its result type. (Note: no stripTypeVar needed because TypeVar's can't refer to ExprTypes.)

Definition Classes
Type
final def widenIfUnstable(implicit ctx: Context): Type

Widen type if it is unstable (i.e.
Widen type if it is unstable (i.e. an ExprType, or TermRef to unstable symbol

Definition Classes
Type
final def widenSingleton(implicit ctx: Context): Type

Widen from singleton type to its underlying non-singleton base type by applying one or more underlying dereferences.
Widen from singleton type to its underlying non-singleton base type by applying one or more underlying dereferences.

Definition Classes
Type
final def widenSkolem(implicit ctx: Context): Type

If this is a skolem, its underlying type, otherwise the type itself
If this is a skolem, its underlying type, otherwise the type itself

Definition Classes
Type
final def widenTermRefExpr(implicit ctx: Context): Type

Widen from TermRef to its underlying non-termref base type, while also skipping Expr types.
Widen from TermRef to its underlying non-termref base type, while also skipping Expr types.

Definition Classes
Type
def withDecls(decls: Scope): ClassfileLoader.this.type

Definition Classes
LazyType
def withModuleClass(moduleClassFn: (Context) ⇒ Symbol): ClassfileLoader.this.type

Definition Classes
LazyType
def withSourceModule(sourceModuleFn: (Context) ⇒ Symbol): ClassfileLoader.this.type

Definition Classes
LazyType
def |(that: Type)(implicit ctx: Context): Type

Definition Classes
Type

Related Doc: package core

class ClassfileLoader extends SymbolLoader

Instance Constructors

new ClassfileLoader(classfile: AbstractFile)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def &(that: Type)(implicit ctx: Context): Type

final def <:<(that: Type)(implicit ctx: Context): Boolean

final def =:=(that: Type)(implicit ctx: Context): Boolean

final def ==(arg0: Any): Boolean

final def abstractTermMembers(implicit ctx: Context): Seq[SingleDenotation]

final def abstractTypeMembers(implicit ctx: Context): Seq[SingleDenotation]

final def addDelta(elemHash: Int, delta: Int): Int

def andThen[A](g: (LazyType) ⇒ A): (Symbol) ⇒ A

def apply(module: TermSymbol, modcls: ClassSymbol): LazyType

def apply(sym: Symbol): LazyType

final def asInstanceOf[T0]: T0

final def asSeenFrom(pre: Type, cls: Symbol)(implicit ctx: Context): Type

final def baseClasses(implicit ctx: Context): List[ClassSymbol]

final def baseTypeRef(base: Symbol)(implicit ctx: Context): Type

final def bounds(implicit ctx: Context): TypeBounds

final def classSymbol(implicit ctx: Context): Symbol

final def classSymbols(implicit ctx: Context): List[ClassSymbol]

val classfile: AbstractFile

def clone(): AnyRef

def complete(root: SymDenotation)(implicit ctx: Context): Unit

def compose[A](g: (A) ⇒ Symbol): (A) ⇒ LazyType

def curried: (TermSymbol) ⇒ (ClassSymbol) ⇒ LazyType

final def deAnonymize(implicit ctx: Context): Type

final def dealias(implicit ctx: Context): Type

final def dealiasKeepAnnots(implicit ctx: Context): Type

final def decl(name: Name)(implicit ctx: Context): Denotation

def decls: Scope

final def decls(implicit ctx: Context): Scope

final def deconst(implicit ctx: Context): Type

def deepenProto(implicit ctx: Context): Type

final def derivesFrom(cls: Symbol)(implicit ctx: Context): Boolean

def description: String

def doComplete(root: SymDenotation)(implicit ctx: Context): Unit

final def doHash(x1: Int, x2: Int): Int

final def doHash(x1: Any, tp2: Type, tps3: List[Type]): Int

final def doHash(tp1: Type, tps2: List[Type]): Int

final def doHash(x1: Any, tp2: Type, tp3: Type): Int

final def doHash(tp1: Type, tp2: Type): Int

final def doHash(x1: Any, tp2: Type): Int

final def doHash(tp: Type): Int

final def doHash(x: Any): Int

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists: Boolean

final def existsPart(p: (Type) ⇒ Boolean, forceLazy: Boolean = true)(implicit ctx: Context): Boolean

def fallbackToText(printer: Printer): Text

final def fields(implicit ctx: Context): Seq[SingleDenotation]

def finalResultType(implicit ctx: Context): Type

def finalize(): Unit

final def findDecl(name: Name, excluded: FlagSet)(implicit ctx: Context): Denotation

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

def finishHash(seed: Int, arity: Int, tp: Type, tps: List[Type]): Int

def finishHash(seed: Int, arity: Int, tps: List[Type]): Int

def finishHash(seed: Int, arity: Int, tp1: Type, tp2: Type): Int

def finishHash(seed: Int, arity: Int, tp: Type): Int

final def finishHash(hashCode: Int, arity: Int): Int

final def firstParamTypes(implicit ctx: Context): List[Type]

def firstParent(implicit ctx: Context): TypeRef

final def forallParts(p: (Type) ⇒ Boolean)(implicit ctx: Context): Boolean

final def foreachPart(p: (Type) ⇒ Unit, stopAtStatic: Boolean = false)(implicit ctx: Context): Unit

final def frozen_<:<(that: Type)(implicit ctx: Context): Boolean

final def getClass(): Class[_]

def givenSelfType(implicit ctx: Context): Type

final def hasAnnotation(cls: ClassSymbol)(implicit ctx: Context): Boolean

final def hasUnsafeNonvariant(implicit ctx: Context): Boolean

final def hash: Int

def hashCode(): Int

def hashSeed: Int

final def identityHash: Int

final def implicitMembers(implicit ctx: Context): List[TermRef]

def isAlias: Boolean

def isDirectRef(sym: Symbol)(implicit ctx: Context): Boolean