TreeBuilder

abstract val global: Global

abstract def source: SourceFile

abstract def unit: Global.CompilationUnit

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: Any): Boolean

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

Append implicit parameter section if contextBounds nonempty

final def asInstanceOf[T0]: T0

def byNameApplication(tpe: Global.Tree): Global.Tree

def clone(): AnyRef

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

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

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

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

def ensuring(cond: Boolean): TreeBuilder

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

implicit def fresh: FreshNameCreator

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

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

Create tree for a pattern alternative

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

def makeBinop(isExpr: Boolean, left: Global.Tree, op: Global.TermName, right: Global.Tree, opPos: Global.Position, targs: List[Global.Tree] = Nil): Global.Tree

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

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

Create block of statements stats

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

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

def makeCatchFromExpr(catchExpr: Global.Tree): Global.CaseDef

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

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

Create tree representing a do-while loop

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

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

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

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

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

def makePostfixSelect(start0: Int, end: Int, od: Global.Tree, op: Global.Name): Global.Tree

Tree for od op, start is start0 if od.pos is borked.

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

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

def makeTupleTerm(elems: List[Global.Tree]): Global.Tree

def makeTupleType(elems: List[Global.Tree]): Global.Tree

def makeWhile(startPos: Int, cond: Global.Tree, body: Global.Tree): Global.Tree

Create tree representing a while loop

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def o2p(offset: Int): Global.Position

def r2p(start: Int, mid: Int, end: Int): Global.Position

def repeatedApplication(tpe: Global.Tree): Global.Tree

def rootScalaDot(name: Global.Name): Global.Select

def scalaAnyRefConstr: Global.Select

def scalaDot(name: Global.Name): Global.Select

def scalaUnitConstr: Global.Select

def stripParens(t: Global.Tree): Global.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

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