Type

Compute hashcode relative to enclosing binders bs

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

Is this type a subtype of that type?

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

Convert a type constructor TC which has type parameters X1, ..., Xn to [X1, ..., Xn] -> TC[X1, ..., Xn].

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

The set of abstract term members of this type.

The set of abstract type members of this type.

All members of this type. Warning: this can be expensive to compute!

If this is an AndType, the number of factors, 1 for all other types

The type representing

T[U1, ..., Un]

where

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

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

Argument types where existential types in arguments are disallowed

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

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

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

The singleton types that must or may be in this type. @see Atoms. Overridden and cached in OrType.

The base classes of this type as determined by ClassDenotation in linearization order, with the class itself as first element. Inherited by all type proxies. Overridden for And and Or types. Nil for all other types.

The basetype of this type with given class symbol, NoType if base is not a class.

This type seen as a TypeBounds

The capture set of this type. Overridden and cached in CaptureRef

A type capturing ref

A type capturing the capture set cs. If this type is already a capturing type the two capture sets are combined.

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 (wrt <:<) set of class symbols of which this type is a subtype

Does this type contain wildcard types?

The set of distinct symbols referred to by this type, after all aliases are expanded

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

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

Like dealiasKeepAnnots, but keeps only refining annotations

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.

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

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

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

If this is a prototype with some ignored component, reveal it, and deepen the result transitively. Otherwise the type itself.

Does this type have a supertype with an annotation satisfying given predicate p?

True if this type is an instance of the given cls or an instance of a non-bottom subclass of cls.

Approximate this type with a type that does not contain skolem types.

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

Drop annotation of given cls from this type

Dealias, and if result is a dependent function type, drop the apply refinement.

If this is a proto type, WildcardType, otherwise the type itself

The element type of a sequence or array

If self is not lambda-bound, eta expand it.

Equality used for hash-consing; uses eq on all recursive invocations, except where a BindingType is involved. The latter demand a deep isomorphism check.

Compare this == that, assuming corresponding binders in bs are equal. The normal equals should be equivalent to equals(that, null). We usually overrideequalswhen we overrideisoexcept if theequals` comes from a case class, so it already has the right definition anyway.

Is this type different from NoType?

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

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

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.

Determine the expected function type from the prototype. If no function type is found, NoType is returned. If multiple function types are found in an intersection, their intersection is returned. This works since & invokes TypeComparer.distributeAnd, which ensures that (A1 => B1) & (A2 => B2) simplifies to (A1 | A2) => (B1 & B2), so the result is again a function type. An analogous distribution mechanism does not exist for |. Therefore, a union of function types also yields NoType, since we cannot determine a single expected function type.

Find member of this type with given name, all required flags and no excluded flag and produce a denotation that contains the type of the member as seen from given prefix pre.

The parameter names 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

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

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

Performs operation on all parts of this type

Is this type a subtype of that type?

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

Is this type of kind AnyKind?

Same as this.classSymbols.contains(cls) but more efficient

Do self and other have the same kinds (not counting bounds and variances)? Note: An any-kinded type "has the same kind" as any other type.

Is self type of kind "*"?

Is the hash of this type the same for all possible sequences of enclosing binders?

The upper bound of a TypeBounds type, the type itself otherwise

If self type is higher-kinded, its result type, otherwise NoType. Note: The hkResult of an any-kinded type is again AnyKind.

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

The set of implicit term members of this type

True iff symd is a denotation of a class type parameter and the reference `

 . ` is an actual argument reference, i.e. `pre` is not the
ThisType of `symd`'s owner, or a reference to `symd`'s owner.'

Is this a Method or PolyType which has contextual parameters as first value parameter list?

Is this a higher-kinded type lambda with given parameter variances?

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

Is this a MethodType for which the parameters will not be used?

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

Is this type produced as a repair for an error?

Is this type exactly Any (no vars, aliases, refinements etc allowed)?

Is this type exactly Nothing (no vars, aliases, refinements etc allowed)?

Is this type exactly Null (no vars, aliases, refinements etc allowed)?

Does this type not refer to TypeParamRefs or uninstantiated TypeVars?

Is this a Method or PolyType which has implicit or contextual parameters?

Is self type bounded by a type lambda or AnyKind?

Is this a match type or a higher-kinded abstraction of one?

Same as hasClassSmbol(MatchableClass), except that we also follow the constraint bounds of type variables in the constraint.

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

Is this (an alias of) the scala.Nothing type?

Is this (an alias of) the scala.Null type?

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

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

Is this type still provisional? This is the case if the type contains, or depends on, uninstantiated type variables or type symbols that have the Provisional flag set. This is an antimonotonic property - once a type is not provisional, it stays so forever.

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

Is this a type of a repeated parameter?

Is this type a (possibly aliased) singleton type?

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

Like in isStableMember, "stability" means idempotence. Rationale: If an expression has a stable type, the expression must be idempotent, so stable types must be singleton types of stable expressions.

Is this an alias TypeBounds?

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

Is this type a value type?

Is this a value type or a type lambda?

Is this a value type or a wildcard?

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

Is this isomorphic to that, assuming pairs of matching binders bs? It is assumed that this.ne(that).

The lower bound of a TypeBounds type, the type itself otherwise

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.

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

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

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.

Under explicit nulls, this function will always use unsafe-nulls semamtics to check the types. This is because we are using a relaxed rule (ignoring Null types) to check overriding Java methods.

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

The member of this type with the given name

The member with given name and required and/or excluded flags

The set of member classes of this type

The info of sym, seen as a member of this 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 that keepOnly(pre, name) is true.

The set of members of this type that have all of required flags but none of excluded flags set.

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

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

The set of abstract type members of this type.

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

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

The result of normalization using tryNormalize, or the type itself if tryNormlize yields NoType

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.

Does this type occur as a part of type that?

This type, if it exists, otherwise that type

If this is a OrType, the number of factors if that match soft, 1 for all other types.

Is this type a legal type for member sym1 that overrides another member sym2 of type that? This is the same as <:<, except that

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

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

The least (wrt <:<) set of symbols satisfying the include predicate of which this type is a subtype

The full parent types, including all type arguments

Returns the set of methods that are abstract and do not overlap with any of java.lang.Object methods.

Conceptually, a SAM (functional interface) has exactly one abstract method. If an interface declares an abstract method overriding one of the public methods of java.lang.Object, that also does not count toward the interface's abstract method count.

this & that, but handle CyclicReferences by falling back to safe_&.

If this is a repeated type, its element type, otherwise the type itself

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

If this is an ignored proto type, its underlying type, otherwise the type itself

A cycle-safe version of appliedTo where computing type parameters do not force the typeconstructor. Instead, if the type constructor is completing, we make up hk type parameters matching the arguments. This is needed when unpickling Scala2 files such as scala.collection.generic.Mapfactory.

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

Safer version of &.

This version does not simplify the bounds 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). pos/i536 demonstrates that the infinite loop can also involve lower bounds.

The type <this . name> , reduced if possible

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

The type <this . sym>, reduced if possible

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

The signature of this type. This is by default NotAMethod, but is overridden for PolyTypes, MethodTypes, and TermRef 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).

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.
• maps poly params in the current constraint set back to their type vars.
• forces match types to be fully defined and tries to normalize them.

NOTE: Simplifying an intersection type might change its erasure (for example, the Java erasure of Object & Serializable is Object, but its simplification is Serializable). This means that simplification should never be used in a MethodicType, because that could lead to a different signature. Since this isn't very useful anyway, this method handles this by never simplifying inside a MethodicType, except for replacing type parameters with associated type variables.

Remove all AnnotatedTypes wrapping this type.

Strip LazyRef wrappers

Strip PolyType prefixes

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.

Strip TypeVars and Annotation and CapturingType wrappers

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 of the form TypeParamRef(from, N) by TypeParamRef(to, N).

Substitute all occurrences of symbols in from by corresponding types in to. Unlike for subst, the to types can be type bounds. A TypeBounds target will be replaced by range that gets absorbed in an approximating type map.

Substitute a bound type by some other type

Substitute bound types by some other types

Substitute all occurrences of RecThis(binder) by tp

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

Substitute all occurrences of This(cls) by tp

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

The term symbol associated with the type

Turns non-bounds types to type bounds. A (possible lambda abstracted) match type is turned into a match alias. Every other type is turned into a type alias

Turn type into a function type.

Convert to text

The top type with the same kind as self. This is largest type capturing the parameter shape of a type without looking at precise bounds.

• The top-type of simple-kinded types is Any
• A kind like (* -> *) -> * is represented by the top type [X1 <: [X2] =>> Any] =>> Any

If this is a repeated parameter *T, translate it to either Seq[T] or Array[? <: T] depending on the value of toArray. Additionally, if translateWildcard is true, a wildcard type will be translated to *<?>. Other types are kept as-is.

Translate T to T & Object in the situations where an Array[T] coming from Java would need to be interpreted as an Array[T & Object] to be erased correctly.

Object is the top-level type in Java, but when it appears in a Java signature we replace it by a special FromJavaObject type for convenience, this in turns requires us to special-case generic arrays as described in case 3 in the documentation of FromJavaObjectSymbol. This is necessary because a fully generic Java array erases to an array of Object, whereas a fully generic Scala array erases to Object to allow primitive arrays as subtypes.

Note: According to http://cr.openjdk.java.net/~briangoetz/valhalla/sov/02-object-model.html, it's possible that future JVMs will consider that:

int[] <: Integer[] <: Object[]

So hopefully our grand-children will not have to deal with this non-sense!

Translate a type of the form From[T] to either To[T] or To[? <: T] (if wildcardArg is set). Keep other types as they are. from and to must be static classes, both with one type parameter, and the same variance. Do the same for by name types => From[T] and => To[T]

Translate a From[T] into a *T.

If this type can be normalized at the top-level by rewriting match types of S[n] types, the result after applying all toplevel normalizations, otherwise NoType

The set of type alias members of this type

The type constructor of an applied type, otherwise the type itself

The set of type members of this type

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.

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

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 the class. For a refinement type, the type parameters of its parent, dropping any type parameter that is-rebound by the refinement.

The number of applications and refinements in this type, after all aliases are expanded

The type symbol associated with the type

If this is a (possibly aliased, annotated, and/or parameterized) reference to a class, the class type ref, otherwise NoType.

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

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

Is this type unusable for implicit search or overloading resolution since it has embedded errors that can match anything? This is weaker and more ad-hoc than isErroneous. The main differences are that we always consider aliases (since these are relevant for inference or resolution) but never consider prefixes (since these often do not constrain the search space anyway).

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

Perform successive widenings and dealiasings until none can be applied anymore

Perform successive widenings and dealiasings while rewrapping annotations, until none can be applied anymore

Perform successive widenings and dealiasings while rewrapping refining annotations, until none can be applied anymore

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

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

If this is a nullary method type, its result type

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

Widen all top-level singletons reachable by dealiasing and going to the operands of & and |. Overridden and cached in OrType.

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

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

Widen this type and if the result contains embedded soft union types, replace them by their joins. "Embedded" means: inside type lambdas, intersections or recursive types, in prefixes of refined types, or in hard union types. If an embedded soft union is found, we first try to simplify or eliminate it by re-lubbing it while allowing type parameters to be constrained further. Any remaining union types are replaced by their joins.

For instance, if A is an unconstrained type variable, then

  ArrayBuffer[Int] | ArrayBuffer[A]

is approximated by constraining A to be =:= to Int and returning ArrayBuffer[Int] instead of ArrayBuffer[? >: Int | A <: Int & A]

Exception (if -YexplicitNulls is set): if this type is a nullable union (i.e. of the form T | Null), then the top-level union isn't widened. This is needed so that type inference can infer nullable types.

Overridden in OrType

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

The string representation of this showable element.

The string representation with each line after the first one indented by the given given margin (in spaces).

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