MatchOptimizer

abstract val EmptyModel: Model

abstract val NoModel: Model

abstract def addFormula(buff: FormulaBuilder, f: Formula): Unit

abstract def analyzeCases(prevBinder: Global.Symbol, cases: List[List[TreeMaker]], pt: Global.Type, suppression: MatchOptimization.Suppression): Unit

abstract def andFormula(a: Formula, b: Formula): Formula

abstract def cnfString(f: Formula): String

abstract def eqFreePropToSolvable(p: Prop): Formula

abstract def findAllModelsFor(f: Formula): List[Model]

abstract def findModelFor(f: Formula): Model

abstract def formulaBuilder: FormulaBuilder

abstract def simplifyFormula(a: Formula): Formula

abstract def toFormula(buff: FormulaBuilder): Formula

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

def /\(props: Iterable[Prop]): Prop

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object AnalysisBudget

object Const

object EmptySubstitution extends Substitution

object False extends Prop with Product with Serializable

object IrrefutableExtractorTreeMaker

object NullConst extends Const with Product with Serializable

lazy val NullTp: Global.UniqueConstantType

object ReusedCondTreeMaker

object Substitution

object Sym extends Serializable

object Test extends Serializable

object True extends Prop with Product with Serializable

object TypeConst extends TypeConstExtractor

object TypeTestTreeMaker extends Serializable

object ValueConst extends ValueConstExtractor

object Var extends VarExtractor

def \/(props: Iterable[Prop]): Prop

def approximateMatchConservative(root: Global.Symbol, cases: List[List[TreeMaker]]): List[List[Test]]

final def asInstanceOf[T0]: T0

final def caseWithoutBodyToProp(tests: List[Test]): Prop

def checkableType(tp: Global.Type): Global.Type

def clone(): AnyRef

def codegen: AbsCodegen

def combineCases(scrut: Global.Tree, scrutSym: Global.Symbol, casesRaw: List[List[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[TreeMaker]], pt: Global.Type, owner: Global.Symbol, matchFailGenOverride: Option[(Global.Tree) ⇒ Global.Tree]): Global.Tree

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

val debugInfoEmitVars: Boolean

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

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

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

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

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

def ensuring(cond: Boolean): MatchOptimizer

def enumerateSubtypes(tp: Global.Type): Option[List[Global.Type]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

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

def formatted(fmtstr: String): String

def freshName(prefix: String): Global.TermName

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

def gatherVariables(p: Prop): Set[Var]

final def getClass(): Class[_]

def hashCode(): Int

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

final def isInstanceOf[T0]: Boolean

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

def matchMonadSym: Global.ClassSymbol

val matchOwner: Global.Symbol

final def ne(arg0: AnyRef): Boolean

def newSynthCaseLabel(name: String): Global.MethodSymbol

final def notify(): Unit

final def notifyAll(): Unit

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

object optimizedCodegen extends CommonCodegen

def prepareNewAnalysis(): Unit

def propToSolvable(p: Prop): Formula

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

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

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

def removeVarEq(props: List[Prop], modelNull: Boolean = false): (Formula, List[Formula])

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

def reportUnreachable(pos: Position): Unit

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

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

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

def toString(): String

def uncheckableType(tp: Global.Type): Boolean

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def →[B](y: B): (MatchOptimizer, B)

val self: Any

val self: Any

def x: MatchOptimizer

def x: MatchOptimizer