scala.reflect.base

Universe

abstract class Universe extends Symbols with Types with FlagSets with Scopes with Names with Trees with Constants with AnnotationInfos with Positions with TypeTags with TagInterop with StandardDefinitions with StandardNames with BuildUtils with Mirrors

Source
Universe.scala
Linear Supertypes
Known Subclasses
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Universe
  2. Mirrors
  3. BuildUtils
  4. StandardNames
  5. StandardDefinitions
  6. StandardTypes
  7. TagInterop
  8. TypeTags
  9. Positions
  10. AnnotationInfos
  11. Constants
  12. Trees
  13. Names
  14. Scopes
  15. FlagSets
  16. Types
  17. Symbols
  18. AnyRef
  19. 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

    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
    Trees
  3. abstract class AlternativeExtractor extends AnyRef

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

  4. abstract type Annotated >: Null <: Tree

    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
    Trees
  5. abstract class AnnotatedExtractor extends AnyRef

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

  6. abstract type AnnotatedType >: Null <: Type

    The AnnotatedType type signature is used for annotated types of the for <type> @<annotation>.

    The AnnotatedType type signature is used for annotated types of the for <type> @<annotation>.

    Definition Classes
    Types
  7. abstract class AnnotatedTypeExtractor extends AnyRef

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

  8. abstract type AnnotationInfo >: Null <: AnyRef

    Definition Classes
    AnnotationInfos
  9. abstract class AnnotationInfoExtractor extends AnyRef

    Definition Classes
    AnnotationInfos
  10. abstract type AppliedTypeTree >: Null <: TypTree

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

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

    Definition Classes
    Trees
  11. abstract class AppliedTypeTreeExtractor extends AnyRef

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

  12. abstract type Apply >: Null <: GenericApply

    Value application

    Value application

    Definition Classes
    Trees
  13. abstract type ApplyDynamic >: Null <: TermTree with SymTree

    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
    Trees
  14. abstract class ApplyDynamicExtractor extends AnyRef

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

  15. abstract class ApplyExtractor extends AnyRef

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

  16. abstract type ArrayAnnotArg >: Null <: ClassfileAnnotArg

    Definition Classes
    AnnotationInfos
  17. abstract class ArrayAnnotArgExtractor extends AnyRef

    Definition Classes
    AnnotationInfos
  18. abstract type ArrayValue >: Null <: TermTree

    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
    Trees
  19. abstract class ArrayValueExtractor extends AnyRef

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

  20. abstract type Assign >: Null <: TermTree

    Assignment

    Assignment

    Definition Classes
    Trees
  21. abstract class AssignExtractor extends AnyRef

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

  22. abstract type AssignOrNamedArg >: Null <: TermTree

    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
    Trees
  23. abstract class AssignOrNamedArgExtractor extends AnyRef

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

  24. abstract type Bind >: Null <: DefTree

    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
    Trees
  25. abstract class BindExtractor extends AnyRef

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

  26. abstract type Block >: Null <: TermTree

    Block of expressions (semicolon separated expressions)

    Block of expressions (semicolon separated expressions)

    Definition Classes
    Trees
  27. abstract class BlockExtractor extends AnyRef

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

  28. abstract type BoundedWildcardType >: Null <: Type

    BoundedWildcardTypes, used only during type inference, are created in two places that I can find:

    BoundedWildcardTypes, used only during type inference, are created in two places that I can find:

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

    Definition Classes
    Types
  30. abstract class BuildBase extends AnyRef

    Definition Classes
    BuildUtils
  31. abstract type CaseDef >: Null <: Tree

    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
    Trees
  32. abstract class CaseDefExtractor extends AnyRef

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

  33. abstract type ClassDef >: Null <: ImplDef

    A class definition.

    A class definition.

    Definition Classes
    Trees
  34. abstract class ClassDefExtractor extends AnyRef

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

  35. abstract type ClassInfoType >: Null <: CompoundType

    The ClassInfo type signature is used to define parents and declarations of classes, traits, and objects.

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

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

    its ClassInfo type has the following form:

    ClassInfo(List(P_1, ..., P_m), Scope(D_1, ..., D_n), C)
    Definition Classes
    Types
  36. 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.

  37. abstract type ClassSymbol >: Null <: TypeSymbol with ClassSymbolBase

    The abstract type of class symbols representing class and trait definitions

    The abstract type of class symbols representing class and trait definitions

    Definition Classes
    Symbols
  38. trait ClassSymbolBase extends TypeSymbolBase

    The base API that all class symbols support

  39. abstract type ClassfileAnnotArg >: Null <: AnyRef

    Definition Classes
    AnnotationInfos
  40. 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
  41. abstract type CompoundTypeTree >: Null <: TypTree

    Intersection type <parent1> with .

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

    Definition Classes
    Trees
  42. abstract class CompoundTypeTreeExtractor extends AnyRef

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

  43. abstract type Constant >: Null <: AnyRef

    Definition Classes
    Constants
  44. abstract class ConstantExtractor extends AnyRef

    Definition Classes
    Constants
  45. abstract type ConstantType >: Null <: SingletonType

    The ConstantType type is not directly written in user programs, but arises as the type of a constant.

    The ConstantType type is not directly written in user programs, but arises as the type of a constant. The REPL expresses constant types like Int(11). Here are some constants with their types.

    1           ConstantType(Constant(1))
    "abc"       ConstantType(Constant("abc"))
    Definition Classes
    Types
  46. 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.

  47. abstract type DefDef >: Null <: ValOrDefDef

    A method or macro definition.

    A method or macro definition.

    Definition Classes
    Trees
  48. abstract class DefDefExtractor extends AnyRef

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

  49. abstract type DefTree >: Null <: SymTree with NameTree

    A tree which defines a symbol-carrying entity.

    A tree which defines a symbol-carrying entity.

    Definition Classes
    Trees
  50. trait DefinitionsBase extends AnyRef

    Definition Classes
    StandardDefinitions
  51. abstract type ExistentialType >: Null <: Type

    The ExistentialType type signature is used for existential types and wildcard types.

    The ExistentialType type signature is used for existential types and wildcard types.

    Definition Classes
    Types
  52. abstract class ExistentialTypeExtractor extends AnyRef

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

  53. abstract type ExistentialTypeTree >: Null <: TypTree

    Document me!

    Document me!

    Definition Classes
    Trees
  54. abstract class ExistentialTypeTreeExtractor extends AnyRef

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

  55. abstract type FlagSet

    An abstract type representing sets of flags that apply to definition trees and symbols

    An abstract type representing sets of flags that apply to definition trees and symbols

    Definition Classes
    FlagSets
  56. abstract type FreeTermSymbol >: Null <: TermSymbol with FreeTermSymbolBase

    The abstract type of free terms introduced by reification

    The abstract type of free terms introduced by reification

    Definition Classes
    Symbols
  57. trait FreeTermSymbolBase extends TermSymbolBase

    The base API that all free term symbols support

  58. abstract type FreeTypeSymbol >: Null <: TypeSymbol with FreeTypeSymbolBase

    The abstract type of free types introduced by reification

    The abstract type of free types introduced by reification

    Definition Classes
    Symbols
  59. trait FreeTypeSymbolBase extends TypeSymbolBase

    The base API that all free type symbols support

  60. abstract type Function >: Null <: TermTree with SymTree

    Anonymous function, eliminated by lambdalift

    Anonymous function, eliminated by lambdalift

    Definition Classes
    Trees
  61. abstract class FunctionExtractor extends AnyRef

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

  62. abstract type GenericApply >: Null <: TermTree

    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
    Trees
  63. abstract type Ident >: Null <: RefTree

    Identifier <name>

    Identifier <name>

    Definition Classes
    Trees
  64. abstract class IdentExtractor extends AnyRef

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

  65. abstract type If >: Null <: TermTree

    Conditional expression

    Conditional expression

    Definition Classes
    Trees
  66. abstract class IfExtractor extends AnyRef

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

  67. abstract type ImplDef >: Null <: MemberDef

    A common base class for class and object definitions.

    A common base class for class and object definitions.

    Definition Classes
    Trees
  68. abstract type Import >: Null <: SymTree

    Import clause

    Import clause

    Definition Classes
    Trees
  69. abstract class ImportExtractor extends AnyRef

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

  70. abstract type ImportSelector >: Null <: AnyRef

    Import selector

    Import selector

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

    Eliminated by typecheck.

    Definition Classes
    Trees
  71. abstract class ImportSelectorExtractor extends AnyRef

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

  72. abstract type LabelDef >: Null <: DefTree with TermTree

    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
    Trees
  73. abstract class LabelDefExtractor extends AnyRef

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

  74. abstract type Literal >: Null <: TermTree

    Literal

    Literal

    Definition Classes
    Trees
  75. abstract type LiteralAnnotArg >: Null <: ClassfileAnnotArg

    Definition Classes
    AnnotationInfos
  76. abstract class LiteralAnnotArgExtractor extends AnyRef

    Definition Classes
    AnnotationInfos
  77. abstract class LiteralExtractor extends AnyRef

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

  78. abstract type Match >: Null <: TermTree

    - 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
    Trees
  79. abstract class MatchExtractor extends AnyRef

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

  80. abstract type MemberDef >: Null <: DefTree

    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
    Trees
  81. abstract type MethodSymbol >: Null <: TermSymbol with MethodSymbolBase

    The abstract type of method symbols representing def declarations

    The abstract type of method symbols representing def declarations

    Definition Classes
    Symbols
  82. trait MethodSymbolBase extends TermSymbolBase

    The base API that all method symbols support

  83. abstract type MethodType >: Null <: Type

    The MethodType type signature is used to indicate parameters and result type of a method

    The MethodType type signature is used to indicate parameters and result type of a method

    Definition Classes
    Types
  84. 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.

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

    .

    ..

    Definition Classes
    Mirrors
  86. abstract type Modifiers >: Null <: ModifiersBase

    .

    ...

    Definition Classes
    Trees
  87. abstract class ModifiersBase extends AnyRef

    .

  88. abstract class ModifiersCreator extends AnyRef

    Definition Classes
    Trees
  89. abstract type ModuleDef >: Null <: ImplDef

    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
    Trees
  90. abstract class ModuleDefExtractor extends AnyRef

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

  91. abstract type ModuleSymbol >: Null <: TermSymbol with ModuleSymbolBase

    The abstract type of module symbols representing object declarations

    The abstract type of module symbols representing object declarations

    Definition Classes
    Symbols
  92. trait ModuleSymbolBase extends TermSymbolBase

    The base API that all module symbols support

  93. abstract type Name >: Null <: NameBase

    The abstract type of names

    The abstract type of names

    Definition Classes
    Names
  94. abstract class NameBase extends AnyRef

    The base API that all names support

  95. abstract type NameTree >: Null <: Tree

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

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

    Definition Classes
    Trees
  96. trait NamesBase extends AnyRef

    Definition Classes
    StandardNames
  97. abstract type NestedAnnotArg >: Null <: ClassfileAnnotArg

    Definition Classes
    AnnotationInfos
  98. abstract class NestedAnnotArgExtractor extends AnyRef

    Definition Classes
    AnnotationInfos
  99. abstract type New >: Null <: TermTree

    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
    Trees
  100. abstract class NewExtractor extends AnyRef

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

  101. abstract type NullaryMethodType >: Null <: Type

    The NullaryMethodType type signature is used for parameterless methods with declarations of the form def foo: T

    The NullaryMethodType type signature is used for parameterless methods with declarations of the form def foo: T

    Definition Classes
    Types
  102. abstract class NullaryMethodTypeExtractor extends AnyRef

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

  103. abstract type PackageDef >: Null <: MemberDef

    A packaging, such as package pid { stats }

    A packaging, such as package pid { stats }

    Definition Classes
    Trees
  104. abstract class PackageDefExtractor extends AnyRef

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

  105. abstract type PolyType >: Null <: Type

    The PolyType type signature is used for polymorphic methods that have at least one type parameter.

    The PolyType type signature is used for polymorphic methods that have at least one type parameter.

    Definition Classes
    Types
  106. abstract class PolyTypeExtractor extends AnyRef

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

  107. abstract type Position >: Null <: Attachments { type Pos = Universe.this.Position }

    .

    ..

    Definition Classes
    Positions
  108. abstract type RefTree >: Null <: SymTree with NameTree

    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
    Trees
  109. abstract type ReferenceToBoxed >: Null <: TermTree

    Marks underlying reference to id as boxed.

    Marks underlying reference to id as boxed.

    Definition Classes
    Trees
  110. abstract class ReferenceToBoxedExtractor extends AnyRef

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

  111. abstract type RefinedType >: Null <: CompoundType

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

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

    P_1 with ... with P_m { D_1; ...; D_n}      RefinedType(List(P_1, ..., P_m), Scope(D_1, ..., D_n))
    P_1 with ... with P_m                       RefinedType(List(P_1, ..., P_m), Scope())
    { D_1; ...; D_n}                            RefinedType(List(AnyRef), Scope(D_1, ..., D_n))
    Definition Classes
    Types
  112. 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.

  113. abstract type Return >: Null <: TermTree with SymTree

    Return expression

    Return expression

    Definition Classes
    Trees
  114. abstract class ReturnExtractor extends AnyRef

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

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

    Definition Classes
    Scopes
  116. abstract type Select >: Null <: RefTree

    Designator <qualifier> .

    Designator <qualifier> . <name>

    Definition Classes
    Trees
  117. abstract class SelectExtractor extends AnyRef

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

  118. abstract type SelectFromTypeTree >: Null <: TypTree with RefTree

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

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

    Definition Classes
    Trees
  119. abstract class SelectFromTypeTreeExtractor extends AnyRef

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

  120. abstract type SingleType >: Null <: SingletonType

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

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

    (T # x).type             SingleType(T, x)
    p.x.type                 SingleType(p.type, x)
    x.type                   SingleType(NoPrefix, x)
    Definition Classes
    Types
  121. 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.

  122. 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
  123. abstract type SingletonTypeTree >: Null <: TypTree

    Singleton type, eliminated by RefCheck

    Singleton type, eliminated by RefCheck

    Definition Classes
    Trees
  124. abstract class SingletonTypeTreeExtractor extends AnyRef

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

  125. abstract type Star >: Null <: TermTree

    Repetition of pattern.

    Repetition of pattern. Eliminated by patmat/explicitouter.

    Definition Classes
    Trees
  126. abstract class StarExtractor extends AnyRef

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

  127. abstract type Super >: Null <: TermTree

    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
    Trees
  128. abstract class SuperExtractor extends AnyRef

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

  129. abstract type SuperType >: Null <: SingletonType

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

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

    SuperType(thistpe, supertpe)

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

    Definition Classes
    Types
  130. abstract class SuperTypeExtractor extends AnyRef

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

  131. abstract type SymTree >: Null <: Tree

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

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

    Definition Classes
    Trees
  132. abstract type Symbol >: Null <: SymbolBase

    The abstract type of symbols representing declarations

    The abstract type of symbols representing declarations

    Definition Classes
    Symbols
  133. trait SymbolBase extends AnyRef

    The base API that all symbols support

  134. abstract type Template >: Null <: SymTree

    Instantiation template of a class or trait

    Instantiation template of a class or trait

    Definition Classes
    Trees
  135. abstract class TemplateExtractor extends AnyRef

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

  136. abstract type TermName >: Null <: Name

    The abstract type of names representing types

    The abstract type of names representing types

    Definition Classes
    Names
  137. trait TermNamesBase extends NamesBase

    Definition Classes
    StandardNames
  138. abstract type TermSymbol >: Null <: Symbol with TermSymbolBase

    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
    Symbols
  139. trait TermSymbolBase extends SymbolBase

    The base API that all term symbols support

  140. abstract type TermTree >: Null <: Tree

    A tree for a term.

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

    Definition Classes
    Trees
  141. abstract type This >: Null <: TermTree with SymTree

    Self reference

    Self reference

    Definition Classes
    Trees
  142. abstract class ThisExtractor extends AnyRef

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

  143. abstract type ThisType >: Null <: SingletonType

    The ThisType type describes types of the form on the left with the correspnding ThisType representations to the right.

    The ThisType type describes types of the form on the left with the correspnding ThisType representations to the right.

    C.this.type             ThisType(C)
    Definition Classes
    Types
  144. 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.

  145. abstract type Throw >: Null <: TermTree

    Throw expression

    Throw expression

    Definition Classes
    Trees
  146. abstract class ThrowExtractor extends AnyRef

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

  147. abstract type Tree >: Null <: TreeBase

    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
    Trees
  148. abstract class TreeBase extends Product

    The base API that all trees support

  149. abstract type Try >: Null <: TermTree

    [Eugene++] comment me!

    [Eugene++] comment me!

    Definition Classes
    Trees
  150. abstract class TryExtractor extends AnyRef

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

  151. abstract type TypTree >: Null <: Tree

    A tree for a type.

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

    Definition Classes
    Trees
  152. abstract type Type >: Null <: TypeBase

    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
    Types
  153. abstract type TypeApply >: Null <: GenericApply

    Explicit type application.

    Explicit type application.

    Definition Classes
    Trees
  154. abstract class TypeApplyExtractor extends AnyRef

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

  155. abstract class TypeBase extends AnyRef

    The base API that all types support

  156. abstract type TypeBounds >: Null <: Type

    The TypeBounds type signature is used to indicate lower and upper type bounds of type parameters and abstract types.

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

    T >: L <: U               TypeBounds(L, U)
    T >: L                    TypeBounds(L, Any)
    T <: U                    TypeBounds(Nothing, U)
    Definition Classes
    Types
  157. 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.

  158. abstract type TypeBoundsTree >: Null <: TypTree

    Document me!

    Document me!

    Definition Classes
    Trees
  159. abstract class TypeBoundsTreeExtractor extends AnyRef

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

  160. abstract type TypeDef >: Null <: MemberDef

    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
    Trees
  161. abstract class TypeDefExtractor extends AnyRef

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

  162. abstract type TypeName >: Null <: Name

    The abstract type of names representing terms

    The abstract type of names representing terms

    Definition Classes
    Names
  163. trait TypeNamesBase extends NamesBase

    Definition Classes
    StandardNames
  164. abstract type TypeRef >: Null <: Type

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

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

    T # C[T_1, ..., T_n]      TypeRef(T, C, List(T_1, ..., T_n))
    p.C[T_1, ..., T_n]        TypeRef(p.type, C, List(T_1, ..., T_n))
    C[T_1, ..., T_n]          TypeRef(NoPrefix, C, List(T_1, ..., T_n))
    T # C                     TypeRef(T, C, Nil)
    p.C                       TypeRef(p.type, C, Nil)
    C                         TypeRef(NoPrefix, C, Nil)
    Definition Classes
    Types
  165. 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.

  166. abstract type TypeSymbol >: Null <: Symbol with TypeSymbolBase

    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
    Symbols
  167. trait TypeSymbolBase extends SymbolBase

    The base API that all type symbols support

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

    If an implicit value of type u.

  169. abstract type TypeTree >: Null <: TypTree

    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
    Trees
  170. abstract class TypeTreeExtractor extends AnyRef

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

  171. abstract type Typed >: Null <: TermTree

    Type annotation, eliminated by cleanup

    Type annotation, eliminated by cleanup

    Definition Classes
    Trees
  172. abstract class TypedExtractor extends AnyRef

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

  173. abstract type UnApply >: Null <: TermTree

    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
    Trees
  174. abstract class UnApplyExtractor extends AnyRef

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

  175. abstract type ValDef >: Null <: ValOrDefDef

    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
    Trees
  176. abstract class ValDefExtractor extends AnyRef

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

  177. abstract type ValOrDefDef >: Null <: MemberDef

    A common base class for ValDefs and DefDefs.

    A common base class for ValDefs and DefDefs.

    Definition Classes
    Trees

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. 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
  71. abstract val FloatTpe: Type

    Definition Classes
    StandardTypes
  72. 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
  73. 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
  74. abstract val Function: FunctionExtractor

    The constructor/deconstructor for Function instances.

    The constructor/deconstructor for Function instances.

    Definition Classes
    Trees
  75. 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
  76. 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
  77. abstract def Ident(sym: Symbol): Ident

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

    Definition Classes
    Trees
  79. abstract val Ident: IdentExtractor

    The constructor/deconstructor for Ident instances.

    The constructor/deconstructor for Ident instances.

    Definition Classes
    Trees
  80. 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
  81. abstract val If: IfExtractor

    The constructor/deconstructor for If instances.

    The constructor/deconstructor for If instances.

    Definition Classes
    Trees
  82. 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
  83. 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
  84. abstract val Import: ImportExtractor

    The constructor/deconstructor for Import instances.

    The constructor/deconstructor for Import instances.

    Definition Classes
    Trees
  85. abstract val ImportSelector: ImportSelectorExtractor

    The constructor/deconstructor for ImportSelector instances.

    The constructor/deconstructor for ImportSelector instances.

    Definition Classes
    Trees
  86. 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
  87. 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
  88. abstract val IntTpe: Type

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

    Definition Classes
    Trees
  90. abstract val LabelDef: LabelDefExtractor

    The constructor/deconstructor for LabelDef instances.

    The constructor/deconstructor for LabelDef instances.

    Definition Classes
    Trees
  91. 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
  92. abstract val Literal: LiteralExtractor

    The constructor/deconstructor for Literal instances.

    The constructor/deconstructor for Literal instances.

    Definition Classes
    Trees
  93. abstract val LiteralAnnotArg: LiteralAnnotArgExtractor

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

    Definition Classes
    AnnotationInfos
  95. 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
  96. abstract val LongTpe: Type

    Definition Classes
    StandardTypes
  97. abstract val Match: MatchExtractor

    The constructor/deconstructor for Match instances.

    The constructor/deconstructor for Match instances.

    Definition Classes
    Trees
  98. 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
  99. 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
  100. 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
  101. abstract val MethodType: MethodTypeExtractor

    The constructor/deconstructor for MethodType instances.

    The constructor/deconstructor for MethodType instances.

    Definition Classes
    Types
  102. 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
  103. abstract val Modifiers: ModifiersCreator

    Definition Classes
    Trees
  104. 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
  105. abstract def ModuleDef(sym: Symbol, impl: Template): ModuleDef

    sym

    the class symbol

    impl

    the implementation template

    Definition Classes
    Trees
  106. abstract val ModuleDef: ModuleDefExtractor

    The constructor/deconstructor for ModuleDef instances.

    The constructor/deconstructor for ModuleDef instances.

    Definition Classes
    Trees
  107. 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
  108. 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
  109. implicit abstract val NameTag: ClassTag[Name]

    Definition Classes
    Names
  110. 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
  111. abstract val NestedAnnotArg: NestedAnnotArgExtractor

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

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

    Definition Classes
    Trees
  114. 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
  115. 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
  116. abstract val New: NewExtractor

    The constructor/deconstructor for New instances.

    The constructor/deconstructor for New instances.

    Definition Classes
    Trees
  117. 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
  118. abstract val NoFlags: FlagSet

    The empty set of flags

    The empty set of flags

    Definition Classes
    FlagSets
  119. abstract val NoPosition: Position

    .

    ..

    Definition Classes
    Positions
  120. 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
  121. abstract val NoSymbol: Symbol

    A special "missing" symbol

    A special "missing" symbol

    Definition Classes
    Symbols
  122. 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
  123. abstract val NothingTpe: Type

    Definition Classes
    StandardTypes
  124. abstract val NullTpe: Type

    Definition Classes
    StandardTypes
  125. abstract val NullaryMethodType: NullaryMethodTypeExtractor

    The constructor/deconstructor for NullaryMethodType instances.

    The constructor/deconstructor for NullaryMethodType instances.

    Definition Classes
    Types
  126. 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
  127. abstract val ObjectTpe: Type

    Definition Classes
    StandardTypes
  128. abstract val PackageDef: PackageDefExtractor

    The constructor/deconstructor for PackageDef instances.

    The constructor/deconstructor for PackageDef instances.

    Definition Classes
    Trees
  129. 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
  130. abstract val PolyType: PolyTypeExtractor

    The constructor/deconstructor for PolyType instances.

    The constructor/deconstructor for PolyType instances.

    Definition Classes
    Types
  131. 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
  132. 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
  133. 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
  134. abstract val ReferenceToBoxed: ReferenceToBoxedExtractor

    The constructor/deconstructor for ReferenceToBoxed instances.

    The constructor/deconstructor for ReferenceToBoxed instances.

    Definition Classes
    Trees
  135. 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
  136. abstract val RefinedType: RefinedTypeExtractor

    The constructor/deconstructor for RefinedType instances.

    The constructor/deconstructor for RefinedType instances.

    Definition Classes
    Types
  137. 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
  138. abstract val Return: ReturnExtractor

    The constructor/deconstructor for Return instances.

    The constructor/deconstructor for Return instances.

    Definition Classes
    Trees
  139. 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
  140. 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
  141. abstract def Select(qualifier: Tree, sym: Symbol): Select

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

    Definition Classes
    Trees
  143. abstract val Select: SelectExtractor

    The constructor/deconstructor for Select instances.

    The constructor/deconstructor for Select instances.

    Definition Classes
    Trees
  144. abstract val SelectFromTypeTree: SelectFromTypeTreeExtractor

    The constructor/deconstructor for SelectFromTypeTree instances.

    The constructor/deconstructor for SelectFromTypeTree instances.

    Definition Classes
    Trees
  145. 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
  146. 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
  147. abstract val ShortTpe: Type

    Definition Classes
    StandardTypes
  148. abstract val SingleType: SingleTypeExtractor

    The constructor/deconstructor for SingleType instances.

    The constructor/deconstructor for SingleType instances.

    Definition Classes
    Types
  149. 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
  150. 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
  151. abstract val SingletonTypeTree: SingletonTypeTreeExtractor

    The constructor/deconstructor for SingletonTypeTree instances.

    The constructor/deconstructor for SingletonTypeTree instances.

    Definition Classes
    Trees
  152. 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
  153. abstract val Star: StarExtractor

    The constructor/deconstructor for Star instances.

    The constructor/deconstructor for Star instances.

    Definition Classes
    Trees
  154. 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
  155. abstract def Super(sym: Symbol, mix: TypeName): Tree

    Definition Classes
    Trees
  156. abstract val Super: SuperExtractor

    The constructor/deconstructor for Super instances.

    The constructor/deconstructor for Super instances.

    Definition Classes
    Trees
  157. 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
  158. abstract val SuperType: SuperTypeExtractor

    The constructor/deconstructor for SuperType instances.

    The constructor/deconstructor for SuperType instances.

    Definition Classes
    Types
  159. 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
  160. 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
  161. 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
  162. abstract val Template: TemplateExtractor

    The constructor/deconstructor for Template instances.

    The constructor/deconstructor for Template instances.

    Definition Classes
    Trees
  163. 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
  164. implicit abstract val TermNameTag: ClassTag[TermName]

    Definition Classes
    Names
  165. 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
  166. 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
  167. abstract def This(sym: Symbol): Tree

    Definition Classes
    Trees
  168. abstract val This: ThisExtractor

    The constructor/deconstructor for This instances.

    The constructor/deconstructor for This instances.

    Definition Classes
    Trees
  169. 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
  170. abstract val ThisType: ThisTypeExtractor

    The constructor/deconstructor for ThisType instances.

    The constructor/deconstructor for ThisType instances.

    Definition Classes
    Types
  171. 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
  172. abstract def Throw(tpe: Type, args: Tree*): Throw

    Definition Classes
    Trees
  173. abstract val Throw: ThrowExtractor

    The constructor/deconstructor for Throw instances.

    The constructor/deconstructor for Throw instances.

    Definition Classes
    Trees
  174. 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
  175. 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
  176. abstract def Try(body: Tree, cases: (Tree, Tree)*): Try

    Definition Classes
    Trees
  177. abstract val Try: TryExtractor

    The constructor/deconstructor for Try instances.

    The constructor/deconstructor for Try instances.

    Definition Classes
    Trees
  178. 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
  179. 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
  180. abstract val TypeApply: TypeApplyExtractor

    The constructor/deconstructor for TypeApply instances.

    The constructor/deconstructor for TypeApply instances.

    Definition Classes
    Trees
  181. 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
  182. abstract val TypeBounds: TypeBoundsExtractor

    The constructor/deconstructor for TypeBounds instances.

    The constructor/deconstructor for TypeBounds instances.

    Definition Classes
    Types
  183. 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
  184. abstract val TypeBoundsTree: TypeBoundsTreeExtractor

    The constructor/deconstructor for TypeBoundsTree instances.

    The constructor/deconstructor for TypeBoundsTree instances.

    Definition Classes
    Trees
  185. 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
  186. 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
  187. 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
  188. abstract val TypeDef: TypeDefExtractor

    The constructor/deconstructor for TypeDef instances.

    The constructor/deconstructor for TypeDef instances.

    Definition Classes
    Trees
  189. 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
  190. implicit abstract val TypeNameTag: ClassTag[TypeName]

    Definition Classes
    Names
  191. abstract val TypeRef: TypeRefExtractor

    The constructor/deconstructor for TypeRef instances.

    The constructor/deconstructor for TypeRef instances.

    Definition Classes
    Types
  192. 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
  193. 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
  194. 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
  195. abstract def TypeTree(tp: Type): TypeTree

    Definition Classes
    Trees
  196. abstract val TypeTree: TypeTreeExtractor

    The constructor/deconstructor for TypeTree instances.

    The constructor/deconstructor for TypeTree instances.

    Definition Classes
    Trees
  197. 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
  198. abstract val Typed: TypedExtractor

    The constructor/deconstructor for Typed instances.

    The constructor/deconstructor for Typed instances.

    Definition Classes
    Trees
  199. 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
  200. abstract val UnApply: UnApplyExtractor

    The constructor/deconstructor for UnApply instances.

    The constructor/deconstructor for UnApply instances.

    Definition Classes
    Trees
  201. 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
  202. abstract val UnitTpe: Type

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

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

    Definition Classes
    Trees
  205. abstract val ValDef: ValDefExtractor

    The constructor/deconstructor for ValDef instances.

    The constructor/deconstructor for ValDef instances.

    Definition Classes
    Trees
  206. 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
  207. 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
  208. 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
  209. 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
  210. abstract val build: BuildBase

    Definition Classes
    BuildUtils
  211. abstract val definitions: DefinitionsBase

    Definition Classes
    StandardDefinitions
  212. 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
  213. abstract def newScope: Scope

    Create a new scope

    Create a new scope

    Definition Classes
    Scopes
  214. 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
  215. abstract def newTermName(s: String): TermName

    Create a new term name.

    Create a new term name.

    Definition Classes
    Names
  216. abstract def newTypeName(s: String): TypeName

    Creates a new type name.

    Creates a new type name.

    Definition Classes
    Names
  217. abstract val nme: TermNamesBase

    Definition Classes
    StandardNames
  218. abstract val rootMirror: Mirror

    .

    ..

    Definition Classes
    Mirrors
  219. abstract val tpnme: TypeNamesBase

    Definition Classes
    StandardNames
  220. abstract def treeToString(tree: Tree): String

    Obtains string representation of a tree

    Obtains string representation of a tree

    Attributes
    protected
    Definition Classes
    Trees

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. def EmptyTermName: TermName

    Definition Classes
    Names
  10. def EmptyTypeName: TypeName

    Definition Classes
    Names
  11. def Modifiers(flags: FlagSet): Modifiers

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

    Definition Classes
    Trees
  13. lazy val NoMods: Modifiers

    .

    ...

    Definition Classes
    Trees
  14. object TypeTag extends Serializable

    Definition Classes
    TypeTags
  15. 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.

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

  17. 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
  18. 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
  19. 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
  20. 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
  21. 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
  22. 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
  23. 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

  24. 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()
  25. 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

  26. 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
  27. 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
  28. def manifestToTypeTag[T](mirror: Any, manifest: Manifest[T]): TypeTag[T]

    Definition Classes
    TagInterop
  29. 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
  30. 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

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

  32. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  33. 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
  34. def typeOf[T](implicit ttag: TypeTag[T]): Type

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

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

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

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws()
  40. 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 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]