TreeTransformer

abstract def miniPhases: Array[MiniPhase]

abstract def phaseName: String

final def !=(arg0: Any): Boolean

final def ##(): Int

final def <=(that: Phase): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def checkPostCondition(tree: ast.tpd.Tree)(implicit ctx: Context): Unit

Check what the phase achieves, to be called at any point after it is finished.

def clone(): AnyRef

def description: String

def end: PhaseId

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def erasedTypes: Boolean

def exists: Boolean

def finalize(): Unit

final def flatClasses: Boolean

final def getClass(): Class[_]

final def hasNext: Boolean

def hashCode(): Int

def id: Int

The sequence position of this phase in the given context where 0 is reserved for NoPhase and the first real phase is at position 1.

def init(base: ContextBase, id: Int): Unit

def init(base: ContextBase, start: Int, end: Int): Unit

val initialInfoCache: TransformerInfo

val initialTransformationsCache: Array[TreeTransform]

def isCheckable: Boolean

Output should be checkable by TreeChecker

final def isInstanceOf[T0]: Boolean

def isTyper: Boolean

Is this phase the standard typerphase? True for FrontEnd, but not for other first phases (such as FromTasty).

final def iterator: Iterator[Phase]

final def labelsReordered: Boolean

def localContext(sym: Symbol)(implicit ctx: Context): FreshContext

def macroTransform(t: ast.tpd.Tree)(implicit ctx: Context): ast.tpd.Tree

def mutateTransformers[T](info: TransformerInfo, mutator: Mutator[T], mutationPlan: Array[Int], tree: T, cur: Int)(implicit ctx: Context): TransformerInfo

final def ne(arg0: AnyRef): Boolean

final def next: Phase

final def notify(): Unit

final def notifyAll(): Unit

def period: Period

val prepForAlternative: Mutator[ast.tpd.Alternative]

val prepForApply: Mutator[ast.tpd.Apply]

val prepForAssign: Mutator[ast.tpd.Assign]

val prepForBind: Mutator[ast.tpd.Bind]

val prepForBlock: Mutator[ast.tpd.Block]

val prepForCaseDef: Mutator[ast.tpd.CaseDef]

val prepForClosure: Mutator[ast.tpd.Closure]

val prepForDefDef: Mutator[ast.tpd.DefDef]

val prepForIdent: Mutator[ast.tpd.Ident]

val prepForIf: Mutator[ast.tpd.If]

val prepForLiteral: Mutator[ast.tpd.Literal]

val prepForMatch: Mutator[ast.tpd.Match]

val prepForNew: Mutator[ast.tpd.New]

val prepForPackageDef: Mutator[ast.tpd.PackageDef]

val prepForPair: Mutator[ast.tpd.Pair]

val prepForReturn: Mutator[ast.tpd.Return]

val prepForSelect: Mutator[ast.tpd.Select]

val prepForSelectFromTypeTree: Mutator[ast.tpd.SelectFromTypeTree]

val prepForSeqLiteral: Mutator[ast.tpd.SeqLiteral]

val prepForStats: Mutator[List[ast.tpd.Tree]]

val prepForSuper: Mutator[ast.tpd.Super]

val prepForTemplate: Mutator[ast.tpd.Template]

val prepForThis: Mutator[ast.tpd.This]

val prepForTry: Mutator[ast.tpd.Try]

val prepForTypeApply: Mutator[ast.tpd.TypeApply]

val prepForTypeDef: Mutator[ast.tpd.TypeDef]

val prepForTypeTree: Mutator[ast.tpd.TypeTree]

val prepForTyped: Mutator[ast.tpd.Typed]

val prepForUnApply: Mutator[ast.tpd.UnApply]

val prepForUnit: Mutator[ast.tpd.Tree]

val prepForValDef: Mutator[ast.tpd.ValDef]

final def prev: Phase

final def refChecked: Boolean

def relaxedTyping: Boolean

If set, allow missing or superfluous arguments in applications and type applications.

def run(implicit ctx: Context): Unit

def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit]

def runsAfter: Set[Class[_ <: Phase]]

List of names of phases that should precede this phase

def start: Int

final def symbolicRefs: Boolean

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

def toString(): String

def transform(tree: ast.tpd.Tree, info: TransformerInfo, cur: Int)(implicit ctx: Context): ast.tpd.Tree

def transformStats(trees: List[ast.tpd.Tree], exprOwner: Symbol, info: TransformerInfo, current: Int)(implicit ctx: Context): List[ast.tpd.Tree]

def transformSub[Tr <: ast.tpd.Tree](tree: Tr, info: TransformerInfo, current: Int)(implicit ctx: Context): Tr

def transformSubTrees[Tr <: ast.tpd.Tree](trees: List[Tr], info: TransformerInfo, current: Int)(implicit ctx: Context): List[Tr]

def transformTrees(trees: List[ast.tpd.Tree], info: TransformerInfo, current: Int)(implicit ctx: Context): List[ast.tpd.Tree]

def unsupported(methodName: String): Nothing

Throws an UnsupportedOperationException with the given method name.

final def wait(): Unit

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

final def wait(arg0: Long): Unit