BagEncoder

abstract val evaluator: DeterministicEvaluator { val program: BagEncoder.this.sourceProgram.type }

abstract val sourceProgram: Program

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val Add: ast.Trees.FunDef

val AddID: ast.Identifier

val Bag: (dsl)#IdToADTType

val BagEquals: ast.Trees.FunDef

val BagID: ast.Identifier

val BagInvariant: ast.Trees.FunDef

val Difference: ast.Trees.FunDef

val DifferenceID: ast.Identifier

val DifferenceImpl: ast.Trees.FunDef

val Elem: (dsl)#ADTConsIdentifier

val ElemID: ast.Identifier

val EqualsID: ast.Identifier

val Get: ast.Trees.FunDef

val GetID: ast.Identifier

val Intersect: ast.Trees.FunDef

val IntersectID: ast.Identifier

val IntersectImpl: ast.Trees.FunDef

val InvID: ast.Identifier

val Leaf: (dsl)#ADTConsIdentifier

val LeafID: ast.Identifier

val Sum: (dsl)#ADTConsIdentifier

val SumID: ast.Identifier

val Union: ast.Trees.FunDef

val UnionID: ast.Identifier

def andThen(that: ProgramTransformer { val sourceProgram: inox.ast.ProgramEncoder.<refinement>.type }): ProgramTransformer { ... /* 2 definitions in type refinement */ }

final def asInstanceOf[T0]: T0

val bagSort: ast.Trees.ADTSort

def clone(): AnyRef

def compose(that: ProgramTransformer { val targetProgram: BagEncoder.this.sourceProgram.type }): ProgramTransformer { ... /* 2 definitions in type refinement */ }

def decode(tpe: ast.Trees.Type): ast.Trees.Type

def decode(e: ast.Trees.Expr): ast.Trees.Expr

def decode(v: ast.Trees.Variable): ast.Trees.Variable

def decode(vd: ast.Trees.ValDef): ast.Trees.ValDef

object decoder extends ast.Trees.SelfTreeTransformer

val diff: ast.Identifier

def encode(tpe: ast.Trees.Type): ast.Trees.Type

def encode(e: ast.Trees.Expr): ast.Trees.Expr

def encode(v: ast.Trees.Variable): ast.Trees.Variable

def encode(vd: ast.Trees.ValDef): ast.Trees.ValDef

def encodedProgram: Program { val trees: BagEncoder.this.t.type }

Override point for more complex program transformations

object encoder extends ast.Trees.SelfTreeTransformer

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val extraFunctions: Seq[ast.Trees.FunDef]

val extraSorts: Seq[ast.Trees.ADTSort]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

val inter: ast.Identifier

final def isInstanceOf[T0]: Boolean

val key: ast.Identifier

val left: ast.Identifier

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def reverse: ProgramTransformer { ... /* 2 definitions in type refinement */ }

val right: ast.Identifier

final lazy val s: Program.trees.type

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

val t: Program.trees.type

final lazy val targetProgram: Program { val trees: BagEncoder.this.t.type }

def toString(): String

lazy val trees: Program.trees.type

val value: ast.Identifier

final def wait(): Unit

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

final def wait(arg0: Long): Unit