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

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object Cond

object Const

object CounterExample

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

object EmptySubstitution extends Substitution

object EqualityCond

object False extends Prop with Product with Serializable

object FalseCond extends (TreeMakerApproximation.this)#Cond 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 NonNullCond

object NullConst extends (SymbolicMatchAnalysis.this)#Const with Product with Serializable

lazy val NullTp: Global.UniqueConstantType

object ReusedCondTreeMaker

object Substitution

object Test extends Serializable

object True extends Prop with Product with Serializable

object TrueCond extends (TreeMakerApproximation.this)#Cond with Product with Serializable

object TypeCond

object TypeConst extends (SymbolicMatchAnalysis.this)#TypeConstExtractor

object TypeTestTreeMaker extends Serializable

object ValueConst

object Var

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

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

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

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

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

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: Global.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: (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: 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: Global.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: Global.Position): Global.Traverser

def formatted(fmtstr: String): String

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

def freshName(prefix: String): Global.TermName

def freshSym(pos: Global.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

def instanceOfTpImplies(tp: Global.Type, tpImplied: Global.Type): Boolean

final def isInstanceOf[T0]: Boolean

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

def matchMonadSym: Global.ClassSymbol

val matchOwner: Global.Symbol

def modelString(model: (MatchOptimizations.this)#Model): String

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

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

def reportUnreachable(pos: Global.Position): Unit

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

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

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

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

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

def toString(): String

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

def uncheckableType(tp: Global.Type): Boolean

def unreachableCase(prevBinder: Global.Symbol, cases: List[List[(MatchOptimizations.this)#TreeMaker]], pt: Global.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 →[B](y: B): (MatchOptimizations, B)

val self: Any

val self: Any

def x: MatchOptimizations

def x: MatchOptimizations