trait Types extends api.Types with TypeComparers with TypeToStrings with CommonOwners with GlbLubs with TypeMaps with TypeConstraints with FindMembers with Collections
- Alphabetic
- By Inheritance
- Types
- Collections
- FindMembers
- TypeConstraints
- TypeMaps
- GlbLubs
- CommonOwners
- TypeToStrings
- TypeComparers
- Types
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
trait
AnnotatedTypeApi extends Universe.TypeApi
The API that all annotated types support.
The API that all annotated types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
AnnotatedTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
AnnotatedType(annotations, underlying)
.An extractor class to create and pattern match with syntax
AnnotatedType(annotations, underlying)
. Here,annotations
are the annotations decorating the underlying typeunderlying
.selfSym
is a symbol representing the annotated type itself.- Definition Classes
- Types
-
trait
BoundedWildcardTypeApi extends Universe.TypeApi
The API that all this types support.
The API that all this types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
BoundedWildcardTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
BoundedWildcardTypeExtractor(bounds)
withbounds
denoting the type bounds.An extractor class to create and pattern match with syntax
BoundedWildcardTypeExtractor(bounds)
withbounds
denoting the type bounds.- Definition Classes
- Types
-
trait
ClassInfoTypeApi extends Universe.TypeApi
The API that all class info types support.
The API that all class info types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
ClassInfoTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
ClassInfo(parents, decls, clazz)
Here,parents
is the list of parent types of the class,decls
is the scope containing all declarations in the class, andclazz
is the symbol of the class itself.An extractor class to create and pattern match with syntax
ClassInfo(parents, decls, clazz)
Here,parents
is the list of parent types of the class,decls
is the scope containing all declarations in the class, andclazz
is the symbol of the class itself.- Definition Classes
- Types
-
trait
CompoundTypeApi extends AnyRef
Has no special methods.
Has no special methods. Is here to provides erased identity for
CompoundType
.- Definition Classes
- Types
-
trait
ConstantTypeApi extends Universe.TypeApi
The API that all constant types support.
The API that all constant types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
ConstantTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
ConstantType(constant)
Here,constant
is the constant value represented by the type.An extractor class to create and pattern match with syntax
ConstantType(constant)
Here,constant
is the constant value represented by the type.- Definition Classes
- Types
-
trait
ExistentialTypeApi extends Universe.TypeApi
The API that all existential types support.
The API that all existential types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
ExistentialTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
ExistentialType(quantified, underlying)
.An extractor class to create and pattern match with syntax
ExistentialType(quantified, underlying)
. Here,quantified
are the type variables bound by the existential type andunderlying
is the type that's existentially quantified.- Definition Classes
- Types
-
trait
MethodTypeApi extends Universe.TypeApi
The API that all method types support.
The API that all method types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
MethodTypeExtractor extends AnyRef
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, andrestpe
is the result type of the method.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, andrestpe
is the result type of the method. If the method is curried,restpe
would be anotherMethodType
. 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
.- Definition Classes
- Types
-
trait
NullaryMethodTypeApi extends Universe.TypeApi
The API that all nullary method types support.
The API that all nullary method types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
NullaryMethodTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
NullaryMethodType(resultType)
.An extractor class to create and pattern match with syntax
NullaryMethodType(resultType)
. Here,resultType
is the result type of the parameterless method.- Definition Classes
- Types
-
trait
PolyTypeApi extends Universe.TypeApi
The API that all polymorphic types support.
The API that all polymorphic types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
PolyTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
PolyType(typeParams, resultType)
.An extractor class to create and pattern match with syntax
PolyType(typeParams, resultType)
. Here,typeParams
are the type parameters of the method andresultType
is the type signature following the type parameters.- Definition Classes
- Types
-
trait
RefinedTypeApi extends Universe.TypeApi
The API that all refined types support.
The API that all refined types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
RefinedTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
RefinedType(parents, decls)
Here,parents
is the list of parent types of the class, anddecls
is the scope containing all declarations in the class.An extractor class to create and pattern match with syntax
RefinedType(parents, decls)
Here,parents
is the list of parent types of the class, anddecls
is the scope containing all declarations in the class.- Definition Classes
- Types
-
trait
SingleTypeApi extends Universe.TypeApi
The API that all single types support.
The API that all single types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
SingleTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
SingleType(pre, sym)
Here,pre
is the prefix of the single-type, andsym
is the stable value symbol referred to by the single-type.An extractor class to create and pattern match with syntax
SingleType(pre, sym)
Here,pre
is the prefix of the single-type, andsym
is the stable value symbol referred to by the single-type.- Definition Classes
- Types
-
trait
SingletonTypeApi extends AnyRef
Has no special methods.
Has no special methods. Is here to provides erased identity for
SingletonType
.- Definition Classes
- Types
-
trait
SuperTypeApi extends Universe.TypeApi
The API that all super types support.
The API that all super types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
SuperTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
SingleType(thistpe, supertpe)
An extractor class to create and pattern match with syntax
SingleType(thistpe, supertpe)
- Definition Classes
- Types
-
trait
ThisTypeApi extends Universe.TypeApi
The API that all this types support.
The API that all this types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
ThisTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
ThisType(sym)
wheresym
is the class prefix of the this type.An extractor class to create and pattern match with syntax
ThisType(sym)
wheresym
is the class prefix of the this type.- Definition Classes
- Types
-
abstract
class
TypeApi extends AnyRef
The API of types.
The API of types. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
trait
TypeBoundsApi extends Universe.TypeApi
The API that all type bounds support.
The API that all type bounds support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
TypeBoundsExtractor extends AnyRef
An extractor class to create and pattern match with syntax
TypeBound(lower, upper)
Here,lower
is the lower bound of theTypeBounds
pair, andupper
is the upper bound.An extractor class to create and pattern match with syntax
TypeBound(lower, upper)
Here,lower
is the lower bound of theTypeBounds
pair, andupper
is the upper bound.- Definition Classes
- Types
-
trait
TypeRefApi extends Universe.TypeApi
The API that all type refs support.
The API that all type refs support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
TypeRefExtractor extends AnyRef
An extractor class to create and pattern match with syntax
TypeRef(pre, sym, args)
Here,pre
is the prefix of the type reference,sym
is the symbol referred to by the type reference, andargs
is a possible empty list of type arguments.An extractor class to create and pattern match with syntax
TypeRef(pre, sym, args)
Here,pre
is the prefix of the type reference,sym
is the symbol referred to by the type reference, andargs
is a possible empty list of type arguments.- Definition Classes
- Types
- trait AbstractTypeRef extends SymbolTable.TypeRef with SymbolTable.NonClassTypeRef
- trait AliasTypeRef extends SymbolTable.TypeRef with SymbolTable.NonClassTypeRef
-
case class
AnnotatedType(annotations: List[SymbolTable.AnnotationInfo], underlying: SymbolTable.Type) extends SymbolTable.Type with SymbolTable.RewrappingTypeProxy with SymbolTable.AnnotatedTypeApi with Product with Serializable
A type carrying some annotations.
A type carrying some annotations. Created by the typechecker when eliminating Annotated trees (see typedAnnotated).
- annotations
the list of annotations on the type
- underlying
the type without the annotation
-
trait
AnnotationFilter extends SymbolTable.TypeMap
- Definition Classes
- TypeMaps
-
case class
AntiPolyType(pre: SymbolTable.Type, targs: List[SymbolTable.Type]) extends SymbolTable.Type with Product with Serializable
A class remembering a type instantiation for some a set of overloaded polymorphic symbols.
A class remembering a type instantiation for some a set of overloaded polymorphic symbols. Not used after phase
typer
. -
class
AppliedTypeVar extends SymbolTable.TypeVar
Precondition: zipped params/args nonEmpty.
Precondition: zipped params/args nonEmpty. (Size equivalence enforced structurally.)
- class ArgsTypeRef extends SymbolTable.TypeRef
-
class
AsSeenFromMap extends SymbolTable.TypeMap with SymbolTable.KeepOnlyTypeConstraints
A map to compute the asSeenFrom method.
A map to compute the asSeenFrom method.
- Definition Classes
- TypeMaps
-
case class
BoundedWildcardType(bounds: SymbolTable.TypeBounds) extends SymbolTable.Type with SymbolTable.BoundedWildcardTypeApi with Product with Serializable
BoundedWildcardTypes, used only during type inference, are created in two places that I can find:
BoundedWildcardTypes, used only during type inference, are created in two places that I can find:
- 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.
-
case class
ClassInfoType(parents: List[SymbolTable.Type], decls: SymbolTable.Scope, typeSymbol: SymbolTable.Symbol) extends SymbolTable.CompoundType with SymbolTable.ClassInfoTypeApi with Product with Serializable
A class representing a class info
- class ClassUnwrapper extends SymbolTable.TypeUnwrapper
-
class
CollectTypeCollector[T] extends SymbolTable.TypeCollector[List[T]]
A map to implement the
collect
method.A map to implement the
collect
method.- Definition Classes
- TypeMaps
-
class
CommonOwnerMap extends SymbolTable.TypeTraverserWithResult[SymbolTable.Symbol]
- Attributes
- protected
- Definition Classes
- CommonOwners
-
abstract
class
CompoundType extends SymbolTable.Type with SymbolTable.CompoundTypeApi
A common base class for intersection types and class types
-
abstract
case class
ConstantType(value: SymbolTable.Constant) extends SymbolTable.SingletonType with SymbolTable.ConstantTypeApi with Product with Serializable
A class representing a constant type.
-
class
ContainsCollector extends SymbolTable.TypeCollector[Boolean]
A map to implement the
contains
method.A map to implement the
contains
method.- Definition Classes
- TypeMaps
-
abstract
case class
ErasedValueType(valueClazz: SymbolTable.Symbol, erasedUnderlying: SymbolTable.Type) extends SymbolTable.UniqueType with Product with Serializable
A temporary type representing the erasure of a user-defined value type.
A temporary type representing the erasure of a user-defined value type. Created during phase erasure, eliminated again in posterasure.
scala/bug#6385 Erasure's creation of bridges considers method signatures
exitingErasure
, which containErasedValueType
-s. In order to correctly consider the overriding and overridden signatures as equivalent inrun/t6385.scala
, it is critical that this type contains the erasure of the wrapped type, rather than the unerased type of the value class itself, as was originally done.- valueClazz
The value class symbol
- erasedUnderlying
The erased type of the unboxed value
-
class
ExistentialExtrapolation extends SymbolTable.TypeMap
Used by existentialAbstraction.
Used by existentialAbstraction.
- Definition Classes
- TypeMaps
- case class ExistentialType(quantified: List[SymbolTable.Symbol], underlying: SymbolTable.Type) extends SymbolTable.Type with SymbolTable.RewrappingTypeProxy with SymbolTable.ExistentialTypeApi with Product with Serializable
-
class
FilterTypeCollector extends SymbolTable.TypeCollector[List[SymbolTable.Type]]
A map to implement the
filter
method.A map to implement the
filter
method.- Definition Classes
- TypeMaps
-
class
FindTypeCollector extends SymbolTable.TypeCollector[Option[SymbolTable.Type]]
A map to implement the
filter
method.A map to implement the
filter
method.- Definition Classes
- TypeMaps
-
trait
FlagAgnosticCompleter extends SymbolTable.LazyType
A marker trait representing an as-yet unevaluated type which doesn't assign flags to the underlying symbol.
-
trait
FlagAssigningCompleter extends SymbolTable.LazyType
A marker trait representing an as-yet unevaluated type which assigns flags to the underlying symbol.
-
class
ForEachTypeTraverser extends SymbolTable.TypeTraverser
- Definition Classes
- TypeMaps
-
class
HKTypeVar extends SymbolTable.TypeVar
Precondition: params.nonEmpty.
Precondition: params.nonEmpty. (args.nonEmpty enforced structurally.)
- case class ImportType(expr: SymbolTable.Tree) extends SymbolTable.Type with Product with Serializable
-
class
InstantiateDependentMap extends SymbolTable.TypeMap with SymbolTable.KeepOnlyTypeConstraints
Note: This map is needed even for non-dependent method types, despite what the name might imply.
Note: This map is needed even for non-dependent method types, despite what the name might imply.
- Definition Classes
- TypeMaps
- class JavaMethodType extends SymbolTable.MethodType
-
trait
KeepOnlyTypeConstraints extends SymbolTable.TypeMap with SymbolTable.AnnotationFilter
- Definition Classes
- TypeMaps
- abstract class LazyPolyType extends SymbolTable.LazyType
-
abstract
class
LazyType extends SymbolTable.Type
A class representing an as-yet unevaluated type.
-
class
MalformedType extends SymbolTable.TypeError
A throwable signalling a malformed type
-
case class
MethodType(params: List[SymbolTable.Symbol], resultType: SymbolTable.Type) extends SymbolTable.Type with SymbolTable.MethodTypeApi with Product with Serializable
A class representing a method type with parameters.
A class representing a method type with parameters. Note that a parameterless method is represented by a NullaryMethodType:
def m(): Int MethodType(Nil, Int) def m: Int NullaryMethodType(Int)
- class MissingAliasControl extends Throwable with ControlThrowable
- class MissingTypeControl extends Throwable with ControlThrowable
- class ModuleTypeRef extends SymbolTable.NoArgsTypeRef
-
case class
NamedType(name: SymbolTable.Name, tp: SymbolTable.Type) extends SymbolTable.Type with Product with Serializable
A class representing types with a name.
A class representing types with a name. When an application uses named arguments, the named argument types for calling isApplicable are represented as NamedType.
- class NoArgsTypeRef extends SymbolTable.TypeRef
- class NoCommonType extends Throwable with ControlThrowable
- trait NonClassTypeRef extends SymbolTable.TypeRef
- case class NullaryMethodType(resultType: SymbolTable.Type) extends SymbolTable.Type with SymbolTable.NullaryMethodTypeApi with Product with Serializable
-
case class
OverloadedType(pre: SymbolTable.Type, alternatives: List[SymbolTable.Symbol]) extends SymbolTable.Type with Product with Serializable
A class containing the alternatives and type prefix of an overloaded symbol.
A class containing the alternatives and type prefix of an overloaded symbol. Not used after phase
typer
. - class PackageClassInfoType extends SymbolTable.ClassInfoType
- class PackageTypeRef extends SymbolTable.ModuleTypeRef
-
case class
PolyType(typeParams: List[SymbolTable.Symbol], resultType: SymbolTable.Type) extends SymbolTable.Type with SymbolTable.PolyTypeApi with Product with Serializable
A type function or the type of a polymorphic value (and thus of kind *).
A type function or the type of a polymorphic value (and thus of kind *).
Before the introduction of NullaryMethodType, a polymorphic nullary method (e.g, def isInstanceOf[T]: Boolean) used to be typed as PolyType(tps, restpe), and a monomorphic one as PolyType(Nil, restpe) This is now: PolyType(tps, NullaryMethodType(restpe)) and NullaryMethodType(restpe) by symmetry to MethodTypes: PolyType(tps, MethodType(params, restpe)) and MethodType(params, restpe)
Thus, a PolyType(tps, TypeRef(...)) unambiguously indicates a type function (which results from eta-expanding a type constructor alias). Similarly, PolyType(tps, ClassInfoType(...)) is a type constructor.
A polytype is of kind * iff its resultType is a (nullary) method type.
-
case class
RecoverableCyclicReference(sym: SymbolTable.Symbol) extends SymbolTable.TypeError with Product with Serializable
An exception for cyclic references from which we can recover
-
case class
RefinedType(parents: List[SymbolTable.Type], decls: SymbolTable.Scope) extends SymbolTable.CompoundType with SymbolTable.RefinedTypeApi with Product with Serializable
A class representing intersection types with refinements of the form
<parents_0> with ... with <parents_n> { decls }
Cannot be created directly; one should always userefinedType
for creation. - final class RefinedType0 extends SymbolTable.RefinedType
- class RefinementTypeRef extends SymbolTable.NoArgsTypeRef
-
case class
RepeatedType(tp: SymbolTable.Type) extends SymbolTable.Type with Product with Serializable
As with NamedType, used only when calling isApplicable.
As with NamedType, used only when calling isApplicable. Records that the application has a wildcard star (aka _*) at the end of it.
-
trait
RewrappingTypeProxy extends SymbolTable.Type with SymbolTable.SimpleTypeProxy
A proxy for a type (identified by field
underlying
) that forwards most operations to it.A proxy for a type (identified by field
underlying
) that forwards most operations to it. Every operation that is overridden for some kind of types is forwarded here. Some operations are rewrapped again. -
trait
SimpleTypeProxy extends SymbolTable.Type
A proxy for a type (identified by field
underlying
) that forwards most operations to it (for exceptions, see WrappingProxy, which forwards even more operations).A proxy for a type (identified by field
underlying
) that forwards most operations to it (for exceptions, see WrappingProxy, which forwards even more operations). every operation that is overridden for some kind of types should be forwarded. -
abstract
case class
SingleType(pre: SymbolTable.Type, sym: SymbolTable.Symbol) extends SymbolTable.SingletonType with SymbolTable.SingleTypeApi with Product with Serializable
A class for singleton types of the form
<prefix>.<sym.name>.type
.A class for singleton types of the form
<prefix>.<sym.name>.type
. Cannot be created directly; one should always usesingleType
for creation. -
abstract
class
SingletonType extends SymbolTable.SubType with SymbolTable.SimpleTypeProxy with SymbolTable.SingletonTypeApi
A base class for types that represent a single value (single-types and this-types).
-
abstract
class
SubType extends SymbolTable.UniqueType
A base class for types that defer some operations to their immediate supertype.
-
abstract
class
SubstMap[T] extends SymbolTable.TypeMap
A base class to compute all substitutions
A base class to compute all substitutions
- Definition Classes
- TypeMaps
-
class
SubstSymMap extends SymbolTable.SubstMap[SymbolTable.Symbol]
A map to implement the
substSym
method.A map to implement the
substSym
method.- Definition Classes
- TypeMaps
-
class
SubstThisMap extends SymbolTable.TypeMap
A map to implement the
substThis
method.A map to implement the
substThis
method.- Definition Classes
- TypeMaps
-
class
SubstTypeMap extends SymbolTable.SubstMap[SymbolTable.Type]
A map to implement the
subst
method.A map to implement the
subst
method.- Definition Classes
- TypeMaps
-
class
SubstWildcardMap extends SymbolTable.TypeMap
- Definition Classes
- TypeMaps
- abstract case class SuperType(thistpe: SymbolTable.Type, supertpe: SymbolTable.Type) extends SymbolTable.SingletonType with SymbolTable.SuperTypeApi with Product with Serializable
-
abstract
case class
ThisType(sym: SymbolTable.Symbol) extends SymbolTable.SingletonType with SymbolTable.ThisTypeApi with Product with Serializable
A class for this-types of the form <sym>.this.type
-
abstract
class
Type extends SymbolTable.TypeApiImpl with SymbolTable.Annotatable[SymbolTable.Type]
The base class for all types
- abstract class TypeApiImpl extends SymbolTable.TypeApi
-
abstract
case class
TypeBounds(lo: SymbolTable.Type, hi: SymbolTable.Type) extends SymbolTable.SubType with SymbolTable.TypeBoundsApi with Product with Serializable
A class for the bounds of abstract types and type parameters
-
abstract
class
TypeCollector[T] extends SymbolTable.TypeTraverser
- Definition Classes
- TypeMaps
-
class
TypeConstraint extends AnyRef
A class expressing upper and lower bounds constraints of type variables, as well as their instantiations.
A class expressing upper and lower bounds constraints of type variables, as well as their instantiations.
- Definition Classes
- TypeConstraints
-
class
TypeError extends Throwable
A throwable signalling a type error
-
abstract
class
TypeMap extends (SymbolTable.Type) ⇒ SymbolTable.Type
A prototype for mapping a function over all possible types
A prototype for mapping a function over all possible types
- Definition Classes
- TypeMaps
-
abstract
case class
TypeRef(pre: SymbolTable.Type, sym: SymbolTable.Symbol, args: List[SymbolTable.Type]) extends SymbolTable.UniqueType with SymbolTable.TypeRefApi with Product with Serializable
A class for named types of the form
<prefix>.<sym.name>[args]
Cannot be created directly; one should always usetypeRef
for creation.A class for named types of the form
<prefix>.<sym.name>[args]
Cannot be created directly; one should always usetypeRef
for creation. (@M: Otherwise hashing breaks) -
abstract
class
TypeTraverser extends SymbolTable.TypeMap
- Definition Classes
- TypeMaps
-
abstract
class
TypeTraverserWithResult[T] extends SymbolTable.TypeTraverser
- Definition Classes
- TypeMaps
- class TypeUnwrapper extends (SymbolTable.Type) ⇒ SymbolTable.Type
-
abstract
case class
TypeVar(origin: SymbolTable.Type, constr: SymbolTable.TypeConstraint) extends SymbolTable.Type with Product with Serializable
A class representing a type variable: not used after phase
typer
.A class representing a type variable: not used after phase
typer
.A higher-kinded TypeVar has params (Symbols) and typeArgs (Types). A TypeVar with nonEmpty typeArgs can only be instantiated by a higher-kinded type that can be applied to those args. A TypeVar is much like a TypeRef, except it has special logic for equality and subtyping.
Precondition for this class, enforced structurally: args.isEmpty && params.isEmpty.
-
class
UndoLog extends Clearable
- Definition Classes
- TypeConstraints
- final class UniqueConstantType extends SymbolTable.ConstantType
- final class UniqueErasedValueType extends SymbolTable.ErasedValueType
- final class UniqueSingleType extends SymbolTable.SingleType
- final class UniqueSuperType extends SymbolTable.SuperType
- final class UniqueThisType extends SymbolTable.ThisType
-
abstract
class
UniqueType extends SymbolTable.Type with Product
A type that can be passed to unique(..) and be stored in the uniques map.
- final class UniqueTypeBounds extends SymbolTable.TypeBounds
- trait UntouchableTypeVar extends SymbolTable.TypeVar
-
final
case class
SubTypePair(tp1: SymbolTable.Type, tp2: SymbolTable.Type) extends Product with Serializable
- Definition Classes
- TypeComparers
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- implicit val AnnotatedTypeTag: ClassTag[SymbolTable.AnnotatedType]
- implicit val BoundedWildcardTypeTag: ClassTag[SymbolTable.BoundedWildcardType]
- implicit val ClassInfoTypeTag: ClassTag[SymbolTable.ClassInfoType]
- implicit val CompoundTypeTag: ClassTag[SymbolTable.CompoundType]
- implicit val ConstantTypeTag: ClassTag[SymbolTable.ConstantType]
- implicit val ExistentialTypeTag: ClassTag[SymbolTable.ExistentialType]
-
val
GlbFailure: java.lang.Throwable
- Definition Classes
- GlbLubs
-
def
JavaMethodType(params: List[SymbolTable.Symbol], resultType: SymbolTable.Type): SymbolTable.JavaMethodType
The canonical creator for implicit method types
- implicit val MethodTypeTag: ClassTag[SymbolTable.MethodType]
- implicit val NullaryMethodTypeTag: ClassTag[SymbolTable.NullaryMethodType]
- implicit val PolyTypeTag: ClassTag[SymbolTable.PolyType]
- implicit val RefinedTypeTag: ClassTag[SymbolTable.RefinedType]
- implicit val SingleTypeTag: ClassTag[SymbolTable.SingleType]
- implicit val SingletonTypeTag: ClassTag[SymbolTable.SingletonType]
- implicit val SuperTypeTag: ClassTag[SymbolTable.SuperType]
- implicit val ThisTypeTag: ClassTag[SymbolTable.ThisType]
- implicit val TypeBoundsTag: ClassTag[SymbolTable.TypeBounds]
- implicit val TypeRefTag: ClassTag[SymbolTable.TypeRef]
- implicit val TypeTagg: ClassTag[SymbolTable.Type]
-
def
addMember(thistp: SymbolTable.Type, tp: SymbolTable.Type, sym: SymbolTable.Symbol, depth: Depth): Unit
Make symbol
sym
a member of scopetp.decls
wherethistp
is the narrowed owner type of the scope. - def addMember(thistp: SymbolTable.Type, tp: SymbolTable.Type, sym: SymbolTable.Symbol): Unit
- def addSerializable(ps: SymbolTable.Type*): List[SymbolTable.Type]
-
def
annotatedType(annots: List[SymbolTable.AnnotationInfo], underlying: SymbolTable.Type): SymbolTable.Type
Creator for AnnotatedTypes.
Creator for AnnotatedTypes. It returns the underlying type if annotations.isEmpty rather than walking into the assertion.
-
def
appliedType(tyconSym: SymbolTable.Symbol, args: SymbolTable.Type*): SymbolTable.Type
Very convenient.
- def appliedType(tyconSym: SymbolTable.Symbol, args: List[SymbolTable.Type]): SymbolTable.Type
- def appliedType(tycon: SymbolTable.Type, args: SymbolTable.Type*): SymbolTable.Type
-
def
appliedType(tycon: SymbolTable.Type, args: List[SymbolTable.Type]): SymbolTable.Type
A creator for type applications
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
- def basetypeRecursions: Int
- def basetypeRecursions_=(value: Int): Unit
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
final
def
collectFirst[A, B](as: List[A])(pf: PartialFunction[A, B]): Option[B]
- Definition Classes
- Collections
-
final
def
collectMap2[A, B, C](xs1: List[A], xs2: List[B])(p: (A, B) ⇒ Boolean): Map[A, B]
- Definition Classes
- Collections
-
def
commonOwner(tps: List[SymbolTable.Type]): SymbolTable.Symbol
The most deeply nested owner that contains all the symbols of thistype or prefixless typerefs/singletype occurrences in given list of types.
The most deeply nested owner that contains all the symbols of thistype or prefixless typerefs/singletype occurrences in given list of types.
- Attributes
- protected[scala.reflect.internal]
- Definition Classes
- CommonOwners
-
def
commonOwner(t: SymbolTable.Type): SymbolTable.Symbol
The most deeply nested owner that contains all the symbols of thistype or prefixless typerefs/singletype occurrences in given type.
The most deeply nested owner that contains all the symbols of thistype or prefixless typerefs/singletype occurrences in given type.
- Attributes
- protected[scala.reflect.internal]
- Definition Classes
- CommonOwners
-
def
commonOwnerMap: SymbolTable.CommonOwnerMap
- Attributes
- protected
- Definition Classes
- CommonOwners
-
final
def
compareLengths(xs1: List[_], xs2: List[_]): Int
- Definition Classes
- Collections
- Annotations
- @tailrec()
-
def
computeBaseClasses(tpe: SymbolTable.Type): List[SymbolTable.Symbol]
- Attributes
- protected
- def containsExistential(tpe: SymbolTable.Type): Boolean
-
def
copyMethodType(tp: SymbolTable.Type, params: List[SymbolTable.Symbol], restpe: SymbolTable.Type): SymbolTable.Type
Create a new MethodType of the same class as tp, i.e.
Create a new MethodType of the same class as tp, i.e. keep JavaMethodType
- def copyRefinedType(original: SymbolTable.RefinedType, parents: List[SymbolTable.Type], decls: SymbolTable.Scope): SymbolTable.Type
- def copyTypeRef(tp: SymbolTable.Type, pre: SymbolTable.Type, sym: SymbolTable.Symbol, args: List[SymbolTable.Type]): SymbolTable.Type
-
final
def
corresponds3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Boolean): Boolean
True if all three arguments have the same number of elements and the function is true for all the triples.
True if all three arguments have the same number of elements and the function is true for all the triples.
- Definition Classes
- Collections
- Annotations
- @tailrec()
-
def
defineBaseClassesOfCompoundType(tpe: SymbolTable.CompoundType): Unit
- Attributes
- protected
-
def
defineBaseTypeSeqOfCompoundType(tpe: SymbolTable.CompoundType): Unit
- Attributes
- protected
-
def
defineBaseTypeSeqOfTypeRef(tpe: SymbolTable.TypeRef): Unit
- Attributes
- protected
-
def
defineParentsOfTypeRef(tpe: SymbolTable.TypeRef): Unit
- Attributes
- protected
-
def
defineUnderlyingOfSingleType(tpe: SymbolTable.SingleType): Unit
- Attributes
- protected
-
final
def
distinctBy[A, B](xs: List[A])(f: (A) ⇒ B): List[A]
- Definition Classes
- Collections
- def elementExtract(container: SymbolTable.Symbol, tp: SymbolTable.Type): SymbolTable.Type
- def elementExtractOption(container: SymbolTable.Symbol, tp: SymbolTable.Type): Option[SymbolTable.Type]
- def elementTest(container: SymbolTable.Symbol, tp: SymbolTable.Type)(f: (SymbolTable.Type) ⇒ Boolean): Boolean
- def elementTransform(container: SymbolTable.Symbol, tp: SymbolTable.Type)(f: (SymbolTable.Type) ⇒ SymbolTable.Type): SymbolTable.Type
- def elimAnonymousClass(t: SymbolTable.Type): SymbolTable.Type
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
existentialAbstraction(tparams: List[SymbolTable.Symbol], tpe0: SymbolTable.Type): SymbolTable.Type
A creator for existential types.
A creator for existential types. This generates:
tpe1 where { tparams }
where
tpe1
is the result of extrapolatingtpe
with respect totparams
. Extrapolating means that type variables intparams
occurring in covariant positions are replaced by upper bounds, (minus any SingletonClass markers), type variables intparams
occurring in contravariant positions are replaced by upper bounds, provided the resulting type is legal with regard to stability, and does not contain any type variable intparams
.The abstraction drops all type parameters that are not directly or indirectly referenced by type
tpe1
. If there are no remaining type parameters, simply returns result typetpe
. - def existentialsInType(tpe: SymbolTable.Type): List[SymbolTable.Symbol]
-
final
def
exists2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ Boolean): Boolean
- Definition Classes
- Collections
-
final
def
exists3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Boolean): Boolean
- Definition Classes
- Collections
-
def
explain[T](op: String, p: (SymbolTable.Type, T) ⇒ Boolean, tp1: SymbolTable.Type, arg2: T): Boolean
Perform operation
p
on argumentstp1
,arg2
and print trace of computation.Perform operation
p
on argumentstp1
,arg2
and print trace of computation.- Attributes
- protected
-
def
explainTypes(op: (SymbolTable.Type, SymbolTable.Type) ⇒ Any, found: SymbolTable.Type, required: SymbolTable.Type): Unit
If option
explaintypes
is set, print a subtype trace forop(found, required)
. -
def
explainTypes(found: SymbolTable.Type, required: SymbolTable.Type): Unit
If option
explaintypes
is set, print a subtype trace forfound <:< required
. -
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
findOrElse[A](xs: TraversableOnce[A])(p: (A) ⇒ Boolean)(orElse: ⇒ A): A
- Definition Classes
- Collections
-
def
findRecursiveBounds(ts: List[SymbolTable.Type]): List[(SymbolTable.Symbol, SymbolTable.Symbol)]
From a list of types, find any which take type parameters where the type parameter bounds contain references to other any types in the list (including itself.)
From a list of types, find any which take type parameters where the type parameter bounds contain references to other any types in the list (including itself.)
- returns
List of symbol pairs holding the recursive type parameter and the parameter which references it.
- Definition Classes
- GlbLubs
-
final
def
flatCollect[A, B](elems: List[A])(pf: PartialFunction[A, Traversable[B]]): List[B]
- Definition Classes
- Collections
-
final
def
flatMap2[A, B, C](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ List[C]): List[C]
- Definition Classes
- Collections
-
final
def
flattensToEmpty(xss: Seq[Seq[_]]): Boolean
- Definition Classes
- Collections
- Annotations
- @tailrec()
-
final
def
forall3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Boolean): Boolean
- Definition Classes
- Collections
-
final
def
foreach2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ Unit): Unit
- Definition Classes
- Collections
-
final
def
foreach3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Unit): Unit
- Definition Classes
- Collections
-
final
def
foreachWithIndex[A, B](xs: List[A])(f: (A, Int) ⇒ Unit): Unit
- Definition Classes
- Collections
- def genPolyType(params: List[SymbolTable.Symbol], tpe: SymbolTable.Type): SymbolTable.Type
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
glb(ts: List[SymbolTable.Type], depth: Depth): SymbolTable.Type
- Attributes
- protected[scala.reflect.internal]
- Definition Classes
- GlbLubs
-
def
glb(ts: List[SymbolTable.Type]): SymbolTable.Type
The greatest lower bound of a list of types (as determined by
<:<
).The greatest lower bound of a list of types (as determined by
<:<
).- Definition Classes
- GlbLubs
-
def
glbNorm(ts: List[SymbolTable.Type], depth: Depth): SymbolTable.Type
The greatest lower bound of a list of types (as determined by
<:<
), which have been normalized with regard toelimSuper
.The greatest lower bound of a list of types (as determined by
<:<
), which have been normalized with regard toelimSuper
.- Attributes
- protected
- Definition Classes
- GlbLubs
-
def
glbResults: HashMap[(Depth, List[SymbolTable.Type]), SymbolTable.Type]
- Definition Classes
- GlbLubs
-
final
def
hasLength(xs: List[_], len: Int): Boolean
Again avoiding calling length, but the lengthCompare interface is clunky.
Again avoiding calling length, but the lengthCompare interface is clunky.
- Definition Classes
- Collections
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def howManyUniqueTypes: Int
-
def
importableMembers(pre: SymbolTable.Type): SymbolTable.Scope
Members which can be imported into other scopes.
-
def
indent: String
- Attributes
- protected
-
def
indent_=(value: String): Unit
- Attributes
- protected
- def inheritsJavaVarArgsMethod(clazz: SymbolTable.Symbol): Boolean
- def instantiatedBounds(pre: SymbolTable.Type, owner: SymbolTable.Symbol, tparams: List[SymbolTable.Symbol], targs: List[SymbolTable.Type]): List[SymbolTable.TypeBounds]
-
def
intersectionType(tps: List[SymbolTable.Type]): SymbolTable.Type
A creator for intersection type where intersections of a single type are replaced by the type itself.
-
def
intersectionType(tps: List[SymbolTable.Type], owner: SymbolTable.Symbol): SymbolTable.Type
A creator for intersection type where intersections of a single type are replaced by the type itself, and repeated parent classes are merged.
A creator for intersection type where intersections of a single type are replaced by the type itself, and repeated parent classes are merged.
!!! Repeated parent classes are not merged - is this a bug in the comment or in the code?
- def intersectionTypeForLazyBaseType(tps: List[SymbolTable.Type]): SymbolTable.Type
- def intersectionWitness: WeakHashMap[List[SymbolTable.Type], WeakReference[SymbolTable.Type]]
- def invalidateCaches(t: SymbolTable.Type, updatedSyms: List[SymbolTable.Symbol]): Unit
- def invalidateTreeTpeCaches(tree: SymbolTable.Tree, updatedSyms: List[SymbolTable.Symbol]): Unit
- def isBoundedGeneric(tp: SymbolTable.Type): Boolean
- def isConstantType(tp: SymbolTable.Type): Boolean
-
def
isDifferentType(tp1: SymbolTable.Type, tp2: SymbolTable.Type): Boolean
- Definition Classes
- TypeComparers
-
def
isDifferentTypeConstructor(tp1: SymbolTable.Type, tp2: SymbolTable.Type): Boolean
- Definition Classes
- TypeComparers
- def isDummyAppliedType(tp: SymbolTable.Type): Boolean
-
def
isEligibleForPrefixUnification(tp: SymbolTable.Type): Boolean
Does this type have a prefix that begins with a type variable, or is it a refinement type? For type prefixes that fulfil this condition, type selections with the same name of equal (as determined by
=:=
) prefixes are considered equal in regard to=:=
. - def isErrorOrWildcard(tp: SymbolTable.Type): Boolean
- def isExistentialType(tp: SymbolTable.Type): Boolean
-
def
isHKSubType(tp1: SymbolTable.Type, tp2: SymbolTable.Type, depth: Depth): Boolean
- Definition Classes
- TypeComparers
- def isImplicitMethodType(tp: SymbolTable.Type): Boolean
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def isIntersectionTypeForLazyBaseType(tp: SymbolTable.RefinedType): Boolean
- def isJavaVarargsAncestor(clazz: SymbolTable.Symbol): Boolean
-
def
isNonRefinementClassType(tpe: SymbolTable.Type): Boolean
def isNonValueType(tp: Type) = !isValueElseNonValue(tp)
-
def
isNumericSubType(tp1: SymbolTable.Type, tp2: SymbolTable.Type): Boolean
- Definition Classes
- TypeComparers
-
def
isPopulated(tp1: SymbolTable.Type, tp2: SymbolTable.Type): Boolean
Is intersection of given types populated? That is, for all types tp1, tp2 in intersection for all common base classes bc of tp1 and tp2 let bt1, bt2 be the base types of tp1, tp2 relative to class bc Then: bt1 and bt2 have the same prefix, and any corresponding non-variant type arguments of bt1 and bt2 are the same
-
def
isPossiblePrefix(clazz: SymbolTable.Symbol): Boolean
Might the given symbol be important when calculating the prefix of a type? When tp.asSeenFrom(pre, clazz) is called on
tp
, the result will betp
unchanged ifpre
is trivial andclazz
is a symbol such that isPossiblePrefix(clazz) == false.Might the given symbol be important when calculating the prefix of a type? When tp.asSeenFrom(pre, clazz) is called on
tp
, the result will betp
unchanged ifpre
is trivial andclazz
is a symbol such that isPossiblePrefix(clazz) == false.- Definition Classes
- TypeMaps
- def isRawIfWithoutArgs(sym: SymbolTable.Symbol): Boolean
-
def
isRawType(tp: SymbolTable.Type): Boolean
Is type tp a raw type?
-
def
isSameType(tp1: SymbolTable.Type, tp2: SymbolTable.Type): Boolean
Do
tp1
andtp2
denote equivalent types?Do
tp1
andtp2
denote equivalent types?- Definition Classes
- TypeComparers
-
def
isSameType2(tp1: SymbolTable.Type, tp2: SymbolTable.Type): Boolean
- Definition Classes
- TypeComparers
-
def
isSameTypes(tps1: List[SymbolTable.Type], tps2: List[SymbolTable.Type]): Boolean
Are
tps1
andtps2
lists of pairwise equivalent types? -
def
isSingleType(tp: SymbolTable.Type): Boolean
This appears to be equivalent to tp.isInstanceof[SingletonType], except it excludes ConstantTypes.
- def isSubArgs(tps1: List[SymbolTable.Type], tps2: List[SymbolTable.Type], tparams: List[SymbolTable.Symbol], depth: Depth): Boolean
-
def
isSubType(tp1: SymbolTable.Type, tp2: SymbolTable.Type, depth: Depth = Depth.AnyDepth): Boolean
- Definition Classes
- TypeComparers
-
def
isUseableAsTypeArg(tp: SymbolTable.Type): Boolean
This is defined and named as it is because the goal is to exclude source level types which are not value types (e.g.
This is defined and named as it is because the goal is to exclude source level types which are not value types (e.g. MethodType) without excluding necessary internal types such as WildcardType. There are also non-value types which can be used as type arguments (e.g. type constructors.)
-
final
def
isUseableAsTypeArgs(tps: List[SymbolTable.Type]): Boolean
- Annotations
- @tailrec()
-
def
isWeakSubType(tp1: SymbolTable.Type, tp2: SymbolTable.Type): Boolean
- Definition Classes
- TypeComparers
-
def
isWithinBounds(pre: SymbolTable.Type, owner: SymbolTable.Symbol, tparams: List[SymbolTable.Symbol], targs: List[SymbolTable.Type]): Boolean
Do type arguments
targs
conform to formal parameterstparams
? -
final
def
linkedMapFrom[A, A1 >: A, B](xs: List[A])(f: (A) ⇒ B): LinkedHashMap[A1, B]
- Definition Classes
- Collections
-
def
lub(ts: List[SymbolTable.Type], depth: Depth): SymbolTable.Type
The least upper bound wrt <:< of a list of types
The least upper bound wrt <:< of a list of types
- Attributes
- protected[scala.reflect.internal]
- Definition Classes
- GlbLubs
-
def
lub(ts: List[SymbolTable.Type]): SymbolTable.Type
- Definition Classes
- GlbLubs
-
def
lubDepth(ts: List[SymbolTable.Type]): Depth
The maximum allowable depth of lubs or glbs over types
ts
. -
def
lubList(ts: List[SymbolTable.Type], depth: Depth): List[SymbolTable.Type]
Given a matrix
tsBts
whose columns are basetype sequences (and the symbolstsParams
that should be interpreted as type parameters in this matrix), compute its least sorted upwards closed upper bound relative to the following ordering <= between lists of types:Given a matrix
tsBts
whose columns are basetype sequences (and the symbolstsParams
that should be interpreted as type parameters in this matrix), compute its least sorted upwards closed upper bound relative to the following ordering <= between lists of types:xs <= ys iff forall y in ys exists x in xs such that x <: y
- Definition Classes
- GlbLubs
-
def
lubResults: HashMap[(Depth, List[SymbolTable.Type]), SymbolTable.Type]
- Definition Classes
- GlbLubs
-
final
def
map2[A, B, C](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ C): List[C]
- Definition Classes
- Collections
-
final
def
map2Conserve[A <: AnyRef, B](xs: List[A], ys: List[B])(f: (A, B) ⇒ A): List[A]
like map2, but returns list
xs
itself - instead of a copy - if functionf
maps all elements to themselves.like map2, but returns list
xs
itself - instead of a copy - if functionf
maps all elements to themselves.- Definition Classes
- Collections
-
final
def
map3[A, B, C, D](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ D): List[D]
- Definition Classes
- Collections
-
final
def
mapFrom[A, A1 >: A, B](xs: List[A])(f: (A) ⇒ B): Map[A1, B]
- Definition Classes
- Collections
-
final
def
mapList[A, B](as: List[A])(f: (A) ⇒ B): List[B]
A version of List#map, specialized for List, and optimized to avoid allocation if
as
is emptyA version of List#map, specialized for List, and optimized to avoid allocation if
as
is empty- Definition Classes
- Collections
-
final
def
mapWithIndex[A, B](xs: List[A])(f: (A, Int) ⇒ B): List[B]
- Definition Classes
- Collections
-
final
def
matchesType(tp1: SymbolTable.Type, tp2: SymbolTable.Type, alwaysMatchSimple: Boolean): Boolean
A function implementing
tp1
matchestp2
. -
def
matchingParams(syms1: List[SymbolTable.Symbol], syms2: List[SymbolTable.Symbol], syms1isJava: Boolean, syms2isJava: Boolean): Boolean
Are
syms1
andsyms2
parameter lists with pairwise equivalent types?Are
syms1
andsyms2
parameter lists with pairwise equivalent types?- Attributes
- protected[scala.reflect.internal]
-
final
val
maxToStringRecursions: Int(50)
The maximum number of recursions allowed in toString
The maximum number of recursions allowed in toString
- Definition Classes
- TypeToStrings
-
def
mergePrefixAndArgs(tps0: List[SymbolTable.Type], variance: Variance, depth: Depth): SymbolTable.Type
Compute lub (if
variance == Covariant
) or glb (ifvariance == Contravariant
) of given list of typestps
.Compute lub (if
variance == Covariant
) or glb (ifvariance == Contravariant
) of given list of typestps
. All types intps
are typerefs or singletypes with the same symbol. Returnx
if the computation succeeds with resultx
. ReturnNoType
if the computation fails. -
final
def
mexists[A](xss: List[List[A]])(p: (A) ⇒ Boolean): Boolean
All these mm methods are "deep map" style methods for mapping etc.
All these mm methods are "deep map" style methods for mapping etc. on a list of lists while avoiding unnecessary intermediate structures like those created via flatten.
- Definition Classes
- Collections
-
final
def
mfind[A](xss: List[List[A]])(p: (A) ⇒ Boolean): Option[A]
- Definition Classes
- Collections
-
final
def
mforall[A](xss: List[List[A]])(p: (A) ⇒ Boolean): Boolean
- Definition Classes
- Collections
-
final
def
mforeach[A](xss: Traversable[Traversable[A]])(f: (A) ⇒ Unit): Unit
- Definition Classes
- Collections
-
final
def
mforeach[A](xss: List[List[A]])(f: (A) ⇒ Unit): Unit
These are all written in terms of List because we're trying to wring all the performance we can and List is used almost exclusively in the compiler, but people are branching out in their collections so here's an overload.
These are all written in terms of List because we're trying to wring all the performance we can and List is used almost exclusively in the compiler, but people are branching out in their collections so here's an overload.
- Definition Classes
- Collections
- val missingAliasException: SymbolTable.MissingAliasControl
-
final
def
mmap[A, B](xss: List[List[A]])(f: (A) ⇒ B): collection.immutable.List[collection.immutable.List[B]]
- Definition Classes
- Collections
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
nestedMemberType(sym: SymbolTable.Symbol, pre: SymbolTable.Type, owner: SymbolTable.Symbol): SymbolTable.Type
A more persistent version of
Type#memberType
which does not require that the symbol is a direct member of the prefix.A more persistent version of
Type#memberType
which does not require that the symbol is a direct member of the prefix.For instance:
class C[T] { sealed trait F[A] object X { object S1 extends F[T] } class S2 extends F[T] } object O extends C[Int] { def foo(f: F[Int]) = f match {...} // need to enumerate sealed subtypes of the scrutinee here. } class S3 extends O.F[String] nestedMemberType(<S1>, <O.type>, <C>) = O.X.S1.type nestedMemberType(<S2>, <O.type>, <C>) = O.S2.type nestedMemberType(<S3>, <O.type>, <C>) = S3.type
- sym
The symbol of the subtype
- pre
The prefix from which the symbol is seen
-
def
newExistentialType(quantified: List[SymbolTable.Symbol], underlying: SymbolTable.Type): SymbolTable.Type
A creator for existential types which flattens nested existentials.
-
def
nonTrivialMembers(clazz: SymbolTable.Symbol): SymbolTable.Scope
Members of the given class, other than those inherited from Any or AnyRef.
- def normalizePlus(tp: SymbolTable.Type): SymbolTable.Type
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
numericLub(ts: List[SymbolTable.Type]): SymbolTable.Type
- Definition Classes
- GlbLubs
- def objToAny(tp: SymbolTable.Type): SymbolTable.Type
-
def
overloadedType(pre: SymbolTable.Type, alternatives: List[SymbolTable.Symbol]): SymbolTable.Type
The canonical creator for OverloadedTypes.
- def pendingBaseTypes: HashSet[SymbolTable.Type]
-
def
pendingSubTypes: HashSet[SymbolTable.SubTypePair]
- Definition Classes
- TypeComparers
-
def
rawToExistential: SymbolTable.TypeMap
The raw to existential map converts a raw type to an existential type.
The raw to existential map converts a raw type to an existential type. It is necessary because we might have read a raw type of a parameterized Java class from a class file. At the time we read the type the corresponding class file might still not be read, so we do not know what the type parameters of the type are. Therefore the conversion of raw types to existential types might not have taken place in ClassFileParser.sigToType (where it is usually done).
- Definition Classes
- TypeMaps
-
def
refinedType(parents: List[SymbolTable.Type], owner: SymbolTable.Symbol): SymbolTable.Type
The canonical creator for a refined type with an initially empty scope.
-
def
refinedType(parents: List[SymbolTable.Type], owner: SymbolTable.Symbol, decls: SymbolTable.Scope, pos: SymbolTable.Position): SymbolTable.Type
the canonical creator for a refined type with a given scope
-
def
repackExistential(tp: SymbolTable.Type): SymbolTable.Type
Repack existential types, otherwise they sometimes get unpacked in the wrong location (type inference comes up with an unexpected skolem)
-
final
def
sameElementsEquals(thiss: List[AnyRef], that: List[AnyRef]): Boolean
- Definition Classes
- Collections
-
final
def
sameLength(xs1: List[_], xs2: List[_]): Boolean
True if two lists have the same length.
True if two lists have the same length. Since calling length on linear sequences is O(n), it is an inadvisable way to test length equality.
- Definition Classes
- Collections
-
def
sameWeakLubAsLub(tps: List[SymbolTable.Type]): Boolean
Does this set of types have the same weak lub as it does regular lub? This is exposed so lub callers can discover whether the trees they are typing will may require further adaptation.
Does this set of types have the same weak lub as it does regular lub? This is exposed so lub callers can discover whether the trees they are typing will may require further adaptation. It may return false negatives, but it will not return false positives.
- Definition Classes
- GlbLubs
-
final
def
sequenceOpt[A](as: List[Option[A]]): Option[List[A]]
- Definition Classes
- Collections
- val shorthands: Set[String]
-
def
singleType(pre: SymbolTable.Type, sym: SymbolTable.Symbol): SymbolTable.Type
The canonical creator for single-types
- def singletonBounds(hi: SymbolTable.Type): SymbolTable.TypeBounds
-
def
skipPrefixOf(pre: SymbolTable.Type, clazz: SymbolTable.Symbol): Boolean
- Attributes
- protected[scala.reflect.internal]
- Definition Classes
- TypeMaps
- def skolemizationLevel: Int
- def skolemizationLevel_=(value: Int): Unit
-
def
solve(tvars: List[SymbolTable.TypeVar], tparams: List[SymbolTable.Symbol], variances: List[Variance], upper: Boolean, depth: Depth): Boolean
Solve constraint collected in types
tvars
.Solve constraint collected in types
tvars
.- tvars
All type variables to be instantiated.
- tparams
The type parameters corresponding to
tvars
- variances
The variances of type parameters; need to reverse solution direction for all contravariant variables.
- upper
When
true
search for max solution else min.
- Definition Classes
- TypeConstraints
-
def
spanningTypes(ts: List[SymbolTable.Type]): List[SymbolTable.Type]
A minimal type list which has a given list of types as its base type sequence
A minimal type list which has a given list of types as its base type sequence
- Definition Classes
- GlbLubs
-
def
specializesSym(preLo: SymbolTable.Type, symLo: SymbolTable.Symbol, preHi: SymbolTable.Type, symHi: SymbolTable.Symbol, depth: Depth): Boolean
Does member
symLo
oftpLo
have a stronger type than membersymHi
oftpHi
?Does member
symLo
oftpLo
have a stronger type than membersymHi
oftpHi
?- Attributes
- protected[scala.reflect.internal]
- def specializesSym(tp: SymbolTable.Type, sym: SymbolTable.Symbol, depth: Depth): Boolean
- final def stripExistentialsAndTypeVars(ts: List[SymbolTable.Type], expandLazyBaseType: Boolean = false): (List[SymbolTable.Type], List[SymbolTable.Symbol])
-
def
subsametypeRecursions: Int
- Definition Classes
- TypeComparers
-
def
subsametypeRecursions_=(value: Int): Unit
- Definition Classes
- TypeComparers
-
final
def
suspendingTypeVars[T](tvs: List[SymbolTable.TypeVar])(op: ⇒ T): T
- Annotations
- @inline()
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
toStringRecursions: Int
- Definition Classes
- TypeToStrings
-
def
toStringRecursions_=(value: Int): Unit
- Definition Classes
- TypeToStrings
-
def
toStringSubjects: HashSet[SymbolTable.Type]
- Definition Classes
- TypeToStrings
- def transparentShallowTransform(container: SymbolTable.Symbol, tp: SymbolTable.Type)(f: (SymbolTable.Type) ⇒ SymbolTable.Type): SymbolTable.Type
-
final
def
transposeSafe[A](ass: List[List[A]]): Option[List[List[A]]]
- Definition Classes
- Collections
-
final
def
traverseOpt[A, B](as: List[A])(f: (A) ⇒ Option[B]): Option[List[B]]
- Definition Classes
- Collections
-
def
typeDepth(tp: SymbolTable.Type): Depth
The maximum depth of type
tp
-
def
typeFun(tps: List[SymbolTable.Symbol], body: SymbolTable.Type): SymbolTable.Type
A creator for a type functions, assuming the type parameters tps already have the right owner.
-
def
typeFunAnon(tps: List[SymbolTable.Symbol], body: SymbolTable.Type): SymbolTable.Type
A creator for anonymous type functions, where the symbol for the type function still needs to be created.
A creator for anonymous type functions, where the symbol for the type function still needs to be created.
TODO: type params of anonymous type functions, which currently can only arise from normalising type aliases, are owned by the type alias of which they are the eta-expansion higher-order subtyping expects eta-expansion of type constructors that arise from a class; here, the type params are owned by that class, but is that the right thing to do?
- def typeParamsToExistentials(clazz: SymbolTable.Symbol): List[SymbolTable.Symbol]
- def typeParamsToExistentials(clazz: SymbolTable.Symbol, tparams: List[SymbolTable.Symbol]): List[SymbolTable.Symbol]
-
def
typeRef(pre: SymbolTable.Type, sym: SymbolTable.Symbol, args: List[SymbolTable.Type]): SymbolTable.Type
The canonical creator for typerefs todo: see how we can clean this up a bit
-
def
typeToString(tpe: SymbolTable.Type): String
- Attributes
- protected
- Definition Classes
- TypeToStrings
-
def
typeVarsInType(tp: SymbolTable.Type): List[SymbolTable.TypeVar]
A list of the typevars in a type.
-
final
def
uncheckedBounds(tp: SymbolTable.Type): SymbolTable.Type
Adds the @uncheckedBound annotation if the given
tp
has type arguments -
def
undoLog: SymbolTable.UndoLog
- Definition Classes
- TypeConstraints
-
def
unique[T <: SymbolTable.Type](tp: T): T
- Attributes
- protected
-
def
validateClassInfo(tp: SymbolTable.ClassInfoType): Unit
Overridden in reflection compiler
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
weakLub(tps: List[SymbolTable.Type]): SymbolTable.Type
If the arguments are all numeric value types, the numeric lub according to the weak conformance spec.
If the arguments are all numeric value types, the numeric lub according to the weak conformance spec. If any argument has type annotations, take the lub of the unannotated type and call the analyzerPlugin method annotationsLub so it can be further altered. Otherwise, the regular lub.
- Definition Classes
- GlbLubs
-
def
withTypesExplained[A](op: ⇒ A): A
Execute
op
while printing a trace of the operations on types executed. -
object
AnnotatedType extends SymbolTable.AnnotatedTypeExtractor with Serializable
The constructor/extractor for
AnnotatedType
instances. -
object
ApproximateDependentMap extends SymbolTable.TypeMap
- Definition Classes
- TypeMaps
- object ArrayTypeRef
-
object
BoundedWildcardType extends SymbolTable.BoundedWildcardTypeExtractor with Serializable
The constructor/extractor for
BoundedWildcardType
instances. -
object
ClassInfoType extends SymbolTable.ClassInfoTypeExtractor with Serializable
The constructor/extractor for
ClassInfoType
instances. - object CompoundType
-
object
ConstantType extends SymbolTable.ConstantTypeExtractor with Serializable
The constructor/extractor for
ConstantType
instances. - object ErasedValueType extends Serializable
-
object
ErroneousCollector extends SymbolTable.TypeCollector[Boolean]
A map to implement the
contains
method.A map to implement the
contains
method.- Definition Classes
- TypeMaps
-
object
ErrorType extends SymbolTable.Type with Product with Serializable
An object representing an erroneous type
-
object
ExistentialType extends SymbolTable.ExistentialTypeExtractor with Serializable
The constructor/extractor for
ExistentialType
instances. -
object
GenPolyType
A creator and extractor for type parameterizations that strips empty type parameter lists.
A creator and extractor for type parameterizations that strips empty type parameter lists. Use this factory method to indicate the type has kind * (it's a polymorphic value) until we start tracking explicit kinds equivalent to typeFun (except that the latter requires tparams nonEmpty).
PP to AM: I've co-opted this for where I know tparams may well be empty, and expecting to get back
tpe
in such cases. Re being "forgiving" below, can we instead say this is the canonical creator for polyTypes which may or may not be poly? (It filched the standard "canonical creator" name.) - object HasTypeMember
-
object
IsDependentCollector extends SymbolTable.TypeCollector[Boolean]
- Definition Classes
- TypeMaps
-
object
MethodType extends SymbolTable.MethodTypeExtractor with Serializable
The constructor/extractor for
MethodType
instances. -
object
NoPrefix extends SymbolTable.Type with Product with Serializable
An object representing a non-existing prefix
-
object
NoType extends SymbolTable.Type with Product with Serializable
An object representing a non-existing type
-
object
NullaryMethodType extends SymbolTable.NullaryMethodTypeExtractor with Serializable
The constructor/extractor for
NullaryMethodType
instances. -
object
PolyType extends SymbolTable.PolyTypeExtractor with Serializable
The constructor/extractor for
PolyType
instances. -
object
RefinedType extends SymbolTable.RefinedTypeExtractor with Serializable
The constructor/extractor for
RefinedType
instances. -
object
SingleType extends SymbolTable.SingleTypeExtractor with Serializable
The constructor/extractor for
SingleType
instances. - object StaticallyAnnotatedType
-
object
SuperType extends SymbolTable.SuperTypeExtractor with Serializable
The constructor/extractor for
SuperType
instances. -
object
ThisType extends SymbolTable.ThisTypeExtractor with Serializable
The constructor/extractor for
ThisType
instances. -
object
TypeBounds extends SymbolTable.TypeBoundsExtractor with Serializable
The constructor/extractor for
TypeBounds
instances. -
object
TypeRef extends SymbolTable.TypeRefExtractor with Serializable
The constructor/extractor for
TypeRef
instances. - object TypeVar extends Serializable
- object UnmappableTree extends SymbolTable.Tree with SymbolTable.TermTree with Product with Serializable
-
object
WildcardType extends SymbolTable.Type with Product with Serializable
An object representing an unknown type, used during type inference.
-
object
abstractTypesToBounds extends SymbolTable.TypeMap
Type with all top-level occurrences of abstract types replaced by their bounds
Type with all top-level occurrences of abstract types replaced by their bounds
- Definition Classes
- TypeMaps
-
object
adaptToNewRunMap extends SymbolTable.TypeMap
- Definition Classes
- TypeMaps
- object baseClassesCycleMonitor
-
object
dropIllegalStarTypes extends SymbolTable.TypeMap
Turn any T* types into Seq[T] except when in method parameter position.
Turn any T* types into Seq[T] except when in method parameter position.
- Definition Classes
- TypeMaps
-
object
dropSingletonType extends SymbolTable.TypeMap
Remove any occurrence of type <singleton> from this type and its parents
Remove any occurrence of type <singleton> from this type and its parents
- Definition Classes
- TypeMaps
-
object
normalizeAliases extends SymbolTable.TypeMap
Normalize any type aliases within this type (@see Type#normalize).
Normalize any type aliases within this type (@see Type#normalize). Note that this depends very much on the call to "normalize", not "dealias", so it is no longer carries the too-stealthy name "deAlias".
- Definition Classes
- TypeMaps
-
object
typeVarToOriginMap extends SymbolTable.TypeMap
A map to convert each occurrence of a type variable to its origin.
A map to convert each occurrence of a type variable to its origin.
- Definition Classes
- TypeMaps
- object unwrapToClass extends SymbolTable.ClassUnwrapper
- object unwrapToStableClass extends SymbolTable.ClassUnwrapper
- object unwrapWrapperTypes extends SymbolTable.TypeUnwrapper
-
object
wildcardExtrapolation extends SymbolTable.TypeMap
Get rid of BoundedWildcardType where variance allows us to do so.
Get rid of BoundedWildcardType where variance allows us to do so. Invariant:
wildcardExtrapolation(tp) =:= tp
For example, the MethodType given by
def bla(x: (_ >: String)): (_ <: Int)
is both a subtype and a supertype ofdef bla(x: String): Int
.- Definition Classes
- TypeMaps
-
object
wildcardToTypeVarMap extends SymbolTable.TypeMap
A map to convert every occurrence of a wildcard type to a fresh type variable
A map to convert every occurrence of a wildcard type to a fresh type variable
- Definition Classes
- TypeMaps
Deprecated Value Members
-
def
isRaw(sym: SymbolTable.Symbol, args: List[SymbolTable.Type]): Boolean
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.1) use isRawType
-
final
def
newAsSeenFromMap(pre: SymbolTable.Type, clazz: SymbolTable.Symbol): SymbolTable.AsSeenFromMap
- Definition Classes
- TypeMaps
- Annotations
- @deprecated
- Deprecated
(Since version 2.12.0) use new AsSeenFromMap instead
-
def
polyType(params: List[SymbolTable.Symbol], tpe: SymbolTable.Type): SymbolTable.Type
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.0) use genPolyType(...) instead