diff --git a/ParseMe.scala b/ParseMe.scala
index 51d34280866d171c2af4c26bd084d515f9028f98..1ff92a2725f9c5ee8da5cce5927ade75bf6e0993 100644
--- a/ParseMe.scala
+++ b/ParseMe.scala
@@ -11,6 +11,6 @@ object ParseMe {
   }
 
   def emptySet(n: Tree) : Tree = {
-    Leaf()
+    Node(Leaf(), 5, Leaf())
   }
 }
diff --git a/src/funcheck/CodeExtraction.scala b/src/funcheck/CodeExtraction.scala
index a391b51b95505291fbff664be8009815bad73f25..692fd689001d83d12c4a9f82af3ef912edd1f0c5 100644
--- a/src/funcheck/CodeExtraction.scala
+++ b/src/funcheck/CodeExtraction.scala
@@ -233,6 +233,18 @@ trait CodeExtraction extends Extractors {
         case Some(fun) => fun()
         case None => Variable(id)
       }
+      case ExCaseClassConstruction(tpt, args) => {
+        val cctype = scalaType2PureScala(unit, silent)(tpt.tpe)
+        if(!cctype.isInstanceOf[CaseClassType]) {
+          if(!silent) {
+            println(tr)
+            unit.error(tree.pos, "Construction of a non-case class.")
+          }
+          throw ImpureCodeEncounteredException(tree)
+        }
+        val nargs = args.map(rec(_))
+        CaseClass(cctype.asInstanceOf[CaseClassType], nargs)
+      }
       case ExAnd(l, r) => And(rec(l), rec(r))
       case ExOr(l, r) => Or(rec(l), rec(r))
       case ExNot(e) => Not(rec(e))
diff --git a/src/funcheck/Extractors.scala b/src/funcheck/Extractors.scala
index 7711d5373ab1a3f3e754861e892f082f6bd8b182..8f68309facb3bb199a563bc809ce2ae21ccedad8 100644
--- a/src/funcheck/Extractors.scala
+++ b/src/funcheck/Extractors.scala
@@ -98,7 +98,7 @@ trait Extractors {
 
     object ExConstructorDef {
       def unapply(dd: DefDef): Boolean = dd match {
-        case DefDef(_, name, tparams, vparamss, tpt, rhs) if(name.toString == "<init>" && tparams.isEmpty && vparamss.size == 1) => true
+        case DefDef(_, name, tparams, vparamss, tpt, rhs) if(name == nme.CONSTRUCTOR && tparams.isEmpty && vparamss.size == 1) => true
         case _ => false
       }
     }
@@ -131,7 +131,7 @@ trait Extractors {
     }
 
     object ExBooleanLiteral {
-      def unapply(tree: Tree): Option[Boolean] = tree match {
+      def unapply(tree: Literal): Option[Boolean] = tree match {
         case Literal(Constant(true)) => Some(true)
         case Literal(Constant(false)) => Some(false)
         case _ => None
@@ -139,28 +139,37 @@ trait Extractors {
     }
 
     object ExInt32Literal {
-      def unapply(tree: Tree): Option[Int] = tree match {
+      def unapply(tree: Literal): Option[Int] = tree match {
         case Literal(c @ Constant(i)) if c.tpe == IntClass.tpe => Some(c.intValue)
         case _ => None
       }
     }
 
+    object ExCaseClassConstruction {
+      def unapply(tree: Apply): Option[(Tree,Seq[Tree])] = tree match {
+        case Apply(s @ Select(New(tpt), n), args) if (n == nme.CONSTRUCTOR) => {
+          Some((tpt, args))
+        }
+        case _ => None
+      }
+    }
+
     object ExIdentifier {
-      def unapply(tree: Tree): Option[(String,Tree)] = tree match {
+      def unapply(tree: Ident): Option[(String,Tree)] = tree match {
         case i: Ident => Some((i.symbol.name.toString, i))
         case _ => None
       }
     }
 
     object ExIntIdentifier {
-      def unapply(tree: Tree): Option[String] = tree match {
+      def unapply(tree: Ident): Option[String] = tree match {
         case i: Ident if i.symbol.tpe == IntClass.tpe => Some(i.symbol.name.toString)
         case _ => None
       }
     }
 
     object ExAnd {
-      def unapply(tree: Tree): Option[(Tree,Tree)] = tree match {
+      def unapply(tree: Apply): Option[(Tree,Tree)] = tree match {
         case Apply(s @ Select(lhs, _), List(rhs)) if (s.symbol == Boolean_and) =>
           Some((lhs,rhs))
         case _ => None
@@ -259,8 +268,4 @@ trait Extractors {
       }
     }
   }
-
-  object TypeExtractors {
-
-  }
 }
diff --git a/src/purescala/PrettyPrinter.scala b/src/purescala/PrettyPrinter.scala
index aa17e1d16daaa28c08e044e4f7faaa4b21bd5fad..e57c1d34e4fcee824c84978e6f6bd9c16ffe8dbb 100644
--- a/src/purescala/PrettyPrinter.scala
+++ b/src/purescala/PrettyPrinter.scala
@@ -71,6 +71,13 @@ object PrettyPrinter {
     case Equals(l,r) => ppBinary(sb, l, r, " == ")
     case IntLiteral(v) => sb.append(v)
     case BooleanLiteral(v) => sb.append(v)
+    case StringLiteral(s) => sb.append("\"" + s + "\"")
+    case CaseClass(ct, args) => {
+      var nsb = sb
+      nsb.append(ct.id)
+      nsb = ppNary(nsb, args, ", ")
+      nsb
+    }
     case Plus(l,r) => ppBinary(sb, l, r, " + ")
     case Minus(l,r) => ppBinary(sb, l, r, " - ")
     case Times(l,r) => ppBinary(sb, l, r, " * ")
diff --git a/src/purescala/Trees.scala b/src/purescala/Trees.scala
index ace8d8e01f5b0102c7dbbd2513e355e6040ea94d..b89a6ac1ef3d6cfe33ae454a5a6463601beb6862 100644
--- a/src/purescala/Trees.scala
+++ b/src/purescala/Trees.scala
@@ -75,7 +75,7 @@ object Trees {
   case class BooleanLiteral(value: Boolean) extends Literal[Boolean] 
   case class StringLiteral(value: String) extends Literal[String]
 
-  case class CaseClass(classDef: CaseClassDef, args: Seq[Expr]) extends Expr
+  case class CaseClass(classType: CaseClassType, args: Seq[Expr]) extends Expr
 
   /* Arithmetic */
   case class Plus(lhs: Expr, rhs: Expr) extends Expr
diff --git a/src/purescala/TypeTrees.scala b/src/purescala/TypeTrees.scala
index 5bd212f146b1804f2b589558d8bf0f46863924c5..35740fbaa08455b0ea7a5fd1faf4a13179bc48fd 100644
--- a/src/purescala/TypeTrees.scala
+++ b/src/purescala/TypeTrees.scala
@@ -40,9 +40,10 @@ object TypeTrees {
 
   sealed abstract class ClassType extends TypeTree {
     val classDef: ClassTypeDef
+    val id: Identifier = classDef.id
   }
 
   case class AbstractClassType(classDef: AbstractClassDef) extends ClassType
-  case class CaseClassType(classDef: CaseClassDef) extends ClassType
+  case class CaseClassType(classDef: CaseClassDef) extends ClassType 
   case class OptionType(base: TypeTree) extends TypeTree
 }