CommonSubconditionElimination

abstract def inMatchMonad(tp: Type): Type

abstract def matchMonadSym: Symbol

abstract def pureType(tp: Type): Type

abstract val typer: Typer

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object Cond

object EmptySubstitution extends Substitution

object EqualityCond

object FalseCond extends Cond with Product with Serializable

object IrrefutableExtractorTreeMaker

object NonNullCond

object ReusedCondTreeMaker

object Substitution

object Test extends Serializable

object TrueCond extends Cond with Product with Serializable

object TypeCond

object TypeTestTreeMaker extends Serializable

def alignAcrossRows(xss: List[List[AnyRef]], sep: String, lineSep: String = "\n"): String

def alignedColumns(cols: Seq[AnyRef]): Seq[String]

def approximateMatch(root: Symbol, cases: List[List[TreeMaker]]): List[List[Test]]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def combineCases(scrut: Tree, scrutSym: Symbol, casesRaw: List[List[TreeMaker]], pt: Type, owner: Symbol, matchFailGenOverride: Option[(Tree) ⇒ Tree]): Tree

def combineCasesNoSubstOnly(scrut: Tree, scrutSym: Symbol, casesNoSubstOnly: List[List[TreeMaker]], pt: Type, owner: Symbol, matchFailGenOverride: Option[(Tree) ⇒ Tree]): Tree

def combineExtractors(treeMakers: List[TreeMaker])(casegen: Casegen): Tree

def doCSE(prevBinder: Symbol, cases: List[List[TreeMaker]], pt: Type): List[List[TreeMaker]]

a flow-sensitive, generalised, common sub-expression elimination reuse knowledge from performed tests the only sub-expressions we consider are the conditions and results of the three tests (type, type&equality, equality) when a sub-expression is shared, it is stored in a mutable variable the variable is floated up so that its scope includes all of the program that shares it we generalize sharing to implication, where b reuses a if a => b and priors(a) => priors(b) (the priors of a sub expression form the path through the decision tree)

def emitSwitch(scrut: Tree, scrutSym: Symbol, cases: List[List[TreeMaker]], pt: Type, matchFailGenOverride: Option[(Tree) ⇒ Tree], unchecked: Boolean): Option[Tree]

def emitTypeSwitch(bindersAndCases: List[(Symbol, List[TreeMaker])], pt: Type): Option[List[CaseDef]]

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

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

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

def ensuring(cond: Boolean): CommonSubconditionElimination

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def fixerUpper(origOwner: Symbol, pos: Position): Traverser

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def matchMonadResult(tp: Type): Type

val matchOwner: Symbol

final def ne(arg0: AnyRef): Boolean

def needsTypeTest(tp: Type, pt: Type): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def optimizeCases(prevBinder: Symbol, cases: List[List[TreeMaker]], pt: Type, unchecked: Boolean): (List[List[TreeMaker]], List[Tree])

def propagateSubstitution(treeMakers: List[TreeMaker], initial: Substitution): List[TreeMaker]

def removeSubstOnly(makers: List[TreeMaker]): List[TreeMaker]

def reportMissingCases(pos: Position, counterExamples: List[String]): Unit

def reportUnreachable(pos: Position): Unit

def sameValue(a: Tree, b: Tree): Boolean

def showTests(testss: List[List[Test]]): Unit

def showTreeMakers(cases: List[List[TreeMaker]]): Unit

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

val self: Any

val self: Any

def x: CommonSubconditionElimination

def x: CommonSubconditionElimination