TreeBuilder

abstract def freshName(prefix: String): Name

abstract def freshTermName(prefix: String): TermName

abstract def freshTypeName(prefix: String): TypeName

abstract val global: Global

abstract def o2p(offset: Int): Position

abstract def r2p(start: Int, point: Int, end: Int): Position

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def addEvidenceParams(owner: Name, vparamss: List[List[ValDef]], contextBounds: List[Tree]): List[List[ValDef]]

Append implicit parameter section if contextBounds' nonempty

final def asInstanceOf[T0]: T0

def byNameApplication(tpe: Tree): Tree

def clone(): AnyRef

def convertToTypeName(t: Tree): Option[RefTree]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def freshName(): Name

def freshTermName(): TermName

final def getClass(): java.lang.Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def makeAlternative(ts: List[Tree]): Tree

Create tree for a pattern alternative

def makeAnnotated(t: Tree, annot: Tree): Tree

def makeAssign(lhs: Tree, rhs: Tree): Tree

Create a tree representing an assignment <lhs = rhs>

def makeBinop(isExpr: Boolean, left: Tree, op: TermName, right: Tree, opPos: Position): Tree

Create tree representing (unencoded) binary operation expression or pattern.

def makeBlock(stats: List[Tree]): Tree

Create block of statements stats'

def makeCaseDef(pat: Tree, guard: Tree, rhs: Tree): CaseDef

Create tree for case definition <case pat if guard => rhs>

def makeCatchFromExpr(catchExpr: Tree): CaseDef

Creates tree representing: { case x: Throwable => val catchFn = catchExpr if (catchFn isDefinedAt x) catchFn(x) else throw x }

def makeDoWhile(lname: TermName, body: Tree, cond: Tree): Tree

Create tree representing a do-while loop

def makeFor(enums: List[Enumerator], body: Tree): Tree

Create tree for for-do comprehension <for (enums) body>

def makeForYield(enums: List[Enumerator], body: Tree): Tree

Create tree for for-yield comprehension <for (enums) yield body>

def makeFunctionTypeTree(argtpes: List[Tree], restpe: Tree): Tree

Create a tree representing the function type (argtpes) => restpe

def makeGenerator(pos: Position, pat: Tree, valeq: Boolean, rhs: Tree): Enumerator

Create tree for for-comprehension generator <val pat0 <- rhs0>

def makeImportSelector(name: Name, nameOffset: Int): ImportSelector

def makeIntersectionTypeTree(tps: List[Tree]): Tree

A type tree corresponding to (possibly unary) intersection type

def makeLifted(gs: List[ValFrom], body: Tree): Tree

Create tree for a lifted expression XX-LIFTING

def makeNew(parents: List[Tree], self: ValDef, stats: List[Tree], argss: List[List[Tree]], npos: Position, cpos: Position): Tree

Create positioned tree representing an object creation <new parents { stats }

def makeParam(pname: TermName, tpe: Tree): ValDef

def makePatDef(mods: Modifiers, pat: Tree, rhs: Tree): List[Tree]

Create tree for pattern definition <mods val pat0 = rhs>

def makePatDef(pat: Tree, rhs: Tree): List[Tree]

Create tree for pattern definition <val pat0 = rhs>

def makeSelfDef(name: TermName, tpt: Tree): ValDef

def makeSequencedMatch(selector: Tree, cases: List[CaseDef]): Tree

For debugging only.

def makeSyntheticParam(pname: TermName): ValDef

def makeSyntheticTypeParam(pname: TypeName, bounds: Tree): TypeDef

def makeTupleTerm(trees: List[Tree], flattenUnary: Boolean): Tree

def makeTupleType(trees: List[Tree], flattenUnary: Boolean): Tree

def makeVisitor(cases: List[CaseDef], checkExhaustive: Boolean, prefix: String): Tree

Create visitor <x => x match cases>

def makeVisitor(cases: List[CaseDef], checkExhaustive: Boolean): Tree

Create visitor <x => x match cases>

def makeWhile(lname: TermName, cond: Tree, body: Tree): Tree

Create tree representing a while loop

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def productConstr: Select

def repeatedApplication(tpe: Tree): Tree

def rootId(name: Name): Select

def rootScalaDot(name: Name): Select

def scalaAnyRefConstr: Select

def scalaDot(name: Name): Select

def scalaScalaObjectConstr: Select

def scalaUnitConstr: Select

def serializableConstr: Select

def stripParens(t: Tree): Tree

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit