CommonSubconditionElimination

abstract def inMatchMonad(tp: Global.Type): Global.Type

abstract def matchMonadSym: Global.Symbol

abstract def pureType(tp: Global.Type): Global.Type

abstract val typer: (analyzer)#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 (TreeMakerApproximation.this)#Cond with Product with Serializable

object IrrefutableExtractorTreeMaker

object NonNullCond

object ReusedCondTreeMaker

object Substitution

object Test extends Serializable

object TrueCond extends (TreeMakerApproximation.this)#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 approximateMatchConservative(root: Global.Symbol, cases: List[List[(CommonSubconditionElimination.this)#TreeMaker]]): List[List[(CommonSubconditionElimination.this)#Test]]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

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

def combineExtractors(treeMakers: List[(CommonSubconditionElimination.this)#TreeMaker])(casegen: (CommonSubconditionElimination.this)#Casegen): Global.Tree

val debugInfoEmitVars: Boolean

def doCSE(prevBinder: Global.Symbol, cases: List[List[(CommonSubconditionElimination.this)#TreeMaker]], pt: Global.Type): List[List[(CommonSubconditionElimination.this)#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: Global.Tree, scrutSym: Global.Symbol, cases: List[List[(CommonSubconditionElimination.this)#TreeMaker]], pt: Global.Type, matchFailGenOverride: Option[(Global.Tree) ⇒ Global.Tree], unchecked: Boolean): Option[Global.Tree]

def emitTypeSwitch(bindersAndCases: List[(Global.Symbol, List[(CommonSubconditionElimination.this)#TreeMaker])], pt: Global.Type): Option[List[Global.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: Global.Symbol, pos: Global.Position): Global.Traverser

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def matchMonadResult(tp: Global.Type): Global.Type

val matchOwner: Global.Symbol

final def ne(arg0: AnyRef): Boolean

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

final def notify(): Unit

final def notifyAll(): Unit

def optimizeCases(prevBinder: Global.Symbol, cases: List[List[(CommonSubconditionElimination.this)#TreeMaker]], pt: Global.Type, unchecked: Boolean): (List[List[(CommonSubconditionElimination.this)#TreeMaker]], List[Global.Tree])

def propagateSubstitution(treeMakers: List[(CommonSubconditionElimination.this)#TreeMaker], initial: (CommonSubconditionElimination.this)#Substitution): List[(CommonSubconditionElimination.this)#TreeMaker]

def removeSubstOnly(makers: List[(CommonSubconditionElimination.this)#TreeMaker]): collection.immutable.List[(CommonSubconditionElimination.this)#TreeMaker]

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

def reportUnreachable(pos: Global.Position): Unit

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

def showTests(testss: List[List[(CommonSubconditionElimination.this)#Test]]): Unit

def showTreeMakers(cases: List[List[(CommonSubconditionElimination.this)#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