trait Types extends api.Types with TypeComparers with TypeToStrings with CommonOwners with GlbLubs with TypeMaps with TypeConstraints with FindMembers with Collections

Self Type
SymbolTable
Linear Supertypes
Collections, tpe.FindMembers, TypeConstraints, TypeMaps, GlbLubs, CommonOwners, TypeToStrings, TypeComparers, api.Types, AnyRef, Any
Known Subclasses
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Types
  2. Collections
  3. FindMembers
  4. TypeConstraints
  5. TypeMaps
  6. GlbLubs
  7. CommonOwners
  8. TypeToStrings
  9. TypeComparers
  10. Types
  11. AnyRef
  12. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. 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
  2. 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 type underlying. selfSym is a symbol representing the annotated type itself.

    Definition Classes
    Types
  3. 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
  4. abstract class BoundedWildcardTypeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax BoundedWildcardTypeExtractor(bounds) with bounds denoting the type bounds.

    An extractor class to create and pattern match with syntax BoundedWildcardTypeExtractor(bounds) with bounds denoting the type bounds.

    Definition Classes
    Types
  5. 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
  6. 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, and clazz 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, and clazz is the symbol of the class itself.

    Definition Classes
    Types
  7. trait CompoundTypeApi extends AnyRef

    Has no special methods.

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

    Definition Classes
    Types
  8. 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
  9. 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
  10. 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
  11. 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 and underlying is the type that's existentially quantified.

    Definition Classes
    Types
  12. 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
  13. 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, and restpe 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, 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.

    Definition Classes
    Types
  14. 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
  15. 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
  16. 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
  17. 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 and resultType is the type signature following the type parameters.

    Definition Classes
    Types
  18. 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
  19. 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, and decls 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, and decls is the scope containing all declarations in the class.

    Definition Classes
    Types
  20. 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
  21. 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, and sym 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, and sym is the stable value symbol referred to by the single-type.

    Definition Classes
    Types
  22. trait SingletonTypeApi extends AnyRef

    Has no special methods.

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

    Definition Classes
    Types
  23. 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
  24. 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
  25. 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
  26. abstract class ThisTypeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax ThisType(sym) where sym is the class prefix of the this type.

    An extractor class to create and pattern match with syntax ThisType(sym) where sym is the class prefix of the this type.

    Definition Classes
    Types
  27. 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
  28. 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
  29. 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 the TypeBounds pair, and upper is the upper bound.

    An extractor class to create and pattern match with syntax TypeBound(lower, upper) Here, lower is the lower bound of the TypeBounds pair, and upper is the upper bound.

    Definition Classes
    Types
  30. 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
  31. 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, and args 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, and args is a possible empty list of type arguments.

    Definition Classes
    Types
  32. trait AbstractTypeRef extends SymbolTable.TypeRef with SymbolTable.NonClassTypeRef
  33. trait AliasTypeRef extends SymbolTable.TypeRef with SymbolTable.NonClassTypeRef
  34. 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

  35. trait AnnotationFilter extends SymbolTable.TypeMap
    Definition Classes
    TypeMaps
  36. 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.

  37. class AppliedTypeVar extends SymbolTable.TypeVar

    Precondition: params.length == typeArgs.length > 0 (enforced structurally).

  38. class ArgsTypeRef extends SymbolTable.TypeRef
  39. 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
  40. 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:

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

  42. class ClassUnwrapper extends SymbolTable.TypeUnwrapper
  43. 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
  44. class CommonOwnerMap extends SymbolTable.TypeTraverserWithResult[SymbolTable.Symbol]
    Attributes
    protected
    Definition Classes
    CommonOwners
  45. abstract class CompoundType extends SymbolTable.Type with SymbolTable.CompoundTypeApi

    A common base class for intersection types and class types

  46. abstract case class ConstantType(value: SymbolTable.Constant) extends SymbolTable.SingletonType with SymbolTable.ConstantTypeApi with Product with Serializable

    A class representing a constant type.

  47. class ContainsCollector extends SymbolTable.TypeCollector[Boolean]

    A map to implement the contains method.

    A map to implement the contains method.

    Definition Classes
    TypeMaps
  48. 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 contain ErasedValueType-s. In order to correctly consider the overriding and overridden signatures as equivalent in run/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

  49. class ExistentialExtrapolation extends SymbolTable.TypeMap

    Used by existentialAbstraction.

    Used by existentialAbstraction.

    Definition Classes
    TypeMaps
  50. case class ExistentialType(quantified: List[SymbolTable.Symbol], underlying: SymbolTable.Type) extends SymbolTable.Type with SymbolTable.RewrappingTypeProxy with SymbolTable.ExistentialTypeApi with Product with Serializable
  51. 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
  52. 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
  53. trait FlagAgnosticCompleter extends SymbolTable.LazyType

    A marker trait representing an as-yet unevaluated type which doesn't assign flags to the underlying symbol.

  54. trait FlagAssigningCompleter extends SymbolTable.LazyType

    A marker trait representing an as-yet unevaluated type which assigns flags to the underlying symbol.

  55. class ForEachTypeTraverser extends SymbolTable.TypeTraverser
    Definition Classes
    TypeMaps
  56. class HKTypeVar extends SymbolTable.TypeVar

    Precondition: params.nonEmpty.

    Precondition: params.nonEmpty. (args.nonEmpty enforced structurally.)

  57. case class ImportType(expr: SymbolTable.Tree) extends SymbolTable.Type with Product with Serializable
  58. 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
  59. class JavaMethodType extends SymbolTable.MethodType
  60. trait KeepOnlyTypeConstraints extends SymbolTable.TypeMap with SymbolTable.AnnotationFilter
    Definition Classes
    TypeMaps
  61. abstract class LazyPolyType extends SymbolTable.LazyType
  62. abstract class LazyType extends SymbolTable.Type

    A class representing an as-yet unevaluated type.

  63. class MalformedType extends SymbolTable.TypeError

    A throwable signalling a malformed type

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

  65. class MissingAliasControl extends Throwable with ControlThrowable
  66. class MissingTypeControl extends Throwable with ControlThrowable
  67. class ModuleTypeRef extends SymbolTable.NoArgsTypeRef
  68. 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.

  69. class NoArgsTypeRef extends SymbolTable.TypeRef
  70. class NoCommonType extends Throwable with ControlThrowable
  71. trait NonClassTypeRef extends SymbolTable.TypeRef
  72. case class NullaryMethodType(resultType: SymbolTable.Type) extends SymbolTable.Type with SymbolTable.NullaryMethodTypeApi with Product with Serializable
  73. 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.

  74. class PackageClassInfoType extends SymbolTable.ClassInfoType
  75. class PackageTypeRef extends SymbolTable.ModuleTypeRef
  76. 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.

  77. case class RecoverableCyclicReference(sym: SymbolTable.Symbol) extends SymbolTable.TypeError with Product with Serializable

    An exception for cyclic references from which we can recover

  78. 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 use refinedType for creation.

  79. final class RefinedType0 extends SymbolTable.RefinedType
  80. class RefinementTypeRef extends SymbolTable.NoArgsTypeRef
  81. 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.

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

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

  84. 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 use singleType for creation.

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

  86. abstract class SubType extends SymbolTable.UniqueType

    A base class for types that defer some operations to their immediate supertype.

  87. abstract class SubstMap[T] extends SymbolTable.TypeMap

    A base class to compute all substitutions

    A base class to compute all substitutions

    Definition Classes
    TypeMaps
  88. class SubstSymMap extends SymbolTable.SubstMap[SymbolTable.Symbol]

    A map to implement the substSym method.

    A map to implement the substSym method.

    Definition Classes
    TypeMaps
  89. class SubstThisMap extends SymbolTable.TypeMap

    A map to implement the substThis method.

    A map to implement the substThis method.

    Definition Classes
    TypeMaps
  90. class SubstTypeMap extends SymbolTable.SubstMap[SymbolTable.Type]

    A map to implement the subst method.

    A map to implement the subst method.

    Definition Classes
    TypeMaps
  91. class SubstWildcardMap extends SymbolTable.TypeMap
    Definition Classes
    TypeMaps
  92. abstract case class SuperType(thistpe: SymbolTable.Type, supertpe: SymbolTable.Type) extends SymbolTable.SingletonType with SymbolTable.SuperTypeApi with Product with Serializable
  93. 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

  94. abstract class Type extends SymbolTable.TypeApiImpl with SymbolTable.Annotatable[SymbolTable.Type]

    The base class for all types

  95. abstract class TypeApiImpl extends SymbolTable.TypeApi
  96. 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

  97. abstract class TypeCollector[T] extends SymbolTable.TypeTraverser
    Definition Classes
    TypeMaps
  98. 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
  99. class TypeError extends Throwable

    A throwable signalling a type error

  100. 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
  101. 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 use typeRef for creation.

    A class for named types of the form <prefix>.<sym.name>[args] Cannot be created directly; one should always use typeRef for creation. (@M: Otherwise hashing breaks)

  102. abstract class TypeTraverser extends SymbolTable.TypeMap
    Definition Classes
    TypeMaps
  103. abstract class TypeTraverserWithResult[T] extends SymbolTable.TypeTraverser
    Definition Classes
    TypeMaps
  104. class TypeUnwrapper extends (SymbolTable.Type) ⇒ SymbolTable.Type
  105. 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.

  106. class UndoLog extends Clearable
    Definition Classes
    TypeConstraints
  107. final class UniqueConstantType extends SymbolTable.ConstantType
  108. final class UniqueErasedValueType extends SymbolTable.ErasedValueType
  109. final class UniqueSingleType extends SymbolTable.SingleType
  110. final class UniqueSuperType extends SymbolTable.SuperType
  111. final class UniqueThisType extends SymbolTable.ThisType
  112. abstract class UniqueType extends SymbolTable.Type with Product

    A type that can be passed to unique(..) and be stored in the uniques map.

  113. final class UniqueTypeBounds extends SymbolTable.TypeBounds
  114. trait UntouchableTypeVar extends SymbolTable.TypeVar
  115. final case class SubTypePair(tp1: SymbolTable.Type, tp2: SymbolTable.Type) extends Product with Serializable
    Definition Classes
    TypeComparers

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. implicit val AnnotatedTypeTag: ClassTag[SymbolTable.AnnotatedType]
  5. implicit val BoundedWildcardTypeTag: ClassTag[SymbolTable.BoundedWildcardType]
  6. implicit val ClassInfoTypeTag: ClassTag[SymbolTable.ClassInfoType]
  7. implicit val CompoundTypeTag: ClassTag[SymbolTable.CompoundType]
  8. implicit val ConstantTypeTag: ClassTag[SymbolTable.ConstantType]
  9. implicit val ExistentialTypeTag: ClassTag[SymbolTable.ExistentialType]
  10. val GlbFailure: java.lang.Throwable
    Definition Classes
    GlbLubs
  11. def JavaMethodType(params: List[SymbolTable.Symbol], resultType: SymbolTable.Type): SymbolTable.JavaMethodType

    The canonical creator for implicit method types

  12. implicit val MethodTypeTag: ClassTag[SymbolTable.MethodType]
  13. implicit val NullaryMethodTypeTag: ClassTag[SymbolTable.NullaryMethodType]
  14. implicit val PolyTypeTag: ClassTag[SymbolTable.PolyType]
  15. implicit val RefinedTypeTag: ClassTag[SymbolTable.RefinedType]
  16. implicit val SingleTypeTag: ClassTag[SymbolTable.SingleType]
  17. implicit val SingletonTypeTag: ClassTag[SymbolTable.SingletonType]
  18. implicit val SuperTypeTag: ClassTag[SymbolTable.SuperType]
  19. implicit val ThisTypeTag: ClassTag[SymbolTable.ThisType]
  20. implicit val TypeBoundsTag: ClassTag[SymbolTable.TypeBounds]
  21. implicit val TypeRefTag: ClassTag[SymbolTable.TypeRef]
  22. implicit val TypeTagg: ClassTag[SymbolTable.Type]
  23. def addMember(thistp: SymbolTable.Type, tp: SymbolTable.Type, sym: SymbolTable.Symbol, depth: Depth): Unit

    Make symbol sym a member of scope tp.decls where thistp is the narrowed owner type of the scope.

  24. def addMember(thistp: SymbolTable.Type, tp: SymbolTable.Type, sym: SymbolTable.Symbol): Unit
  25. def addSerializable(ps: SymbolTable.Type*): List[SymbolTable.Type]
  26. 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.

  27. def appliedType(tyconSym: SymbolTable.Symbol, args: SymbolTable.Type*): SymbolTable.Type

    Very convenient.

    Very convenient.

    Definition Classes
    TypesTypes
  28. def appliedType(tyconSym: SymbolTable.Symbol, args: List[SymbolTable.Type]): SymbolTable.Type

    Definition Classes
    TypesTypes
    See also

    appliedType

  29. def appliedType(tycon: SymbolTable.Type, args: SymbolTable.Type*): SymbolTable.Type

    Definition Classes
    TypesTypes
    See also

    appliedType

  30. def appliedType(tycon: SymbolTable.Type, args: List[SymbolTable.Type]): SymbolTable.Type

    A creator for type applications

    A creator for type applications

    Definition Classes
    TypesTypes
  31. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  32. def basetypeRecursions: Int
  33. def basetypeRecursions_=(value: Int): Unit
  34. final def bitSetByPredicate[A](xs: List[A])(pred: (A) ⇒ Boolean): BitSet
    Definition Classes
    Collections
  35. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  36. final def collectFirst[A, B](as: List[A])(pf: PartialFunction[A, B]): Option[B]
    Definition Classes
    Collections
  37. final def collectMap2[A, B, C](xs1: List[A], xs2: List[B])(p: (A, B) ⇒ Boolean): Map[A, B]
    Definition Classes
    Collections
  38. 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[internal]
    Definition Classes
    CommonOwners
  39. 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[internal]
    Definition Classes
    CommonOwners
  40. def commonOwnerMap: SymbolTable.CommonOwnerMap
    Attributes
    protected
    Definition Classes
    CommonOwners
  41. final def compareLengths(xs1: List[_], xs2: List[_]): Int
    Definition Classes
    Collections
    Annotations
    @tailrec()
  42. def computeBaseClasses(tpe: SymbolTable.Type): List[SymbolTable.Symbol]
    Attributes
    protected
  43. def containsExistential(tpe: SymbolTable.Type): Boolean
  44. 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

  45. def copyRefinedType(original: SymbolTable.RefinedType, parents: List[SymbolTable.Type], decls: SymbolTable.Scope): SymbolTable.Type
  46. def copyTypeRef(tp: SymbolTable.Type, pre: SymbolTable.Type, sym: SymbolTable.Symbol, args: List[SymbolTable.Type]): SymbolTable.Type
  47. 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()
  48. def defineBaseClassesOfCompoundType(tpe: SymbolTable.CompoundType): Unit
    Attributes
    protected
  49. def defineBaseTypeSeqOfCompoundType(tpe: SymbolTable.CompoundType): Unit
    Attributes
    protected
  50. def defineBaseTypeSeqOfTypeRef(tpe: SymbolTable.TypeRef): Unit
    Attributes
    protected
  51. def defineParentsOfTypeRef(tpe: SymbolTable.TypeRef): Unit
    Attributes
    protected
  52. def defineUnderlyingOfSingleType(tpe: SymbolTable.SingleType): Unit
    Attributes
    protected
  53. final def distinctBy[A, B](xs: List[A])(f: (A) ⇒ B): List[A]
    Definition Classes
    Collections
  54. def elementExtract(container: SymbolTable.Symbol, tp: SymbolTable.Type): SymbolTable.Type
  55. def elementExtractOption(container: SymbolTable.Symbol, tp: SymbolTable.Type): Option[SymbolTable.Type]
  56. def elementTest(container: SymbolTable.Symbol, tp: SymbolTable.Type)(f: (SymbolTable.Type) ⇒ Boolean): Boolean
  57. def elementTransform(container: SymbolTable.Symbol, tp: SymbolTable.Type)(f: (SymbolTable.Type) ⇒ SymbolTable.Type): SymbolTable.Type
  58. def elimAnonymousClass(t: SymbolTable.Type): SymbolTable.Type
  59. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  60. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  61. 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 extrapolating tpe with respect to tparams. Extrapolating means that type variables in tparams occurring in covariant positions are replaced by upper bounds, (minus any SingletonClass markers), type variables in tparams 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 in tparams.

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

  62. def existentialsInType(tpe: SymbolTable.Type): List[SymbolTable.Symbol]
  63. final def exists2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ Boolean): Boolean
    Definition Classes
    Collections
  64. final def exists3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Boolean): Boolean
    Definition Classes
    Collections
  65. def explain[T](op: String, p: (SymbolTable.Type, T) ⇒ Boolean, tp1: SymbolTable.Type, arg2: T): Boolean

    Perform operation p on arguments tp1, arg2 and print trace of computation.

    Perform operation p on arguments tp1, arg2 and print trace of computation.

    Attributes
    protected
  66. def explainTypes(op: (SymbolTable.Type, SymbolTable.Type) ⇒ Any, found: SymbolTable.Type, required: SymbolTable.Type): Unit

    If option explaintypes is set, print a subtype trace for op(found, required).

  67. def explainTypes(found: SymbolTable.Type, required: SymbolTable.Type): Unit

    If option explaintypes is set, print a subtype trace for found <:< required.

  68. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  69. final def findOrElse[A](xs: TraversableOnce[A])(p: (A) ⇒ Boolean)(orElse: ⇒ A): A
    Definition Classes
    Collections
  70. 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
  71. final def flatCollect[A, B](elems: List[A])(pf: PartialFunction[A, Traversable[B]]): List[B]
    Definition Classes
    Collections
  72. final def flatMap2[A, B, C](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ List[C]): List[C]
    Definition Classes
    Collections
  73. final def flattensToEmpty(xss: Seq[Seq[_]]): Boolean
    Definition Classes
    Collections
    Annotations
    @tailrec()
  74. final def foldLeft2[A1, A2, B](xs1: List[A1], xs2: List[A2])(z0: B)(f: (B, A1, A2) ⇒ B): B
    Definition Classes
    Collections
  75. final def forall3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Boolean): Boolean
    Definition Classes
    Collections
  76. final def foreach2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ Unit): Unit
    Definition Classes
    Collections
  77. final def foreach3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) ⇒ Unit): Unit
    Definition Classes
    Collections
  78. final def foreachWithIndex[A](xs: List[A])(f: (A, Int) ⇒ Unit): Unit
    Definition Classes
    Collections
  79. def genPolyType(params: List[SymbolTable.Symbol], tpe: SymbolTable.Type): SymbolTable.Type
  80. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  81. def glb(ts: List[SymbolTable.Type], depth: Depth): SymbolTable.Type
    Attributes
    protected[internal]
    Definition Classes
    GlbLubs
  82. 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
  83. 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 to elimSuper.

    The greatest lower bound of a list of types (as determined by <:<), which have been normalized with regard to elimSuper.

    Attributes
    protected
    Definition Classes
    GlbLubs
  84. def glbResults: HashMap[(Depth, List[SymbolTable.Type]), SymbolTable.Type]
    Definition Classes
    GlbLubs
  85. 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
  86. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  87. final def howManyUniqueTypes: Int
  88. def importableMembers(pre: SymbolTable.Type): SymbolTable.Scope

    Members which can be imported into other scopes.

  89. def indent: String
    Attributes
    protected
  90. def indent_=(value: String): Unit
    Attributes
    protected
  91. def inheritsJavaVarArgsMethod(clazz: SymbolTable.Symbol): Boolean
  92. 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.

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

  94. def intersectionTypeForLazyBaseType(tps: List[SymbolTable.Type]): SymbolTable.Type
  95. def intersectionWitness: WeakHashMap[List[SymbolTable.Type], WeakReference[SymbolTable.Type]]
  96. def invalidateCaches(t: SymbolTable.Type, updatedSyms: List[SymbolTable.Symbol]): Unit
  97. def invalidateTreeTpeCaches(tree: SymbolTable.Tree, updatedSyms: List[SymbolTable.Symbol]): Unit
  98. def isBoundedGeneric(tp: SymbolTable.Type): Boolean
  99. def isConstantType(tp: SymbolTable.Type): Boolean
  100. def isDifferentType(tp1: SymbolTable.Type, tp2: SymbolTable.Type): Boolean
    Definition Classes
    TypeComparers
  101. def isDifferentTypeConstructor(tp1: SymbolTable.Type, tp2: SymbolTable.Type): Boolean
    Definition Classes
    TypeComparers
  102. def isDummyAppliedType(tp: SymbolTable.Type): Boolean
  103. 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 =:=.

  104. def isErrorOrWildcard(tp: SymbolTable.Type): Boolean
  105. def isExistentialType(tp: SymbolTable.Type): Boolean
  106. def isHKSubType(tp1: SymbolTable.Type, tp2: SymbolTable.Type, depth: Depth): Boolean
    Definition Classes
    TypeComparers
  107. def isImplicitMethodType(tp: SymbolTable.Type): Boolean
  108. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  109. def isIntersectionTypeForLazyBaseType(tp: SymbolTable.RefinedType): Boolean
  110. def isJavaVarargsAncestor(clazz: SymbolTable.Symbol): Boolean
  111. def isNonRefinementClassType(tpe: SymbolTable.Type): Boolean

    def isNonValueType(tp: Type) = !isValueElseNonValue(tp)

  112. def isNumericSubType(tp1: SymbolTable.Type, tp2: SymbolTable.Type): Boolean
    Definition Classes
    TypeComparers
  113. 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

  114. 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 be tp unchanged if pre is trivial and clazz 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 be tp unchanged if pre is trivial and clazz is a symbol such that isPossiblePrefix(clazz) == false.

    Definition Classes
    TypeMaps
  115. def isRawIfWithoutArgs(sym: SymbolTable.Symbol): Boolean
  116. def isRawType(tp: SymbolTable.Type): Boolean

    Is type tp a raw type?

  117. def isSameType(tp1: SymbolTable.Type, tp2: SymbolTable.Type): Boolean

    Do tp1 and tp2 denote equivalent types?

    Do tp1 and tp2 denote equivalent types?

    Definition Classes
    TypeComparers
  118. def isSameType2(tp1: SymbolTable.Type, tp2: SymbolTable.Type): Boolean
    Definition Classes
    TypeComparers
  119. def isSameTypes(tps1: List[SymbolTable.Type], tps2: List[SymbolTable.Type]): Boolean

    Are tps1 and tps2 lists of pairwise equivalent types?

  120. def isSingleType(tp: SymbolTable.Type): Boolean

    This appears to be equivalent to tp.isInstanceof[SingletonType], except it excludes ConstantTypes.

  121. def isSubArgs(tps1: List[SymbolTable.Type], tps2: List[SymbolTable.Type], tparams: List[SymbolTable.Symbol], depth: Depth): Boolean
  122. def isSubType(tp1: SymbolTable.Type, tp2: SymbolTable.Type, depth: Depth = Depth.AnyDepth): Boolean
    Definition Classes
    TypeComparers
  123. 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.)

  124. final def isUseableAsTypeArgs(tps: List[SymbolTable.Type]): Boolean
    Annotations
    @tailrec()
  125. def isWeakSubType(tp1: SymbolTable.Type, tp2: SymbolTable.Type): Boolean
    Definition Classes
    TypeComparers
  126. def isWithinBounds(pre: SymbolTable.Type, owner: SymbolTable.Symbol, tparams: List[SymbolTable.Symbol], targs: List[SymbolTable.Type]): Boolean

    Do type arguments targs conform to formal parameters tparams?

  127. final def linkedMapFrom[A, A1 >: A, B](xs: List[A])(f: (A) ⇒ B): LinkedHashMap[A1, B]
    Definition Classes
    Collections
  128. 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[internal]
    Definition Classes
    GlbLubs
  129. def lub(ts: List[SymbolTable.Type]): SymbolTable.Type
    Definition Classes
    GlbLubs
  130. def lubDepth(ts: List[SymbolTable.Type]): Depth

    The maximum allowable depth of lubs or glbs over types ts.

  131. def lubList(ts: List[SymbolTable.Type], depth: Depth): List[SymbolTable.Type]

    Given a matrix tsBts whose columns are basetype sequences (and the symbols tsParams 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 symbols tsParams 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
  132. def lubResults: HashMap[(Depth, List[SymbolTable.Type]), SymbolTable.Type]
    Definition Classes
    GlbLubs
  133. final def map2[A, B, C](xs1: List[A], xs2: List[B])(f: (A, B) ⇒ C): List[C]
    Definition Classes
    Collections
  134. 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 function f maps all elements to themselves.

    like map2, but returns list xs itself - instead of a copy - if function f maps all elements to themselves.

    Definition Classes
    Collections
  135. 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
  136. final def mapFilter2[A, B, C](itA: Iterator[A], itB: Iterator[B])(f: (A, B) ⇒ Option[C]): Iterator[C]
    Definition Classes
    Collections
  137. final def mapFrom[A, A1 >: A, B](xs: List[A])(f: (A) ⇒ B): Map[A1, B]
    Definition Classes
    Collections
  138. 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 empty

    A version of List#map, specialized for List, and optimized to avoid allocation if as is empty

    Definition Classes
    Collections
  139. final def mapWithIndex[A, B](xs: List[A])(f: (A, Int) ⇒ B): List[B]
    Definition Classes
    Collections
  140. final def matchesType(tp1: SymbolTable.Type, tp2: SymbolTable.Type, alwaysMatchSimple: Boolean): Boolean

    A function implementing tp1 matches tp2.

  141. def matchingParams(syms1: List[SymbolTable.Symbol], syms2: List[SymbolTable.Symbol], syms1isJava: Boolean, syms2isJava: Boolean): Boolean

    Are syms1 and syms2 parameter lists with pairwise equivalent types?

    Are syms1 and syms2 parameter lists with pairwise equivalent types?

    Attributes
    protected[internal]
  142. final val maxToStringRecursions: Int(50)

    The maximum number of recursions allowed in toString

    The maximum number of recursions allowed in toString

    Definition Classes
    TypeToStrings
  143. def mergePrefixAndArgs(tps0: List[SymbolTable.Type], variance: Variance, depth: Depth): SymbolTable.Type

    Compute lub (if variance == Covariant) or glb (if variance == Contravariant) of given list of types tps.

    Compute lub (if variance == Covariant) or glb (if variance == Contravariant) of given list of types tps. All types in tps are typerefs or singletypes with the same symbol. Return x if the computation succeeds with result x. Return NoType if the computation fails.

  144. 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
  145. final def mfind[A](xss: List[List[A]])(p: (A) ⇒ Boolean): Option[A]
    Definition Classes
    Collections
  146. final def mforall[A](xss: List[List[A]])(p: (A) ⇒ Boolean): Boolean
    Definition Classes
    Collections
  147. final def mforeach[A](xss: Traversable[Traversable[A]])(f: (A) ⇒ Unit): Unit
    Definition Classes
    Collections
  148. 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
  149. val missingAliasException: SymbolTable.MissingAliasControl
  150. final def mmap[A, B](xss: List[List[A]])(f: (A) ⇒ B): collection.immutable.List[collection.immutable.List[B]]
    Definition Classes
    Collections
  151. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  152. 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

  153. def newExistentialType(quantified: List[SymbolTable.Symbol], underlying: SymbolTable.Type): SymbolTable.Type

    A creator for existential types which flattens nested existentials.

  154. def nonTrivialMembers(clazz: SymbolTable.Symbol): SymbolTable.Scope

    Members of the given class, other than those inherited from Any or AnyRef.

  155. def normalizePlus(tp: SymbolTable.Type): SymbolTable.Type
  156. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  157. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  158. def numericLub(ts: List[SymbolTable.Type]): SymbolTable.Type
    Definition Classes
    GlbLubs
  159. def objToAny(tp: SymbolTable.Type): SymbolTable.Type
  160. def overloadedType(pre: SymbolTable.Type, alternatives: List[SymbolTable.Symbol]): SymbolTable.Type

    The canonical creator for OverloadedTypes.

  161. def pendingBaseTypes: HashSet[SymbolTable.Type]
  162. def pendingSubTypes: HashSet[SymbolTable.SubTypePair]
    Definition Classes
    TypeComparers
  163. 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
  164. def refinedType(parents: List[SymbolTable.Type], owner: SymbolTable.Symbol): SymbolTable.Type

    The canonical creator for a refined type with an initially empty scope.

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

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

  167. final def sameElementsEquals(thiss: List[AnyRef], that: List[AnyRef]): Boolean
    Definition Classes
    Collections
  168. 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
  169. 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
  170. final def sequence[A](as: List[Option[A]]): Option[List[A]]
    Definition Classes
    Collections
  171. final def sequenceOpt[A](as: List[Option[A]]): Option[List[A]]
    Definition Classes
    Collections
  172. val shorthands: Set[String]
  173. def singleType(pre: SymbolTable.Type, sym: SymbolTable.Symbol): SymbolTable.Type

    The canonical creator for single-types

  174. def singletonBounds(hi: SymbolTable.Type): SymbolTable.TypeBounds
  175. def skipPrefixOf(pre: SymbolTable.Type, clazz: SymbolTable.Symbol): Boolean
    Attributes
    protected[internal]
    Definition Classes
    TypeMaps
  176. def skolemizationLevel: Int
  177. def skolemizationLevel_=(value: Int): Unit
  178. def solve(tvars: List[SymbolTable.TypeVar], tparams: List[SymbolTable.Symbol], getVariance: Extractor[SymbolTable.Symbol], 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

    getVariance

    Function to extract variances of type parameters; we need to reverse solution direction for all contravariant variables.

    upper

    When true search for max solution else min.

    Definition Classes
    TypeConstraints
  179. 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
  180. def specializesSym(preLo: SymbolTable.Type, symLo: SymbolTable.Symbol, preHi: SymbolTable.Type, symHi: SymbolTable.Symbol, depth: Depth): Boolean

    Does member symLo of tpLo have a stronger type than member symHi of tpHi?

    Does member symLo of tpLo have a stronger type than member symHi of tpHi?

    Attributes
    protected[internal]
  181. def specializesSym(tp: SymbolTable.Type, sym: SymbolTable.Symbol, depth: Depth): Boolean
  182. final def stripExistentialsAndTypeVars(ts: List[SymbolTable.Type], expandLazyBaseType: Boolean = false): (List[SymbolTable.Type], List[SymbolTable.Symbol])
  183. def subsametypeRecursions: Int
    Definition Classes
    TypeComparers
  184. def subsametypeRecursions_=(value: Int): Unit
    Definition Classes
    TypeComparers
  185. final def sumSize(xss: List[List[_]], acc: Int): Int
    Definition Classes
    Collections
    Annotations
    @tailrec()
  186. final def suspendingTypeVars[T](tvs: List[SymbolTable.TypeVar])(op: ⇒ T): T
    Annotations
    @inline()
  187. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  188. def toString(): String
    Definition Classes
    AnyRef → Any
  189. def toStringRecursions: Int
    Definition Classes
    TypeToStrings
  190. def toStringRecursions_=(value: Int): Unit
    Definition Classes
    TypeToStrings
  191. def toStringSubjects: HashSet[SymbolTable.Type]
    Definition Classes
    TypeToStrings
  192. def transparentShallowTransform(container: SymbolTable.Symbol, tp: SymbolTable.Type)(f: (SymbolTable.Type) ⇒ SymbolTable.Type): SymbolTable.Type
  193. final def transposeSafe[A](ass: List[List[A]]): Option[List[List[A]]]
    Definition Classes
    Collections
  194. final def traverseOpt[A, B](as: List[A])(f: (A) ⇒ Option[B]): Option[List[B]]
    Definition Classes
    Collections
  195. def typeDepth(tp: SymbolTable.Type): Depth

    The maximum depth of type tp

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

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

  198. def typeParamsToExistentials(clazz: SymbolTable.Symbol): List[SymbolTable.Symbol]
  199. def typeParamsToExistentials(clazz: SymbolTable.Symbol, tparams: List[SymbolTable.Symbol]): List[SymbolTable.Symbol]
  200. 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

  201. def typeToString(tpe: SymbolTable.Type): String
    Attributes
    protected
    Definition Classes
    TypeToStrings
  202. def typeVarsInType(tp: SymbolTable.Type): List[SymbolTable.TypeVar]

    A list of the typevars in a type.

  203. final def uncheckedBounds(tp: SymbolTable.Type): SymbolTable.Type

    Adds the @uncheckedBound annotation if the given tp has type arguments

  204. def undoLog: SymbolTable.UndoLog
    Definition Classes
    TypeConstraints
  205. def unique[T <: SymbolTable.Type](tp: T): T
    Attributes
    protected
  206. def validateClassInfo(tp: SymbolTable.ClassInfoType): Unit

    Overridden in reflection compiler

  207. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  208. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  209. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  210. 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
  211. def withTypesExplained[A](op: ⇒ A): A

    Execute op while printing a trace of the operations on types executed.

  212. object AnnotatedType extends SymbolTable.AnnotatedTypeExtractor with Serializable

    The constructor/extractor for AnnotatedType instances.

    The constructor/extractor for AnnotatedType instances.

    Definition Classes
    TypesTypes
  213. object ApproximateDependentMap extends SymbolTable.TypeMap
    Definition Classes
    TypeMaps
  214. object ArrayTypeRef
  215. object BoundedWildcardType extends SymbolTable.BoundedWildcardTypeExtractor with Serializable

    The constructor/extractor for BoundedWildcardType instances.

    The constructor/extractor for BoundedWildcardType instances.

    Definition Classes
    TypesTypes
  216. object ClassInfoType extends SymbolTable.ClassInfoTypeExtractor with Serializable

    The constructor/extractor for ClassInfoType instances.

    The constructor/extractor for ClassInfoType instances.

    Definition Classes
    TypesTypes
  217. object CompoundType
  218. object ConstantType extends SymbolTable.ConstantTypeExtractor with Serializable

    The constructor/extractor for ConstantType instances.

    The constructor/extractor for ConstantType instances.

    Definition Classes
    TypesTypes
  219. object ErasedValueType extends Serializable
  220. object ErroneousCollector extends SymbolTable.TypeCollector[Boolean]

    A map to implement the contains method.

    A map to implement the contains method.

    Definition Classes
    TypeMaps
  221. object ErrorType extends SymbolTable.Type with Product with Serializable

    An object representing an erroneous type

  222. object ExistentialType extends SymbolTable.ExistentialTypeExtractor with Serializable

    The constructor/extractor for ExistentialType instances.

    The constructor/extractor for ExistentialType instances.

    Definition Classes
    TypesTypes
  223. 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.)

  224. object HasTypeMember
  225. object IsDependentCollector extends SymbolTable.TypeCollector[Boolean]
    Definition Classes
    TypeMaps
  226. object MethodType extends SymbolTable.MethodTypeExtractor with Serializable

    The constructor/extractor for MethodType instances.

    The constructor/extractor for MethodType instances.

    Definition Classes
    TypesTypes
  227. object NoPrefix extends SymbolTable.Type with Product with Serializable

    An object representing a non-existing prefix

    An object representing a non-existing prefix

    Definition Classes
    TypesTypes
  228. object NoType extends SymbolTable.Type with Product with Serializable

    An object representing a non-existing type

    An object representing a non-existing type

    Definition Classes
    TypesTypes
  229. object NullaryMethodType extends SymbolTable.NullaryMethodTypeExtractor with Serializable

    The constructor/extractor for NullaryMethodType instances.

    The constructor/extractor for NullaryMethodType instances.

    Definition Classes
    TypesTypes
  230. object PolyType extends SymbolTable.PolyTypeExtractor with Serializable

    The constructor/extractor for PolyType instances.

    The constructor/extractor for PolyType instances.

    Definition Classes
    TypesTypes
  231. object RefinedType extends SymbolTable.RefinedTypeExtractor with Serializable

    The constructor/extractor for RefinedType instances.

    The constructor/extractor for RefinedType instances.

    Definition Classes
    TypesTypes
  232. object SingleType extends SymbolTable.SingleTypeExtractor with Serializable

    The constructor/extractor for SingleType instances.

    The constructor/extractor for SingleType instances.

    Definition Classes
    TypesTypes
  233. object StaticallyAnnotatedType
  234. object SuperType extends SymbolTable.SuperTypeExtractor with Serializable

    The constructor/extractor for SuperType instances.

    The constructor/extractor for SuperType instances.

    Definition Classes
    TypesTypes
  235. object ThisType extends SymbolTable.ThisTypeExtractor with Serializable

    The constructor/extractor for ThisType instances.

    The constructor/extractor for ThisType instances.

    Definition Classes
    TypesTypes
  236. object TypeBounds extends SymbolTable.TypeBoundsExtractor with Serializable

    The constructor/extractor for TypeBounds instances.

    The constructor/extractor for TypeBounds instances.

    Definition Classes
    TypesTypes
  237. object TypeRef extends SymbolTable.TypeRefExtractor with Serializable

    The constructor/extractor for TypeRef instances.

    The constructor/extractor for TypeRef instances.

    Definition Classes
    TypesTypes
  238. object TypeVar extends Serializable
  239. object UnmappableTree extends SymbolTable.Tree with SymbolTable.TermTree with Product with Serializable
  240. object WildcardType extends SymbolTable.Type with Product with Serializable

    An object representing an unknown type, used during type inference.

    An object representing an unknown type, used during type inference. If you see WildcardType outside of inference it is almost certainly a bug.

    Definition Classes
    TypesTypes
  241. 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
  242. object adaptToNewRunMap extends SymbolTable.TypeMap
    Definition Classes
    TypeMaps
  243. 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
  244. 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
  245. 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
  246. 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
  247. object unwrapToClass extends SymbolTable.ClassUnwrapper
  248. object unwrapToStableClass extends SymbolTable.ClassUnwrapper
  249. object unwrapWrapperTypes extends SymbolTable.TypeUnwrapper
  250. 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 of def bla(x: String): Int.

    Definition Classes
    TypeMaps
  251. 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

  1. def isRaw(sym: SymbolTable.Symbol, args: List[SymbolTable.Type]): Boolean
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.1) use isRawType

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

  3. def polyType(params: List[SymbolTable.Symbol], tpe: SymbolTable.Type): SymbolTable.Type
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.0) use genPolyType(...) instead

Inherited from Collections

Inherited from tpe.FindMembers

Inherited from TypeConstraints

Inherited from TypeMaps

Inherited from GlbLubs

Inherited from CommonOwners

Inherited from TypeToStrings

Inherited from TypeComparers

Inherited from api.Types

Inherited from AnyRef

Inherited from Any

API

Extractors

Types - Operations

Types

Ungrouped