diff --git a/mytest/IfExpr1.scala b/mytest/IfExpr1.scala
index 3978b974552545f1db46e0676b758251af741c4e..4910ca339d6c94ac83eddcd56d854a0a7e6b045b 100644
--- a/mytest/IfExpr1.scala
+++ b/mytest/IfExpr1.scala
@@ -8,6 +8,6 @@ object IfExpr1 {
else
b = a + b
a
- }
+ } ensuring(_ == 1)
}
diff --git a/src/main/scala/leon/Analysis.scala b/src/main/scala/leon/Analysis.scala
index ed874898c05507c57b3e880ca8df1a7941255e27..3ae042b129b87bf26e8164fd766f2ab71d600ff6 100644
--- a/src/main/scala/leon/Analysis.scala
+++ b/src/main/scala/leon/Analysis.scala
@@ -11,7 +11,7 @@ class Analysis(pgm : Program, val reporter: Reporter = Settings.reporter) {
Extensions.loadAll(reporter)
println("Analysis on program:\n" + pgm)
- val passManager = new PassManager(Seq(FunctionClosure, FunctionHoisting))
+ val passManager = new PassManager(Seq(ImperativeCodeElimination, FunctionClosure, FunctionHoisting))
val program = passManager.run(pgm)
val analysisExtensions: Seq[Analyser] = loadedAnalysisExtensions
diff --git a/src/main/scala/leon/ImperativeCodeElimination.scala b/src/main/scala/leon/ImperativeCodeElimination.scala
index 11f8df42efa056fc436e6902812d92513321350f..dab564e46fe68e422ce279e5168d29b2fdb25a2f 100644
--- a/src/main/scala/leon/ImperativeCodeElimination.scala
+++ b/src/main/scala/leon/ImperativeCodeElimination.scala
@@ -13,7 +13,7 @@ object ImperativeCodeElimination extends Pass {
val allFuns = pgm.definedFunctions
allFuns.foreach(fd => {
val ((scope, fun), last) = fd.getBody match {
- case Block(stmts) => (toFunction(Block(stmts.init)), stmts.last)
+ case Block(stmts, stmt) => (toFunction(Block(stmts.init, stmts.last)), stmt)
case _ => sys.error("not supported")
}
fd.body = Some(scope(replace(fun.map{case (i1, i2) => (i1.toVariable, i2.toVariable)}, last)))
@@ -27,41 +27,48 @@ object ImperativeCodeElimination extends Pass {
private def toFunction(expr: Expr): (Expr => Expr, Map[Identifier, Identifier]) = {
println("toFunction of: " + expr)
val res = expr match {
- case Assignment(id, e) => {
- val newId = FreshIdentifier(id.name).setType(id.getType)
- val scope = ((body: Expr) => Let(newId, e, body))
- (scope, Map(id -> newId))
- }
- case IfExpr(cond, tExpr, eExpr) => {
- val (tScope, tFun) = toFunction(tExpr)
- val (eScope, eFun) = toFunction(eExpr)
- val modifiedVars: Seq[Identifier] = (tFun.keys ++ eFun.keys).toSeq
- val freshIds = modifiedVars.map(id => FreshIdentifier(id.name).setType(id.getType))
- val newTExpr = tScope(Tuple(modifiedVars.map(vId => tFun.get(vId) match {
- case Some(newId) => newId.toVariable
- case None => vId.toVariable
- })))
- val newEExpr = eScope(Tuple(modifiedVars.map(vId => eFun.get(vId) match {
- case Some(newId) => newId.toVariable
- case None => vId.toVariable
- })))
- val newIfExpr = IfExpr(cond, newTExpr, newEExpr).setType(newTExpr.getType)
- val scope = ((body: Expr) => LetTuple(freshIds, newIfExpr, body))
- (scope, Map(modifiedVars.zip(freshIds):_*))
- }
- case Block(exprs) => {
- val (headScope, headFun) = toFunction(exprs.head)
- exprs.tail.foldLeft((headScope, headFun))((acc, e) => {
- val (accScope, accFun) = acc
- val (rScope, rFun) = toFunction(e)
- val scope = ((body: Expr) =>
- accScope(replace(accFun.map{case (i1, i2) => (i1.toVariable, i2.toVariable)}, rScope(body))))
- (scope, accFun ++ rFun)
- })
- }
- case _ => sys.error("not supported: " + expr)
+ case Assignment(id, e) => {
+ val newId = FreshIdentifier(id.name).setType(id.getType)
+ val scope = ((body: Expr) => Let(newId, e, body))
+ (scope, Map(id -> newId))
+ }
+ case IfExpr(cond, tExpr, eExpr) => {
+ val (tScope, tFun) = toFunction(tExpr)
+ val (eScope, eFun) = toFunction(eExpr)
+ val modifiedVars: Seq[Identifier] = (tFun.keys ++ eFun.keys).toSeq
+ val freshIds = modifiedVars.map(id => FreshIdentifier(id.name).setType(id.getType))
+ val tupleType = TupleType(freshIds.map(_.getType))
+ val newTExpr = tScope(Tuple(modifiedVars.map(vId => tFun.get(vId) match {
+ case Some(newId) => newId.toVariable
+ case None => vId.toVariable
+ })).setType(tupleType))
+ val newEExpr = eScope(Tuple(modifiedVars.map(vId => eFun.get(vId) match {
+ case Some(newId) => newId.toVariable
+ case None => vId.toVariable
+ })).setType(tupleType))
+ val newIfExpr = IfExpr(cond, newTExpr, newEExpr).setType(newTExpr.getType)
+ val scope = ((body: Expr) => {
+ val tupleId = FreshIdentifier("t").setType(TupleType(freshIds.map(_.getType)))
+ Let(tupleId, newIfExpr, freshIds.zipWithIndex.foldLeft(body)((b, id) =>
+ Let(id._1,
+ TupleSelect(tupleId.toVariable, id._2 + 1).setType(id._1.getType),
+ b)))
+ })
+ (scope, Map(modifiedVars.zip(freshIds):_*))
+ }
+ case Block(head::exprs, expr) => {
+ val (headScope, headFun) = toFunction(head)
+ (exprs:+expr).foldLeft((headScope, headFun))((acc, e) => {
+ val (accScope, accFun) = acc
+ val (rScope, rFun) = toFunction(e)
+ val scope = ((body: Expr) =>
+ accScope(replace(accFun.map{case (i1, i2) => (i1.toVariable, i2.toVariable)}, rScope(body))))
+ (scope, accFun ++ rFun)
+ })
+ }
+ case _ => sys.error("not supported: " + expr)
}
- val codeRepresentation = res._1(Block(res._2.map{ case (id1, id2) => Assignment(id1, id2.toVariable)}.toSeq))
+ val codeRepresentation = res._1(Block(res._2.map{ case (id1, id2) => Assignment(id1, id2.toVariable)}.toSeq, UnitLiteral))
println("res of toFunction on: " + expr + " IS: " + codeRepresentation)
res
}
diff --git a/src/main/scala/leon/plugin/Extractors.scala b/src/main/scala/leon/plugin/Extractors.scala
index 02493c088d9f5d0407242e0a9b3133fb866a65ea..54a5fb7f02c4ddd0d56ee371deddd0700894c660 100644
--- a/src/main/scala/leon/plugin/Extractors.scala
+++ b/src/main/scala/leon/plugin/Extractors.scala
@@ -185,8 +185,8 @@ trait Extractors {
object ExWhile {
def unapply(tree: LabelDef): Option[(Tree,Tree)] = tree match {
case (label@LabelDef(
- _, _, If(cond, Block(body, jump@Apply(_, _)), unit@Literal(_))))
- if label.symbol == jump.symbol && unit.symbol == null => Some((cond, body))
+ _, _, If(cond, Block(body, jump@Apply(_, _)), unit@ExUnitLiteral())))
+ if label.symbol == jump.symbol && unit.symbol == null => Some((cond, Block(body, unit)))
case _ => None
}
}
diff --git a/src/main/scala/leon/purescala/PrettyPrinter.scala b/src/main/scala/leon/purescala/PrettyPrinter.scala
index 002a9ef79c1c99647982fe39fa85d9caa5c392fb..0c8d88f14c1e51cdafc80ab0c8ae1c8a9f02570c 100644
--- a/src/main/scala/leon/purescala/PrettyPrinter.scala
+++ b/src/main/scala/leon/purescala/PrettyPrinter.scala
@@ -90,9 +90,10 @@ object PrettyPrinter {
case IntLiteral(v) => sb.append(v)
case BooleanLiteral(v) => sb.append(v)
case StringLiteral(s) => sb.append("\"" + s + "\"")
- case Block(exprs) => {
+ case UnitLiteral => sb.append("()")
+ case Block(exprs, last) => {
sb.append("{\n")
- exprs.foreach(e => {
+ (exprs :+ last).foreach(e => {
ind(sb, lvl+1)
pp(e, sb, lvl+1)
sb.append("\n")
@@ -102,7 +103,6 @@ object PrettyPrinter {
sb
}
case Assignment(lhs, rhs) => ppBinary(sb, lhs.toVariable, rhs, " = ", lvl)
- case Skip => sb.append("()")
case While(cond, body) => {
sb.append("while(")
pp(cond, sb, lvl)
diff --git a/src/main/scala/leon/purescala/Trees.scala b/src/main/scala/leon/purescala/Trees.scala
index 309cc68732e865f11dcb3f1d4a38be18a99de28b..3157e8eb7f24c9dbe17984cfb987d6409f0b83c0 100644
--- a/src/main/scala/leon/purescala/Trees.scala
+++ b/src/main/scala/leon/purescala/Trees.scala
@@ -258,6 +258,7 @@ object Trees {
case class StringLiteral(value: String) extends Literal[String]
case object UnitLiteral extends Literal[Unit] with FixedType {
val fixedType = UnitType
+ val value = ()
}
case class CaseClass(classDef: CaseClassDef, args: Seq[Expr]) extends Expr with FixedType {
@@ -730,11 +731,11 @@ object Trees {
case Block(exprs, last) => {
val nexprs = (exprs :+ last).flatMap{
case Block(es2, el) => es2 :+ el
- case Skip => Seq()
+ case UnitLiteral => Seq()
case e2 => Seq(e2)
}
val fexpr = nexprs match {
- case Seq() => Skip
+ case Seq() => UnitLiteral
case Seq(e) => e
case es => Block(es.init, es.last).setType(es.last.getType)
}