UnitTreeBuilder

abstract val global: Global

abstract def unit: Global.CompilationUnit

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: AnyRef): Boolean

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: (UnitTreeBuilder) ⇒ Boolean, msg: ⇒ Any): UnitTreeBuilder

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

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

def ensuring(cond: Boolean): UnitTreeBuilder

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

def freshName(prefix: String): Global.Name

def freshName(): Global.Name

def freshTermName(prefix: String): Global.TermName

def freshTermName(): Global.TermName

def freshTypeName(prefix: String): Global.TypeName

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): 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 makeFilter(tree: Global.Tree, condition: Global.Tree, scrutineeName: String): Global.Tree

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

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

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

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

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

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

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

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

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.Tree]

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

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

Create tree for pattern definition <val pat0 = rhs>

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

Tree for od op, start is start0 if od.

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

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

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

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

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

Create visitor <x => x match cases>

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

Create visitor <x => x match cases>

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

object patvarTransformer extends Global.Transformer

Convert all occurrences of (lower-case) variables in a pattern as follows: x becomes x @ _ x: T becomes x @ (_: T)

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): (UnitTreeBuilder, B)