QueryCompiler

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(p: Phase): QueryCompiler

Return a new compiler with the new phase added at the end.

def ++(ps: Seq[Phase]): QueryCompiler

Return a new compiler with the new phases added at the end.

def -(p: Phase): QueryCompiler

Return a new compiler without the given phase (or a different implementation of the same phase name.

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

final def ==(arg0: Any): Boolean

def addAfter(p: Phase, after: Phase): QueryCompiler

Return a new compiler with the new phase added directly after another phase (or a different implementation of the same phase name).

def addBefore(p: Phase, before: Phase): QueryCompiler

Return a new compiler with the new phase added directly before another phase (or a different implementation of the same phase name).

final def asInstanceOf[T0]: T0

lazy val benchmarkLogger: SlickLogger

def clone(): AnyRef

def detectRebuiltLeafs(n1: Node, n2: Node): Set[RefId[Dumpable]]

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

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

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

def ensuring(cond: Boolean): QueryCompiler

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

lazy val logger: SlickLogger

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val phases: Vector[Phase]

def replace(p: Phase): QueryCompiler

Return a new compiler that replaces an existing phase by a new one with the same name.

def run(state: CompilerState): CompilerState

Compile an AST in an existing CompilerState.

def run(tree: Node): CompilerState

Compile an AST with a new CompilerState.

def runBefore(before: Phase, state: CompilerState): CompilerState

Compile an AST in an existing CompilerState, stopping just before the specified phase.

def runPhase(p: Phase, state: CompilerState): CompilerState

def runPhases(it: Iterator[Phase], state: CompilerState): CompilerState

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

def +(other: String): String