now with construction of case classes

ParseMe.scala

@@ -11,6 +11,6 @@ object ParseMe {
   }
 
   def emptySet(n: Tree) : Tree = {
-    Leaf()
+    Node(Leaf(), 5, Leaf())
   }
 }

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))

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 {
-
-  }
 }

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, " * ")

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

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
 }