Type

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (Type, B)

def <:<(that: Type): Boolean

Is this type a subtype of that type?

def =:=(that: Type): Boolean

Is this type equivalent to that type?

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def annotations: List[AnnotationInfo]

The annotations on this type.

final def asInstanceOf[T0]: T0

def asSeenFrom(pre: Type, clazz: Symbol): Type

This type as seen from prefix pre and class clazz.

def atOwner(owner: Symbol): Type

Make sure this type is correct as the info of given owner; clone it if not.

def baseClasses: List[Symbol]

The list of all baseclasses of this type (including its own typeSymbol) in reverse linearization order, starting with the class itself and ending in class Any.

def baseType(clazz: Symbol): Type

The least type instance of given class which is a supertype of this type.

def baseTypeIndex(sym: Symbol): Int

def baseTypeSeq: BaseTypeSeq

The shortest sorted upwards closed array of types that contains this type as first element.

def baseTypeSeqDepth: Int

The maximum depth (@see maxDepth) of each type in the BaseTypeSeq of this type.

def boundSyms: Set[Symbol]

For a (potentially wrapped) poly or existential type, its bound symbols, the empty list for all other types

def bounds: TypeBounds

For a TypeBounds type, itself; for a reference denoting an abstract type, its bounds, for all other types, a TypeBounds type all of whose bounds are this type.

def clone(): AnyRef

def cloneInfo(owner: Symbol): Type

If this is a poly- or methodtype, a copy with cloned type / value parameters owned by owner.

def collect[T](pf: PartialFunction[Type, T]): List[T]

Apply pf' to each part of this type on which the function is defined

def complete(sym: Symbol): Unit

If this is a lazy type, assign a new type to sym.

def computeMemberType(sym: Symbol): Type

def contains(sym: Symbol): Boolean

Does this type contain a reference to this symbol?

def containsTp(tp: Type): Boolean

Does this type contain a reference to this type

def dealias: Type

Expands type aliases.

def decl(name: Name): Symbol

The defined or declared members with name name in this type; an OverloadedSymbol if several exist, NoSymbol if none exist.

def declaration(name: Name): Symbol

def declarations: Scope

def decls: Scope

For a classtype or refined type, its defined or declared members; inherited by subtypes and typerefs.

def deconst: Type

Map a constant type or not-null-type to its underlying base type, identity for all other types.

def deferredMembers: List[Symbol]

A list of all deferred symbols of this type (defined or inherited)

def directObjectString: String

The string representation of this type when the direct object in a sentence.

def dummyArgs: List[Type]

A list of placeholder types derived from the type parameters.

def ensuring(cond: (Type) ⇒ Boolean, msg: ⇒ Any): Type

def ensuring(cond: (Type) ⇒ Boolean): Type

def ensuring(cond: Boolean, msg: ⇒ Any): Type

def ensuring(cond: Boolean): Type

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def erasure: Type

def exists(p: (Type) ⇒ Boolean): Boolean

Is there part of this type which satisfies predicate p?

def filter(p: (Type) ⇒ Boolean): List[Type]

Returns all parts of this type which satisfy predicate p

def filterAnnotations(p: (AnnotationInfo) ⇒ Boolean): Type

def finalResultType: Type

For a curried/nullary method or poly type its non-method result type, the type itself for all other types

def finalize(): Unit

def find(p: (Type) ⇒ Boolean): Option[Type]

Returns optionally first type (in a preorder traversal) which satisfies predicate p, or None if none exists.

def findMember(name: Name, excludedFlags: Long, requiredFlags: Long, stableOnly: Boolean): Symbol

Find member(s) in this type.

def firstParent: Type

For a class with nonEmpty parents, the first parent.

def foreach(f: (Type) ⇒ Unit): Unit

Apply f to each part of this type

def formatted(fmtstr: String): String

def getAnnotation(cls: Symbol): Option[AnnotationInfo]

final def getClass(): Class[_]

def hasAnnotation(cls: Symbol): Boolean

Test for, get, or remove an annotation

def hashCode(): Int

def implicitMembers: List[Symbol]

A list of all implicit symbols of this type (defined or inherited)

def instantiateTypeParams(formals: List[Symbol], actuals: List[Type]): Type

Replace formal type parameter symbols with actual type arguments.

def isComplete: Boolean

Is this type completed (i.

def isConcrete: Boolean

def isDependent: Boolean

Does this depend on an enclosing method parameter?

def isErroneous: Boolean

Is this type produced as a repair for an error?

def isError: Boolean

Is this type produced as a repair for an error?

def isFinalType: Boolean

Can this type only be subtyped by bottom types? This is assessed to be the case if the class is final, and all type parameters (if any) are invariant.

def isGround: Boolean

A test whether a type contains any unification type variables.

def isHigherKinded: Boolean

Is this type higher-kinded, i.

def isImmediatelyDependent: Boolean

Does this type depend immediately on an enclosing method parameter? I.

final def isInstanceOf[T0]: Boolean

def isNotNull: Boolean

Is this type guaranteed not to have null as a value?

def isSpliceable: Boolean

def isStable: Boolean

Does this type denote a stable reference (i.

def isStructuralRefinement: Boolean

Is this type a structural refinement type (it refines members that have not been inherited)

def isTrivial: Boolean

Types for which asSeenFrom always is the identity, no matter what prefix or owner.

def isVolatile: Boolean

Is this type dangerous (i.

def isWildcard: Boolean

True for WildcardType or BoundedWildcardType.

def kind: String

The kind of this type; used for debugging

def load(sym: Symbol): Unit

If this is a symbol loader type, load and assign a new type to sym.

def looselyMatches(that: Type): Boolean

Same as matches, except that non-method types are always assumed to match.

def map(f: (Type) ⇒ Type): Type

Apply f to each part of this type; children get mapped before their parents

def matches(that: Type): Boolean

Is this type close enough to that type so that members with the two type would override each other? This means:

def matchesPattern(that: Type): Boolean

Is this type a subtype of that type in a pattern context? Any type arguments on the right hand side are replaced with fresh existentials, except for Arrays.

def member(name: Name): Symbol

The member with given name, an OverloadedSymbol if several exist, NoSymbol if none exist

def memberBasedOnName(name: Name, excludedFlags: Long): Symbol

def memberInfo(sym: Symbol): Type

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

class D[T] { def m: T }
class C extends p.D[Int]
ThisType(C).memberType(m) = Int

def memberType(sym: Symbol): Type

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

def members: List[Symbol]

A list of all members of this type (defined or inherited) Members appear in linearization order of their owners.

def membersBasedOnFlags(excludedFlags: Long, requiredFlags: Long): List[Symbol]

Members excluding and requiring the given flags.

def membersWithFlags(requiredFlags: Long): List[Symbol]

All members with the given flags, excluding bridges.

def narrow: Type

Map to a singleton type which is a subtype of this type.

T.narrow  =  (T {}).this.type

final def ne(arg0: AnyRef): Boolean

def nonLocalMember(name: Name): Symbol

The non-local member with given name, an OverloadedSymbol if several exist, NoSymbol if none exist

def nonPrivateDecl(name: Name): Symbol

The non-private defined or declared members with name name in this type; an OverloadedSymbol if several exist, NoSymbol if none exist.

def nonPrivateDeclaration(name: Name): Symbol

def nonPrivateDecls: List[Symbol]

A list of all non-private members defined or declared in this type.

def nonPrivateMember(name: Name): Symbol

The non-private member with given name, an OverloadedSymbol if several exist, NoSymbol if none exist.

def nonPrivateMemberAdmitting(name: Name, admit: Long): Symbol

The non-private member with given name, admitting members with given flags admit.

def nonPrivateMembers: List[Symbol]

A list of all non-private members of this type (defined or inherited)

def nonPrivateMembersAdmitting(admit: Long): List[Symbol]

A list of all non-private members of this type (defined or inherited), admitting members with given flags admit

def nonPrivateMembersWithFlags(requiredFlags: Long): List[Symbol]

All non-private members with the given flags, excluding bridges.

def normalize: Type

Reduce to beta eta-long normal form.

def notNull: Type

Mixin a NotNull trait unless type already has one .

final def notify(): Unit

final def notifyAll(): Unit

def objectPrefix: String

def packagePrefix: String

def paramSectionCount: Int

For a method type, the number of its value parameter sections, 0 for all other types

def paramTypes: List[Type]

For a method or poly type, the types of its first value parameter section, the empty list for all other types

def params: List[Symbol]

For a method or poly type, its first value parameter section, the empty list for all other types

def paramss: List[List[Symbol]]

For a method or poly type, a list of its value parameter sections, the empty list for all other types

def parents: List[Type]

For a class or intersection type, its parents.

def prefix: Type

For a typeref or single-type, the prefix of the normalized type (@see normalize).

def prefixChain: List[Type]

A chain of all typeref or singletype prefixes of this type, longest first.

def prefixString: String

The string representation of this type used as a prefix

def remove(clazz: Symbol): Type

If this is a TypeRef clazz[T], return the argument T otherwise return this type

def removeAnnotation(cls: Symbol): Type

def resultApprox: Type

Only used for dependent method types.

def resultType(actuals: List[Type]): Type

def resultType: Type

For a (nullary) method or poly type, its direct result type, the type itself for all other types.

def safeToString: String

Method to be implemented in subclasses.

val self: Any

val self: Any

def selfsym: Symbol

The selfsym of an annotated type, or NoSymbol of anything else

def setAnnotations(annots: List[AnnotationInfo]): Type

def skolemizeExistential: Type

A simple version of skolemizeExistential for situations where owner or unpack location do not matter (typically used in subtype tests)

def skolemizeExistential(owner: Symbol, origin: AnyRef): Type

If this type is an existential, turn all existentially bound variables to type skolems.

def skolemsExceptMethodTypeParams: List[Symbol]

The (existential or otherwise) skolems and existentially quantified variables which are free in this type

def specializes(sym: Symbol): Boolean

Does this type implement symbol sym with same or stronger type?

def stat_<:<(that: Type): Boolean

def stripAnnotations: Type

Remove any annotations from this type and from any types embedded in this type.

def subst(from: List[Symbol], to: List[Type]): Type

Substitute types to for occurrences of references to symbols from in this type.

def substSym(from: List[Symbol], to: List[Symbol]): Type

Substitute symbols to for occurrences of symbols from in this type.

def substThis(from: Symbol, to: Symbol): Type

def substThis(from: Symbol, to: Type): Type

Substitute all occurrences of ThisType(from) in this type by to.

def substThisAndSym(from: Symbol, to: Type, symsFrom: List[Symbol], symsTo: List[Symbol]): Type

Performs both substThis and substSym in one traversal.

def substituteTypes(from: List[Symbol], to: List[Type]): Type

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

def termSymbol: Symbol

The term symbol associated with the type Note that the symbol of the normalized type is returned (@see normalize)

def termSymbolDirect: Symbol

The term symbol directly associated with the type.

def throwsAnnotations(): List[Symbol]

Symbols of any @throws annotations on this symbol.

def toLongString: String

The string representation of this type, with singletypes explained.

def toString(): String

Convert toString avoiding infinite recursions by cutting off after maxTostringRecursions recursion levels.

def trimPrefix(str: String): String

def typeArgs: List[Type]

For a typeref, its arguments.

def typeArguments: List[Type]

def typeConstructor: Type

This type, without its type arguments @M

def typeOfThis: Type

The type of this of a class type or reference type.

def typeParams: List[Symbol]

For a (potentially wrapped) poly type, its type parameters, the empty list for all other types

def typeSymbol: Symbol

The type symbol associated with the type Note that the symbol of the normalized type is returned (@see normalize) A type's typeSymbol should if possible not be inspected directly, due to the likelihood that what is true for tp.

def typeSymbolDirect: Symbol

The type symbol directly associated with the type.

def underlying: Type

The base type underlying a type proxy, identity on all other types

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def weak_<:<(that: Type): Boolean

Is this type a weak subtype of that type? True also for numeric types, i.

def widen: Type

Widen from singleton type to its underlying non-singleton base type by applying one or more underlying dereferences, identity for all other types.

final def withAnnotation(annot: AnnotationInfo): Type

def withAnnotations(annots: List[AnnotationInfo]): Type

def withFilter(p: (Type) ⇒ Boolean): FilterMapForeach

def withSelfsym(sym: Symbol): Type

Set the self symbol of an annotated type, or do nothing otherwise.

def withoutAnnotations: Type

def →[B](y: B): (Type, B)

def x: Type

def x: Type