treehugger.api

Universe

abstract class Universe extends Symbols with Types with Constants with Scopes with Names with Trees with AnnotationInfos with StandardDefinitions with TreePrinters

Linear Supertypes
Known Subclasses
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Hide All
  2. Show all
  1. Universe
  2. TreePrinters
  3. StandardDefinitions
  4. AnnotationInfos
  5. Trees
  6. Names
  7. Scopes
  8. Constants
  9. Types
  10. Symbols
  11. AnyRef
  12. Any
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Universe()

Type Members

  1. abstract class AbsAnnotationInfo extends AnyRef

  2. trait AbsCompoundType extends AbsType

    This class declares methods that are visible in a CompoundType (i.

  3. abstract class AbsConstant extends AnyRef

  4. abstract class AbsDefinitions extends AnyRef

  5. abstract class AbsModifiers extends AnyRef

  6. trait AbsSingletonType extends AbsType

    This class declares methods that are visible in a SingleType.

  7. abstract class AbsSymbol extends AnyRef

  8. abstract class AbsType extends AnyRef

    This class declares operations that are visible in a Type.

  9. case class Alternative(trees: List[Tree]) extends Tree with TermTree with Product with Serializable

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

  10. case class Annotated(annot: Tree, arg: Tree) extends Tree with Product with Serializable

    A tree that has an annotation attached to it.

  11. abstract type AnnotatedType <: Type

    Definition Classes
    Types
  12. abstract class AnnotatedTypeExtractor extends AnyRef

  13. abstract type AnnotationInfo <: AbsAnnotationInfo

    Definition Classes
    AnnotationInfos
  14. abstract class AnnotationInfoExtractor extends AnyRef

  15. abstract type AnnotationType

    Definition Classes
    Trees
  16. case class AnonFunc(vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree) extends Tree with FuncTree with Product with Serializable

  17. case class AppliedTypeTree(tpt: Tree, args: List[Tree]) extends Tree with TypTree with Product with Serializable

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

  18. case class Apply(fun: Tree, args: List[Tree]) extends GenericApply with Product with Serializable

    Value application

  19. case class ApplyDynamic(qual: Tree, args: List[Tree]) extends Tree with TermTree with SymTree with Product with Serializable

    Dynamic value application.

  20. class ApplyImplicitView extends Apply

  21. class ApplyToImplicitArgs extends Apply

  22. case class ArrayValue(elemtpt: Tree, elems: List[Tree]) extends Tree with TermTree with Product with Serializable

    Array of expressions, needs to be translated in backend,

  23. case class Assign(lhs: Tree, rhs: Tree) extends Tree with TermTree with Product with Serializable

    Assignment

  24. class BackQuotedIdent extends Ident

  25. case class Bind(name: Name, body: Tree) extends DefTree with Product with Serializable

    Bind of a variable to a rhs pattern, eliminated by explicitouter

  26. case class Block(stats: List[Tree], expr: Tree) extends Tree with TermTree with Product with Serializable

    Block of expressions (semicolon separated expressions)

  27. case class CaseDef(pat: Tree, guard: Tree, body: Tree) extends Tree with Product with Serializable

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

  28. case class ClassDef(mods: Modifiers, ctormods: Modifiers, name: TypeName, tparams: List[TypeDef], vparams: List[ValDef], impl: Template) extends ImplDef with Product with Serializable

    A class definition.

  29. abstract type ClassInfoType <: 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
  30. 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.

  31. abstract type ClassfileAnnotArg <: AnyRef

    Definition Classes
    AnnotationInfos
  32. case class Commented(mods: Modifiers, comment: List[String], expr: Tree) extends Tree with Product with Serializable

    Commented expression

  33. abstract type CompoundType <: 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
  34. case class CompoundTypeTree(templ: Template) extends Tree with TypTree with Product with Serializable

    Intersection type <parent1> with .

  35. abstract type Constant <: AbsConstant

    Definition Classes
    Constants
  36. abstract class ConstantExtractor extends AnyRef

  37. abstract type ConstantType <: 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
  38. 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.

  39. case class DefDef(mods: Modifiers, name: Name, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree) extends ValOrDefDef with Product with Serializable

    A method or macro definition.

  40. abstract class DefTree extends Tree with SymTree

    A tree which defines a symbol-carrying entity.

  41. sealed trait Enumerator extends Tree

  42. abstract type ExistentialType <: Type

    Definition Classes
    Types
  43. abstract class ExistentialTypeExtractor extends AnyRef

  44. case class ExistentialTypeTree(tpt: Tree, whereClauses: List[Tree]) extends Tree with TypTree with Product with Serializable

  45. class FilterTreeTraverser extends Traverser

  46. class FindTreeTraverser extends Traverser

  47. case class ForFilter(pos: Position, test: Tree) extends Tree with Enumerator with Product with Serializable

  48. case class ForTree(enums: List[Enumerator], body: Tree) extends Tree with Product with Serializable

  49. case class ForValDef(pos: Position, name: TermName, tpt: Tree, rhs: Tree) extends ValOrDefDef with Enumerator with Product with Serializable

  50. case class ForValFrom(pos: Position, name: TermName, tpt: Tree, rhs: Tree) extends ValOrDefDef with Enumerator with Product with Serializable

  51. case class ForYieldTree(enums: List[Enumerator], body: Tree) extends Tree with Product with Serializable

  52. class ForeachTreeTraverser extends Traverser

  53. trait FuncTree extends Tree with TermTree

    A tree for a function expression.

  54. case class Function(vparams: List[ValDef], body: Tree) extends Tree with TermTree with SymTree with Product with Serializable

    Anonymous function, eliminated by analyzer

  55. abstract class GenericApply extends Tree with TermTree

    Common base class for Apply and TypeApply.

  56. case class Ident(name: Name) extends Tree with RefTree with Product with Serializable

    Identifier <name>

  57. case class If(cond: Tree, thenp: Tree, elsep: Tree) extends Tree with TermTree with Product with Serializable

    Conditional expression

  58. abstract class ImplDef extends MemberDef

    A common base class for class and object definitions.

  59. case class Import(expr: Tree, selectors: List[ImportSelector]) extends Tree with SymTree with Product with Serializable

    Import clause

  60. case class ImportSelector(name: Name, namePos: Int, rename: Name, renamePos: Int) extends Product with Serializable

    Import selector

  61. case class Infix(qualifier: Tree, name: Name, args: List[Tree]) extends Tree with Product with Serializable

    Infix application

  62. case class InfixUnApply(qualifier: Tree, name: Name, args: List[Tree]) extends Tree with Product with Serializable

    Infix extraction, for example case x :: rest

  63. case class LabelDef(name: TermName, param: Tree, rhs: Tree) extends DefTree with TermTree with Product with Serializable

    A labelled expression.

  64. class LazyTreeCopier extends TreeCopierOps

  65. case class Literal(value: Constant) extends Tree with TermTree with Product with Serializable

    Literal

  66. case class Match(selector: Tree, cases: List[CaseDef]) extends Tree with TermTree with Product with Serializable

    - Pattern matching expression (before explicitouter)

  67. abstract class MemberDef extends DefTree

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

  68. abstract type MethodType <: 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
  69. 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.

  70. abstract type Modifiers <: AbsModifiers

    Definition Classes
    Trees
  71. case class ModuleDef(mods: Modifiers, name: TermName, impl: Template) extends ImplDef with Product with Serializable

    An object definition, e.

  72. trait Name extends AnyRef

  73. case class New(tpt: Tree) extends Tree with TermTree with Product with Serializable

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

  74. abstract type NullaryMethodType <: Type

    Definition Classes
    Types
  75. abstract class NullaryMethodTypeExtractor extends AnyRef

  76. case class PackageDef(mods: Modifiers, pid: RefTree, stats: List[Tree]) extends MemberDef with Product with Serializable

    A packaging, such as package pid { stats }

  77. abstract type PolyType <: Type

    Definition Classes
    Types
  78. abstract class PolyTypeExtractor extends AnyRef

  79. abstract type Position

  80. class RawTreePrinter extends TreePrinter

  81. trait RefTree extends Tree with SymTree

    A tree which references a symbol-carrying entity.

  82. abstract type RefinedType <: 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
  83. 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.

  84. case class Return(expr: Tree) extends Tree with TermTree with SymTree with Product with Serializable

    Return expression

  85. abstract type Scope

    Definition Classes
    Scopes
  86. case class Select(qualifier: Tree, name: Name) extends Tree with RefTree with Product with Serializable

    Designator <qualifier> .

  87. case class SelectFromTypeTree(qualifier: Tree, name: TypeName) extends Tree with TypTree with RefTree with Product with Serializable

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

  88. abstract type SingleType <: 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
  89. 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.

  90. 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
  91. case class SingletonTypeTree(ref: Tree) extends Tree with TypTree with Product with Serializable

    Singleton type, eliminated by RefCheck

  92. case class Star(elem: Tree) extends Tree with TermTree with Product with Serializable

    Repetition of pattern, eliminated by explicitouter

  93. class StrictTreeCopier extends TreeCopierOps

  94. case class Super(qual: Tree, mix: TypeName) extends Tree with TermTree with Product with Serializable

    Super reference, qual = corresponding this reference

  95. abstract type SuperType <: 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
  96. abstract class SuperTypeExtractor extends AnyRef

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

  97. trait SymTree extends Tree

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

  98. abstract type Symbol >: Null <: AbsSymbol

    Definition Classes
    Symbols
  99. case class Template(parents: List[Tree], self: ValDef, body: List[Tree]) extends Tree with SymTree with Product with Serializable

    Instantiation template of a class or trait

  100. case class TermName(name: String) extends Name with Product with Serializable

  101. trait TermTree extends Tree

    A tree for a term.

  102. case class This(qual: TypeName) extends Tree with TermTree with SymTree with Product with Serializable

    Self reference

  103. abstract type ThisType <: 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
  104. 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.

  105. case class Throw(expr: Tree) extends Tree with TermTree with Product with Serializable

    Throw expression

  106. class Traverser extends AnyRef

  107. abstract class Tree extends Product

    Tree is the basis for scala's abstract syntax.

  108. abstract type TreeCopier <: TreeCopierOps

    Definition Classes
    Trees
  109. trait TreeCopierOps extends AnyRef

  110. trait TreePrinter extends AnyRef

  111. case class Try(block: Tree, catches: List[CaseDef], finalizer: Tree) extends Tree with TermTree with Product with Serializable

  112. trait TypTree extends Tree

    A tree for a type.

  113. abstract type Type >: Null <: AbsType

    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
  114. case class TypeApply(fun: Tree, args: List[Tree]) extends GenericApply with Product with Serializable

    Explicit type application.

  115. abstract type TypeBounds <: 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
  116. 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.

  117. case class TypeBoundsTree(lo: Tree, hi: Tree) extends Tree with TypTree with Product with Serializable

  118. case class TypeDef(mods: Modifiers, name: TypeName, tparams: List[TypeDef], rhs: Tree) extends MemberDef with Product with Serializable

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

  119. case class TypeName(name: String) extends Name with Product with Serializable

  120. abstract type TypeRef <: 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
  121. 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.

  122. case class TypeTree() extends Tree with TypTree with Product with Serializable

    A synthetic tree holding an arbitrary type.

  123. case class Typed(expr: Tree, tpt: Tree) extends Tree with TermTree with Product with Serializable

    Type annotation, eliminated by explicit outer

  124. case class UnApply(fun: Tree, args: List[Tree]) extends Tree with TermTree with Product with Serializable

  125. case class ValDef(mods: Modifiers, lhs: Tree, rhs: Tree) extends ValOrDefDef with Product with Serializable

    A constant value definition (this includes vars as well, which differ from vals only in having the MUTABLE flag set in their Modifiers.

  126. abstract class ValOrDefDef extends MemberDef

    A common base class for ValDefs and DefDefs.

Abstract Value Members

  1. abstract val AnnotatedType: AnnotatedTypeExtractor

    Definition Classes
    Types
  2. abstract val AnnotationInfo: AnnotationInfoExtractor

    Definition Classes
    AnnotationInfos
  3. abstract val ClassInfoType: ClassInfoTypeExtractor

    The constructor/deconstructor for ClassInfoType instances.

    The constructor/deconstructor for ClassInfoType instances.

    Definition Classes
    Types
  4. abstract val Constant: ConstantExtractor

    Definition Classes
    Constants
  5. abstract val ConstantType: ConstantTypeExtractor

    The constructor/deconstructor for ConstantType instances.

    The constructor/deconstructor for ConstantType instances.

    Definition Classes
    Types
  6. abstract val ExistentialType: ExistentialTypeExtractor

    Definition Classes
    Types
  7. abstract val MethodType: MethodTypeExtractor

    The constructor/deconstructor for MethodType instances.

    The constructor/deconstructor for MethodType instances.

    Definition Classes
    Types
  8. abstract def Modifiers(mods: Set[Value] = Set(), privateWithin: Name = EmptyTypeName, annotations: List[AnnotationInfo] = List()): Modifiers

    Definition Classes
    Trees
  9. abstract val NoPosition: Position

  10. 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
  11. abstract val NoSymbol: Symbol

    Definition Classes
    Symbols
  12. 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
  13. abstract val NullaryMethodType: NullaryMethodTypeExtractor

    Definition Classes
    Types
  14. abstract val PolyType: PolyTypeExtractor

    Definition Classes
    Types
  15. abstract val RefinedType: RefinedTypeExtractor

    The constructor/deconstructor for RefinedType instances.

    The constructor/deconstructor for RefinedType instances.

    Definition Classes
    Types
  16. abstract val SingleType: SingleTypeExtractor

    The constructor/deconstructor for SingleType instances.

    The constructor/deconstructor for SingleType instances.

    Definition Classes
    Types
  17. abstract val SuperType: SuperTypeExtractor

    The constructor/deconstructor for SuperType instances.

    The constructor/deconstructor for SuperType instances.

    Definition Classes
    Types
  18. abstract val ThisType: ThisTypeExtractor

    The constructor/deconstructor for ThisType instances.

    The constructor/deconstructor for ThisType instances.

    Definition Classes
    Types
  19. abstract val TypeBounds: TypeBoundsExtractor

    The constructor/deconstructor for TypeBounds instances.

    The constructor/deconstructor for TypeBounds instances.

    Definition Classes
    Types
  20. abstract val TypeRef: TypeRefExtractor

    The constructor/deconstructor for TypeRef instances.

    The constructor/deconstructor for TypeRef instances.

    Definition Classes
    Types
  21. implicit abstract def classfileAnnotArgManifest: ClassManifest[ClassfileAnnotArg]

    Definition Classes
    AnnotationInfos
  22. abstract val definitions: AbsDefinitions

    Definition Classes
    StandardDefinitions
  23. abstract def emptyValDef: ValDef

    Definition Classes
    Trees
  24. abstract def newLazyTreeCopier: TreeCopier

    Definition Classes
    Trees
  25. abstract def newScope(): Scope

    Definition Classes
    Scopes
  26. abstract def newStrictTreeCopier: TreeCopier

    Definition Classes
    Trees
  27. abstract def newTreePrinter(out: PrintWriter): TreePrinter

    Hook to define what show(tree) means.

    Hook to define what show(tree) means.

    Definition Classes
    TreePrinters

Concrete Value Members

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

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

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

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

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

    Definition Classes
    Any
  6. def BackQuotedIdent(sym: Symbol): BackQuotedIdent

    Definition Classes
    Trees
  7. object BackQuotedIdent extends Serializable

  8. object EmptyTree extends Tree with TermTree with Product with Serializable

    The empty tree

  9. def EmptyTypeName: TypeName

    Definition Classes
    Names
  10. def ForFilter(test: Tree): ForFilter

    Definition Classes
    Trees
  11. def ForValDef(name: TermName, tpt: Tree, rhs: Tree): ForValDef

    Definition Classes
    Trees
  12. def ForValFrom(name: TermName, tpt: Tree, rhs: Tree): ForValFrom

    Definition Classes
    Trees
  13. def Ident(sym: Symbol): Ident

    Definition Classes
    Trees
  14. def Infix(qualifier: Tree, sym: Symbol, args: List[Tree]): Infix

    Definition Classes
    Trees
  15. def InfixUnApply(qualifier: Tree, sym: Symbol, args: List[Tree]): InfixUnApply

    Definition Classes
    Trees
  16. def Select(qualifier: Tree, sym: Symbol): Select

    Definition Classes
    Trees
  17. def TypeTree(tp: Type): TypeTree

    Definition Classes
    Trees
  18. def ValDef(mods: Modifiers, name: Name, tpt: Tree, rhs: Tree): ValDef

    Definition Classes
    Trees
  19. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  20. def clone(): AnyRef

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  21. final def eq(arg0: AnyRef): Boolean

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

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

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  24. final def getClass(): java.lang.Class[_]

    Definition Classes
    AnyRef → Any
  25. def hashCode(): Int

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

    Definition Classes
    Any
  27. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  28. def newTermName(name: String): TermName

    Definition Classes
    Names
  29. def newTypeName(name: String): TypeName

    Definition Classes
    Names
  30. final def notify(): Unit

    Definition Classes
    AnyRef
  31. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  32. implicit def promoteTermNamesAsNecessary(name: Name): TermName

    Definition Classes
    Names
  33. def show(tree: Tree, mkPrinter: (PrintWriter) ⇒ TreePrinter = newTreePrinter): String

    Definition Classes
    TreePrinters
  34. def showRaw(tree: Tree): String

    Definition Classes
    TreePrinters
  35. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  36. def toString(): String

    Definition Classes
    AnyRef → Any
  37. val treeCopy: TreeCopier

    Definition Classes
    Trees
  38. final def wait(): Unit

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws()
  41. def xtraverse(traverser: Traverser, tree: Tree): Unit

    Attributes
    protected
    Definition Classes
    Trees

Inherited from TreePrinters

Inherited from StandardDefinitions

Inherited from AnnotationInfos

Inherited from Trees

Inherited from Names

Inherited from Scopes

Inherited from Constants

Inherited from Types

Inherited from Symbols

Inherited from AnyRef

Inherited from Any