Type

abstract def hash: Int

customized hash code of this type.

final def !=(arg0: Any): Boolean

final def ##(): 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.

final def ==(arg0: Any): Boolean

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

The set of abstract term members of this type.

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

The set of abstract type members of this type.

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

final def asInstanceOf[T0]: T0

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.

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.

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

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 type, or because superclasses are ambiguous).

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

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

def clone(): AnyRef

final def deAnonymize(implicit ctx: Context): Type

Eliminate anonymous classes

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.

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.

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

A denotation containing the declaration(s) in this type with the given name.

final def decls(implicit ctx: Context): Scope

The scope of all declarations of this type.

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.

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

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

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

Is this type different from NoType?

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.

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 fields(implicit ctx: Context): Seq[SingleDenotation]

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.

def finalize(): Unit

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.

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.

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]

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 = false)(implicit ctx: Context): Unit

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?

final def getClass(): Class[_]

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 hashCode(): Int

def hashSeed: Int

final def identityHash: Int

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

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?

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?

final def isInstanceOf[T0]: Boolean

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.

final def isParameterless(implicit ctx: Context): Boolean

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

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.

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 alias, return the alias, otherwise return NoType.

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

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

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:

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[SingleDenotation]

The set of member classes of this type

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

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

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

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

The parts of this type which are type or term refs

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.

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 ne(arg0: AnyRef): Boolean

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

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.

def notApplied: Type

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

final def notify(): Unit

final def notifyAll(): Unit

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 identified, and T is seen as overriding either type.

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

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

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

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

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

For a ClassInfo type, its parents, Inherited by all type proxies.

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

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 safe_&(that: Type)(implicit ctx: Context): Type

Safer version of &.

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

The type <this .

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

The type <this .

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

The type <this .

def show(implicit ctx: Context): String

The string representation of this showable element.

def showSummary(implicit ctx: Context): String

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

The summarized string representation of this showable element.

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.

def signature(implicit ctx: Context): Signature

The signature of this type.

def simplified(implicit ctx: Context): Type

A simplified version of this type which is equivalent wrt =:= to this type.

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.

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 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 substDealias(from: List[Symbol], to: List[Type])(implicit ctx: Context): Type

Same as subst but follows aliases as a fallback.

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.

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

final def termSymbol(implicit ctx: Context): Symbol

The term symbol associated with the type

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

Turn type into a function type.

def toString(): String

def toText(printer: Printer): Text

Convert to text

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

The set of type members of this type

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

The type parameter with given name.

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 underlyingIterator(implicit ctx: Context): Iterator[Type]

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

val uniqId: Int

def unsupported(methodName: String): Nothing

Throws an UnsupportedOperationException with the given method name.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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.

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.

final def widenIfUnstable(implicit ctx: Context): Type

Widen type if it is unstable (i.e.

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 |(that: Type)(implicit ctx: Context): Type