TreeGen

abstract val global: Global

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object CODE extends AnyRef

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def convertToSelectFromType(qual: Tree, origName: Name): Tree with Serializable

Try to convert Select(qual, name) to a SelectFromTypeTree.

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

Translate names in Select/Ident nodes to type names.

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

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

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

def ensuring(cond: Boolean): TreeGen

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evalOnce(expr: Tree, owner: Symbol, unit: CompilationUnit)(within: (() ⇒ Tree) ⇒ Tree): Tree

Used in situations where you need to access value of an expression several times

def evalOnceAll(exprs: List[Tree], owner: Symbol, unit: CompilationUnit)(within: (List[() ⇒ Tree]) ⇒ Tree): Tree

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hasSynthCaseSymbol(t: Tree): Boolean

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def maybeMkAsInstanceOf(tree: Tree, pt: Type, tpe: Type, beforeRefChecks: Boolean = false): Tree

Cast tree to pt, unless tpe is a subtype of pt, or pt is Unit.

def mkAnd(tree1: Tree, tree2: Tree): Tree

def mkAppliedTypeForCase(clazz: Symbol): Tree

def mkApplyIfNeeded(qual: Tree): Tree

If this is a reference to a method with an empty parameter list, wrap it in an apply.

def mkAsInstanceOf(value: Tree, tpe: Type, any: Boolean = true, wrapInApply: Boolean = true): Tree

Builds a cast with given value and type.

def mkAssignAndReturn(lhs: Symbol, rhs: Tree): Tree

def mkAttributedIdent(sym: Symbol): Tree

def mkAttributedQualifier(tpe: Type, termSym: Symbol): Tree

Builds a reference to value whose type is given stable prefix.

def mkAttributedQualifier(tpe: Type): Tree

Builds a reference to value whose type is given stable prefix.

def mkAttributedRef(sym: Symbol): Tree

Builds a reference to given symbol.

def mkAttributedRef(pre: Type, sym: Symbol): Tree

Builds a reference to given symbol with given stable prefix.

def mkAttributedSelect(qual: Tree, sym: Symbol): Tree

def mkAttributedStableRef(sym: Symbol): Tree

def mkAttributedStableRef(pre: Type, sym: Symbol): Tree

Builds a reference with stable type to given symbol

def mkAttributedThis(sym: Symbol): Tree

def mkAttributedTypeApply(target: Tree, method: Symbol, targs: List[Type]): Tree

def mkBindForCase(patVar: Symbol, clazz: Symbol, targs: List[Type]): Tree

def mkCached(cvar: Symbol, expr: Tree): Tree

def mkCachedModuleAccessDef(accessor: Symbol, mvar: Symbol): DefDef

def mkCast(tree: Tree, pt: Type): Tree

Cast tree to type pt by creating one of the calls of the form

def mkCastArray(tree: Tree, elemtp: Type, pt: Type): Tree

Generate a cast for tree Tree representing Array with elem type elemtp to expected type pt.

def mkCheckInit(tree: Tree): Tree

def mkClassOf(tp: Type): Tree

Apparently we smuggle a Type around as a Literal(Constant(tp)) and the implementation of Constant#tpe is such that x.

def mkConstantZero(tp: Type): Constant

def mkDoubleCheckedLocking(attrThis: Tree, cond: Tree, syncBody: List[Tree], stats: List[Tree]): Tree

def mkDoubleCheckedLocking(clazz: Symbol, cond: Tree, syncBody: List[Tree], stats: List[Tree]): Tree

Return a double-checked locking idiom around the syncBody tree.

def mkForwarder(target: Tree, vparamss: List[List[Symbol]]): Tree

Make forwarder to method target, passing all parameters in params

def mkIsInstanceOf(value: Tree, tpe: Type, any: Boolean = true, wrapInApply: Boolean = true): Tree

Builds an instance test with given value and type.

def mkManifestFactoryCall(full: Boolean, constructor: String, tparg: Type, args: List[Tree]): Tree

A creator for a call to a scala.

def mkMethodCall(target: Tree, targs: List[Type], args: List[Tree]): Tree

def mkMethodCall(receiver: Tree, method: Symbol, targs: List[Type], args: List[Tree]): Tree

def mkMethodCall(receiver: Symbol, methodName: Name, args: List[Tree]): Tree

def mkMethodCall(target: Tree, args: List[Tree]): Tree

def mkMethodCall(method: Symbol, args: List[Tree]): Tree

def mkMethodCall(method: Symbol, targs: List[Type], args: List[Tree]): Tree

def mkMethodCall(receiver: Symbol, methodName: Name, targs: List[Type], args: List[Tree]): Tree

A creator for method calls, e.

def mkModuleAccessDcl(accessor: Symbol): DefDef

def mkModuleAccessDef(accessor: Symbol, msym: Symbol): DefDef

def mkModuleVarDef(accessor: Symbol): ValDef

def mkNewCons(head: Tree, tail: Tree): Tree

Builds a list with given head and tail.

def mkNil: Tree

Builds a list with given head and tail.

def mkNullaryCall(method: Symbol, targs: List[Type]): Tree

def mkOr(tree1: Tree, tree2: Tree): Tree

def mkRuntimeCall(meth: Name, targs: List[Type], args: List[Tree]): Tree

def mkRuntimeCall(meth: Name, args: List[Tree]): Tree

def mkSoftRef(expr: Tree): Tree

def mkSynchronized(monitor: Tree, body: Tree): Tree

Make a synchronized block on 'monitor'.

def mkSynthSwitchSelector(expr: Tree): Tree

def mkSysErrorCall(message: String): Tree

def mkTuple(elems: List[Tree]): Tree

Builds a tuple

def mkTypeApply(target: Tree, method: Symbol, targs: List[Type]): Tree

def mkTypeApply(fun: Tree, targs: List[Tree]): Tree

Builds a type application node if args.

def mkUnattributedRef(sym: Symbol): Tree

Builds an untyped reference to given symbol.

def mkUnchecked(expr: Tree): Tree

def mkUncheckedMatch(tree: Tree): Tree

def mkWildcardImport(pkg: Symbol): Import

Builds a fully attributed wildcard import node.

def mkWrapArray(tree: Tree, elemtp: Type): Tree

Applies a wrapArray call to an array, making it a WrappedArray.

def mkZero(tp: Type): Tree

Builds a tree representing an undefined local, as in var x: T = _ which is appropriate to the given Type.

def mkZeroContravariantAfterTyper(tp: Type): Tree

final def ne(arg0: AnyRef): Boolean

def newModule(accessor: Symbol, tpe: Type): Tree

final def notify(): Unit

final def notifyAll(): Unit

def paramToArg(vparam: ValDef): Tree with Serializable

def paramToArg(vparam: Symbol): Tree with Serializable

def productConstr: Select

def rootId(name: Name): Select

def rootScalaDot(name: Name): Select

def scalaAnyRefConstr: Select

def scalaDot(name: Name): Select

def scalaFunctionConstr(argtpes: List[Tree], restpe: Tree, abstractFun: Boolean = false): Tree

def scalaUnitConstr: Select

val self: Any

val self: Any

def serializableConstr: Select

def stabilize(tree: Tree): Tree

Replaces tree type with a stable type if possible

def stableTypeFor(tree: Tree): Option[Type]

Computes stable type for a tree if possible

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 wildcardStar(tree: Tree): Typed

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

def x: TreeGen

def x: TreeGen