MatchOptimizations

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

def /\(props: Iterable[(MatchOptimizations.this)#Prop]): (MatchOptimizations.this)#Prop

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object AnalysisBudget

object Const

object CounterExample

val EmptyModel: Map[(MatchOptimizations.this)#Sym, Boolean]

object EmptySubstitution extends Substitution

object False extends Prop with Product with Serializable

object IrrefutableExtractorTreeMaker

def Lit(sym: (MatchOptimizations.this)#Sym, pos: Boolean = true): (MatchOptimizations.this)#Lit

object NoExample extends (SymbolicMatchAnalysis.this)#CounterExample with Product with Serializable

val NoModel: (MatchOptimizations.this)#Model

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

object WildcardExample extends (SymbolicMatchAnalysis.this)#CounterExample with Product with Serializable

def \/(props: Iterable[(MatchOptimizations.this)#Prop]): (MatchOptimizations.this)#Prop

def addFormula(buff: (MatchOptimizations.this)#FormulaBuilder, f: (MatchOptimizations.this)#Formula): Unit

def andFormula(a: (MatchOptimizations.this)#Formula, b: (MatchOptimizations.this)#Formula): (MatchOptimizations.this)#Formula

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

final def asInstanceOf[T0]: T0

final def caseWithoutBodyToProp(tests: List[(MatchOptimizations.this)#Test]): (MatchOptimizations.this)#Prop

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

def clause(l: (MatchOptimizations.this)#Lit*): (MatchOptimizations.this)#Clause

def clone(): AnyRef

def cnfString(f: (MatchOptimizations.this)#Formula): String

def codegen: (MatchOptimizations.this)#AbsCodegen

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

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

val debugInfoEmitVars: Boolean

def doCSE(prevBinder: Global.Symbol, cases: List[List[(MatchOptimizations.this)#TreeMaker]], pt: (MatchOptimizations.this)#Type): List[List[(MatchOptimizations.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 doDCE(prevBinder: Global.Symbol, cases: List[List[(MatchOptimizations.this)#TreeMaker]], pt: Global.Type): List[List[(MatchOptimizations.this)#TreeMaker]]

def emitSwitch(scrut: Global.Tree, scrutSym: Global.Symbol, cases: List[List[(MatchOptimizations.this)#TreeMaker]], pt: Global.Type, matchFailGenOverride: Option[(Global.Tree) ⇒ Global.Tree], unchecked: Boolean): Option[Global.Tree]

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

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

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

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

def ensuring(cond: Boolean): PatternMatching.MatchOptimizations

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

final def eq(arg0: AnyRef): Boolean

def eqFreePropToSolvable(p: (MatchOptimizations.this)#Prop): (MatchOptimizations.this)#Formula

def equals(arg0: Any): Boolean

def exhaustive(prevBinder: Global.Symbol, cases: List[List[(MatchOptimizations.this)#TreeMaker]], pt: (MatchOptimizations.this)#Type): List[String]

def finalize(): Unit

def findAllModelsFor(f: (MatchOptimizations.this)#Formula): List[(MatchOptimizations.this)#Model]

def findModelFor(f: (MatchOptimizations.this)#Formula): (MatchOptimizations.this)#Model

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

def formatted(fmtstr: String): String

def formula(c: (MatchOptimizations.this)#Clause*): (MatchOptimizations.this)#Formula

def formulaBuilder: ArrayBuffer[Set[(MatchOptimizations.this)#Lit]]

def formulaBuilderSized(init: Int): ArrayBuffer[(MatchOptimizations.this)#Clause]

def freshName(prefix: String): Global.TermName

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

def gatherVariables(p: (MatchOptimizations.this)#Prop): Set[(MatchOptimizations.this)#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

def modelToCounterExample(scrutVar: (MatchOptimizations.this)#Var)(model: (MatchOptimizations.this)#Model): (MatchOptimizations.this)#CounterExample

def modelToVarAssignment(model: (MatchOptimizations.this)#Model): Map[(MatchOptimizations.this)#Var, (Seq[(MatchOptimizations.this)#Const], Seq[(MatchOptimizations.this)#Const])]

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[(MatchOptimizations.this)#TreeMaker]], pt: (MatchOptimizations.this)#Type, unchecked: Boolean): (List[List[(MatchOptimizations.this)#TreeMaker]], List[(MatchOptimizations.this)#Tree])

object optimizedCodegen extends CommonCodegen

def prepareNewAnalysis(): Unit

def propToSolvable(p: (MatchOptimizations.this)#Prop): (MatchOptimizations.this)#Formula

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

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

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

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

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

def reportUnreachable(pos: Position): Unit

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

def showTreeMakers(cases: List[List[(MatchOptimizations.this)#TreeMaker]]): Unit

def simplifyFormula(a: (MatchOptimizations.this)#Formula): (MatchOptimizations.this)#Formula

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

def toFormula(buff: (MatchOptimizations.this)#FormulaBuilder): (MatchOptimizations.this)#Formula

def toString(): String

def uncheckableType(tp: Global.Type): Boolean

def uncheckedWarning(pos: Position, msg: String): Any

def unreachableCase(prevBinder: Global.Symbol, cases: List[List[(MatchOptimizations.this)#TreeMaker]], pt: (MatchOptimizations.this)#Type): Option[Int]

def varAssignmentString(varAssignment: Map[(MatchOptimizations.this)#Var, (Seq[(MatchOptimizations.this)#Const], Seq[(MatchOptimizations.this)#Const])]): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def warn(pos: Position, ex: Logic.PropositionalLogic.AnalysisBudget.Exception, kind: String): Any

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