Trees

Type Members

1. abstract type Alternative >: Null <: Universe.AlternativeApi with Universe.TermTree

   

   Alternatives of patterns.

   Alternatives of patterns.

   Eliminated by compiler phases Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher), except for occurrences in encoded Switch stmt (i.e. remaining Match(CaseDef(...)))

2. trait AlternativeApi extends Universe.TermTreeApi

   

   The API that all alternatives support

3. abstract class AlternativeExtractor extends AnyRef

   

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

   An extractor class to create and pattern match with syntax Alternative(trees). This AST node corresponds to the following Scala code:

   pat1 | ... | patn

4. abstract type Annotated >: Null <: Universe.AnnotatedApi with Universe.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.

5. trait AnnotatedApi extends Universe.TreeApi

   

   The API that all annotateds support

6. abstract class AnnotatedExtractor extends AnyRef

   

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

   An extractor class to create and pattern match with syntax Annotated(annot, arg). This AST node corresponds to the following Scala code:

   arg @annot // for types arg: @annot // for exprs

7. abstract type AppliedTypeTree >: Null <: Universe.AppliedTypeTreeApi with Universe.TypTree

   

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

8. trait AppliedTypeTreeApi extends Universe.TypTreeApi

   

   The API that all applied type trees support

9. abstract class AppliedTypeTreeExtractor extends AnyRef

   

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

   An extractor class to create and pattern match with syntax AppliedTypeTree(tpt, args). This AST node corresponds to the following Scala code:

   tpt[args]

   Should only be used with tpt nodes which are types, i.e. which have isType returning true. Otherwise TypeApply should be used instead.

   List[Int] as in val x: List[Int] = ??? // represented as AppliedTypeTree(Ident(<List>), List(TypeTree(<Int>)))

   def foo[T] = ??? foo[Int] // represented as TypeApply(Ident(<foo>), List(TypeTree(<Int>)))

10. abstract type Apply >: Null <: Universe.ApplyApi with Universe.GenericApply

    

    Value application

11. trait ApplyApi extends Universe.GenericApplyApi

    

    The API that all applies support

12. abstract class ApplyExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax Apply(fun, args). This AST node corresponds to the following Scala code:

    fun(args)

    For instance:

    fun[targs](args)

    Is expressed as:

    Apply(TypeApply(fun, targs), args)

13. abstract type Assign >: Null <: Universe.AssignApi with Universe.TermTree

    

    Assignment

14. trait AssignApi extends Universe.TermTreeApi

    

    The API that all assigns support

15. abstract class AssignExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax Assign(lhs, rhs). This AST node corresponds to the following Scala code:

    lhs = rhs

16. abstract type AssignOrNamedArg >: Null <: Universe.AssignOrNamedArgApi with Universe.TermTree

    

    Either an assignment or a named argument.

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

17. trait AssignOrNamedArgApi extends Universe.TermTreeApi

    

    The API that all assigns support

18. abstract class AssignOrNamedArgExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax AssignOrNamedArg(lhs, rhs). This AST node corresponds to the following Scala code:

    m.f(lhs = rhs)

    @annotation(lhs = rhs)

19. abstract type Bind >: Null <: Universe.BindApi with Universe.DefTree

    

    Bind a variable to a rhs pattern.

    Bind a variable to a rhs pattern.

    Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher).

20. trait BindApi extends Universe.DefTreeApi

    

    The API that all binds support

21. abstract class BindExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax Bind(name, body). This AST node corresponds to the following Scala code:

    pat*

22. abstract type Block >: Null <: Universe.BlockApi with Universe.TermTree

    

    Block of expressions (semicolon separated expressions)

23. trait BlockApi extends Universe.TermTreeApi

    

    The API that all blocks support

24. abstract class BlockExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax Block(stats, expr). This AST node corresponds to the following Scala code:

    { stats; expr }

    If the block is empty, the expr is set to Literal(Constant(())).

25. abstract type CaseDef >: Null <: Universe.CaseDefApi with Universe.Tree

    

    Case clause in a pattern match.

    Case clause in a pattern match. (except for occurrences in switch statements). Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher)

26. trait CaseDefApi extends Universe.TreeApi

    

    The API that all case defs support

27. abstract class CaseDefExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax CaseDef(pat, guard, body). This AST node corresponds to the following Scala code:

    case pat if guard => body

    If the guard is not present, the guard is set to EmptyTree. If the body is not specified, the body is set to Literal(Constant(()))

28. abstract type ClassDef >: Null <: Universe.ClassDefApi with Universe.ImplDef

    

    A class definition.

29. trait ClassDefApi extends Universe.ImplDefApi

    

    The API that all class defs support

30. abstract class ClassDefExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax ClassDef(mods, name, tparams, impl). This AST node corresponds to the following Scala code:

    mods class name [tparams] impl

    Where impl stands for:

    extends parents { defs }

31. abstract type CompoundTypeTree >: Null <: Universe.CompoundTypeTreeApi with Universe.TypTree

    

    Intersection type <parent1> with ...

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

32. trait CompoundTypeTreeApi extends Universe.TypTreeApi

    

    The API that all compound type trees support

33. abstract class CompoundTypeTreeExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax CompoundTypeTree(templ). This AST node corresponds to the following Scala code:

    parent1 with ... with parentN { refinement }

34. abstract type DefDef >: Null <: Universe.DefDefApi with Universe.ValOrDefDef

    

    A method or macro definition.

35. trait DefDefApi extends Universe.ValOrDefDefApi

    

    The API that all def defs support

36. abstract class DefDefExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax DefDef(mods, name, tparams, vparamss, tpt, rhs). This AST node corresponds to the following Scala code:

    mods def name[tparams](vparams_1)...(vparams_n): tpt = rhs

    If the return type is not specified explicitly (i.e. is meant to be inferred), this is expressed by having tpt set to TypeTree() (but not to an EmptyTree!).

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

    

    A tree representing a symbol-defining entity: 1) A declaration or a definition (type, class, object, package, val, var, or def) 2) Bind that is used to represent binding occurrences in pattern matches 3) LabelDef that is used internally to represent while loops

38. trait DefTreeApi extends Universe.SymTreeApi with Universe.NameTreeApi

    

    The API that all def trees support

39. abstract type ExistentialTypeTree >: Null <: Universe.ExistentialTypeTreeApi with Universe.TypTree

    

    Existential type tree node

40. trait ExistentialTypeTreeApi extends Universe.TypTreeApi

    

    The API that all existential type trees support

41. abstract class ExistentialTypeTreeExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax ExistentialTypeTree(tpt, whereClauses). This AST node corresponds to the following Scala code:

    tpt forSome { whereClauses }

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

    

    Anonymous function, eliminated by compiler phase lambdalift

43. trait FunctionApi extends Universe.TermTreeApi with Universe.SymTreeApi

    

    The API that all functions support

44. abstract class FunctionExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax Function(vparams, body). This AST node corresponds to the following Scala code:

    vparams => body

    The symbol of a Function is a synthetic TermSymbol. It is the owner of the function's parameters.

45. abstract type GenericApply >: Null <: Universe.GenericApplyApi with Universe.TermTree

    

    Common base class for Apply and TypeApply.

46. trait GenericApplyApi extends Universe.TermTreeApi

    

    The API that all applies support

47. abstract type Ident >: Null <: Universe.IdentApi with Universe.RefTree

    

    A reference to identifier name.

48. trait IdentApi extends Universe.RefTreeApi

    

    The API that all idents support

49. abstract class IdentExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax Ident(qual, name). This AST node corresponds to the following Scala code:

    name

    Type checker converts idents that refer to enclosing fields or methods to selects. For example, name ==> this.name

50. abstract type If >: Null <: Universe.IfApi with Universe.TermTree

    

    Conditional expression

51. trait IfApi extends Universe.TermTreeApi

    

    The API that all ifs support

52. abstract class IfExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax If(cond, thenp, elsep). This AST node corresponds to the following Scala code:

    if (cond) thenp else elsep

    If the alternative is not present, the elsep is set to Literal(Constant(())).

53. abstract type ImplDef >: Null <: Universe.ImplDefApi with Universe.MemberDef

    

    A common base class for class and object definitions.

54. trait ImplDefApi extends Universe.MemberDefApi

    

    The API that all impl defs support

55. abstract type Import >: Null <: Universe.ImportApi with Universe.SymTree

    

    Import clause

56. trait ImportApi extends Universe.SymTreeApi

    

    The API that all imports support

57. abstract class ImportExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax Import(expr, selectors). This AST node corresponds to the following Scala code:

    import expr.{selectors}

    Selectors are a list of ImportSelectors, which conceptually are pairs of names (from, to). The last (and maybe only name) may be a nme.WILDCARD. For instance:

    import qual.{x, y => z, _}

    Would be represented as:

    Import(qual, List(("x", "x"), ("y", "z"), (WILDCARD, null)))

    The symbol of an Import is an import symbol @see Symbol.newImport. It's used primarily as a marker to check that the import has been typechecked.

58. abstract type ImportSelector >: Null <: Universe.ImportSelectorApi

    

    Import selector (not a tree, but a component of the Import tree)

    Import selector (not a tree, but a component of the Import tree)

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

    Eliminated by typecheck.

59. trait ImportSelectorApi extends AnyRef

    

    The API that all import selectors support

60. abstract class ImportSelectorExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax ImportSelector(name:, namePos, rename, renamePos). This is not an AST node, it is used as a part of the Import node.

61. abstract type LabelDef >: Null <: Universe.LabelDefApi with Universe.DefTree with Universe.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.

62. trait LabelDefApi extends Universe.DefTreeApi with Universe.TermTreeApi

    

    The API that all label defs support

63. abstract class LabelDefExtractor extends AnyRef

    

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

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

    This AST node does not have direct correspondence to Scala code. It is used for tailcalls and like. For example, while/do are desugared to label defs as follows:

    while (cond) body ==> LabelDef($L, List(), if (cond) { body; L$() } else ())

    do body while (cond) ==> LabelDef($L, List(), body; if (cond) L$() else ())

64. abstract type Literal >: Null <: Universe.LiteralApi with Universe.TermTree

    

    Literal

65. trait LiteralApi extends Universe.TermTreeApi

    

    The API that all literals support

66. abstract class LiteralExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax Literal(value). This AST node corresponds to the following Scala code:

    value

67. abstract type Match >: Null <: Universe.MatchApi with Universe.TermTree

    

    - Pattern matching expression (before compiler phase explicitouter before 2.10 / patmat from 2.10)

    - Pattern matching expression (before compiler phase explicitouter before 2.10 / patmat from 2.10)

    • Switch statements (after compiler phase explicitouter before 2.10 / patmat from 2.10)

    After compiler phase explicitouter before 2.10 / patmat from 2.10, 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)

68. trait MatchApi extends Universe.TermTreeApi

    

    The API that all matches support

69. abstract class MatchExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax Match(selector, cases). This AST node corresponds to the following Scala code:

    selector match { cases }

    Match is also used in pattern matching assignments like val (foo, bar) = baz.

70. abstract type MemberDef >: Null <: Universe.MemberDefApi with Universe.DefTree

    

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

71. trait MemberDefApi extends Universe.DefTreeApi

    

    The API that all member defs support

72. abstract type Modifiers >: Null <: Universe.ModifiersApi

    

    The type of tree modifiers (not a tree, but rather part of DefTrees).

73. abstract class ModifiersApi extends AnyRef

    

    The API that all Modifiers support

74. abstract class ModifiersExtractor extends AnyRef

    

    An extractor class to create and pattern match with syntax Modifiers(flags, privateWithin, annotations).

    An extractor class to create and pattern match with syntax Modifiers(flags, privateWithin, annotations). Modifiers encapsulate flags, visibility annotations and Scala annotations for member definitions.

75. abstract type ModuleDef >: Null <: Universe.ModuleDefApi with Universe.ImplDef

    

    An object definition, e.g.

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

76. trait ModuleDefApi extends Universe.ImplDefApi

    

    The API that all module defs support

77. abstract class ModuleDefExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax ModuleDef(mods, name, impl). This AST node corresponds to the following Scala code:

    mods object name impl

    Where impl stands for:

    extends parents { defs }

78. abstract type NameTree >: Null <: Universe.NameTreeApi with Universe.Tree

    

    A tree that carries a name, e.g.

    A tree that carries a name, e.g. by defining it (DefTree) or by referring to it (RefTree).

79. trait NameTreeApi extends Universe.TreeApi

    

    The API that all name trees support

80. abstract type New >: Null <: Universe.NewApi with Universe.TermTree

    

    Object instantiation

81. trait NewApi extends Universe.TermTreeApi

    

    The API that all news support

82. abstract class NewExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax New(tpt). This AST node corresponds to the following Scala code:

    new T

    This node always occurs in the following context:

    (new tpt).<init>[targs](args)

    For example, an AST representation of:

    new Example[Int](2)(3)

    is the following code:

    Apply( Apply( TypeApply( Select(New(TypeTree(typeOf[Example])), nme.CONSTRUCTOR) TypeTree(typeOf[Int])), List(Literal(Constant(2)))), List(Literal(Constant(3))))

83. abstract type PackageDef >: Null <: Universe.PackageDefApi with Universe.MemberDef

    

    A packaging, such as package pid { stats }

84. trait PackageDefApi extends Universe.MemberDefApi

    

    The API that all package defs support

85. abstract class PackageDefExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax PackageDef(pid, stats). This AST node corresponds to the following Scala code:

    package pid { stats }

86. abstract type RefTree >: Null <: Universe.RefTreeApi with Universe.SymTree with Universe.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.

87. trait RefTreeApi extends Universe.SymTreeApi with Universe.NameTreeApi

    

    The API that all ref trees support

88. abstract class RefTreeExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax RefTree(qual, name). This AST node corresponds to either Ident, Select or SelectFromTypeTree.

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

    

    Return expression

90. trait ReturnApi extends Universe.TermTreeApi

    

    The API that all returns support

91. abstract class ReturnExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax Return(expr). This AST node corresponds to the following Scala code:

    return expr

    The symbol of a Return node is the enclosing method.

92. abstract type Select >: Null <: Universe.SelectApi with Universe.RefTree

    

    A member selection <qualifier> .

    A member selection <qualifier> . <name>

93. trait SelectApi extends Universe.RefTreeApi

    

    The API that all selects support

94. abstract class SelectExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax Select(qual, name). This AST node corresponds to the following Scala code:

    qualifier.selector

    Should only be used with qualifier nodes which are terms, i.e. which have isTerm returning true. Otherwise SelectFromTypeTree should be used instead.

    foo.Bar // represented as Select(Ident(<foo>), <Bar>) Foo#Bar // represented as SelectFromTypeTree(Ident(<Foo>), <Bar>)

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

    

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

96. trait SelectFromTypeTreeApi extends Universe.TypTreeApi with Universe.RefTreeApi

    

    The API that all selects from type trees support

97. abstract class SelectFromTypeTreeExtractor extends AnyRef

    

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

    An extractor class to create and pattern match with syntax SelectFromTypeTree(qualifier, name). This AST node corresponds to the following Scala code:

    qualifier # selector

    Note: a path-dependent type p.T is expressed as p.type # T

    Should only be used with qualifier nodes which are types, i.e. which have isType returning true. Otherwise Select should be used instead.

    Foo#Bar // represented as SelectFromTypeTree(Ident(<Foo>), <Bar>) foo.Bar // represented as Select(Ident(<foo>), <Bar>)

98. abstract type SingletonTypeTree >: Null <: Universe.SingletonTypeTreeApi with Universe.TypTree

    

    Singleton type, eliminated by RefCheck

99. trait SingletonTypeTreeApi extends Universe.TypTreeApi

    

    The API that all singleton type trees support

100. abstract class SingletonTypeTreeExtractor extends AnyRef

     

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

     An extractor class to create and pattern match with syntax SingletonTypeTree(ref). This AST node corresponds to the following Scala code:

     ref.type

101. abstract type Star >: Null <: Universe.StarApi with Universe.TermTree

     

     Repetition of pattern.

     Repetition of pattern.

     Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher).

102. trait StarApi extends Universe.TermTreeApi

     

     The API that all stars support

103. abstract class StarExtractor extends AnyRef

     

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

     An extractor class to create and pattern match with syntax Star(elem). This AST node corresponds to the following Scala code:

     pat*

104. abstract type Super >: Null <: Universe.SuperApi with Universe.TermTree

     

     Super reference, where qual is the corresponding this reference.

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

105. trait SuperApi extends Universe.TermTreeApi

     

     The API that all supers support

106. abstract class SuperExtractor extends AnyRef

     

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

     An extractor class to create and pattern match with syntax Super(qual, mix). This AST node corresponds to the following Scala code:

     C.super[M]

     Which is represented as:

     Super(This(C), M)

     If mix is empty, it is tpnme.EMPTY.

     The symbol of a Super is the class _from_ which the super reference is made. For instance in C.super(...), it would be C.

107. abstract type SymTree >: Null <: Universe.SymTreeApi with Universe.Tree

     

     A tree that carries a symbol, e.g.

     A tree that carries a symbol, e.g. by defining it (DefTree) or by referring to it (RefTree). Such trees start their life naked, returning NoSymbol, but after being typechecked without errors they hold non-empty symbols.

108. trait SymTreeApi extends Universe.TreeApi

     

     The API that all sym trees support

109. abstract type Template >: Null <: Universe.TemplateApi with Universe.SymTree

     

     Instantiation template of a class or trait

110. trait TemplateApi extends Universe.SymTreeApi

     

     The API that all templates support

111. abstract class TemplateExtractor extends AnyRef

     

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

     An extractor class to create and pattern match with syntax Template(parents, self, body). This AST node corresponds to the following Scala code:

     extends parents { self => body }

     In case when the self-type annotation is missing, it is represented as an empty value definition with nme.WILDCARD as name and NoType as type.

     The symbol of a template is a local dummy. @see Symbol.newLocalDummy The owner of the local dummy is the enclosing trait or class. The local dummy is itself the owner of any local blocks. For example:

     class C { def foo { // owner is C def bar // owner is local dummy } }

112. abstract type TermTree >: Null <: Universe.TermTreeApi with Universe.Tree

     

     A tree for a term.

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

113. trait TermTreeApi extends Universe.TreeApi

     

     The API that all term trees support

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

     

     Self reference

115. trait ThisApi extends Universe.TermTreeApi with Universe.SymTreeApi

     

     The API that all thises support

116. abstract class ThisExtractor extends AnyRef

     

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

     An extractor class to create and pattern match with syntax This(qual). This AST node corresponds to the following Scala code:

     qual.this

     The symbol of a This is the class to which the this refers. For instance in C.this, it would be C.

117. abstract type Throw >: Null <: Universe.ThrowApi with Universe.TermTree

     

     Throw expression

118. trait ThrowApi extends Universe.TermTreeApi

     

     The API that all tries support

119. abstract class ThrowExtractor extends AnyRef

     

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

     An extractor class to create and pattern match with syntax Throw(expr). This AST node corresponds to the following Scala code:

     throw expr

120. abstract class Transformer extends AnyRef

     

     A class that implement a default tree transformation strategy: breadth-first component-wise cloning.

121. class Traverser extends AnyRef

     

     A class that implement a default tree traversal strategy: breadth-first component-wise.

122. abstract type Tree >: Null <: Universe.TreeApi

     

     The type of Scala abstract syntax trees.

123. trait TreeApi extends Product

     

     The API that all trees support.

     The API that all trees support. The main source of information about trees is the scala.reflect.api.Trees page.

124. abstract type TreeCopier >: Null <: Universe.TreeCopierOps

     

     The type of standard (lazy) tree copiers.

125. abstract class TreeCopierOps extends AnyRef

     

     The API of a tree copier.

126. abstract type Try >: Null <: Universe.TryApi with Universe.TermTree

     

     Try catch node

127. trait TryApi extends Universe.TermTreeApi

     

     The API that all tries support

128. abstract class TryExtractor extends AnyRef

     

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

     An extractor class to create and pattern match with syntax Try(block, catches, finalizer). This AST node corresponds to the following Scala code:

     try block catch { catches } finally finalizer

     If the finalizer is not present, the finalizer is set to EmptyTree.

129. abstract type TypTree >: Null <: Universe.TypTreeApi with Universe.Tree

     

     A tree for a type.

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

130. trait TypTreeApi extends Universe.TreeApi

     

     The API that all typ trees support

131. abstract type TypeApply >: Null <: Universe.TypeApplyApi with Universe.GenericApply

     

     Explicit type application.

132. trait TypeApplyApi extends Universe.GenericApplyApi

     

     The API that all type applies support

133. abstract class TypeApplyExtractor extends AnyRef

     

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

     An extractor class to create and pattern match with syntax TypeApply(fun, args). This AST node corresponds to the following Scala code:

     fun[args]

     Should only be used with fun nodes which are terms, i.e. which have isTerm returning true. Otherwise AppliedTypeTree should be used instead.

     def foo[T] = ??? foo[Int] // represented as TypeApply(Ident(<foo>), List(TypeTree(<Int>)))

     List[Int] as in val x: List[Int] = ??? // represented as AppliedTypeTree(Ident(<List>), List(TypeTree(<Int>)))

134. abstract type TypeBoundsTree >: Null <: Universe.TypeBoundsTreeApi with Universe.TypTree

     

     Type bounds tree node

135. trait TypeBoundsTreeApi extends Universe.TypTreeApi

     

     The API that all type bound trees support

136. abstract class TypeBoundsTreeExtractor extends AnyRef

     

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

     An extractor class to create and pattern match with syntax TypeBoundsTree(lo, hi). This AST node corresponds to the following Scala code:

     >: lo <: hi

137. abstract type TypeDef >: Null <: Universe.TypeDefApi with Universe.MemberDef

     

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

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

138. trait TypeDefApi extends Universe.MemberDefApi

     

     The API that all type defs support

139. abstract class TypeDefExtractor extends AnyRef

     

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

     An extractor class to create and pattern match with syntax TypeDef(mods, name, tparams, rhs). This AST node corresponds to the following Scala code:

     mods type name[tparams] = rhs

     mods type name[tparams] >: lo <: hi

     First usage illustrates TypeDefs representing type aliases and type parameters. Second usage illustrates TypeDefs representing abstract types, where lo and hi are both TypeBoundsTrees and Modifier.deferred is set in mods.

140. abstract type TypeTree >: Null <: Universe.TypeTreeApi with Universe.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.

141. trait TypeTreeApi extends Universe.TypTreeApi

     

     The API that all type trees support

142. abstract class TypeTreeExtractor extends AnyRef

     

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

     An extractor class to create and pattern match with syntax TypeTree(). This AST node does not have direct correspondence to Scala code, and is emitted by everywhere when we want to wrap a Type in a Tree.

143. abstract type Typed >: Null <: Universe.TypedApi with Universe.TermTree

     

     Type annotation, eliminated by compiler phase cleanup

144. trait TypedApi extends Universe.TermTreeApi

     

     The API that all typeds support

145. abstract class TypedExtractor extends AnyRef

     

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

     An extractor class to create and pattern match with syntax Typed(expr, tpt). This AST node corresponds to the following Scala code:

     expr: tpt

146. abstract type UnApply >: Null <: Universe.UnApplyApi with Universe.TermTree

     

     Used to represent unapply methods in pattern matching.

     Used to represent unapply methods in pattern matching.

     For example:

     2 match { case Foo(x) => x }

     Is represented as:

     Match(
       Literal(Constant(2)),
       List(
         CaseDef(
           UnApply(
             // a dummy node that carries the type of unapplication to patmat
             // the  here doesn't have an underlying symbol
             // it only has a type assigned, therefore after `untypecheck` this tree is no longer typeable
             Apply(Select(Ident(Foo), TermName("unapply")), List(Ident(TermName("")))),
             // arguments of the unapply => nothing synthetic here
             List(Bind(TermName("x"), Ident(nme.WILDCARD)))),
           EmptyTree,
           Ident(TermName("x")))))

     Introduced by typer. Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher).

147. trait UnApplyApi extends Universe.TermTreeApi

     

     The API that all unapplies support

148. abstract class UnApplyExtractor extends AnyRef

     

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

     An extractor class to create and pattern match with syntax UnApply(fun, args). This AST node does not have direct correspondence to Scala code, and is introduced when typechecking pattern matches and try blocks.

149. abstract type ValDef >: Null <: Universe.ValDefApi with Universe.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 scala.reflect.api.Trees#DefDef - the PARAM flag is set in mods
     • explicit self-types, e.g. class A { self: Bar => }

150. trait ValDefApi extends Universe.ValOrDefDefApi

     

     The API that all val defs support

151. abstract class ValDefExtractor extends AnyRef

     

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

     An extractor class to create and pattern match with syntax ValDef(mods, name, tpt, rhs). This AST node corresponds to any of the following Scala code:

     mods val name: tpt = rhs

     mods var name: tpt = rhs

     mods name: tpt = rhs // in signatures of function and method definitions

     self: Bar => // self-types

     If the type of a value is not specified explicitly (i.e. is meant to be inferred), this is expressed by having tpt set to TypeTree() (but not to an EmptyTree!).

152. abstract type ValOrDefDef >: Null <: Universe.ValOrDefDefApi with Universe.MemberDef

     

     A common base class for ValDefs and DefDefs.

153. trait ValOrDefDefApi extends Universe.MemberDefApi

     

     The API that all val defs and def defs support

154. type ModifiersCreator = Universe.ModifiersExtractor

     

     Annotations

     @deprecated

     Deprecated

     (Since version 2.11.0) Use ModifiersExtractor instead