MatchOptimizations

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

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object Cond extends AnyRef

object Const extends AnyRef

object CounterExample extends AnyRef

val EmptyModel: Map[Sym, Boolean]

object EmptySubstitution extends Substitution

object EqualityCond extends AnyRef

object False extends Prop with Product with Serializable

object Havoc extends Cond with Product with Serializable

def Lit(sym: Sym, pos: Boolean = true): Lit

object NoExample extends CounterExample with Product with Serializable

val NoModel: Model

object NonNullCond extends AnyRef

object NullConst extends Const with Product with Serializable

lazy val NullTp: ConstantType

object ReusedCondTreeMaker extends AnyRef

object Substitution extends AnyRef

object Test extends Serializable

object Top extends Cond with Product with Serializable

object True extends Prop with Product with Serializable

object TypeCond extends AnyRef

object TypeConst extends AnyRef

object TypeTestTreeMaker extends Serializable

object ValueConst extends AnyRef

object Var extends AnyRef

object WildcardExample extends CounterExample with Product with Serializable

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

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

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

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

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

final def asInstanceOf[T0]: T0

def checkableType(tp: Type): Type

def clause(l: Lit*): Clause

def clone(): AnyRef

def cnfString(f: Formula): String

def codegen: AbsCodegen

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

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

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

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

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

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

def ensuring(cond: Boolean): MatchOptimizations

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

final def eq(arg0: AnyRef): Boolean

def eqFreePropToSolvable(p: Prop): Formula

def equals(arg0: Any): Boolean

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

def finalize(): Unit

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

def findModelFor(f: Formula): Model

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

def formatted(fmtstr: String): String

def formula(c: Clause*): Formula

def freshName(prefix: String): TermName

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

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

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: ClassSymbol

val matchOwner: Symbol

def modelString(model: Model): String

def modelToCounterExample(scrutVar: Var)(model: Model): CounterExample

def modelToVarAssignment(model: Model): Map[Var, (Seq[Const], Seq[Const])]

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])

object optimizedCodegen extends CommonCodegen

def prepareNewAnalysis(): Unit

def propToSolvable(p: Prop): Formula

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

def pureType(tp: Type): Type

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

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

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

val self: Any

val self: Any

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

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

def symbolicCase(tests: List[Test], modelNull: Boolean = false): Prop

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

def toString(): String

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

def uncheckableType(tp: Type): Boolean

def unreachableCase(prevBinder: Symbol, cases: List[List[TreeMaker]], pt: Type): Option[Int]

def varAssignmentString(varAssignment: Map[Var, (Seq[Const], Seq[Const])]): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

def x: MatchOptimizations

def x: MatchOptimizations