MatchOptimizations

abstract val typer: Typer

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object Cond extends AnyRef

object EmptySubstitution extends Substitution

object EqualityCond extends AnyRef

object Havoc extends Cond with Product with Serializable

object ReusedCondTreeMaker extends AnyRef

object Substitution extends AnyRef

object Test extends Serializable

object Top extends Cond with Product with Serializable

object TypeAndEqualityCond extends AnyRef

object TypeCond extends AnyRef

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

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def codegen: AbsCodegen

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

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

def combineExtractors(treeMakers: List[TreeMaker], pt: Type): 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 share, 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 doDCE(prevBinder: Symbol, cases: List[List[TreeMaker]], pt: Type): List[List[TreeMaker]]

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

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

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

def freshSym(pos: Position, tp: Type = NoType, prefix: String = "x"): TermSymbol

final def getClass(): Class[_]

def hashCode(): Int

def inMatchMonad(tp: Type): Type

final def isInstanceOf[T0]: Boolean

final def matchMonadResult(tp: Type): Type

def matchMonadSym: Symbol

val matchOwner: Symbol

def maybeWithOuterCheck(binder: Symbol, expectedTp: Type)(cond: Tree): Tree

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): (List[List[TreeMaker]], List[Tree])

object optimizedCodegen extends CommonCodegen

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

def pureType(tp: Type): Type

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

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

def toString(): String

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit