Trait scala.reflect.api.Types

The API that all annotated types support. The main source of information about types is the scala.reflect.api.Types page.

An extractor class to create and pattern match with syntax AnnotatedType(annotations, underlying). Here, annotations are the annotations decorating the underlying type underlying. selfSym is a symbol representing the annotated type itself.

BoundedWildcardTypes, used only during type inference, are created in two places:

If the expected type of an expression is an existential type, its hidden symbols are replaced with bounded wildcards. 2. When an implicit conversion is being sought based in part on the name of a method in the converted type, a HasMethodMatching type is created: a MethodType with parameters typed as BoundedWildcardTypes.

The API that all this types support. The main source of information about types is the scala.reflect.api.Types page.

The ClassInfo type signature is used to define parents and declarations of classes, traits, and objects. If a class, trait, or object C is declared like this

C extends P_1 with ... with P_m { D_1; ...; D_n}

its ClassInfo type has the following form:

ClassInfo(List(P_1, ..., P_m), Scope(D_1, ..., D_n), C)

The API that all class info types support. The main source of information about types is the scala.reflect.api.Types page.

Has no special methods. Is here to provides erased identity for CompoundType.

A ConstantType type cannot be expressed in user programs; it is inferred as the type of a constant. Here are some constants with their types and the internal string representation:

1           ConstantType(Constant(1))       Int(1)
"abc"       ConstantType(Constant("abc"))   String("abc")

ConstantTypes denote values that may safely be constant folded during type checking. The deconst operation returns the equivalent type that will not be constant folded.

The API that all constant types support. The main source of information about types is the scala.reflect.api.Types page.

The API that all existential types support. The main source of information about types is the scala.reflect.api.Types page.

An extractor class to create and pattern match with syntax ExistentialType(quantified, underlying). Here, quantified are the type variables bound by the existential type and underlying is the type that's existentially quantified.

The API that all method types support. The main source of information about types is the scala.reflect.api.Types page.

An extractor class to create and pattern match with syntax MethodType(params, restpe) Here, params is a potentially empty list of parameter symbols of the method, and restpe is the result type of the method. If the method is curried, restpe would be another MethodType. Note: MethodType(Nil, Int) would be the type of a method defined with an empty parameter list.

def f(): Int

If the method is completely parameterless, as in

def f: Int

its type is a NullaryMethodType.

The API that all nullary method types support. The main source of information about types is the scala.reflect.api.Types page.

An extractor class to create and pattern match with syntax NullaryMethodType(resultType). Here, resultType is the result type of the parameterless method.

The API that all polymorphic types support. The main source of information about types is the scala.reflect.api.Types page.

An extractor class to create and pattern match with syntax PolyType(typeParams, resultType). Here, typeParams are the type parameters of the method and resultType is the type signature following the type parameters.

The RefinedType type defines types of any of the forms on the left, with their RefinedType representations to the right.

P_1 with ... with P_m { D_1; ...; D_n}      RefinedType(List(P_1, ..., P_m), Scope(D_1, ..., D_n))
P_1 with ... with P_m                       RefinedType(List(P_1, ..., P_m), Scope())
{ D_1; ...; D_n}                            RefinedType(List(AnyRef), Scope(D_1, ..., D_n))

The API that all refined types support. The main source of information about types is the scala.reflect.api.Types page.

The SingleType type describes types of any of the forms on the left, with their TypeRef representations to the right.

(T # x).type             SingleType(T, x)
p.x.type                 SingleType(p.type, x)
x.type                   SingleType(NoPrefix, x)

The API that all single types support. The main source of information about types is the scala.reflect.api.Types page.

The type of Scala singleton types, i.e., types that are inhabited by only one nun-null value. These include types of the forms

C.this.type
C.super.type
x.type

as well as constant types.

Has no special methods. Is here to provides erased identity for SingletonType.

The SuperType type is not directly written, but arises when C.super is used as a prefix in a TypeRef or SingleType. Its internal presentation is

SuperType(thistpe, supertpe)

Here, thistpe is the type of the corresponding this-type. For instance, in the type arising from C.super, the thistpe part would be ThisType(C). supertpe is the type of the super class referred to by the super.

The API that all super types support. The main source of information about types is the scala.reflect.api.Types page.

A singleton type that describes types of the form on the left with the corresponding ThisType representation to the right:

C.this.type             ThisType(C)

The API that all this types support. The main source of information about types is the scala.reflect.api.Types page.

The type of Scala types, and also Scala type signatures. (No difference is internally made between the two).

The API of types. The main source of information about types is the scala.reflect.api.Types page.

The TypeBounds type signature is used to indicate lower and upper type bounds of type parameters and abstract types. It is not a first-class type. If an abstract type or type parameter is declared with any of the forms on the left, its type signature is the TypeBounds type on the right.

T >: L <: U               TypeBounds(L, U)
T >: L                    TypeBounds(L, Any)
T <: U                    TypeBounds(Nothing, U)

The API that all type bounds support. The main source of information about types is the scala.reflect.api.Types page.

The TypeRef type describes types of any of the forms on the left, with their TypeRef representations to the right.

T # C[T_1, ..., T_n]      TypeRef(T, C, List(T_1, ..., T_n))
p.C[T_1, ..., T_n]        TypeRef(p.type, C, List(T_1, ..., T_n))
C[T_1, ..., T_n]          TypeRef(NoPrefix, C, List(T_1, ..., T_n))
T # C                     TypeRef(T, C, Nil)
p.C                       TypeRef(p.type, C, Nil)
C                         TypeRef(NoPrefix, C, Nil)

The API that all type refs support. The main source of information about types is the scala.reflect.api.Types page.