Templates

Type Members

case class App(caller: Encoded, tpe: ast.Trees.FunctionType, args: Seq[Arg], encoded: Encoded) extends Product with Serializable

Represents an application of a first-class function in the unfolding procedure
type Apps = Map[Encoded, Set[App]]
type Arg = Either[Encoded, Matcher]
implicit class ArgWrapper extends AnyRef
case class Call(tfd: ast.Trees.TypedFunDef, args: Seq[Arg], tpSubst: Seq[Arg]) extends Product with Serializable

Represents a named function call in the unfolding procedure
type Calls = Map[Encoded, Set[Call]]
case class Capture(encoded: Encoded, tpe: ast.Trees.FunctionType) extends Templates.TemplateInstantiator with Product with Serializable

Definition Classes
TypeTemplates
case class CaptureGenerator(container: Encoded, tpe: ast.Trees.FunctionType) extends Templates.TypingGenerator with Product with Serializable

Attributes
protected
Definition Classes
TypeTemplates
class CaptureTemplate extends Template

Template used to unfold ADT closures that may contain functions.
Template used to unfold ADT closures that may contain functions.

Definition Classes
TypeTemplates
type Clauses = Seq[Encoded]

Abstract templates
Abstract templates
Pre-compiled sets of clauses with extra bookkeeping information that enables efficient unfolding of function calls and applications. Template is a super-type for all such clause sets that can be instantiated given a concrete argument list and a blocker in the decision-tree.
implicit class ClausesWrapper extends AnyRef

Attributes
protected
Definition Classes
TemplateGenerator
case class Constraint(result: Encoded, closures: Seq[Arg], free: Boolean) extends Templates.TemplateInstantiator with Product with Serializable

Definition Classes
TypeTemplates
class ConstraintTemplate extends Template

Template used to unfold free symbols in the input expression.
Template used to unfold free symbols in the input expression.

Definition Classes
TypeTemplates
abstract type Encoded
type Equalities = Map[Encoded, Set[Equality]]
case class Equality(tpe: ast.Trees.Type, e1: Encoded, e2: Encoded) extends Product with Serializable

Represents an equality relation between two instances of a given type
class EqualityTemplate extends Template

Definition Classes
EqualityTemplates
class FunctionTemplate extends Template

Definition Classes
FunctionTemplates
class LambdaTemplate extends Template

Definition Classes
LambdaTemplates
trait Manager extends IncrementalStateWrapper
implicit class MapSeqWrapper[A, B] extends AnyRef
implicit class MapSetWrapper[A, B] extends AnyRef

Template instantiations
Template instantiations
Template instances, when provided with concrete arguments and a blocker, will generate three outputs used for program unfolding: - clauses: clauses that will be added to the underlying solver - call blockers: bookkeeping information necessary for named function unfolding - app blockers: bookkeeping information necessary for first-class function unfolding
This object provides helper methods to deal with the triplets generated during unfolding.
case class Matcher(key: Either[(Encoded, ast.Trees.Type), ast.Trees.TypedFunDef], args: Seq[Arg], encoded: Encoded) extends Product with Serializable

Represents an E-matching matcher that will be used to instantiate relevant quantified propositions
type Matchers = Map[Encoded, Set[Matcher]]
case class Negative(insts: (ast.Trees.Variable, Encoded)) extends Templates.Polarity with Product with Serializable

Definition Classes
QuantificationTemplates
type Pointers = Map[Encoded, Encoded]
sealed abstract class Polarity extends AnyRef

Represents the polarity of the quantification within the considered formula.
Represents the polarity of the quantification within the considered formula. Positive and negative polarity enable optimizations during quantifier instantiation.

Definition Classes
QuantificationTemplates
case class Positive(subst: Map[ast.Trees.Variable, Arg]) extends Templates.Polarity with Product with Serializable

Definition Classes
QuantificationTemplates
class QuantificationTemplate extends AnyRef

Definition Classes
QuantificationTemplates
trait Template extends AnyRef
case class TemplateAppInfo(template: Either[Templates.LambdaTemplate, Encoded], equals: Encoded, args: Seq[Arg]) extends Product with Serializable

Represents a POTENTIAL application of a first-class function in the unfolding procedure
Represents a POTENTIAL application of a first-class function in the unfolding procedure
The equals condition guards the application for equality of the concrete caller with the provided template in order to perform dynamic dispatch.

Definition Classes
LambdaTemplates
type TemplateClauses = (Map[ast.Trees.Variable, Encoded], Map[ast.Trees.Variable, Encoded], Map[ast.Trees.Variable, Set[ast.Trees.Variable]], Map[ast.Trees.Variable, Seq[ast.Trees.Expr]], Seq[ast.Trees.Expr], Types, Equalities, Seq[LambdaTemplate], Seq[QuantificationTemplate])

Attributes
protected
Definition Classes
TemplateGenerator
case class TemplateContents(pathVar: (ast.Trees.Variable, Encoded), arguments: Seq[(ast.Trees.Variable, Encoded)], condVars: Map[ast.Trees.Variable, Encoded], exprVars: Map[ast.Trees.Variable, Encoded], condTree: Map[ast.Trees.Variable, Set[ast.Trees.Variable]], clauses: Clauses, types: Types, blockers: Calls, applications: Apps, matchers: Matchers, equalities: Equalities, lambdas: Seq[Templates.LambdaTemplate], quantifications: Seq[Templates.QuantificationTemplate], pointers: Pointers) extends Product with Serializable
sealed abstract class TemplateInstantiator extends AnyRef

Represents the kind of instantiator (@see ConstraintTemplate and CaptureTemplate) a given template info is associated to.
Represents the kind of instantiator (@see ConstraintTemplate and CaptureTemplate) a given template info is associated to.

Definition Classes
TypeTemplates
class TemplateStructure extends AnyRef

Semi-template used for inner-template equality
Semi-template used for inner-template equality
We introduce a structure here that resembles a Template that is instantiated ONCE when the corresponding template becomes of interest.
sealed abstract class TypeUnrolling extends AnyRef

Determines whether a given type should be unrolled, depending on the kind of type unrolling, namely free variable type unrolling (dependent types and ADT invariants), contract type unrolling (dependent types), and capture unrolling (function closure ordering).
Determines whether a given type should be unrolled, depending on the kind of type unrolling, namely free variable type unrolling (dependent types and ADT invariants), contract type unrolling (dependent types), and capture unrolling (function closure ordering).

Attributes
protected
Definition Classes
TypeTemplates
type Types = Map[Encoded, Set[Typing]]
case class Typing(tpe: ast.Trees.Type, arg: Encoded, instantiator: Templates.TemplateInstantiator) extends Product with Serializable

Represents a type unfolding of a free variable (or input) in the unfolding procedure
Represents a type unfolding of a free variable (or input) in the unfolding procedure

Definition Classes
TypeTemplates
sealed abstract class TypingGenerator extends AnyRef

Attributes
protected
Definition Classes
TypeTemplates

Abstract Value Members

abstract def abort: Boolean
abstract def asString(e: Encoded): String
abstract val context: Context
abstract def decodePartial(e: Encoded, tpe: ast.Trees.Type): Option[ast.Trees.Expr]
abstract def encodeSymbol(v: ast.Trees.Variable): Encoded
abstract def extractNot(e: Encoded): Option[Encoded]
abstract def mkAnd(es: Encoded*): Encoded
abstract def mkEncoder(bindings: Map[ast.Trees.Variable, Encoded])(e: ast.Trees.Expr): Encoded
abstract def mkEquals(l: Encoded, r: Encoded): Encoded
abstract def mkImplies(l: Encoded, r: Encoded): Encoded
abstract def mkNot(e: Encoded): Encoded
abstract def mkOr(es: Encoded*): Encoded
abstract def mkSubstituter(map: Map[Encoded, Encoded]): (Encoded) ⇒ Encoded
abstract def pause: Boolean
abstract val program: Program
implicit abstract val semantics: Program.Semantics

Attributes
protected

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object CaptureTemplate

Template generator for CaptureTemplate instances.
Template generator for CaptureTemplate instances.

Definition Classes
TypeTemplates
object CaptureUnrolling extends Templates.TypeUnrolling with Product with Serializable

Attributes
protected
Definition Classes
TypeTemplates
object ConstraintTemplate

Generator for ConstraintTemplate instances.
Generator for ConstraintTemplate instances.

Definition Classes
TypeTemplates
object ContractGenerator extends Templates.TypingGenerator with Product with Serializable

Attributes
protected
Definition Classes
TypeTemplates
object ContractUnrolling extends Templates.TypeUnrolling with Product with Serializable

Attributes
protected
Definition Classes
TypeTemplates
object EqualityTemplate

Definition Classes
EqualityTemplates
object FreeGenerator extends Templates.TypingGenerator with Product with Serializable

Attributes
protected
Definition Classes
TypeTemplates
object FreeUnrolling extends Templates.TypeUnrolling with Product with Serializable

Attributes
protected
Definition Classes
TypeTemplates
object FunctionMatcher

Definition Classes
QuantificationTemplates
object FunctionTemplate

Definition Classes
FunctionTemplates
object LambdaTemplate

Constructor object for LambdaTemplate
Constructor object for LambdaTemplate
The apply methods performs some pre-processing before creating an instance of LambdaTemplate.

Definition Classes
LambdaTemplates
object QuantificationMatcher

Definition Classes
QuantificationTemplates
object QuantificationTemplate

Definition Classes
QuantificationTemplates
object Template
object TemplateAppInfo extends Serializable

Definition Classes
LambdaTemplates
object TemplateContents extends Serializable
final def asInstanceOf[T0]: T0

Definition Classes
Any
def blockerChildren(b: Encoded, strict: Boolean = true): Set[Encoded]

Attributes
protected
def blockerEquals(b: Encoded): Set[Encoded]

Attributes
protected
def blockerParents(b: Encoded, strict: Boolean = true): Set[Encoded]

Attributes
protected
def blockerPath(bs: Set[Encoded]): Set[Encoded]

Attributes
protected
def blockerPath(b: Encoded): Set[Encoded]

Attributes
protected
def canUnroll: Boolean
def clear(): Unit

Definition Classes
IncrementalStateWrapper → IncrementalState
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def correspond(m1: Matcher, m2: Matcher): Option[Boolean]

Attributes
protected
Definition Classes
QuantificationTemplates
Annotations
@inline()
def correspond(k1: MatcherKey, k2: MatcherKey): Option[Boolean]

Attributes
protected
Definition Classes
QuantificationTemplates
def currentGeneration: Int

Attributes
protected
implicit val debugSection: DebugSectionSolver.type
lazy val deferFactor: Int

Attributes
protected
def emptyClauses: TemplateClauses

Attributes
protected
Definition Classes
TemplateGenerator
def encodeBlockers(bs: Set[Encoded]): (Encoded, Clauses)

Attributes
protected
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equalitySymbol(tpe: ast.Trees.Type): (ast.Trees.Variable, Encoded)

Definition Classes
EqualityTemplates
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def freshConds(pathVar: Encoded, condVars: Map[ast.Trees.Variable, Encoded], tree: Map[ast.Trees.Variable, Set[ast.Trees.Variable]]): Map[Encoded, Encoded]

Attributes
protected
def getAxioms: Seq[Axiom]

Definition Classes
QuantificationTemplates
def getCalls: Seq[(Encoded, Call)]

Definition Classes
FunctionTemplates
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getFiniteRangeClauses: Clauses

Definition Classes
QuantificationTemplates
def getGroundInstantiations(e: Encoded, tpe: ast.Trees.Type): Seq[(Encoded, Seq[Encoded])]

Definition Classes
QuantificationTemplates
def getInstantiationsWithBlockers: Seq[(Encoded, Set[Encoded])]

Definition Classes
QuantificationTemplates
def getLambdaTemplates(tpe: ast.Trees.FunctionType): Set[LambdaTemplate]

Definition Classes
LambdaTemplates
def hasAxioms: Boolean

Definition Classes
QuantificationTemplates
def hashCode(): Int

Definition Classes
AnyRef → Any
val incrementals: Seq[IncrementalState]

Definition Classes
Templates → IncrementalStateWrapper
def instantiateApp(blocker: Encoded, app: App): Clauses

Definition Classes
LambdaTemplates
def instantiateCall(blocker: Encoded, fi: Call): Clauses

Definition Classes
FunctionTemplates
def instantiateEquality(blocker: Encoded, equality: Equality): Clauses

Definition Classes
EqualityTemplates
def instantiateExpr(expr: ast.Trees.Expr, bindings: Map[ast.Trees.Variable, Encoded]): Clauses
def instantiateLambda(template: LambdaTemplate): (Encoded, Clauses)

Definition Classes
LambdaTemplates
def instantiateMatcher(blocker: Encoded, matcher: Matcher): Clauses

Definition Classes
QuantificationTemplates
def instantiateQuantification(template: QuantificationTemplate): (Map[Encoded, Encoded], Clauses)

Definition Classes
QuantificationTemplates
def instantiateType(blocker: Encoded, typing: Typing): Clauses

Definition Classes
TypeTemplates
def instantiateVariable(v: ast.Trees.Variable, bindings: Map[ast.Trees.Variable, Encoded]): Clauses
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def mkClauses(pathVar: ast.Trees.Variable, tpe: ast.Trees.Type, expr: ast.Trees.Expr, substMap: Map[ast.Trees.Variable, Encoded])(implicit generator: TypingGenerator): TemplateClauses

Definition Classes
TemplateGenerator
def mkClauses(pathVar: ast.Trees.Variable, expr: ast.Trees.Expr, substMap: Map[ast.Trees.Variable, Encoded], polarity: Option[Boolean] = None): TemplateClauses

Definition Classes
TemplateGenerator
def mkExprClauses(pathVar: ast.Trees.Variable, expr: ast.Trees.Expr, substMap: Map[ast.Trees.Variable, Encoded], polarity: Option[Boolean] = None): (ast.Trees.Expr, TemplateClauses)

Attributes
protected
Definition Classes
TemplateGenerator
def mkExprStructure(pathVar: ast.Trees.Variable, expr: ast.Trees.Expr, substMap: Map[ast.Trees.Variable, Encoded], onlySimple: Boolean = false): (ast.Trees.Expr, TemplateStructure, Map[ast.Trees.Variable, Encoded])

Attributes
protected
Definition Classes
TemplateGenerator
def mkTypeClauses(pathVar: ast.Trees.Variable, tpe: ast.Trees.Type, expr: ast.Trees.Expr, substMap: Map[ast.Trees.Variable, Encoded])(implicit generator: TypingGenerator): (ast.Trees.Expr, TemplateClauses)

Generates the clauses and other bookkeeping relevant to a type unfolding template.
Generates the clauses and other bookkeeping relevant to a type unfolding template.

Attributes
protected
Definition Classes
TemplateGenerator
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nextGeneration(gen: Int): Int

Attributes
protected
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def pop(): Unit

Definition Classes
IncrementalStateWrapper → IncrementalState
final def pop(lvl: Int): Unit

Definition Classes
IncrementalState
def promoteBlocker(b: Encoded, force: Boolean = false): Boolean
def promoteQuantifications: Unit

Definition Classes
QuantificationTemplates
def push(): Unit

Definition Classes
IncrementalStateWrapper → IncrementalState
def refutationAssumptions: Seq[Encoded]
def registerClosure(start: Encoded, container: (Encoded, ast.Trees.FunctionType), arg: (Encoded, ast.Trees.Type)): Clauses

Sets up the relevant unfolding procedure for closure ordering
Sets up the relevant unfolding procedure for closure ordering

Definition Classes
TypeTemplates
def registerEquality(blocker: Encoded, equality: Equality): Encoded

Definition Classes
EqualityTemplates
def registerEquality(blocker: Encoded, tpe: ast.Trees.Type, e1: Encoded, e2: Encoded): Encoded

Definition Classes
EqualityTemplates
def registerFunction(b: Encoded, r: Encoded, tpe: ast.Trees.Type, f: Encoded, closures: Seq[Arg], free: Boolean): Clauses

Definition Classes
LambdaTemplates
def registerImplication(b1: Encoded, b2: Encoded): Unit

Attributes
protected
def registerLambda(pointer: Encoded, target: Encoded): Boolean

Definition Classes
LambdaTemplates
def requiresFiniteRangeCheck: Boolean

Definition Classes
QuantificationTemplates
def reset(): Unit

Definition Classes
IncrementalStateWrapper → IncrementalState
def satisfactionAssumptions: Seq[Encoded]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def unroll: Clauses
def unrollEquality(tpe: ast.Trees.Type): Boolean

Definition Classes
EqualityTemplates
def variableSeq(tpe: ast.Trees.Type): Seq[ast.Trees.Variable]

Attributes
protected
Definition Classes
FunctionTemplates
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package unrolling

trait Templates extends TemplateGenerator with FunctionTemplates with LambdaTemplates with QuantificationTemplates with EqualityTemplates with TypeTemplates with IncrementalStateWrapper

Type Members

case class App(caller: Encoded, tpe: ast.Trees.FunctionType, args: Seq[Arg], encoded: Encoded) extends Product with Serializable

type Apps = Map[Encoded, Set[App]]

type Arg = Either[Encoded, Matcher]

implicit class ArgWrapper extends AnyRef

case class Call(tfd: ast.Trees.TypedFunDef, args: Seq[Arg], tpSubst: Seq[Arg]) extends Product with Serializable

type Calls = Map[Encoded, Set[Call]]

case class Capture(encoded: Encoded, tpe: ast.Trees.FunctionType) extends Templates.TemplateInstantiator with Product with Serializable

case class CaptureGenerator(container: Encoded, tpe: ast.Trees.FunctionType) extends Templates.TypingGenerator with Product with Serializable

class CaptureTemplate extends Template

type Clauses = Seq[Encoded]

implicit class ClausesWrapper extends AnyRef

case class Constraint(result: Encoded, closures: Seq[Arg], free: Boolean) extends Templates.TemplateInstantiator with Product with Serializable

class ConstraintTemplate extends Template

abstract type Encoded

type Equalities = Map[Encoded, Set[Equality]]

case class Equality(tpe: ast.Trees.Type, e1: Encoded, e2: Encoded) extends Product with Serializable

class EqualityTemplate extends Template

class FunctionTemplate extends Template

class LambdaTemplate extends Template

trait Manager extends IncrementalStateWrapper

implicit class MapSeqWrapper[A, B] extends AnyRef

implicit class MapSetWrapper[A, B] extends AnyRef

case class Matcher(key: Either[(Encoded, ast.Trees.Type), ast.Trees.TypedFunDef], args: Seq[Arg], encoded: Encoded) extends Product with Serializable

type Matchers = Map[Encoded, Set[Matcher]]

case class Negative(insts: (ast.Trees.Variable, Encoded)) extends Templates.Polarity with Product with Serializable

type Pointers = Map[Encoded, Encoded]

sealed abstract class Polarity extends AnyRef

case class Positive(subst: Map[ast.Trees.Variable, Arg]) extends Templates.Polarity with Product with Serializable

class QuantificationTemplate extends AnyRef

trait Template extends AnyRef

case class TemplateAppInfo(template: Either[Templates.LambdaTemplate, Encoded], equals: Encoded, args: Seq[Arg]) extends Product with Serializable

type TemplateClauses = (Map[ast.Trees.Variable, Encoded], Map[ast.Trees.Variable, Encoded], Map[ast.Trees.Variable, Set[ast.Trees.Variable]], Map[ast.Trees.Variable, Seq[ast.Trees.Expr]], Seq[ast.Trees.Expr], Types, Equalities, Seq[LambdaTemplate], Seq[QuantificationTemplate])

sealed abstract class TemplateInstantiator extends AnyRef

class TemplateStructure extends AnyRef

sealed abstract class TypeUnrolling extends AnyRef

type Types = Map[Encoded, Set[Typing]]

case class Typing(tpe: ast.Trees.Type, arg: Encoded, instantiator: Templates.TemplateInstantiator) extends Product with Serializable

sealed abstract class TypingGenerator extends AnyRef

Abstract Value Members

abstract def abort: Boolean

abstract def asString(e: Encoded): String

abstract val context: Context

abstract def decodePartial(e: Encoded, tpe: ast.Trees.Type): Option[ast.Trees.Expr]

abstract def encodeSymbol(v: ast.Trees.Variable): Encoded

abstract def extractNot(e: Encoded): Option[Encoded]

abstract def mkAnd(es: Encoded*): Encoded

abstract def mkEncoder(bindings: Map[ast.Trees.Variable, Encoded])(e: ast.Trees.Expr): Encoded

abstract def mkEquals(l: Encoded, r: Encoded): Encoded

abstract def mkImplies(l: Encoded, r: Encoded): Encoded

abstract def mkNot(e: Encoded): Encoded

abstract def mkOr(es: Encoded*): Encoded

abstract def mkSubstituter(map: Map[Encoded, Encoded]): (Encoded) ⇒ Encoded

abstract def pause: Boolean

abstract val program: Program

implicit abstract val semantics: Program.Semantics

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object CaptureTemplate

object CaptureUnrolling extends Templates.TypeUnrolling with Product with Serializable

object ConstraintTemplate

object ContractGenerator extends Templates.TypingGenerator with Product with Serializable

object ContractUnrolling extends Templates.TypeUnrolling with Product with Serializable

object EqualityTemplate

object FreeGenerator extends Templates.TypingGenerator with Product with Serializable

object FreeUnrolling extends Templates.TypeUnrolling with Product with Serializable

object FunctionMatcher

object FunctionTemplate

object LambdaTemplate

object QuantificationMatcher

object QuantificationTemplate

object Template

object TemplateAppInfo extends Serializable

object TemplateContents extends Serializable

final def asInstanceOf[T0]: T0