abstract class Type

Main class representing types.

The principal subclasses and sub-objects are as follows:

Type -+- ProxyType --+- NamedType ----+--- TypeRef
      |              |                 \
      |              +- SingletonType-+-+- TermRef
      |              |                |
      |              |                +--- ThisType
      |              |                +--- SuperType
      |              |                +--- ConstantType
      |              |                +--- MethodParam
      |              |                +----RecThis
      |              |                +--- SkolemType
      |              +- PolyParam
      |              +- RefinedOrRecType -+-- RefinedType
      |              |                   -+-- RecType
      |              +- HKApply
      |              +- TypeBounds
      |              +- ExprType
      |              +- AnnotatedType
      |              +- TypeVar
      |              +- PolyType
      |
      +- GroundType -+- AndType
                     +- OrType
                     +- MethodType -----+- ImplicitMethodType
                     |                  +- JavaMethodType
                     +- ClassInfo
                     |
                     +- NoType
                     +- NoPrefix
                     +- ErrorType
                     +- WildcardType

Note: please keep in sync with copy in docs/docs/internals/type-system.md.

Members

val uniqId : Int
def & ( that: Type ) ( implicit ctx: Context ) : Type
final def <:< ( that: Type ) ( implicit ctx: Context ) : Boolean

Is this type a subtype of that 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.

def EtaExpand ( tparams: List [ TypeSymbol ] ) ( implicit ctx: Context ) : Type

Convert a type constructor TC which has type parameters T1, ..., Tn in a context where type parameters U1,...,Un are expected to

LambdaXYZ { Apply = TCh...

def EtaExpandIfHK ( bound: Type ) ( implicit ctx: Context ) : Type

Eta expand if self is a (non-lambda) class reference and bound is a higher-kinded type

def LambdaAbstract ( tparams: List [ TypeParamInfo ] ) ( implicit ctx: Context ) : Type

Lambda abstract self with given type parameters. Examples:

type T[X] = U        becomes    type T = [X] -> U
type T[X] >: L <: U  becomes    type T >: L <: ([X] -> U)

TODO: Handle parameterized lower bounds

final def abstractTermMembers ( implicit ctx: Context ) : Seq

The set of abstract term members of this type.

final def abstractTypeMembers ( implicit ctx: Context ) : Seq

The set of abstract type members of this type.

def adaptHkVariances ( bound: Type ) ( implicit ctx: Context ) : Type

If argument A and type parameter P are higher-kinded, adapt the variances of A to those of P, ensuring that the variances of the type lambda A agree wit...

[X] [List]

[X][X]

[+X][X]

GenericCompanion[[X] -> ListBuffer[X]] <: GenericCompanion[[+X] -> GenTraversable[X]]

[X][X]

def appliedTo ( arg1: Type , arg2: Type ) ( implicit ctx: Context ) : Type
def appliedTo ( args: List [ Type ] ) ( implicit ctx: Context ) : Type

The type representing

T[U1, ..., Un]

where

def appliedTo ( arg: Type ) ( implicit ctx: Context ) : Type
def applyIfParameterized ( args: List [ Type ] ) ( implicit ctx: Context ) : Type
def argInfo ( implicit ctx: Context ) : Type

If this is the image of a type argument; recover the type argument, otherwise NoType.

def argInfos ( implicit ctx: Context ) : List

If this is an encoding of a (partially) applied type, return its arguments, otherwise return Nil. Existential types in arguments are returned as TypeBou...

def argTypes ( implicit ctx: Context ) : List

Argument types where existential types in arguments are disallowed

def argTypesHi ( implicit ctx: Context ) : List

Argument types where existential types in arguments are approximated by their upper bound

def argTypesLo ( implicit ctx: Context ) : List

Argument types where existential types in arguments are approximated by their lower bound

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.

def baseArgInfos ( base: Symbol ) ( implicit ctx: Context ) : List

The type arguments of this type's base type instance wrt. base. Existential types in arguments are returned as TypeBounds instances.

def baseArgTypes ( base: Symbol ) ( implicit ctx: Context ) : List

The type arguments of this type's base type instance wrt.base. Existential types in arguments are disallowed.

def baseArgTypesHi ( base: Symbol ) ( implicit ctx: Context ) : List

The type arguments of this type's base type instance wrt.base. Existential types in arguments are approximated by their upper bound.

def baseArgTypesLo ( base: Symbol ) ( implicit ctx: Context ) : List

The type arguments of this type's base type instance wrt.base. Existential types in arguments are approximated by their lower bound.

final def baseClasses ( implicit ctx: Context ) : List

The base classes of this type as determined by ClassDenotation in linearization order, with the class itself as first element. For AndTypes/OrTypes, the...

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

def baseTypeWithArgs ( base: Symbol ) ( implicit ctx: Context ) : Type

The base type including all type arguments and applicable refinements of this type. Refinements are applicable if they refine a member of the parent typ...

final def bounds ( implicit ctx: Context ) : TypeBounds

This type seen as a TypeBounds

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...

final def classSymbols ( implicit ctx: Context ) : List

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

final def deAnonymize ( implicit ctx: Context ) : Type

Eliminate anonymous classes

private def dealias ( keepAnnots: Boolean ) ( implicit ctx: Context ) : 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 inst...

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. Goes thro...

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

A denotation containing the declaration(s) in this type with the given name. The result is either a SymDenotation or a MultiDenotation of SymDenotation...

final def decls ( implicit ctx: Context ) : Scope

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

final def deconst ( implicit ctx: Context ) : Type

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

def deepenProto ( implicit ctx: Context ) : Type

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

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

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

def dropAlias ( implicit ctx: Context ) : Type

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

def elemType ( implicit ctx: Context ) : Type

The element type of a sequence or array

def ensureHK ( implicit ctx: Context ) : Type

If self is not higher-kinded, eta expand it.

def ensureMethodic ( implicit ctx: Context ) : Type
def exists : Boolean

Is this type different from NoType?

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

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

def existsPart$default$2 : Boolean

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

final def fields ( implicit ctx: Context ) : Seq
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.

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. Declarations that have a flag in excluded are...

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. Exclude all member...

final def firstParamTypes ( implicit ctx: Context ) : List

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

def firstParent ( implicit ctx: Context ) : TypeRef

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

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

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

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

Performs operation on all parts of this type

def foreachPart$default$2 : Boolean

Performs operation on all parts of this type

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

Is this type a subtype of that type?

def givenSelfType ( implicit ctx: Context ) : Type

the self type of the underlying classtype

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

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

final def hasUnsafeNonvariant ( implicit ctx: Context ) : Boolean

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

def hash : Int

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

def hkTypeParams ( implicit ctx: Context ) : List

If self is a higher-kinded type, its type parameters, otherwise Nil

final def implicitMembers ( implicit ctx: Context ) : List

The set of implicit members of this type

def isAlias : Boolean

Is this an alias TypeBounds?

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

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

def isErasedValueType ( implicit ctx: Context ) : Boolean
final def isErroneous ( implicit ctx: Context ) : Boolean

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

final def isError ( implicit ctx: Context ) : Boolean

Is this type produced as a repair for an error?

def isHK ( implicit ctx: Context ) : Boolean

Is self type higher-kinded (i.e. of kind != "*")?

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.

def isNullaryMethod ( implicit ctx: Context ) : Boolean

Is this the type of a method with a leading empty parameter list?

final def isParameterless ( implicit ctx: Context ) : Boolean

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

def isPrimitiveValueType ( implicit ctx: Context ) : Boolean
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?

def isRepeatedParam ( implicit ctx: Context ) : Boolean

Is this a type of a repeated parameter?

final def isStable ( implicit ctx: Context ) : Boolean

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

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

Does this type refer exactly to class symbol sym, instead of to a subclass of sym? Implemented like isRef, but follows more types: all type proxies as...

final def isUnsafeNonvariant ( implicit ctx: Context ) : Boolean

Does this type carry an UnsafeNonvariant annotation?

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?

final def isValueType : Boolean

Is this type a value type?

final def isValueTypeOrLambda : Boolean

Is the is value type or type lambda?

def isVarArgsMethod ( implicit ctx: Context ) : Boolean

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

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... 

P { type T = String, type R = P{...}.T } # R  -->  String

def mapReduceAnd ( f: Type => T ) ( g: (T, T) => T ) ( implicit ctx: Context ) : T

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

final def mapReduceOr ( f: Type => T ) ( g: (T, T) => T ) ( implicit ctx: Context ) : T

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

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: - Either both types are polytypes with t...

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.

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

The member of this type with the given name

final def memberClasses ( implicit ctx: Context ) : Seq

The set of member classes of this type

def memberDenots ( keepOnly: NameFilter , f: (Name, Buffer [ SingleDenotation ]) => Unit ) ( implicit ctx: Context ) : Seq
final def memberExcluding ( name: Name , excluding: FlagSet ) ( implicit ctx: Context ) : Denotation
final def memberInfo ( sym: Symbol ) ( implicit ctx: Context ) : Type

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

final def memberNames ( keepOnly: NameFilter , pre: Type ) ( implicit ctx: Context ) : Set

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...

def memberNames$default$2 : Type

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...

final def membersBasedOnFlags ( requiredFlags: FlagSet , excludedFlags: FlagSet ) ( implicit ctx: Context ) : Seq

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

final def namedParts ( implicit ctx: Context ) : Set

The parts of this type which are type or term refs

def namedPartsWith ( p: NamedType => Boolean , excludeLowerBounds: Boolean ) ( implicit ctx: Context ) : Set

The parts of this type which are type or term refs and which satisfy predicate p.

def namedPartsWith$default$2 : Boolean

The parts of this type which are type or term refs and which satisfy predicate p.

def namedTypeParams ( implicit ctx: Context ) : Set

The named type parameters declared or inherited by this type. These are all uninstantiated named type parameters of this type or one of its base types.

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.

final def nonClassTypeMembers ( implicit ctx: Context ) : Seq

The set of abstract type members of this 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

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

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

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. Inheri...

def notApplied : Type

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

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

Does this type occur as a part of type that?

def orElse ( that: => Type ) : Type

This type, if it exists, otherwise that 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 ident...

final def paramNamess ( implicit ctx: Context ) : List

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

final def paramTypess ( implicit ctx: Context ) : List

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

def parents ( implicit ctx: Context ) : List

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

def parentsWithArgs ( implicit ctx: Context ) : List

The full parent types, including all type arguments

def relaxed_<:< ( that: Type ) ( implicit ctx: Context ) : Boolean
def resultType ( implicit ctx: Context ) : Type

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

def safeAppliedTo ( args: List [ Type ] ) ( implicit ctx: Context ) : Type

A cycle-safe version of appliedTo where computing type parameters do not force the typeconstructor. Instead, if the type constructor is completing, we...

def safeDealias ( implicit ctx: Context ) : Type

Dealias type if it can be done without forcing the TypeRef's info

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

Safer version of &.

This version does not simplify the upper bound of the intersection of two TypeBounds. The simplification done by & requires subtypin...

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

The type <this . name> , reduced if possible

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

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

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

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

def showWithUnderlying ( n: Int ) ( implicit ctx: Context ) : String

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

def showWithUnderlying$default$1 : Int

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

def signature ( implicit ctx: Context ) : Signature

The signature of this type. This is by default NotAMethod, but is overridden for PolyTypes, MethodTypes, and TermRefWithSignature types. (the reason why...

def simplified ( implicit ctx: Context ) : 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 vari...

def stripAnnots ( implicit ctx: Context ) : Type

Remove all AnnotatedTypes wrapping this 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. Identity on all other types...

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.

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

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

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

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

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

Substitute a bound type by some other type

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

Substitute bound types by some other types

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

Substitute all occurrences of RecThis(binder) by tp

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

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

Substitute all occurrences of This(cls) by tp

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

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

final def termSymbol ( implicit ctx: Context ) : Symbol

The term symbol associated with the type

def toBounds ( tparam: TypeParamInfo ) ( implicit ctx: Context ) : TypeBounds

Turn this type, which is used as an argument for type parameter tparam, into a TypeBounds RHS

def toFunctionType ( dropLast: Int ) ( implicit ctx: Context ) : Type

Turn type into a function type.

def toFunctionType$default$1 : Int

Turn type into a function type.

def toText ( printer: Printer ) : Text

Convert to text

def translateParameterized ( from: ClassSymbol , to: ClassSymbol ) ( implicit ctx: Context ) : Type

Translate a type of the form From[T] to To[T], keep other types as they are. from and to must be static classes, both with one type parameter, and the same... [T][T]

final def typeMembers ( implicit ctx: Context ) : Seq

The set of type members of this type

def typeParamNamed ( name: TypeName ) ( implicit ctx: Context ) : Symbol

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

def typeParamSymbols ( implicit ctx: Context ) : List

If self is a generic class, its type parameter symbols, otherwise Nil

def typeParams ( implicit ctx: Context ) : List

The type parameters of this type are: For a ClassInfo type, the type parameters of its class. For a typeref referring to a class, the type parameters of...

final def typeSymbol ( implicit ctx: Context ) : Symbol

The type symbol associated with the 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.

def underlyingIfProxy ( implicit ctx: Context ) : Type

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

def underlyingIfRepeated ( isJava: Boolean ) ( implicit ctx: Context ) : Type

If this is repeated parameter type, its underlying Seq type, or, if isJava is true, Array type, else the type itself.

def underlyingIterator ( implicit ctx: Context ) : Iterator

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

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. Identity for...

final def widenDealias ( implicit ctx: Context ) : Type

Perform successive widenings and dealiasings until none can be applied anymore

final def widenExpr : Type

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

final def widenIfUnstable ( implicit ctx: Context ) : Type

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

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.

final def widenSkolem ( implicit ctx: Context ) : Type

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

final def widenTermRefExpr ( implicit ctx: Context ) : Type

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

def widenToNamedTypeParams ( params: Set [ TypeSymbol ] ) ( implicit ctx: Context ) : Type

The smallest supertype of this type that instantiated none of the named type parameters in params. That is, for each named type parameter p in params,...

def withoutArgs ( typeArgs: List [ Type ] ) : Type

The core type without any type arguments.

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