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

object Const

object CounterExample

val EmptyModel: Map[Sym, Boolean]

object EmptySubstitution extends Substitution

object EqualityCond

object False extends Prop with Product with Serializable

object FalseCond extends Cond with Product with Serializable

object IrrefutableExtractorTreeMaker

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

object NoExample extends CounterExample with Product with Serializable

val NoModel: Model

object NonNullCond

object NullConst extends Const with Product with Serializable

lazy val NullTp: ConstantType

object ReusedCondTreeMaker

object Substitution

object Test extends Serializable

object True extends Prop with Product with Serializable

object TrueCond extends Cond with Product with Serializable

object TypeCond

object TypeConst extends TypeConstExtractor

object TypeTestTreeMaker extends Serializable

object ValueConst

object Var

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], unchecked: Boolean): 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], modelNull: Boolean = false): (Prop, List[Prop])

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

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)

val self: Any

val self: Any

def x: MatchOptimizations

def x: MatchOptimizations