Trees

abstract def treeToString(tree: Tree): String

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

implicit val AlternativeTag: ClassTag[Alternative]

implicit val AnnotatedTag: ClassTag[Annotated]

implicit val AppliedTypeTreeTag: ClassTag[AppliedTypeTree]

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

def ApplyConstructor(tpt: Tree, args: List[Tree]): Apply

implicit val ApplyDynamicTag: ClassTag[ApplyDynamic]

implicit val ApplyTag: ClassTag[Apply]

implicit val ArrayValueTag: ClassTag[ArrayValue]

implicit val AssignOrNamedArgTag: ClassTag[AssignOrNamedArg]

implicit val AssignTag: ClassTag[Assign]

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

implicit val BindTag: ClassTag[Bind]

def Block(stats: Tree*): Block

implicit val BlockTag: ClassTag[Block]

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

implicit val CaseDefTag: ClassTag[CaseDef]

def ClassDef(sym: Symbol, constrMods: Modifiers, vparamss: List[List[ValDef]], argss: List[List[Tree]], body: List[Tree], superPos: Position): ClassDef

Construct class definition with given class symbol, value parameters, supercall arguments and template body.

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

implicit val ClassDefTag: ClassTag[ClassDef]

implicit val CompoundTypeTreeTag: ClassTag[CompoundTypeTree]

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

implicit val DefDefTag: ClassTag[DefDef]

implicit val DefTreeTag: ClassTag[DefTree]

lazy val EmptyTreeTypeSubstituter: TreeTypeSubstituter

implicit val ExistentialTypeTreeTag: ClassTag[ExistentialTypeTree]

implicit val FunctionTag: ClassTag[Function]

implicit val GenericApplyTag: ClassTag[GenericApply]

def Ident(sym: Symbol): Ident

def Ident(name: String): Ident

implicit val IdentTag: ClassTag[Ident]

implicit val IfTag: ClassTag[If]

implicit val ImplDefTag: ClassTag[ImplDef]

implicit val ImportSelectorTag: ClassTag[ImportSelector]

implicit val ImportTag: ClassTag[Import]

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

implicit val LabelDefTag: ClassTag[LabelDef]

implicit val LiteralTag: ClassTag[Literal]

implicit val MatchTag: ClassTag[Match]

implicit val MemberDefTag: ClassTag[MemberDef]

def Modifiers(flags: FlagSet): Modifiers

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

implicit val ModifiersTag: ClassTag[Modifiers]

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

implicit val ModuleDefTag: ClassTag[ModuleDef]

implicit val NameTreeTag: ClassTag[NameTree]

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

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

def New(tpt: Tree, argss: List[List[Tree]]): Tree

implicit val NewTag: ClassTag[New]

lazy val NoMods: Modifiers

implicit val PackageDefTag: ClassTag[PackageDef]

implicit val RefTreeTag: ClassTag[RefTree]

implicit val ReferenceToBoxedTag: ClassTag[ReferenceToBoxed]

implicit val ReturnTag: ClassTag[Return]

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

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

implicit val SelectFromTypeTreeTag: ClassTag[SelectFromTypeTree]

implicit val SelectTag: ClassTag[Select]

implicit val SingletonTypeTreeTag: ClassTag[SingletonTypeTree]

implicit val StarTag: ClassTag[Star]

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

implicit val SuperTag: ClassTag[Super]

implicit val SymTreeTag: ClassTag[SymTree]

def Template(parents: List[Tree], self: ValDef, constrMods: Modifiers, vparamss: List[List[ValDef]], argss: List[List[Tree]], body: List[Tree], superPos: Position): Template

Generates a template with constructor corresponding to

implicit val TemplateTag: ClassTag[Template]

implicit val TermTreeTag: ClassTag[TermTree]

def This(sym: Symbol): Tree

implicit val ThisTag: ClassTag[This]

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

implicit val ThrowTag: ClassTag[Throw]

implicit val TreeTag: ClassTag[Tree]

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

implicit val TryTag: ClassTag[Try]

implicit val TypTreeTag: ClassTag[TypTree]

implicit val TypeApplyTag: ClassTag[TypeApply]

implicit val TypeBoundsTreeTag: ClassTag[TypeBoundsTree]

def TypeDef(sym: Symbol): TypeDef

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

implicit val TypeDefTag: ClassTag[TypeDef]

def TypeTree(tp: Type): TypeTree

implicit val TypeTreeTag: ClassTag[TypeTree]

implicit val TypedTag: ClassTag[Typed]

implicit val UnApplyTag: ClassTag[UnApply]

def ValDef(sym: Symbol): ValDef

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

implicit val ValDefTag: ClassTag[ValDef]

implicit val ValOrDefDefTag: ClassTag[ValOrDefDef]

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

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

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

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

final def ne(arg0: AnyRef): Boolean

def newLazyTreeCopier: TreeCopier

def newStrictTreeCopier: TreeCopier

object noopTransformer extends Transformer

final def notify(): Unit

final def notifyAll(): Unit

def resetAllAttrs(x: Tree, leaveAlone: (Tree) ⇒ Boolean = null): Tree

resets symbol and tpe fields in a tree, @see ResetAttrs

def resetLocalAttrs(x: Tree, leaveAlone: (Tree) ⇒ Boolean = null): Tree

def resetLocalAttrsKeepLabels(x: Tree, leaveAlone: (Tree) ⇒ Boolean = null): Tree

object resetPos extends Traverser

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

def toString(): String

val treeCopy: TreeCopier

object treeInfo extends TreeInfo

def treeLine(t: Tree): String

val treeNodeCount: View

lazy val treePrinter: TreePrinter

def treeStatus(t: Tree, enclosingTree: Tree = null): String

def treeSymStatus(t: Tree): String

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)

val self: Any

val self: Any

def duplicateTree(tree: Tree): Tree

def x: Trees

def x: Trees