scala.reflect.api

Universe

abstract class Universe extends Universe with Symbols with Types with FlagSets with Names with Trees with Printers with Constants with Positions with Mirrors with StandardDefinitions with StandardNames with Importers with Exprs with AnnotationInfos

Source
Universe.scala
Linear Supertypes
Known Subclasses
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Universe
  2. AnnotationInfos
  3. Exprs
  4. Importers
  5. StandardNames
  6. StandardDefinitions
  7. Mirrors
  8. Positions
  9. Constants
  10. Printers
  11. Trees
  12. Names
  13. FlagSets
  14. Types
  15. Symbols
  16. Universe
  17. Mirrors
  18. BuildUtils
  19. StandardNames
  20. StandardDefinitions
  21. StandardTypes
  22. TagInterop
  23. TypeTags
  24. Positions
  25. AnnotationInfos
  26. Constants
  27. Trees
  28. Names
  29. Scopes
  30. FlagSets
  31. Types
  32. Symbols
  33. AnyRef
  34. Any
Implicitly
  1. by any2stringadd
  2. by any2stringfmt
  3. by any2ArrowAssoc
  4. by any2Ensuring
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Universe()

Type Members

  1. trait AbsTypeTag[T] extends Equals with Serializable

    If an implicit value of type u.

  2. abstract type Alternative >: Null <: TermTree with AlternativeApi

    Alternatives of patterns, eliminated by explicitouter, except for occurrences in encoded Switch stmt (=remaining Match(CaseDef(.

    Alternatives of patterns, eliminated by explicitouter, except for occurrences in encoded Switch stmt (=remaining Match(CaseDef(...))) Eliminated by patmat/explicitouter.

    Definition Classes
    TreesTrees
  3. trait AlternativeApi extends TreeBase with TermTreeApi

    The API that all alternatives support

  4. abstract class AlternativeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Alternative(trees).

  5. abstract type Annotated >: Null <: Tree with AnnotatedApi

    A tree that has an annotation attached to it.

    A tree that has an annotation attached to it. Only used for annotated types and annotation ascriptions, annotations on definitions are stored in the Modifiers. Eliminated by typechecker (typedAnnotated), the annotations are then stored in an AnnotatedType.

    Definition Classes
    TreesTrees
  6. trait AnnotatedApi extends TreeBase with TreeApi

    The API that all annotateds support

  7. abstract class AnnotatedExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Annotated(annot, arg).

  8. abstract type AnnotatedType >: Null <: Type with AnnotatedTypeApi

    .

    ..

    Definition Classes
    TypesTypes
  9. trait AnnotatedTypeApi extends TypeApi

    The API that all annotated types support

  10. abstract class AnnotatedTypeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax AnnotatedType(annotations, underlying, selfsym).

  11. abstract type AnnotationInfo >: Null <: AnnotationInfoApi

    Definition Classes
    AnnotationInfosAnnotationInfos
  12. trait AnnotationInfoApi extends AnyRef

    Definition Classes
    AnnotationInfos
  13. abstract class AnnotationInfoExtractor extends AnyRef

    Definition Classes
    AnnotationInfos
  14. abstract type AppliedTypeTree >: Null <: TypTree with AppliedTypeTreeApi

    Applied type <tpt> [ <args> ], eliminated by RefCheck

    Applied type <tpt> [ <args> ], eliminated by RefCheck

    Definition Classes
    TreesTrees
  15. trait AppliedTypeTreeApi extends TreeBase with TypTreeApi

    The API that all applied type trees support

  16. abstract class AppliedTypeTreeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax AppliedTypeTree(tpt, args).

  17. abstract type Apply >: Null <: GenericApply with ApplyApi

    Value application

    Value application

    Definition Classes
    TreesTrees
  18. trait ApplyApi extends TreeBase with GenericApplyApi

    The API that all applies support

  19. abstract type ApplyDynamic >: Null <: TermTree with SymTree with ApplyDynamicApi

    Dynamic value application.

    Dynamic value application. In a dynamic application q.f(as)

    • q is stored in qual
    • as is stored in args
    • f is stored as the node's symbol field. [Eugene++] what is it used for? Introduced by erasure, eliminated by cleanup.
    Definition Classes
    TreesTrees
  20. trait ApplyDynamicApi extends TreeBase with TermTreeApi with SymTreeApi

    The API that all apply dynamics support

  21. abstract class ApplyDynamicExtractor extends AnyRef

    An extractor class to create and pattern match with syntax ApplyDynamic(qual, args).

  22. abstract class ApplyExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Apply(fun, args).

  23. abstract type ArrayAnnotArg >: Null <: ClassfileAnnotArg with ArrayAnnotArgApi

    Definition Classes
    AnnotationInfosAnnotationInfos
  24. trait ArrayAnnotArgApi extends AnyRef

    Definition Classes
    AnnotationInfos
  25. abstract class ArrayAnnotArgExtractor extends AnyRef

    Definition Classes
    AnnotationInfos
  26. abstract type ArrayValue >: Null <: TermTree with ArrayValueApi

    Array of expressions, needs to be translated in backend.

    Array of expressions, needs to be translated in backend. This AST node is used to pass arguments to vararg arguments. Introduced by uncurry.

    Definition Classes
    TreesTrees
  27. trait ArrayValueApi extends TreeBase with TermTreeApi

    The API that all array values support

  28. abstract class ArrayValueExtractor extends AnyRef

    An extractor class to create and pattern match with syntax ArrayValue(elemtpt, elems).

  29. abstract type Assign >: Null <: TermTree with AssignApi

    Assignment

    Assignment

    Definition Classes
    TreesTrees
  30. trait AssignApi extends TreeBase with TermTreeApi

    The API that all assigns support

  31. abstract class AssignExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Assign(lhs, rhs).

  32. abstract type AssignOrNamedArg >: Null <: TermTree with AssignOrNamedArgApi

    Either an assignment or a named argument.

    Either an assignment or a named argument. Only appears in argument lists, eliminated by typecheck (doTypedApply), resurrected by reifier.

    Definition Classes
    TreesTrees
  33. trait AssignOrNamedArgApi extends TreeBase with TermTreeApi

    The API that all assigns support

  34. abstract class AssignOrNamedArgExtractor extends AnyRef

    An extractor class to create and pattern match with syntax AssignOrNamedArg(lhs, rhs).

  35. abstract type Bind >: Null <: DefTree with BindApi

    Bind of a variable to a rhs pattern, eliminated by explicitouter Eliminated by patmat/explicitouter.

    Bind of a variable to a rhs pattern, eliminated by explicitouter Eliminated by patmat/explicitouter.

    Definition Classes
    TreesTrees
  36. trait BindApi extends TreeBase with DefTreeApi

    The API that all binds support

  37. abstract class BindExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Bind(name, body).

  38. abstract type Block >: Null <: TermTree with BlockApi

    Block of expressions (semicolon separated expressions)

    Block of expressions (semicolon separated expressions)

    Definition Classes
    TreesTrees
  39. trait BlockApi extends TreeBase with TermTreeApi

    The API that all blocks support

  40. abstract class BlockExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Block(stats, expr).

  41. case class BooleanFlag(value: Option[Boolean]) extends Product with Serializable

    Definition Classes
    Printers
  42. abstract type BoundedWildcardType >: Null <: Type with BoundedWildcardTypeApi

    .

    ..

    Definition Classes
    TypesTypes
  43. trait BoundedWildcardTypeApi extends TypeApi

    The API that all this types support

  44. abstract class BoundedWildcardTypeExtractor extends AnyRef

    Definition Classes
    Types
  45. abstract class BuildBase extends AnyRef

    Definition Classes
    BuildUtils
  46. abstract type CaseDef >: Null <: Tree with CaseDefApi

    Case clause in a pattern match, eliminated during explicitouter (except for occurrences in switch statements).

    Case clause in a pattern match, eliminated during explicitouter (except for occurrences in switch statements). Eliminated by patmat/explicitouter.

    Definition Classes
    TreesTrees
  47. trait CaseDefApi extends TreeBase with TreeApi

    The API that all case defs support

  48. abstract class CaseDefExtractor extends AnyRef

    An extractor class to create and pattern match with syntax CaseDef(pat, guard, body).

  49. abstract type ClassDef >: Null <: ImplDef with ClassDefApi

    A class definition.

    A class definition.

    Definition Classes
    TreesTrees
  50. trait ClassDefApi extends TreeBase with ImplDefApi

    The API that all class defs support

  51. abstract class ClassDefExtractor extends AnyRef

    An extractor class to create and pattern match with syntax ClassDef(mods, name, tparams, impl).

  52. abstract type ClassInfoType >: Null <: CompoundType with ClassInfoTypeApi

    .

    ..

    Definition Classes
    TypesTypes
  53. trait ClassInfoTypeApi extends TypeApi

    The API that all class info types support

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

  55. trait ClassMirror extends TemplateMirror

    A mirror that reflects the instance parts of a runtime class

  56. abstract type ClassSymbol >: Null <: TypeSymbol with ClassSymbolApi

    The abstract type of class symbols representing class and trait definitions

    The abstract type of class symbols representing class and trait definitions

    Definition Classes
    SymbolsSymbols
  57. trait ClassSymbolApi extends TypeSymbolApi with ClassSymbolBase

    The API of class symbols

  58. trait ClassSymbolBase extends TypeSymbolBase

    The base API that all class symbols support

  59. abstract type ClassfileAnnotArg >: Null <: AnyRef

    Definition Classes
    AnnotationInfos
  60. abstract type CompoundType >: Null <: Type

    A subtype of Type representing refined types as well as ClassInfo signatures.

    A subtype of Type representing refined types as well as ClassInfo signatures.

    Definition Classes
    Types
  61. abstract type CompoundTypeTree >: Null <: TypTree with CompoundTypeTreeApi

    Intersection type <parent1> with .

    Intersection type <parent1> with ... with <parentN> { <decls> }, eliminated by RefCheck

    Definition Classes
    TreesTrees
  62. trait CompoundTypeTreeApi extends TreeBase with TypTreeApi

    The API that all compound type trees support

  63. abstract class CompoundTypeTreeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax CompoundTypeTree(templ).

  64. abstract type Constant >: Null <: ConstantApi

    Definition Classes
    ConstantsConstants
  65. abstract class ConstantApi extends AnyRef

    Definition Classes
    Constants
  66. abstract class ConstantExtractor extends AnyRef

    Definition Classes
    Constants
  67. abstract type ConstantType >: Null <: SingletonType with ConstantTypeApi

    .

    ..

    Definition Classes
    TypesTypes
  68. trait ConstantTypeApi extends TypeApi

    The API that all constant types support

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

  70. abstract type DefDef >: Null <: ValOrDefDef with DefDefApi

    A method or macro definition.

    A method or macro definition.

    Definition Classes
    TreesTrees
  71. trait DefDefApi extends TreeBase with ValOrDefDefApi

    The API that all def defs support

  72. abstract class DefDefExtractor extends AnyRef

    An extractor class to create and pattern match with syntax DefDef(mods, name, tparams, vparamss, tpt, rhs).

  73. abstract type DefTree >: Null <: SymTree with NameTree with DefTreeApi

    A tree which defines a symbol-carrying entity.

    A tree which defines a symbol-carrying entity.

    Definition Classes
    TreesTrees
  74. trait DefTreeApi extends TreeBase with SymTreeApi with NameTreeApi

    The API that all def trees support

  75. trait DefinitionsApi extends DefinitionsBase

    Definition Classes
    StandardDefinitions
  76. trait DefinitionsBase extends AnyRef

    Definition Classes
    StandardDefinitions
  77. abstract type ExistentialType >: Null <: Type with ExistentialTypeApi

    .

    ..

    Definition Classes
    TypesTypes
  78. trait ExistentialTypeApi extends TypeApi

    The API that all existential types support

  79. abstract class ExistentialTypeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax ExistentialType(quantified, underlying).

  80. abstract type ExistentialTypeTree >: Null <: TypTree with ExistentialTypeTreeApi

    Document me!

    Document me!

    Definition Classes
    TreesTrees
  81. trait ExistentialTypeTreeApi extends TreeBase with TypTreeApi

    The API that all existential type trees support

  82. abstract class ExistentialTypeTreeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax ExistentialTypeTree(tpt, whereClauses).

  83. trait Expr[+T] extends Equals with Serializable

    An expression tree tagged with its type

  84. trait FieldMirror extends AnyRef

    A mirror that reflects a field

  85. trait FlagOps extends Any

    Definition Classes
    FlagSets
  86. abstract type FlagSet

    Definition Classes
    FlagSets
  87. abstract type FlagValues >: Null <: FlagValuesApi

    Definition Classes
    FlagSets
  88. trait FlagValuesApi extends AnyRef

    Definition Classes
    FlagSets
  89. abstract type FreeTermSymbol >: Null <: TermSymbol with FreeTermSymbolApi

    The abstract type of free terms introduced by reification

    The abstract type of free terms introduced by reification

    Definition Classes
    SymbolsSymbols
  90. trait FreeTermSymbolApi extends TermSymbolApi with FreeTermSymbolBase

    The API of free term symbols

  91. trait FreeTermSymbolBase extends TermSymbolBase

    The base API that all free term symbols support

  92. abstract type FreeTypeSymbol >: Null <: TypeSymbol with FreeTypeSymbolApi

    The abstract type of free types introduced by reification

    The abstract type of free types introduced by reification

    Definition Classes
    SymbolsSymbols
  93. trait FreeTypeSymbolApi extends TypeSymbolApi with FreeTypeSymbolBase

    The API of free term symbols

  94. trait FreeTypeSymbolBase extends TypeSymbolBase

    The base API that all free type symbols support

  95. abstract type Function >: Null <: TermTree with SymTree with FunctionApi

    Anonymous function, eliminated by lambdalift

    Anonymous function, eliminated by lambdalift

    Definition Classes
    TreesTrees
  96. trait FunctionApi extends TreeBase with TermTreeApi with SymTreeApi

    The API that all functions support

  97. abstract class FunctionExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Function(vparams, body).

  98. abstract type GenericApply >: Null <: TermTree with GenericApplyApi

    Common base class for Apply and TypeApply.

    Common base class for Apply and TypeApply. This could in principle be a SymTree, but whether or not a Tree is a SymTree isn't used to settle any interesting questions, and it would add a useless field to all the instances (useless, since GenericApply forwards to the underlying fun.)

    Definition Classes
    TreesTrees
  99. trait GenericApplyApi extends TreeBase with TermTreeApi

    The API that all applies support

  100. trait HasFlagsApi extends AnyRef

    Definition Classes
    Symbols
  101. abstract type Ident >: Null <: RefTree with IdentApi

    Identifier <name>

    Identifier <name>

    Definition Classes
    TreesTrees
  102. trait IdentApi extends TreeBase with RefTreeApi

    The API that all idents support

  103. abstract class IdentExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Ident(qual, name).

  104. abstract type If >: Null <: TermTree with IfApi

    Conditional expression

    Conditional expression

    Definition Classes
    TreesTrees
  105. trait IfApi extends TreeBase with TermTreeApi

    The API that all ifs support

  106. abstract class IfExtractor extends AnyRef

    An extractor class to create and pattern match with syntax If(cond, thenp, elsep).

  107. abstract type ImplDef >: Null <: MemberDef with ImplDefApi

    A common base class for class and object definitions.

    A common base class for class and object definitions.

    Definition Classes
    TreesTrees
  108. trait ImplDefApi extends TreeBase with MemberDefApi

    The API that all impl defs support

  109. abstract type Import >: Null <: SymTree with ImportApi

    Import clause

    Import clause

    Definition Classes
    TreesTrees
  110. trait ImportApi extends TreeBase with SymTreeApi

    The API that all imports support

  111. abstract class ImportExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Import(expr, selectors).

  112. abstract type ImportSelector >: Null <: ImportSelectorApi

    Import selector

    Import selector

    Representation of an imported name its optional rename and their optional positions

    Eliminated by typecheck.

    Definition Classes
    TreesTrees
  113. trait ImportSelectorApi extends AnyRef

    The API that all import selectors support

  114. abstract class ImportSelectorExtractor extends AnyRef

    An extractor class to create and pattern match with syntax ImportSelector(name:, namePos, rename, renamePos).

  115. trait Importer extends AnyRef

    Definition Classes
    Importers
  116. trait InstanceMirror extends AnyRef

    A mirror that reflects a runtime value

  117. abstract type LabelDef >: Null <: DefTree with TermTree with LabelDefApi

    A labelled expression.

    A labelled expression. Not expressible in language syntax, but generated by the compiler to simulate while/do-while loops, and also by the pattern matcher.

    The label acts much like a nested function, where params represents the incoming parameters. The symbol given to the LabelDef should have a MethodType, as if it were a nested function.

    Jumps are apply nodes attributed with a label's symbol. The arguments from the apply node will be passed to the label and assigned to the Idents.

    Forward jumps within a block are allowed.

    Definition Classes
    TreesTrees
  118. trait LabelDefApi extends TreeBase with DefTreeApi with TermTreeApi

    The API that all label defs support

  119. abstract class LabelDefExtractor extends AnyRef

    An extractor class to create and pattern match with syntax LabelDef(name, params, rhs).

  120. abstract type Literal >: Null <: TermTree with LiteralApi

    Literal

    Literal

    Definition Classes
    TreesTrees
  121. abstract type LiteralAnnotArg >: Null <: ClassfileAnnotArg with LiteralAnnotArgApi

    Definition Classes
    AnnotationInfosAnnotationInfos
  122. trait LiteralAnnotArgApi extends AnyRef

    Definition Classes
    AnnotationInfos
  123. abstract class LiteralAnnotArgExtractor extends AnyRef

    Definition Classes
    AnnotationInfos
  124. trait LiteralApi extends TreeBase with TermTreeApi

    The API that all literals support

  125. abstract class LiteralExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Literal(value).

  126. abstract type Match >: Null <: TermTree with MatchApi

    - Pattern matching expression (before explicitouter)

    - Pattern matching expression (before explicitouter)

    • Switch statements (after explicitouter)

    After explicitouter, cases will satisfy the following constraints:

    • all guards are EmptyTree,
    • all patterns will be either Literal(Constant(x:Int)) or Alternative(lit|...|lit)
    • except for an "otherwise" branch, which has pattern Ident(nme.WILDCARD)
    Definition Classes
    TreesTrees
  127. trait MatchApi extends TreeBase with TermTreeApi

    The API that all matches support

  128. abstract class MatchExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Match(selector, cases).

  129. abstract type MemberDef >: Null <: DefTree with MemberDefApi

    Common base class for all member definitions: types, classes, objects, packages, vals and vars, defs.

    Common base class for all member definitions: types, classes, objects, packages, vals and vars, defs.

    Definition Classes
    TreesTrees
  130. trait MemberDefApi extends TreeBase with DefTreeApi

    The API that all member defs support

  131. trait MethodMirror extends AnyRef

    A mirror that reflects a method handle

  132. abstract type MethodSymbol >: Null <: TermSymbol with MethodSymbolApi

    The abstract type of method symbols representing def declarations

    The abstract type of method symbols representing def declarations

    Definition Classes
    SymbolsSymbols
  133. type MethodSymbolApi = MethodSymbolBase

    The API of method symbols

    The API of method symbols

    Definition Classes
    Symbols
  134. trait MethodSymbolBase extends TermSymbolBase

    The base API that all method symbols support

  135. abstract type MethodType >: Null <: Type with MethodTypeApi

    .

    ..

    Definition Classes
    TypesTypes
  136. trait MethodTypeApi extends TypeApi

    The API that all method types support

  137. abstract class MethodTypeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax MethodType(params, respte) Here, params is a potentially empty list of parameter symbols of the method, and restpe is the result type of the method.

  138. abstract type Mirror >: Null <: MirrorOf[Universe.this.type]

    .

    ..

    Definition Classes
    Mirrors
  139. abstract type Modifiers >: Null <: ModifiersApi

    .

    ...

    Definition Classes
    TreesTrees
  140. abstract class ModifiersApi extends ModifiersBase with HasFlagsApi

    Definition Classes
    Trees
  141. abstract class ModifiersBase extends AnyRef

    .

  142. abstract class ModifiersCreator extends AnyRef

    Definition Classes
    Trees
  143. abstract type ModuleDef >: Null <: ImplDef with ModuleDefApi

    An object definition, e.

    An object definition, e.g. object Foo. Internally, objects are quite frequently called modules to reduce ambiguity. Eliminated by refcheck.

    Definition Classes
    TreesTrees
  144. trait ModuleDefApi extends TreeBase with ImplDefApi

    The API that all module defs support

  145. abstract class ModuleDefExtractor extends AnyRef

    An extractor class to create and pattern match with syntax ModuleDef(mods, name, impl).

  146. trait ModuleMirror extends TemplateMirror

    A mirror that reflects a Scala object definition or the static parts of a runtime class

  147. abstract type ModuleSymbol >: Null <: TermSymbol with ModuleSymbolApi

    The abstract type of module symbols representing object declarations

    The abstract type of module symbols representing object declarations

    Definition Classes
    SymbolsSymbols
  148. type ModuleSymbolApi = ModuleSymbolBase

    The API of module symbols

    The API of module symbols

    Definition Classes
    Symbols
  149. trait ModuleSymbolBase extends TermSymbolBase

    The base API that all module symbols support

  150. abstract type Name >: Null <: NameApi

    The abstract type of names

    The abstract type of names

    Definition Classes
    NamesNames
  151. abstract class NameApi extends NameBase

    The extended API of names that's supported on reflect mirror via an implicit conversion in reflect.

  152. abstract class NameBase extends AnyRef

    The base API that all names support

  153. abstract type NameTree >: Null <: Tree with NameTreeApi

    A tree with a name - effectively, a DefTree or RefTree.

    A tree with a name - effectively, a DefTree or RefTree.

    Definition Classes
    TreesTrees
  154. trait NameTreeApi extends TreeBase with TreeApi

    The API that all name trees support

  155. trait NamesApi extends NamesBase

    Definition Classes
    StandardNames
  156. trait NamesBase extends AnyRef

    Definition Classes
    StandardNames
  157. abstract type NestedAnnotArg >: Null <: ClassfileAnnotArg with NestedAnnotArgApi

    Definition Classes
    AnnotationInfosAnnotationInfos
  158. trait NestedAnnotArgApi extends AnyRef

    Definition Classes
    AnnotationInfos
  159. abstract class NestedAnnotArgExtractor extends AnyRef

    Definition Classes
    AnnotationInfos
  160. abstract type New >: Null <: TermTree with NewApi

    Object instantiation One should always use factory method below to build a user level new.

    Object instantiation One should always use factory method below to build a user level new.

    Definition Classes
    TreesTrees
  161. trait NewApi extends TreeBase with TermTreeApi

    The API that all news support

  162. abstract class NewExtractor extends AnyRef

    An extractor class to create and pattern match with syntax New(tpt).

  163. abstract type NullaryMethodType >: Null <: Type with NullaryMethodTypeApi

    .

    ..

    Definition Classes
    TypesTypes
  164. trait NullaryMethodTypeApi extends TypeApi

    The API that all nullary method types support

  165. abstract class NullaryMethodTypeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax NullaryMethodType(resultType).

  166. abstract type PackageDef >: Null <: MemberDef with PackageDefApi

    A packaging, such as package pid { stats }

    A packaging, such as package pid { stats }

    Definition Classes
    TreesTrees
  167. trait PackageDefApi extends TreeBase with MemberDefApi

    The API that all package defs support

  168. abstract class PackageDefExtractor extends AnyRef

    An extractor class to create and pattern match with syntax PackageDef(pid, stats).

  169. abstract type PolyType >: Null <: Type with PolyTypeApi

    .

    ..

    Definition Classes
    TypesTypes
  170. trait PolyTypeApi extends TypeApi

    The API that all polymorphic types support

  171. abstract class PolyTypeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax PolyType(typeParams, resultType).

  172. abstract type Position >: Null <: PositionApi { type Pos = Universe.this.Position }

    .

    ..

    Definition Classes
    PositionsPositions
  173. abstract type RefTree >: Null <: SymTree with NameTree with RefTreeApi

    A tree which references a symbol-carrying entity.

    A tree which references a symbol-carrying entity. References one, as opposed to defining one; definitions are in DefTrees.

    Definition Classes
    TreesTrees
  174. trait RefTreeApi extends TreeBase with SymTreeApi with NameTreeApi

    The API that all ref trees support

  175. abstract type ReferenceToBoxed >: Null <: TermTree with ReferenceToBoxedApi

    Marks underlying reference to id as boxed.

    Marks underlying reference to id as boxed.

    Definition Classes
    TreesTrees
  176. trait ReferenceToBoxedApi extends TreeBase with TermTreeApi

    The API that all references support

  177. abstract class ReferenceToBoxedExtractor extends AnyRef

    An extractor class to create and pattern match with syntax ReferenceToBoxed(ident).

  178. abstract type RefinedType >: Null <: CompoundType with RefinedTypeApi

    .

    ..

    Definition Classes
    TypesTypes
  179. trait RefinedTypeApi extends TypeApi

    The API that all refined types support

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

  181. trait ReflectiveMirror extends MirrorOf[Mirrors.this.type]

    A mirror that reflects instances and static classes

  182. abstract type Return >: Null <: TermTree with SymTree with ReturnApi

    Return expression

    Return expression

    Definition Classes
    TreesTrees
  183. trait ReturnApi extends TreeBase with TermTreeApi

    The API that all returns support

  184. abstract class ReturnExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Return(expr).

  185. abstract type RuntimeClass >: Null

    Definition Classes
    Mirrors
  186. trait RuntimeMirror extends MirrorOf[Mirrors.this.type] with ReflectiveMirror

    The API of a mirror for a reflective universe

  187. abstract type Scope >: Null <: Iterable[Symbol]

    Definition Classes
    Scopes
  188. abstract type Select >: Null <: RefTree with SelectApi

    Designator <qualifier> .

    Designator <qualifier> . <name>

    Definition Classes
    TreesTrees
  189. trait SelectApi extends TreeBase with RefTreeApi

    The API that all selects support

  190. abstract class SelectExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Select(qual, name).

  191. abstract type SelectFromTypeTree >: Null <: TypTree with RefTree with SelectFromTypeTreeApi

    Type selection <qualifier> # <name>, eliminated by RefCheck

    Type selection <qualifier> # <name>, eliminated by RefCheck

    Definition Classes
    TreesTrees
  192. trait SelectFromTypeTreeApi extends TreeBase with TypTreeApi with RefTreeApi

    The API that all selects from type trees support

  193. abstract class SelectFromTypeTreeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax SelectFromTypeTree(qualifier, name).

  194. abstract type SingleType >: Null <: SingletonType with SingleTypeApi

    .

    ..

    Definition Classes
    TypesTypes
  195. trait SingleTypeApi extends TypeApi

    The API that all single types support

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

  197. abstract type SingletonType >: Null <: Type

    The type of Scala singleton types, i.

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

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

    as well as constant types.

    Definition Classes
    Types
  198. abstract type SingletonTypeTree >: Null <: TypTree with SingletonTypeTreeApi

    Singleton type, eliminated by RefCheck

    Singleton type, eliminated by RefCheck

    Definition Classes
    TreesTrees
  199. trait SingletonTypeTreeApi extends TreeBase with TypTreeApi

    The API that all singleton type trees support

  200. abstract class SingletonTypeTreeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax SingletonTypeTree(ref).

  201. abstract type Star >: Null <: TermTree with StarApi

    Repetition of pattern.

    Repetition of pattern. Eliminated by patmat/explicitouter.

    Definition Classes
    TreesTrees
  202. trait StarApi extends TreeBase with TermTreeApi

    The API that all stars support

  203. abstract class StarExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Star(elem).

  204. abstract type Super >: Null <: TermTree with SuperApi

    Super reference, qual = corresponding this reference A super reference C.

    Super reference, qual = corresponding this reference A super reference C.super[M] is represented as Super(This(C), M).

    Definition Classes
    TreesTrees
  205. trait SuperApi extends TreeBase with TermTreeApi

    The API that all supers support

  206. abstract class SuperExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Super(qual, mix).

  207. abstract type SuperType >: Null <: SingletonType with SuperTypeApi

    .

    ..

    Definition Classes
    TypesTypes
  208. trait SuperTypeApi extends TypeApi

    The API that all super types support

  209. abstract class SuperTypeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax SingleType(thistpe, supertpe)

  210. abstract type SymTree >: Null <: Tree with SymTreeApi

    A tree with a mutable symbol field, initialized to NoSymbol.

    A tree with a mutable symbol field, initialized to NoSymbol.

    Definition Classes
    TreesTrees
  211. trait SymTreeApi extends TreeBase with TreeApi

    The API that all sym trees support

  212. abstract type Symbol >: Null <: SymbolApi

    The abstract type of symbols representing declarations

    The abstract type of symbols representing declarations

    Definition Classes
    SymbolsSymbols
  213. trait SymbolApi extends SymbolBase with HasFlagsApi

    The API of symbols

  214. trait SymbolBase extends AnyRef

    The base API that all symbols support

  215. abstract type Template >: Null <: SymTree with TemplateApi

    Instantiation template of a class or trait

    Instantiation template of a class or trait

    Definition Classes
    TreesTrees
  216. trait TemplateApi extends TreeBase with SymTreeApi

    The API that all templates support

  217. abstract class TemplateExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Template(parents, self, body).

  218. trait TemplateMirror extends AnyRef

    A mirror that reflects the instance or static parts of a runtime class

  219. abstract type TermName >: Null <: Name

    The abstract type of names representing types

    The abstract type of names representing types

    Definition Classes
    Names
  220. trait TermNamesApi extends NamesApi with TermNamesBase

    Definition Classes
    StandardNames
  221. trait TermNamesBase extends NamesBase

    Definition Classes
    StandardNames
  222. abstract type TermSymbol >: Null <: Symbol with TermSymbolApi

    The abstract type of term symbols representing val, var, def, and object declarations as well as packages and value parameters.

    The abstract type of term symbols representing val, var, def, and object declarations as well as packages and value parameters.

    Definition Classes
    SymbolsSymbols
  223. trait TermSymbolApi extends SymbolApi with HasFlagsApi with TermSymbolBase

    The API of term symbols

  224. trait TermSymbolBase extends SymbolBase

    The base API that all term symbols support

  225. abstract type TermTree >: Null <: Tree with TermTreeApi

    A tree for a term.

    A tree for a term. Not all terms are TermTrees; use isTerm to reliably identify terms.

    Definition Classes
    TreesTrees
  226. trait TermTreeApi extends TreeBase with TreeApi

    The API that all term trees support

  227. abstract type This >: Null <: TermTree with SymTree with ThisApi

    Self reference

    Self reference

    Definition Classes
    TreesTrees
  228. trait ThisApi extends TreeBase with TermTreeApi with SymTreeApi

    The API that all thises support

  229. abstract class ThisExtractor extends AnyRef

    An extractor class to create and pattern match with syntax This(qual).

  230. abstract type ThisType >: Null <: SingletonType with ThisTypeApi

    .

    ..

    Definition Classes
    TypesTypes
  231. trait ThisTypeApi extends TypeApi

    The API that all this types support

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

  233. abstract type Throw >: Null <: TermTree with ThrowApi

    Throw expression

    Throw expression

    Definition Classes
    TreesTrees
  234. trait ThrowApi extends TreeBase with TermTreeApi

    The API that all tries support

  235. abstract class ThrowExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Throw(expr).

  236. abstract class Transformer extends AnyRef

    Definition Classes
    Trees
  237. class Traverser extends AnyRef

    Definition Classes
    Trees
  238. abstract type Tree >: Null <: TreeApi

    Tree is the basis for scala's abstract syntax.

    Tree is the basis for scala's abstract syntax. The nodes are implemented as case classes, and the parameters which initialize a given tree are immutable: however Trees have several mutable fields which are manipulated in the course of typechecking, including pos, symbol, and tpe.

    Newly instantiated trees have tpe set to null (though it may be set immediately thereafter depending on how it is constructed.) When a tree is passed to the typer, typically via typer.typed(tree), under normal circumstances the tpe must be null or the typer will ignore it. Furthermore, the typer is not required to return the same tree it was passed.

    Trees can be easily traversed with e.g. foreach on the root node; for a more nuanced traversal, subclass Traverser. Transformations can be considerably trickier: see the numerous subclasses of Transformer found around the compiler.

    Copying Trees should be done with care depending on whether it need be done lazily or strictly (see LazyTreeCopier and StrictTreeCopier) and on whether the contents of the mutable fields should be copied. The tree copiers will copy the mutable attributes to the new tree; calling Tree#duplicate will copy symbol and tpe, but all the positions will be focused.

    Trees can be coarsely divided into four mutually exclusive categories:

    • TermTrees, representing terms
    • TypTrees, representing types. Note that is TypTree, not TypeTree.
    • SymTrees, which may represent types or terms.
    • Other Trees, which have none of those as parents.

    SymTrees include important nodes Ident and Select, which are used as both terms and types; they are distinguishable based on whether the Name is a TermName or TypeName. The correct way for to test for a type or a term (on any Tree) are the isTerm/isType methods on Tree.

    "Others" are mostly syntactic or short-lived constructs. Examples include CaseDef, which wraps individual match cases: they are neither terms nor types, nor do they carry a symbol. Another example is Parens, which is eliminated during parsing.

    Definition Classes
    TreesTrees
  239. trait TreeApi extends TreeBase

    .

  240. abstract class TreeBase extends Product

    The base API that all trees support

  241. abstract type TreeCopier <: TreeCopierOps

    The standard (lazy) tree copier

    The standard (lazy) tree copier

    Definition Classes
    Trees
  242. abstract class TreeCopierOps extends AnyRef

    The API of a tree copier tree copiers are made available by an implicit conversion in reflect.

  243. trait TreePrinter extends AnyRef

    Definition Classes
    Printers
  244. abstract type Try >: Null <: TermTree with TryApi

    [Eugene++] comment me!

    [Eugene++] comment me!

    Definition Classes
    TreesTrees
  245. trait TryApi extends TreeBase with TermTreeApi

    The API that all tries support

  246. abstract class TryExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Try(block, catches, finalizer).

  247. abstract type TypTree >: Null <: Tree with TypTreeApi

    A tree for a type.

    A tree for a type. Not all types are TypTrees; use isType to reliably identify types.

    Definition Classes
    TreesTrees
  248. trait TypTreeApi extends TreeBase with TreeApi

    The API that all typ trees support

  249. abstract type Type >: Null <: TypeApi

    The type of Scala types, and also Scala type signatures.

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

    Definition Classes
    TypesTypes
  250. abstract class TypeApi extends TypeBase

    The extended API of types

  251. abstract type TypeApply >: Null <: GenericApply with TypeApplyApi

    Explicit type application.

    Explicit type application.

    Definition Classes
    TreesTrees
  252. trait TypeApplyApi extends TreeBase with GenericApplyApi

    The API that all type applies support

  253. abstract class TypeApplyExtractor extends AnyRef

    An extractor class to create and pattern match with syntax TypeApply(fun, args).

  254. abstract class TypeBase extends AnyRef

    The base API that all types support

  255. abstract type TypeBounds >: Null <: Type with TypeBoundsApi

    .

    ..

    Definition Classes
    TypesTypes
  256. trait TypeBoundsApi extends TypeApi

    The API that all type bounds support

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

  258. abstract type TypeBoundsTree >: Null <: TypTree with TypeBoundsTreeApi

    Document me!

    Document me!

    Definition Classes
    TreesTrees
  259. trait TypeBoundsTreeApi extends TreeBase with TypTreeApi

    The API that all type bound trees support

  260. abstract class TypeBoundsTreeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax TypeBoundsTree(lo, hi).

  261. abstract type TypeDef >: Null <: MemberDef with TypeDefApi

    An abstract type, a type parameter, or a type alias.

    An abstract type, a type parameter, or a type alias. Eliminated by erasure.

    Definition Classes
    TreesTrees
  262. trait TypeDefApi extends TreeBase with MemberDefApi

    The API that all type defs support

  263. abstract class TypeDefExtractor extends AnyRef

    An extractor class to create and pattern match with syntax TypeDef(mods, name, tparams, rhs).

  264. abstract type TypeName >: Null <: Name

    The abstract type of names representing terms

    The abstract type of names representing terms

    Definition Classes
    Names
  265. trait TypeNamesApi extends NamesApi with TypeNamesBase

    Definition Classes
    StandardNames
  266. trait TypeNamesBase extends NamesBase

    Definition Classes
    StandardNames
  267. abstract type TypeRef >: Null <: Type with TypeRefApi

    .

    ..

    Definition Classes
    TypesTypes
  268. trait TypeRefApi extends TypeApi

    The API that all type refs support

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

  270. abstract type TypeSymbol >: Null <: Symbol with TypeSymbolApi

    The abstract type of type symbols representing type, class, and trait declarations, as well as type parameters

    The abstract type of type symbols representing type, class, and trait declarations, as well as type parameters

    Definition Classes
    SymbolsSymbols
  271. trait TypeSymbolApi extends SymbolApi with HasFlagsApi with TypeSymbolBase

    The API of type symbols

  272. trait TypeSymbolBase extends SymbolBase

    The base API that all type symbols support

  273. trait TypeTag[T] extends AbsTypeTag[T] with Equals with Serializable

    If an implicit value of type u.

  274. abstract type TypeTree >: Null <: TypTree with TypeTreeApi

    A synthetic tree holding an arbitrary type.

    A synthetic tree holding an arbitrary type. Not to be confused with with TypTree, the trait for trees that are only used for type trees. TypeTree's are inserted in several places, but most notably in RefCheck, where the arbitrary type trees are all replaced by TypeTree's.

    Definition Classes
    TreesTrees
  275. trait TypeTreeApi extends TreeBase with TypTreeApi

    The API that all type trees support

  276. abstract class TypeTreeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax TypeTree().

  277. abstract type Typed >: Null <: TermTree with TypedApi

    Type annotation, eliminated by cleanup

    Type annotation, eliminated by cleanup

    Definition Classes
    TreesTrees
  278. trait TypedApi extends TreeBase with TermTreeApi

    The API that all typeds support

  279. abstract class TypedExtractor extends AnyRef

    An extractor class to create and pattern match with syntax Typed(expr, tpt).

  280. abstract type UnApply >: Null <: TermTree with UnApplyApi

    Noone knows what this is.

    Noone knows what this is. It is not idempotent w.r.t typechecking. Can we, please, remove it? Introduced by typer, eliminated by patmat/explicitouter.

    Definition Classes
    TreesTrees
  281. trait UnApplyApi extends TreeBase with TermTreeApi

    The API that all unapplies support

  282. abstract class UnApplyExtractor extends AnyRef

    An extractor class to create and pattern match with syntax UnApply(fun, args).

  283. abstract type ValDef >: Null <: ValOrDefDef with ValDefApi

    Broadly speaking, a value definition.

    Broadly speaking, a value definition. All these are encoded as ValDefs:

    • immutable values, e.g. "val x"
    • mutable values, e.g. "var x" - the MUTABLE flag set in mods
    • lazy values, e.g. "lazy val x" - the LAZY flag set in mods
    • method parameters, see vparamss in DefDef - the PARAM flag is set in mods
    • explicit self-types, e.g. class A { self: Bar => } - !!! not sure what is set.
    Definition Classes
    TreesTrees
  284. trait ValDefApi extends TreeBase with ValOrDefDefApi

    The API that all val defs support

  285. abstract class ValDefExtractor extends AnyRef

    An extractor class to create and pattern match with syntax ValDef(mods, name, tpt, rhs).

  286. abstract type ValOrDefDef >: Null <: MemberDef with ValOrDefDefApi

    A common base class for ValDefs and DefDefs.

    A common base class for ValDefs and DefDefs.

    Definition Classes
    TreesTrees
  287. trait ValOrDefDefApi extends TreeBase with MemberDefApi

    The API that all val defs and def defs support

Abstract Value Members

  1. abstract val Alternative: AlternativeExtractor

    The constructor/deconstructor for Alternative instances.

    The constructor/deconstructor for Alternative instances.

    Definition Classes
    Trees
  2. implicit abstract val AlternativeTag: ClassTag[Alternative]

    A tag that preserves the identity of the Alternative abstract type from erasure.

    A tag that preserves the identity of the Alternative abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  3. abstract val Annotated: AnnotatedExtractor

    The constructor/deconstructor for Annotated instances.

    The constructor/deconstructor for Annotated instances.

    Definition Classes
    Trees
  4. implicit abstract val AnnotatedTag: ClassTag[Annotated]

    A tag that preserves the identity of the Annotated abstract type from erasure.

    A tag that preserves the identity of the Annotated abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  5. abstract val AnnotatedType: AnnotatedTypeExtractor

    The constructor/deconstructor for AnnotatedType instances.

    The constructor/deconstructor for AnnotatedType instances.

    Definition Classes
    Types
  6. implicit abstract val AnnotatedTypeTag: ClassTag[AnnotatedType]

    A tag that preserves the identity of the AnnotatedType abstract type from erasure.

    A tag that preserves the identity of the AnnotatedType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  7. abstract val AnnotationInfo: AnnotationInfoExtractor

    Definition Classes
    AnnotationInfos
  8. implicit abstract val AnnotationInfoTag: ClassTag[AnnotationInfo]

    Definition Classes
    AnnotationInfos
  9. abstract val AnyRefTpe: Type

    Definition Classes
    StandardTypes
  10. abstract val AnyTpe: Type

    Definition Classes
    StandardTypes
  11. abstract val AnyValTpe: Type

    Definition Classes
    StandardTypes
  12. abstract val AppliedTypeTree: AppliedTypeTreeExtractor

    The constructor/deconstructor for AppliedTypeTree instances.

    The constructor/deconstructor for AppliedTypeTree instances.

    Definition Classes
    Trees
  13. implicit abstract val AppliedTypeTreeTag: ClassTag[AppliedTypeTree]

    A tag that preserves the identity of the AppliedTypeTree abstract type from erasure.

    A tag that preserves the identity of the AppliedTypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  14. abstract def Apply(sym: Symbol, args: Tree*): Tree

    Definition Classes
    Trees
  15. abstract val Apply: ApplyExtractor

    The constructor/deconstructor for Apply instances.

    The constructor/deconstructor for Apply instances.

    Definition Classes
    Trees
  16. abstract def ApplyConstructor(tpt: Tree, args: List[Tree]): Tree

    Definition Classes
    Trees
  17. abstract val ApplyDynamic: ApplyDynamicExtractor

    The constructor/deconstructor for ApplyDynamic instances.

    The constructor/deconstructor for ApplyDynamic instances.

    Definition Classes
    Trees
  18. implicit abstract val ApplyDynamicTag: ClassTag[ApplyDynamic]

    A tag that preserves the identity of the ApplyDynamic abstract type from erasure.

    A tag that preserves the identity of the ApplyDynamic abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  19. implicit abstract val ApplyTag: ClassTag[Apply]

    A tag that preserves the identity of the Apply abstract type from erasure.

    A tag that preserves the identity of the Apply abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  20. abstract val ArrayAnnotArg: ArrayAnnotArgExtractor

    Definition Classes
    AnnotationInfos
  21. implicit abstract val ArrayAnnotArgTag: ClassTag[ArrayAnnotArg]

    Definition Classes
    AnnotationInfos
  22. abstract val ArrayValue: ArrayValueExtractor

    The constructor/deconstructor for ArrayValue instances.

    The constructor/deconstructor for ArrayValue instances.

    Definition Classes
    Trees
  23. implicit abstract val ArrayValueTag: ClassTag[ArrayValue]

    A tag that preserves the identity of the ArrayValue abstract type from erasure.

    A tag that preserves the identity of the ArrayValue abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  24. abstract val Assign: AssignExtractor

    The constructor/deconstructor for Assign instances.

    The constructor/deconstructor for Assign instances.

    Definition Classes
    Trees
  25. abstract val AssignOrNamedArg: AssignOrNamedArgExtractor

    The constructor/deconstructor for AssignOrNamedArg instances.

    The constructor/deconstructor for AssignOrNamedArg instances.

    Definition Classes
    Trees
  26. implicit abstract val AssignOrNamedArgTag: ClassTag[AssignOrNamedArg]

    A tag that preserves the identity of the AssignOrNamedArg abstract type from erasure.

    A tag that preserves the identity of the AssignOrNamedArg abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  27. implicit abstract val AssignTag: ClassTag[Assign]

    A tag that preserves the identity of the Assign abstract type from erasure.

    A tag that preserves the identity of the Assign abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  28. abstract def Bind(sym: Symbol, body: Tree): Bind

    Definition Classes
    Trees
  29. abstract val Bind: BindExtractor

    The constructor/deconstructor for Bind instances.

    The constructor/deconstructor for Bind instances.

    Definition Classes
    Trees
  30. implicit abstract val BindTag: ClassTag[Bind]

    A tag that preserves the identity of the Bind abstract type from erasure.

    A tag that preserves the identity of the Bind abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  31. abstract def Block(stats: Tree*): Block

    Block factory that flattens directly nested blocks.

    Block factory that flattens directly nested blocks.

    Definition Classes
    Trees
  32. abstract val Block: BlockExtractor

    The constructor/deconstructor for Block instances.

    The constructor/deconstructor for Block instances.

    Definition Classes
    Trees
  33. implicit abstract val BlockTag: ClassTag[Block]

    A tag that preserves the identity of the Block abstract type from erasure.

    A tag that preserves the identity of the Block abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  34. abstract val BooleanTpe: Type

    Definition Classes
    StandardTypes
  35. abstract val BoundedWildcardType: BoundedWildcardTypeExtractor

    Definition Classes
    Types
  36. implicit abstract val BoundedWildcardTypeTag: ClassTag[BoundedWildcardType]

    A tag that preserves the identity of the BoundedWildcardType abstract type from erasure.

    A tag that preserves the identity of the BoundedWildcardType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  37. abstract val ByteTpe: Type

    Definition Classes
    StandardTypes
  38. abstract def CaseDef(pat: Tree, body: Tree): CaseDef

    casedef shorthand

    casedef shorthand

    Definition Classes
    Trees
  39. abstract val CaseDef: CaseDefExtractor

    The constructor/deconstructor for CaseDef instances.

    The constructor/deconstructor for CaseDef instances.

    Definition Classes
    Trees
  40. implicit abstract val CaseDefTag: ClassTag[CaseDef]

    A tag that preserves the identity of the CaseDef abstract type from erasure.

    A tag that preserves the identity of the CaseDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  41. abstract val CharTpe: Type

    Definition Classes
    StandardTypes
  42. abstract def ClassDef(sym: Symbol, impl: Template): ClassDef

    sym

    the class symbol

    impl

    the implementation template

    Definition Classes
    Trees
  43. abstract val ClassDef: ClassDefExtractor

    The constructor/deconstructor for ClassDef instances.

    The constructor/deconstructor for ClassDef instances.

    Definition Classes
    Trees
  44. implicit abstract val ClassDefTag: ClassTag[ClassDef]

    A tag that preserves the identity of the ClassDef abstract type from erasure.

    A tag that preserves the identity of the ClassDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  45. abstract val ClassInfoType: ClassInfoTypeExtractor

    The constructor/deconstructor for ClassInfoType instances.

    The constructor/deconstructor for ClassInfoType instances.

    Definition Classes
    Types
  46. implicit abstract val ClassInfoTypeTag: ClassTag[ClassInfoType]

    A tag that preserves the identity of the ClassInfoType abstract type from erasure.

    A tag that preserves the identity of the ClassInfoType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  47. implicit abstract val ClassSymbolTag: ClassTag[ClassSymbol]

    A tag that preserves the identity of the ClassSymbol abstract type from erasure.

    A tag that preserves the identity of the ClassSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols
  48. implicit abstract val ClassfileAnnotArgTag: ClassTag[ClassfileAnnotArg]

    Definition Classes
    AnnotationInfos
  49. implicit abstract val CompoundTypeTag: ClassTag[CompoundType]

    A tag that preserves the identity of the CompoundType abstract type from erasure.

    A tag that preserves the identity of the CompoundType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  50. abstract val CompoundTypeTree: CompoundTypeTreeExtractor

    The constructor/deconstructor for CompoundTypeTree instances.

    The constructor/deconstructor for CompoundTypeTree instances.

    Definition Classes
    Trees
  51. implicit abstract val CompoundTypeTreeTag: ClassTag[CompoundTypeTree]

    A tag that preserves the identity of the CompoundTypeTree abstract type from erasure.

    A tag that preserves the identity of the CompoundTypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  52. abstract val Constant: ConstantExtractor

    Definition Classes
    Constants
  53. implicit abstract val ConstantTag: ClassTag[Constant]

    Definition Classes
    Constants
  54. abstract val ConstantType: ConstantTypeExtractor

    The constructor/deconstructor for ConstantType instances.

    The constructor/deconstructor for ConstantType instances.

    Definition Classes
    Types
  55. implicit abstract val ConstantTypeTag: ClassTag[ConstantType]

    A tag that preserves the identity of the ConstantType abstract type from erasure.

    A tag that preserves the identity of the ConstantType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  56. abstract def DefDef(sym: Symbol, rhs: (List[List[Symbol]]) ⇒ Tree): DefDef

    Definition Classes
    Trees
  57. abstract def DefDef(sym: Symbol, rhs: Tree): DefDef

    Definition Classes
    Trees
  58. abstract def DefDef(sym: Symbol, mods: Modifiers, rhs: Tree): DefDef

    Definition Classes
    Trees
  59. abstract def DefDef(sym: Symbol, vparamss: List[List[ValDef]], rhs: Tree): DefDef

    Definition Classes
    Trees
  60. abstract def DefDef(sym: Symbol, mods: Modifiers, vparamss: List[List[ValDef]], rhs: Tree): DefDef

    Definition Classes
    Trees
  61. abstract val DefDef: DefDefExtractor

    The constructor/deconstructor for DefDef instances.

    The constructor/deconstructor for DefDef instances.

    Definition Classes
    Trees
  62. implicit abstract val DefDefTag: ClassTag[DefDef]

    A tag that preserves the identity of the DefDef abstract type from erasure.

    A tag that preserves the identity of the DefDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  63. implicit abstract val DefTreeTag: ClassTag[DefTree]

    A tag that preserves the identity of the DefTree abstract type from erasure.

    A tag that preserves the identity of the DefTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  64. abstract val DoubleTpe: Type

    Definition Classes
    StandardTypes
  65. abstract val EmptyTree: Tree

    The empty tree

    The empty tree

    Definition Classes
    Trees
  66. abstract val ExistentialType: ExistentialTypeExtractor

    The constructor/deconstructor for ExistentialType instances.

    The constructor/deconstructor for ExistentialType instances.

    Definition Classes
    Types
  67. implicit abstract val ExistentialTypeTag: ClassTag[ExistentialType]

    A tag that preserves the identity of the ExistentialType abstract type from erasure.

    A tag that preserves the identity of the ExistentialType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  68. abstract val ExistentialTypeTree: ExistentialTypeTreeExtractor

    The constructor/deconstructor for ExistentialTypeTree instances.

    The constructor/deconstructor for ExistentialTypeTree instances.

    Definition Classes
    Trees
  69. implicit abstract val ExistentialTypeTreeTag: ClassTag[ExistentialTypeTree]

    A tag that preserves the identity of the ExistentialTypeTree abstract type from erasure.

    A tag that preserves the identity of the ExistentialTypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  70. abstract val Flag: FlagValues

    Definition Classes
    FlagSets
  71. implicit abstract val FlagSetTag: ClassTag[FlagSet]

    A tag that preserves the identity of the FlagSet abstract type from erasure.

    A tag that preserves the identity of the FlagSet abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    FlagSets
  72. abstract val FloatTpe: Type

    Definition Classes
    StandardTypes
  73. implicit abstract val FreeTermSymbolTag: ClassTag[FreeTermSymbol]

    A tag that preserves the identity of the FreeTermSymbol abstract type from erasure.

    A tag that preserves the identity of the FreeTermSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols
  74. implicit abstract val FreeTypeSymbolTag: ClassTag[FreeTypeSymbol]

    A tag that preserves the identity of the FreeTypeSymbol abstract type from erasure.

    A tag that preserves the identity of the FreeTypeSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols
  75. abstract val Function: FunctionExtractor

    The constructor/deconstructor for Function instances.

    The constructor/deconstructor for Function instances.

    Definition Classes
    Trees
  76. implicit abstract val FunctionTag: ClassTag[Function]

    A tag that preserves the identity of the Function abstract type from erasure.

    A tag that preserves the identity of the Function abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  77. implicit abstract val GenericApplyTag: ClassTag[GenericApply]

    A tag that preserves the identity of the GenericApply abstract type from erasure.

    A tag that preserves the identity of the GenericApply abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  78. abstract def Ident(sym: Symbol): Ident

    Definition Classes
    Trees
  79. abstract def Ident(name: String): Ident

    Definition Classes
    Trees
  80. abstract val Ident: IdentExtractor

    The constructor/deconstructor for Ident instances.

    The constructor/deconstructor for Ident instances.

    Definition Classes
    Trees
  81. implicit abstract val IdentTag: ClassTag[Ident]

    A tag that preserves the identity of the Ident abstract type from erasure.

    A tag that preserves the identity of the Ident abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  82. abstract val If: IfExtractor

    The constructor/deconstructor for If instances.

    The constructor/deconstructor for If instances.

    Definition Classes
    Trees
  83. implicit abstract val IfTag: ClassTag[If]

    A tag that preserves the identity of the If abstract type from erasure.

    A tag that preserves the identity of the If abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  84. implicit abstract val ImplDefTag: ClassTag[ImplDef]

    A tag that preserves the identity of the ImplDef abstract type from erasure.

    A tag that preserves the identity of the ImplDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  85. abstract val Import: ImportExtractor

    The constructor/deconstructor for Import instances.

    The constructor/deconstructor for Import instances.

    Definition Classes
    Trees
  86. abstract val ImportSelector: ImportSelectorExtractor

    The constructor/deconstructor for ImportSelector instances.

    The constructor/deconstructor for ImportSelector instances.

    Definition Classes
    Trees
  87. implicit abstract val ImportSelectorTag: ClassTag[ImportSelector]

    A tag that preserves the identity of the ImportSelector abstract type from erasure.

    A tag that preserves the identity of the ImportSelector abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  88. implicit abstract val ImportTag: ClassTag[Import]

    A tag that preserves the identity of the Import abstract type from erasure.

    A tag that preserves the identity of the Import abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  89. abstract val IntTpe: Type

    Definition Classes
    StandardTypes
  90. abstract def LabelDef(sym: Symbol, params: List[Symbol], rhs: Tree): LabelDef

    Definition Classes
    Trees
  91. abstract val LabelDef: LabelDefExtractor

    The constructor/deconstructor for LabelDef instances.

    The constructor/deconstructor for LabelDef instances.

    Definition Classes
    Trees
  92. implicit abstract val LabelDefTag: ClassTag[LabelDef]

    A tag that preserves the identity of the LabelDef abstract type from erasure.

    A tag that preserves the identity of the LabelDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  93. abstract val Literal: LiteralExtractor

    The constructor/deconstructor for Literal instances.

    The constructor/deconstructor for Literal instances.

    Definition Classes
    Trees
  94. abstract val LiteralAnnotArg: LiteralAnnotArgExtractor

    Definition Classes
    AnnotationInfos
  95. implicit abstract val LiteralAnnotArgTag: ClassTag[LiteralAnnotArg]

    Definition Classes
    AnnotationInfos
  96. implicit abstract val LiteralTag: ClassTag[Literal]

    A tag that preserves the identity of the Literal abstract type from erasure.

    A tag that preserves the identity of the Literal abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  97. abstract val LongTpe: Type

    Definition Classes
    StandardTypes
  98. abstract val Match: MatchExtractor

    The constructor/deconstructor for Match instances.

    The constructor/deconstructor for Match instances.

    Definition Classes
    Trees
  99. implicit abstract val MatchTag: ClassTag[Match]

    A tag that preserves the identity of the Match abstract type from erasure.

    A tag that preserves the identity of the Match abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  100. implicit abstract val MemberDefTag: ClassTag[MemberDef]

    A tag that preserves the identity of the MemberDef abstract type from erasure.

    A tag that preserves the identity of the MemberDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  101. implicit abstract val MethodSymbolTag: ClassTag[MethodSymbol]

    A tag that preserves the identity of the MethodSymbol abstract type from erasure.

    A tag that preserves the identity of the MethodSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols
  102. abstract val MethodType: MethodTypeExtractor

    The constructor/deconstructor for MethodType instances.

    The constructor/deconstructor for MethodType instances.

    Definition Classes
    Types
  103. implicit abstract val MethodTypeTag: ClassTag[MethodType]

    A tag that preserves the identity of the MethodType abstract type from erasure.

    A tag that preserves the identity of the MethodType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  104. abstract val Modifiers: ModifiersCreator

    Definition Classes
    Trees
  105. implicit abstract val ModifiersTag: ClassTag[Modifiers]

    A tag that preserves the identity of the Modifiers abstract type from erasure.

    A tag that preserves the identity of the Modifiers abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  106. abstract def ModuleDef(sym: Symbol, impl: Template): ModuleDef

    sym

    the class symbol

    impl

    the implementation template

    Definition Classes
    Trees
  107. abstract val ModuleDef: ModuleDefExtractor

    The constructor/deconstructor for ModuleDef instances.

    The constructor/deconstructor for ModuleDef instances.

    Definition Classes
    Trees
  108. implicit abstract val ModuleDefTag: ClassTag[ModuleDef]

    A tag that preserves the identity of the ModuleDef abstract type from erasure.

    A tag that preserves the identity of the ModuleDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  109. implicit abstract val ModuleSymbolTag: ClassTag[ModuleSymbol]

    A tag that preserves the identity of the ModuleSymbol abstract type from erasure.

    A tag that preserves the identity of the ModuleSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols
  110. implicit abstract val NameTag: ClassTag[Name]

    Definition Classes
    Names
  111. implicit abstract val NameTreeTag: ClassTag[NameTree]

    A tag that preserves the identity of the NameTree abstract type from erasure.

    A tag that preserves the identity of the NameTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  112. abstract val NestedAnnotArg: NestedAnnotArgExtractor

    Definition Classes
    AnnotationInfos
  113. implicit abstract val NestedAnnotArgTag: ClassTag[NestedAnnotArg]

    Definition Classes
    AnnotationInfos
  114. abstract def New(sym: Symbol, args: Tree*): Tree

    Definition Classes
    Trees
  115. abstract def New(tpe: Type, args: Tree*): Tree

    0-1 argument list new, based on a type.

    0-1 argument list new, based on a type.

    Definition Classes
    Trees
  116. abstract def New(tpt: Tree, argss: List[List[Tree]]): Tree

    Factory method for object creation new tpt(args_1)...(args_n) A New(t, as) is expanded to: (new t).<init>(as)

    Factory method for object creation new tpt(args_1)...(args_n) A New(t, as) is expanded to: (new t).<init>(as)

    Definition Classes
    Trees
  117. abstract val New: NewExtractor

    The constructor/deconstructor for New instances.

    The constructor/deconstructor for New instances.

    Definition Classes
    Trees
  118. implicit abstract val NewTag: ClassTag[New]

    A tag that preserves the identity of the New abstract type from erasure.

    A tag that preserves the identity of the New abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  119. abstract val NoFlags: FlagSet

    The empty set of flags

    The empty set of flags

    Definition Classes
    FlagSets
  120. abstract val NoPosition: Position

    .

    ..

    Definition Classes
    Positions
  121. abstract val NoPrefix: Type

    This constant is used as a special value denoting the empty prefix in a path dependent type.

    This constant is used as a special value denoting the empty prefix in a path dependent type. For instance x.type is represented as SingleType(NoPrefix, <x>), where <x> stands for the symbol for x.

    Definition Classes
    Types
  122. abstract val NoSymbol: Symbol

    A special "missing" symbol

    A special "missing" symbol

    Definition Classes
    Symbols
  123. abstract val NoType: Type

    This constant is used as a special value that indicates that no meaningful type exists.

    This constant is used as a special value that indicates that no meaningful type exists.

    Definition Classes
    Types
  124. abstract val NothingTpe: Type

    Definition Classes
    StandardTypes
  125. abstract val NullTpe: Type

    Definition Classes
    StandardTypes
  126. abstract val NullaryMethodType: NullaryMethodTypeExtractor

    The constructor/deconstructor for NullaryMethodType instances.

    The constructor/deconstructor for NullaryMethodType instances.

    Definition Classes
    Types
  127. implicit abstract val NullaryMethodTypeTag: ClassTag[NullaryMethodType]

    A tag that preserves the identity of the NullaryMethodType abstract type from erasure.

    A tag that preserves the identity of the NullaryMethodType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  128. abstract val ObjectTpe: Type

    Definition Classes
    StandardTypes
  129. abstract val PackageDef: PackageDefExtractor

    The constructor/deconstructor for PackageDef instances.

    The constructor/deconstructor for PackageDef instances.

    Definition Classes
    Trees
  130. implicit abstract val PackageDefTag: ClassTag[PackageDef]

    A tag that preserves the identity of the PackageDef abstract type from erasure.

    A tag that preserves the identity of the PackageDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  131. abstract val PolyType: PolyTypeExtractor

    The constructor/deconstructor for PolyType instances.

    The constructor/deconstructor for PolyType instances.

    Definition Classes
    Types
  132. implicit abstract val PolyTypeTag: ClassTag[PolyType]

    A tag that preserves the identity of the PolyType abstract type from erasure.

    A tag that preserves the identity of the PolyType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  133. implicit abstract val PositionTag: ClassTag[Position]

    A tag that preserves the identity of the FlagSet abstract type from erasure.

    A tag that preserves the identity of the FlagSet abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Positions
  134. implicit abstract val RefTreeTag: ClassTag[RefTree]

    A tag that preserves the identity of the RefTree abstract type from erasure.

    A tag that preserves the identity of the RefTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  135. abstract val ReferenceToBoxed: ReferenceToBoxedExtractor

    The constructor/deconstructor for ReferenceToBoxed instances.

    The constructor/deconstructor for ReferenceToBoxed instances.

    Definition Classes
    Trees
  136. implicit abstract val ReferenceToBoxedTag: ClassTag[ReferenceToBoxed]

    A tag that preserves the identity of the ReferenceToBoxed abstract type from erasure.

    A tag that preserves the identity of the ReferenceToBoxed abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  137. abstract val RefinedType: RefinedTypeExtractor

    The constructor/deconstructor for RefinedType instances.

    The constructor/deconstructor for RefinedType instances.

    Definition Classes
    Types
  138. implicit abstract val RefinedTypeTag: ClassTag[RefinedType]

    A tag that preserves the identity of the RefinedType abstract type from erasure.

    A tag that preserves the identity of the RefinedType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  139. abstract val Return: ReturnExtractor

    The constructor/deconstructor for Return instances.

    The constructor/deconstructor for Return instances.

    Definition Classes
    Trees
  140. implicit abstract val ReturnTag: ClassTag[Return]

    A tag that preserves the identity of the Return abstract type from erasure.

    A tag that preserves the identity of the Return abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  141. implicit abstract val ScopeTag: ClassTag[Scope]

    A tag that preserves the identity of the Scope abstract type from erasure.

    A tag that preserves the identity of the Scope abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Scopes
  142. abstract def Select(qualifier: Tree, sym: Symbol): Select

    Definition Classes
    Trees
  143. abstract def Select(qualifier: Tree, name: String): Select

    Definition Classes
    Trees
  144. abstract val Select: SelectExtractor

    The constructor/deconstructor for Select instances.

    The constructor/deconstructor for Select instances.

    Definition Classes
    Trees
  145. abstract val SelectFromTypeTree: SelectFromTypeTreeExtractor

    The constructor/deconstructor for SelectFromTypeTree instances.

    The constructor/deconstructor for SelectFromTypeTree instances.

    Definition Classes
    Trees
  146. implicit abstract val SelectFromTypeTreeTag: ClassTag[SelectFromTypeTree]

    A tag that preserves the identity of the SelectFromTypeTree abstract type from erasure.

    A tag that preserves the identity of the SelectFromTypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  147. implicit abstract val SelectTag: ClassTag[Select]

    A tag that preserves the identity of the Select abstract type from erasure.

    A tag that preserves the identity of the Select abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  148. abstract val ShortTpe: Type

    Definition Classes
    StandardTypes
  149. abstract val SingleType: SingleTypeExtractor

    The constructor/deconstructor for SingleType instances.

    The constructor/deconstructor for SingleType instances.

    Definition Classes
    Types
  150. implicit abstract val SingleTypeTag: ClassTag[SingleType]

    A tag that preserves the identity of the SingleType abstract type from erasure.

    A tag that preserves the identity of the SingleType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  151. implicit abstract val SingletonTypeTag: ClassTag[SingletonType]

    A tag that preserves the identity of the SingletonType abstract type from erasure.

    A tag that preserves the identity of the SingletonType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  152. abstract val SingletonTypeTree: SingletonTypeTreeExtractor

    The constructor/deconstructor for SingletonTypeTree instances.

    The constructor/deconstructor for SingletonTypeTree instances.

    Definition Classes
    Trees
  153. implicit abstract val SingletonTypeTreeTag: ClassTag[SingletonTypeTree]

    A tag that preserves the identity of the SingletonTypeTree abstract type from erasure.

    A tag that preserves the identity of the SingletonTypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  154. abstract val Star: StarExtractor

    The constructor/deconstructor for Star instances.

    The constructor/deconstructor for Star instances.

    Definition Classes
    Trees
  155. implicit abstract val StarTag: ClassTag[Star]

    A tag that preserves the identity of the Star abstract type from erasure.

    A tag that preserves the identity of the Star abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  156. abstract def Super(sym: Symbol, mix: TypeName): Tree

    Definition Classes
    Trees
  157. abstract val Super: SuperExtractor

    The constructor/deconstructor for Super instances.

    The constructor/deconstructor for Super instances.

    Definition Classes
    Trees
  158. implicit abstract val SuperTag: ClassTag[Super]

    A tag that preserves the identity of the Super abstract type from erasure.

    A tag that preserves the identity of the Super abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  159. abstract val SuperType: SuperTypeExtractor

    The constructor/deconstructor for SuperType instances.

    The constructor/deconstructor for SuperType instances.

    Definition Classes
    Types
  160. implicit abstract val SuperTypeTag: ClassTag[SuperType]

    A tag that preserves the identity of the SuperType abstract type from erasure.

    A tag that preserves the identity of the SuperType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  161. implicit abstract val SymTreeTag: ClassTag[SymTree]

    A tag that preserves the identity of the SymTree abstract type from erasure.

    A tag that preserves the identity of the SymTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  162. implicit abstract val SymbolTag: ClassTag[Symbol]

    A tag that preserves the identity of the Symbol abstract type from erasure.

    A tag that preserves the identity of the Symbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols
  163. abstract val Template: TemplateExtractor

    The constructor/deconstructor for Template instances.

    The constructor/deconstructor for Template instances.

    Definition Classes
    Trees
  164. implicit abstract val TemplateTag: ClassTag[Template]

    A tag that preserves the identity of the Template abstract type from erasure.

    A tag that preserves the identity of the Template abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  165. implicit abstract val TermNameTag: ClassTag[TermName]

    Definition Classes
    Names
  166. implicit abstract val TermSymbolTag: ClassTag[TermSymbol]

    A tag that preserves the identity of the TermSymbol abstract type from erasure.

    A tag that preserves the identity of the TermSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols
  167. implicit abstract val TermTreeTag: ClassTag[TermTree]

    A tag that preserves the identity of the TermTree abstract type from erasure.

    A tag that preserves the identity of the TermTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  168. abstract def This(sym: Symbol): Tree

    Definition Classes
    Trees
  169. abstract val This: ThisExtractor

    The constructor/deconstructor for This instances.

    The constructor/deconstructor for This instances.

    Definition Classes
    Trees
  170. implicit abstract val ThisTag: ClassTag[This]

    A tag that preserves the identity of the This abstract type from erasure.

    A tag that preserves the identity of the This abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  171. abstract val ThisType: ThisTypeExtractor

    The constructor/deconstructor for ThisType instances.

    The constructor/deconstructor for ThisType instances.

    Definition Classes
    Types
  172. implicit abstract val ThisTypeTag: ClassTag[ThisType]

    A tag that preserves the identity of the ThisType abstract type from erasure.

    A tag that preserves the identity of the ThisType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  173. abstract def Throw(tpe: Type, args: Tree*): Throw

    Definition Classes
    Trees
  174. abstract val Throw: ThrowExtractor

    The constructor/deconstructor for Throw instances.

    The constructor/deconstructor for Throw instances.

    Definition Classes
    Trees
  175. implicit abstract val ThrowTag: ClassTag[Throw]

    A tag that preserves the identity of the Throw abstract type from erasure.

    A tag that preserves the identity of the Throw abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  176. implicit abstract val TreeTag: ClassTag[Tree]

    A tag that preserves the identity of the Tree abstract type from erasure.

    A tag that preserves the identity of the Tree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  177. abstract def Try(body: Tree, cases: (Tree, Tree)*): Try

    Definition Classes
    Trees
  178. abstract val Try: TryExtractor

    The constructor/deconstructor for Try instances.

    The constructor/deconstructor for Try instances.

    Definition Classes
    Trees
  179. implicit abstract val TryTag: ClassTag[Try]

    A tag that preserves the identity of the Try abstract type from erasure.

    A tag that preserves the identity of the Try abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  180. implicit abstract val TypTreeTag: ClassTag[TypTree]

    A tag that preserves the identity of the TypTree abstract type from erasure.

    A tag that preserves the identity of the TypTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  181. abstract val TypeApply: TypeApplyExtractor

    The constructor/deconstructor for TypeApply instances.

    The constructor/deconstructor for TypeApply instances.

    Definition Classes
    Trees
  182. implicit abstract val TypeApplyTag: ClassTag[TypeApply]

    A tag that preserves the identity of the TypeApply abstract type from erasure.

    A tag that preserves the identity of the TypeApply abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  183. abstract val TypeBounds: TypeBoundsExtractor

    The constructor/deconstructor for TypeBounds instances.

    The constructor/deconstructor for TypeBounds instances.

    Definition Classes
    Types
  184. implicit abstract val TypeBoundsTag: ClassTag[TypeBounds]

    A tag that preserves the identity of the TypeBounds abstract type from erasure.

    A tag that preserves the identity of the TypeBounds abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  185. abstract val TypeBoundsTree: TypeBoundsTreeExtractor

    The constructor/deconstructor for TypeBoundsTree instances.

    The constructor/deconstructor for TypeBoundsTree instances.

    Definition Classes
    Trees
  186. implicit abstract val TypeBoundsTreeTag: ClassTag[TypeBoundsTree]

    A tag that preserves the identity of the TypeBoundsTree abstract type from erasure.

    A tag that preserves the identity of the TypeBoundsTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  187. abstract def TypeDef(sym: Symbol): TypeDef

    A TypeDef node which defines abstract type or type parameter for given sym

    A TypeDef node which defines abstract type or type parameter for given sym

    Definition Classes
    Trees
  188. abstract def TypeDef(sym: Symbol, rhs: Tree): TypeDef

    A TypeDef node which defines given sym with given tight hand side rhs.

    A TypeDef node which defines given sym with given tight hand side rhs.

    Definition Classes
    Trees
  189. abstract val TypeDef: TypeDefExtractor

    The constructor/deconstructor for TypeDef instances.

    The constructor/deconstructor for TypeDef instances.

    Definition Classes
    Trees
  190. implicit abstract val TypeDefTag: ClassTag[TypeDef]

    A tag that preserves the identity of the TypeDef abstract type from erasure.

    A tag that preserves the identity of the TypeDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  191. implicit abstract val TypeNameTag: ClassTag[TypeName]

    Definition Classes
    Names
  192. abstract val TypeRef: TypeRefExtractor

    The constructor/deconstructor for TypeRef instances.

    The constructor/deconstructor for TypeRef instances.

    Definition Classes
    Types
  193. implicit abstract val TypeRefTag: ClassTag[TypeRef]

    A tag that preserves the identity of the TypeRef abstract type from erasure.

    A tag that preserves the identity of the TypeRef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  194. implicit abstract val TypeSymbolTag: ClassTag[TypeSymbol]

    A tag that preserves the identity of the TypeSymbol abstract type from erasure.

    A tag that preserves the identity of the TypeSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Symbols
  195. implicit abstract val TypeTagg: ClassTag[Type]

    A tag that preserves the identity of the Type abstract type from erasure.

    A tag that preserves the identity of the Type abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Types
  196. abstract def TypeTree(tp: Type): TypeTree

    Definition Classes
    Trees
  197. abstract val TypeTree: TypeTreeExtractor

    The constructor/deconstructor for TypeTree instances.

    The constructor/deconstructor for TypeTree instances.

    Definition Classes
    Trees
  198. implicit abstract val TypeTreeTag: ClassTag[TypeTree]

    A tag that preserves the identity of the TypeTree abstract type from erasure.

    A tag that preserves the identity of the TypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  199. abstract val Typed: TypedExtractor

    The constructor/deconstructor for Typed instances.

    The constructor/deconstructor for Typed instances.

    Definition Classes
    Trees
  200. implicit abstract val TypedTag: ClassTag[Typed]

    A tag that preserves the identity of the Typed abstract type from erasure.

    A tag that preserves the identity of the Typed abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  201. abstract val UnApply: UnApplyExtractor

    The constructor/deconstructor for UnApply instances.

    The constructor/deconstructor for UnApply instances.

    Definition Classes
    Trees
  202. implicit abstract val UnApplyTag: ClassTag[UnApply]

    A tag that preserves the identity of the UnApply abstract type from erasure.

    A tag that preserves the identity of the UnApply abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  203. abstract val UnitTpe: Type

    Definition Classes
    StandardTypes
  204. abstract def ValDef(sym: Symbol): ValDef

    Definition Classes
    Trees
  205. abstract def ValDef(sym: Symbol, rhs: Tree): ValDef

    Definition Classes
    Trees
  206. abstract val ValDef: ValDefExtractor

    The constructor/deconstructor for ValDef instances.

    The constructor/deconstructor for ValDef instances.

    Definition Classes
    Trees
  207. implicit abstract val ValDefTag: ClassTag[ValDef]

    A tag that preserves the identity of the ValDef abstract type from erasure.

    A tag that preserves the identity of the ValDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  208. implicit abstract val ValOrDefDefTag: ClassTag[ValOrDefDef]

    A tag that preserves the identity of the ValOrDefDef abstract type from erasure.

    A tag that preserves the identity of the ValOrDefDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

    Definition Classes
    Trees
  209. abstract val WildcardType: Type

    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
    Types
  210. implicit abstract def addFlagOps(left: FlagSet): FlagOps

    Definition Classes
    FlagSets
  211. abstract def appliedType(tycon: Type, args: List[Type]): Type

    A creator for type applications

    A creator for type applications

    Definition Classes
    Types
  212. abstract def atPos[T <: Tree](pos: Position)(tree: T): T

    Assigns a given position to all position-less nodes of a given AST.

    Assigns a given position to all position-less nodes of a given AST.

    Definition Classes
    Positions
  213. abstract val build: BuildBase

    Definition Classes
    BuildUtils
  214. abstract val definitions: DefinitionsApi

  215. abstract val emptyValDef: ValDef

    An empty deferred value definition corresponding to: val _: _ This is used as a placeholder in the self parameter Template if there is no definition of a self value of self type.

    An empty deferred value definition corresponding to: val _: _ This is used as a placeholder in the self parameter Template if there is no definition of a self value of self type.

    Definition Classes
    Trees
  216. abstract def existentialAbstraction(tparams: List[Symbol], tpe0: Type): 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 regard 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.

    Definition Classes
    Types
  217. abstract def glb(ts: List[Type]): 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
    Types
  218. abstract def intersectionType(tps: List[Type], owner: Symbol): 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?

    Definition Classes
    Types
  219. abstract def intersectionType(tps: List[Type]): Type

    A creator for intersection type where intersections of a single type are replaced by the type itself.

    A creator for intersection type where intersections of a single type are replaced by the type itself.

    Definition Classes
    Types
  220. abstract def lub(xs: List[Type]): Type

    The least upper bound of a list of types, as determined by <:<.

    The least upper bound of a list of types, as determined by <:<.

    Definition Classes
    Types
  221. abstract def mkImporter(from0: Universe): Importer { val from: from0.type }

    Definition Classes
    Importers
  222. abstract def newLazyTreeCopier: TreeCopier

    Definition Classes
    Trees
  223. abstract def newNestedScope(outer: Scope): Scope

    Create a new scope nested in another one with which it shares its elements

    Create a new scope nested in another one with which it shares its elements

    Definition Classes
    Scopes
  224. abstract def newRawTreePrinter(out: PrintWriter): TreePrinter

    Hook to define what showRaw(...) means.

    Hook to define what showRaw(...) means.

    Definition Classes
    Printers
  225. abstract def newScope: Scope

    Create a new scope

    Create a new scope

    Definition Classes
    Scopes
  226. abstract def newScopeWith(elems: Symbol*): Scope

    Create a new scope with given initial elements

    Create a new scope with given initial elements

    Definition Classes
    Scopes
  227. abstract def newStrictTreeCopier: TreeCopier

    Definition Classes
    Trees
  228. abstract def newTermName(s: String): TermName

    Create a new term name.

    Create a new term name.

    Definition Classes
    Names
  229. abstract def newTreePrinter(out: PrintWriter): TreePrinter

    Hook to define what show(...) means.

    Hook to define what show(...) means.

    Definition Classes
    Printers
  230. abstract def newTypeName(s: String): TypeName

    Creates a new type name.

    Creates a new type name.

    Definition Classes
    Names
  231. abstract val nme: TermNamesApi

    Definition Classes
    StandardNamesStandardNames
  232. abstract def polyType(tparams: List[Symbol], tpe: Type): Type

    A creator for type parameterizations that strips empty type parameter lists.

    A creator 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).

    Definition Classes
    Types
  233. abstract def refinedType(parents: List[Type], owner: Symbol): Type

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

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

    Definition Classes
    Types
  234. abstract def refinedType(parents: List[Type], owner: Symbol, decls: Scope, pos: Position): Type

    the canonical creator for a refined type with a given scope

    the canonical creator for a refined type with a given scope

    Definition Classes
    Types
  235. abstract val rootMirror: Mirror

    .

    ..

    Definition Classes
    Mirrors
  236. abstract def show(flags: FlagSet): String

    Renders a prettified representation of a flag set.

    Renders a prettified representation of a flag set.

    Definition Classes
    Printers
  237. abstract def show(name: Name): String

    Renders a prettified representation of a name.

    Renders a prettified representation of a name.

    Definition Classes
    Printers
  238. abstract def singleType(pre: Type, sym: Symbol): Type

    The canonical creator for single-types

    The canonical creator for single-types

    Definition Classes
    Types
  239. abstract val tpnme: TypeNamesApi

    Definition Classes
    StandardNamesStandardNames
  240. abstract def typeRef(pre: Type, sym: Symbol, args: List[Type]): Type

    The canonical creator for typerefs

    The canonical creator for typerefs

    Definition Classes
    Types
  241. abstract def wrappingPos(trees: List[Tree]): Position

    A position that wraps the non-empty set of trees.

    A position that wraps the non-empty set of trees. The point of the wrapping position is the point of the first trees' position. If all some the trees are non-synthetic, returns a range position enclosing the non-synthetic trees Otherwise returns a synthetic offset position to point.

    Definition Classes
    Positions
  242. abstract def wrappingPos(default: Position, trees: List[Tree]): Position

    A position that wraps a set of trees.

    A position that wraps a set of trees. The point of the wrapping position is the point of the default position. If some of the trees are ranges, returns a range position enclosing all ranges Otherwise returns default position.

    Definition Classes
    Positions

Concrete Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Test two objects for inequality.

    Test two objects for inequality.

    returns

    true if !(this == that), false otherwise.

    Definition Classes
    Any
  3. final def ##(): Int

    Equivalent to x.hashCode except for boxed numeric types and null.

    Equivalent to x.hashCode except for boxed numeric types and null. For numerics, it returns a hash value which is consistent with value equality: if two value type instances compare as true, then ## will produce the same hash value for each of them. For null returns a hashcode where null.hashCode throws a NullPointerException.

    returns

    a hash value consistent with ==

    Definition Classes
    AnyRef → Any
  4. def +(other: String): String

    Implicit information
    This member is added by an implicit conversion from Universe to StringAdd performed by method any2stringadd in scala.Predef.
    Definition Classes
    StringAdd
  5. def ->[B](y: B): (Universe, B)

    Implicit information
    This member is added by an implicit conversion from Universe to ArrowAssoc[Universe] performed by method any2ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @inline()
  6. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  7. final def ==(arg0: Any): Boolean

    Test two objects for equality.

    Test two objects for equality. The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).

    returns

    true if the receiver object is equivalent to the argument; false otherwise.

    Definition Classes
    Any
  8. object AbsTypeTag extends Serializable

    Definition Classes
    TypeTags
  9. object BooleanFlag extends Serializable

    Definition Classes
    Printers
  10. def EmptyTermName: TermName

    Definition Classes
    Names
  11. def EmptyTypeName: TypeName

    Definition Classes
    Names
  12. object Expr extends Serializable

    Definition Classes
    Exprs
  13. def Modifiers(flags: FlagSet): Modifiers

    Definition Classes
    Trees
  14. def Modifiers(flags: FlagSet, privateWithin: Name): Modifiers

    Definition Classes
    Trees
  15. lazy val NoMods: Modifiers

    .

    ...

    Definition Classes
    Trees
  16. object TypeTag extends Serializable

    Definition Classes
    TypeTags
  17. final def asInstanceOf[T0]: T0

    Cast the receiver object to be of type T0.

    Cast the receiver object to be of type T0.

    Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression 1.asInstanceOf[String] will throw a ClassCastException at runtime, while the expression List(1).asInstanceOf[List[String]] will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested type.

    returns

    the receiver object.

    Definition Classes
    Any
    Exceptions thrown
    ClassCastException

    if the receiver object is not an instance of the erasure of type T0.

  18. def clone(): AnyRef

    Create a copy of the receiver object.

    Create a copy of the receiver object.

    The default implementation of the clone method is platform dependent.

    returns

    a copy of the receiver object.

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
    Note

    not specified by SLS as a member of AnyRef

  19. def ensuring(cond: (Universe) ⇒ Boolean, msg: ⇒ Any): Universe

    Implicit information
    This member is added by an implicit conversion from Universe to Ensuring[Universe] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  20. def ensuring(cond: (Universe) ⇒ Boolean): Universe

    Implicit information
    This member is added by an implicit conversion from Universe to Ensuring[Universe] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  21. def ensuring(cond: Boolean, msg: ⇒ Any): Universe

    Implicit information
    This member is added by an implicit conversion from Universe to Ensuring[Universe] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  22. def ensuring(cond: Boolean): Universe

    Implicit information
    This member is added by an implicit conversion from Universe to Ensuring[Universe] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  23. final def eq(arg0: AnyRef): Boolean

    Tests whether the argument (arg0) is a reference to the receiver object (this).

    Tests whether the argument (arg0) is a reference to the receiver object (this).

    The eq method implements an equivalence relation on non-null instances of AnyRef, and has three additional properties:

    • It is consistent: for any non-null instances x and y of type AnyRef, multiple invocations of x.eq(y) consistently returns true or consistently returns false.
    • For any non-null instance x of type AnyRef, x.eq(null) and null.eq(x) returns false.
    • null.eq(null) returns true.

    When overriding the equals or hashCode methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2), they should be equal to each other (o1 == o2) and they should hash to the same value (o1.hashCode == o2.hashCode).

    returns

    true if the argument is a reference to the receiver object; false otherwise.

    Definition Classes
    AnyRef
  24. def equals(arg0: Any): Boolean

    The equality method for reference types.

    The equality method for reference types. Default implementation delegates to eq.

    See also equals in Any.

    returns

    true if the receiver object is equivalent to the argument; false otherwise.

    Definition Classes
    AnyRef → Any
  25. def finalize(): Unit

    Called by the garbage collector on the receiver object when there are no more references to the object.

    Called by the garbage collector on the receiver object when there are no more references to the object.

    The details of when and if the finalize method is invoked, as well as the interaction between finalize and non-local returns and exceptions, are all platform dependent.

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
    Note

    not specified by SLS as a member of AnyRef

  26. def formatted(fmtstr: String): String

    Returns string formatted according to given format string.

    Returns string formatted according to given format string. Format strings are as for String.format (@see java.lang.String.format).

    Implicit information
    This member is added by an implicit conversion from Universe to StringFormat performed by method any2stringfmt in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @inline()
  27. final def getClass(): Class[_]

    A representation that corresponds to the dynamic class of the receiver object.

    A representation that corresponds to the dynamic class of the receiver object.

    The nature of the representation is platform dependent.

    returns

    a representation that corresponds to the dynamic class of the receiver object.

    Definition Classes
    AnyRef → Any
    Note

    not specified by SLS as a member of AnyRef

  28. def hashCode(): Int

    The hashCode method for reference types.

    The hashCode method for reference types. See hashCode in Any.

    returns

    the hash code value for this object.

    Definition Classes
    AnyRef → Any
  29. final def isInstanceOf[T0]: Boolean

    Test whether the dynamic type of the receiver object is T0.

    Test whether the dynamic type of the receiver object is T0.

    Note that the result of the test is modulo Scala's erasure semantics. Therefore the expression 1.isInstanceOf[String] will return false, while the expression List(1).isInstanceOf[List[String]] will return true. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the specified type.

    returns

    true if the receiver object is an instance of erasure of type T0; false otherwise.

    Definition Classes
    Any
  30. def itransform(transformer: Transformer, tree: Tree): Tree

    Attributes
    protected
    Definition Classes
    Trees
  31. def itraverse(traverser: Traverser, tree: Tree): Unit

    Attributes
    protected
    Definition Classes
    Trees
  32. def manifestToTypeTag[T](mirror: Any, manifest: Manifest[T]): TypeTag[T]

    Definition Classes
    TagInterop
  33. final def ne(arg0: AnyRef): Boolean

    Equivalent to !(this eq that).

    Equivalent to !(this eq that).

    returns

    true if the argument is not a reference to the receiver object; false otherwise.

    Definition Classes
    AnyRef
  34. final def notify(): Unit

    Wakes up a single thread that is waiting on the receiver object's monitor.

    Wakes up a single thread that is waiting on the receiver object's monitor.

    Definition Classes
    AnyRef
    Note

    not specified by SLS as a member of AnyRef

  35. final def notifyAll(): Unit

    Wakes up all threads that are waiting on the receiver object's monitor.

    Wakes up all threads that are waiting on the receiver object's monitor.

    Definition Classes
    AnyRef
    Note

    not specified by SLS as a member of AnyRef

  36. def reify[T](expr: T): Expr[T]

    Given an expression, generate a tree that when compiled and executed produces the original tree.

    Given an expression, generate a tree that when compiled and executed produces the original tree. The produced tree will be bound to the Universe it was called from.

    For instance, given the abstract syntax tree representation of the <[ x + 1 ]> expression:

    Apply(Select(Ident("x"), "+"), List(Literal(Constant(1))))

    The reifier transforms it to the following expression:

    <[
      val $u: u.type = u // where u is a reference to the Universe that calls the reify
      $u.Expr[Int]($u.Apply($u.Select($u.Ident($u.newFreeVar("x", <Int>, x), "+"), List($u.Literal($u.Constant(1))))))
    ]>

    Reification performs expression splicing (when processing Expr.splice) and type splicing (for every type T that has a TypeTag[T] implicit in scope):

    val two = mirror.reify(2)                         // Literal(Constant(2))
    val four = mirror.reify(two.splice + two.splice)  // Apply(Select(two.tree, newTermName("$plus")), List(two.tree))
    
    def macroImpl[T](c: Context) = {
      ...
      // T here is just a type parameter, so the tree produced by reify won't be of much use in a macro expansion
      // however, if T were annotated with c.TypeTag (which would declare an implicit parameter for macroImpl)
      // then reification would subtitute T with the TypeTree that was used in a TypeApply of this particular macro invocation
      val factory = c.reify{ new Queryable[T] }
      ...
    }

    The transformation looks mostly straightforward, but it has its tricky parts: * Reifier retains symbols and types defined outside the reified tree, however locally defined entities get erased and replaced with their original trees * Free variables are detected and wrapped in symbols of the type FreeVar * Mutable variables that are accessed from a local function are wrapped in refs * Since reified trees can be compiled outside of the scope they've been created in, special measures are taken to ensure that all members accessed in the reifee remain visible

  37. def render(what: Any, mkPrinter: (PrintWriter) ⇒ TreePrinter, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None): String

    Attributes
    protected
    Definition Classes
    Printers
  38. def show(any: Any, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None): String

    Renders a prettified representation of a reflection artifact.

    Renders a prettified representation of a reflection artifact. Typically it looks very close to the Scala code it represents.

    Definition Classes
    Printers
  39. def showRaw(flags: FlagSet): String

    Renders internal structure of a flag set.

    Renders internal structure of a flag set.

    Definition Classes
    Printers
  40. def showRaw(name: Name): String

    Renders internal structure of a name.

    Renders internal structure of a name.

    Definition Classes
    Printers
  41. def showRaw(any: Any, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None): String

    Renders internal structure of a reflection artifact.

    Renders internal structure of a reflection artifact.

    Definition Classes
    Printers
  42. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  43. def toString(): String

    Creates a String representation of this object.

    Creates a String representation of this object. The default representation is platform dependent. On the java platform it is the concatenation of the class name, "@", and the object's hashcode in hexadecimal.

    returns

    a String representation of the object.

    Definition Classes
    AnyRef → Any
  44. val treeCopy: TreeCopier

    Definition Classes
    Trees
  45. def treeToString(tree: Tree): String

    By default trees are printed with show

    By default trees are printed with show

    Attributes
    protected
    Definition Classes
    Printers
  46. def typeOf[T](implicit ttag: TypeTag[T]): Type

    Definition Classes
    TypeTags
  47. def typeTag[T](implicit ttag: TypeTag[T]): TypeTag[T]

    Definition Classes
    TypeTags
  48. def typeTagToManifest[T](mirror: Any, tag: TypeTag[T])(implicit arg0: ClassTag[T]): Manifest[T]

    Definition Classes
    TagInterop
  49. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  50. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  51. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  52. def xtransform(transformer: Transformer, tree: Tree): Tree

    Attributes
    protected
    Definition Classes
    Trees
  53. def xtraverse(traverser: Traverser, tree: Tree): Unit

    Attributes
    protected
    Definition Classes
    Trees
  54. def [B](y: B): (Universe, B)

    Implicit information
    This member is added by an implicit conversion from Universe to ArrowAssoc[Universe] performed by method any2ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc

Shadowed Implict Value Members

  1. val self: Any

    Implicit information
    This member is added by an implicit conversion from Universe to StringAdd performed by method any2stringadd in scala.Predef.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (universe: StringAdd).self
    Definition Classes
    StringAdd
  2. val self: Any

    Implicit information
    This member is added by an implicit conversion from Universe to StringFormat performed by method any2stringfmt in scala.Predef.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (universe: StringFormat).self
    Definition Classes
    StringFormat

Deprecated Value Members

  1. def x: Universe

    Implicit information
    This member is added by an implicit conversion from Universe to ArrowAssoc[Universe] performed by method any2ArrowAssoc in scala.Predef.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (universe: ArrowAssoc[Universe]).x
    Definition Classes
    ArrowAssoc
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.0) Use leftOfArrow instead

  2. def x: Universe

    Implicit information
    This member is added by an implicit conversion from Universe to Ensuring[Universe] performed by method any2Ensuring in scala.Predef.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (universe: Ensuring[Universe]).x
    Definition Classes
    Ensuring
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.0) Use resultOfEnsuring instead

Inherited from AnnotationInfos

Inherited from Exprs

Inherited from Importers

Inherited from StandardNames

Inherited from StandardDefinitions

Inherited from Mirrors

Inherited from Positions

Inherited from Constants

Inherited from Printers

Inherited from Trees

Inherited from Names

Inherited from FlagSets

Inherited from Types

Inherited from Symbols

Inherited from Universe

Inherited from Mirrors

Inherited from BuildUtils

Inherited from StandardNames

Inherited from StandardDefinitions

Inherited from StandardTypes

Inherited from TagInterop

Inherited from TypeTags

Inherited from Positions

Inherited from AnnotationInfos

Inherited from Constants

Inherited from Trees

Inherited from Names

Inherited from Scopes

Inherited from FlagSets

Inherited from Types

Inherited from Symbols

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd from Universe to StringAdd

Inherited by implicit conversion any2stringfmt from Universe to StringFormat

Inherited by implicit conversion any2ArrowAssoc from Universe to ArrowAssoc[Universe]

Inherited by implicit conversion any2Ensuring from Universe to Ensuring[Universe]