diff --git a/src/main/scala/leon/evaluators/RecursiveEvaluator.scala b/src/main/scala/leon/evaluators/RecursiveEvaluator.scala
index 0fff170048236ae86d102cc0b4d238956f5f64df..b5db1105561a998dd7e4ee96c798c8f8ac18ae7b 100644
--- a/src/main/scala/leon/evaluators/RecursiveEvaluator.scala
+++ b/src/main/scala/leon/evaluators/RecursiveEvaluator.scala
@@ -577,8 +577,8 @@ abstract class RecursiveEvaluator(ctx: LeonContext, prog: Program, maxSteps: Int
import purescala.TypeOps.isSubtypeOf
def matchesPattern(pat: Pattern, e: Expr): Option[Map[Identifier, Expr]] = (pat, e) match {
- case (InstanceOfPattern(ob, pct), CaseClass(ct, _)) =>
- if (isSubtypeOf(ct, pct)) {
+ case (InstanceOfPattern(ob, pct), e) =>
+ if (isSubtypeOf(e.getType, pct)) {
Some(obind(ob, e))
} else {
None
diff --git a/src/main/scala/leon/purescala/ExprOps.scala b/src/main/scala/leon/purescala/ExprOps.scala
index fb25f9d52e098636b9b18dd78f3ecc068cb11dc7..73e4aaed9087c8b0bc96018441ba4ec5e69fe2b2 100644
--- a/src/main/scala/leon/purescala/ExprOps.scala
+++ b/src/main/scala/leon/purescala/ExprOps.scala
@@ -613,6 +613,8 @@ object ExprOps {
* t -> (a, b2),
* b2 -> 42,
* )
+ *
+ * WARNING: UNUSED, is not maintained
*/
def patternSubstitutions(in: Expr, pattern: Pattern): Seq[(Expr, Expr)] ={
def rec(in: Expr, pattern: Pattern): Seq[(Expr, Expr)] = pattern match {
@@ -621,7 +623,7 @@ object ExprOps {
WildcardPattern(Some(FreshIdentifier(f.id.name, f.getType)))
})
rec(in, pt)
-
+
case TuplePattern(_, subps) =>
val TupleType(subts) = in.getType
val subExprs = (subps zip subts).zipWithIndex map {
@@ -633,7 +635,7 @@ object ExprOps {
case Tuple(ts) =>
ts zip subExprs
case _ =>
- Seq(in -> tupleWrap(subExprs))
+ Seq(in -> tupleWrap(subExprs))
}
subst0 ++ ((subExprs zip subps) flatMap {
@@ -644,13 +646,13 @@ object ExprOps {
val subExprs = (subps zip cct.fields) map {
case (p, f) => p.binder.map(_.toVariable).getOrElse(CaseClassSelector(cct, in, f.id))
}
-
+
// Special case to get rid of Cons(a,b) match { case Cons(c,d) => .. }
val subst0 = in match {
case CaseClass(`cct`, args) =>
args zip subExprs
case _ =>
- Seq(in -> CaseClass(cct, subExprs))
+ Seq(in -> CaseClass(cct, subExprs))
}
subst0 ++ ((subExprs zip subps) flatMap {
@@ -679,7 +681,7 @@ object ExprOps {
recBinder(in, pattern).filter{ case (a, b) => a != b }
}
- def conditionForPattern(in: Expr, pattern: Pattern, includeBinders: Boolean = false) : Expr = {
+ def conditionForPattern(in: Expr, pattern: Pattern, includeBinders: Boolean = false): Expr = {
def bind(ob: Option[Identifier], to: Expr): Expr = {
if (!includeBinders) {
BooleanLiteral(true)
@@ -690,20 +692,16 @@ object ExprOps {
def rec(in: Expr, pattern: Pattern): Expr = {
pattern match {
- case WildcardPattern(ob) => bind(ob, in)
+ case WildcardPattern(ob) =>
+ bind(ob, in)
+
case InstanceOfPattern(ob, ct) =>
if (ct.parent.isEmpty) {
bind(ob, in)
} else {
- val ccs = ct match {
- case act: AbstractClassType =>
- act.knownCCDescendents
- case cct: CaseClassType =>
- Seq(cct)
- }
- val oneOf = ccs map { IsInstanceOf(_, in) }
- and(orJoin(oneOf), bind(ob, in))
+ and(IsInstanceOf(ct, in), bind(ob, in))
}
+
case CaseClassPattern(ob, cct, subps) =>
assert(cct.fields.size == subps.size)
val pairs = cct.fields.map(_.id).toList zip subps.toList
@@ -711,13 +709,14 @@ object ExprOps {
val together = and(bind(ob, in) +: subTests :_*)
and(IsInstanceOf(cct, in), together)
- case TuplePattern(ob, subps) => {
+ case TuplePattern(ob, subps) =>
val TupleType(tpes) = in.getType
assert(tpes.size == subps.size)
val subTests = subps.zipWithIndex.map{case (p, i) => rec(tupleSelect(in, i+1, subps.size), p)}
and(bind(ob, in) +: subTests: _*)
- }
- case LiteralPattern(ob,lit) => and(Equals(in,lit), bind(ob,in))
+
+ case LiteralPattern(ob,lit) =>
+ and(Equals(in,lit), bind(ob,in))
}
}
@@ -860,17 +859,22 @@ object ExprOps {
var ieMap = Seq[(Identifier, Expr)]()
def addBinding(b : Option[Identifier], e : Expr) = b foreach { ieMap +:= (_, e) }
def rec(p : Pattern, expectedType : TypeTree) : Expr = p match {
- case WildcardPattern(b) => Variable(b getOrElse fresh(expectedType))
+ case WildcardPattern(b) =>
+ Variable(b getOrElse fresh(expectedType))
case LiteralPattern(b, lit) =>
addBinding(b,lit)
lit
case InstanceOfPattern(b, ct) => ct match {
- case act : AbstractClassType =>
+ case act: AbstractClassType =>
+ // @mk: This seems dubious, in the sense that it just binds the expression
+ // of the AbstractClassType to an id instead of going case-wise.
+ // I think this is sufficient for the use of this function though:
+ // it is only used to generate examples so it is followed by a type-aware enumerator.
val e = Variable(fresh(act))
addBinding(b, e)
e
- case cct : CaseClassType =>
+ case cct: CaseClassType =>
val fields = cct.fields map { f => Variable(fresh(f.getType)) }
val e = CaseClass(cct, fields)
addBinding(b, e)
diff --git a/src/main/scala/leon/purescala/Expressions.scala b/src/main/scala/leon/purescala/Expressions.scala
index a0e1e67af4063d36fede784a40b943175f096068..b49c61216e540e1011c2b3544c47bd46bc3e2649 100644
--- a/src/main/scala/leon/purescala/Expressions.scala
+++ b/src/main/scala/leon/purescala/Expressions.scala
@@ -164,7 +164,7 @@ object Expressions {
case class MatchCase(pattern : Pattern, optGuard : Option[Expr], rhs: Expr) extends Tree {
- def expressions: Seq[Expr] = List(rhs) ++ optGuard
+ def expressions: Seq[Expr] = optGuard.toList :+ rhs
}
sealed abstract class Pattern extends Tree {