Trees

abstract def newLazyTreeCopier: TreeCopier

abstract def newStrictTreeCopier: TreeCopier

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (Trees, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def Apply(sym: Symbol, args: Tree*): Tree

def Bind(sym: Symbol, body: Tree): Bind

def Block(stats: Tree*): Block

Block factory that flattens directly nested blocks.

def CaseDef(pat: Tree, body: Tree): CaseDef

casedef shorthand

def ClassDef(sym: Symbol, impl: Template): ClassDef

def DefDef(sym: Symbol, rhs: (List[List[Symbol]]) ⇒ Tree): DefDef

def DefDef(sym: Symbol, rhs: Tree): DefDef

def DefDef(sym: Symbol, mods: Modifiers, rhs: Tree): DefDef

def DefDef(sym: Symbol, vparamss: List[List[ValDef]], rhs: Tree): DefDef

def DefDef(sym: Symbol, mods: Modifiers, vparamss: List[List[ValDef]], rhs: Tree): DefDef

lazy val EmptyTreeTypeSubstituter: TreeTypeSubstituter

def Ident(sym: Symbol): Ident

def Ident(name: String): Ident

def LabelDef(sym: Symbol, params: List[Symbol], rhs: Tree): LabelDef

def Modifiers(mods: Set[Modifier], privateWithin: Name, annotations: List[Tree]): Modifiers

def Modifiers(flags: Long): Modifiers

def Modifiers(flags: Long, privateWithin: Name): Modifiers

def ModuleDef(sym: Symbol, impl: Template): ModuleDef

def New(sym: Symbol, args: Tree*): Tree

def New(tpe: Type, args: Tree*): Tree

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

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)

lazy val NoMods: Modifiers

def Select(qualifier: Tree, sym: Symbol): Select

def Select(qualifier: Tree, name: String): Select

def Super(sym: Symbol, mix: TypeName): Tree

def This(sym: Symbol): Tree

def Throw(tpe: Type, args: Tree*): Throw

def Try(body: Tree, cases: (Tree, Tree)*): Try

def TypeDef(sym: Symbol): TypeDef

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

def TypeDef(sym: Symbol, rhs: Tree): TypeDef

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

def TypeTree(tp: Type): TypeTree

def ValDef(sym: Symbol): ValDef

def ValDef(sym: Symbol, rhs: Tree): ValDef

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def copyClassDef(tree: Tree)(mods: Modifiers, name: Name, tparams: List[TypeDef], impl: Template): ClassDef

def copyDefDef(tree: Tree)(mods: Modifiers, name: Name, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree): DefDef

def copyValDef(tree: Tree)(mods: Modifiers, name: Name, tpt: Tree, rhs: Tree): ValDef

def deriveCaseDef(cdef: Tree)(applyToBody: (Tree) ⇒ Tree): CaseDef

def deriveClassDef(cdef: Tree)(applyToImpl: (Template) ⇒ Template): ClassDef

def deriveDefDef(ddef: Tree)(applyToRhs: (Tree) ⇒ Tree): DefDef

def deriveLabelDef(ldef: Tree)(applyToRhs: (Tree) ⇒ Tree): LabelDef

def deriveModuleDef(mdef: Tree)(applyToImpl: (Template) ⇒ Template): ModuleDef

def deriveTemplate(templ: Tree)(applyToBody: (List[Tree]) ⇒ List[Tree]): Template

def deriveValDef(vdef: Tree)(applyToRhs: (Tree) ⇒ Tree): ValDef

def duplicateTree(tree: Tree): Tree

object emptyValDef extends ValDef

def ensuring(cond: (Trees) ⇒ Boolean, msg: ⇒ Any): Trees

def ensuring(cond: (Trees) ⇒ Boolean): Trees

def ensuring(cond: Boolean, msg: ⇒ Any): Trees

def ensuring(cond: Boolean): Trees

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isReferenceToAnyVal(t: Tree): Boolean

def isReferenceToPredef(t: Tree): Boolean

Is the tree Predef, scala.

def isReferenceToScalaMember(t: Tree, Id: Name): Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val self: Any

val self: Any

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

def toString(): String

val treeCopy: TreeCopier

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def xtransform(transformer: Transformer, tree: Tree): Tree

def xtraverse(traverser: Traverser, tree: Tree): Unit

def →[B](y: B): (Trees, B)

def x: Trees

def x: Trees