From 540a61dab9ead8a7936de7f7c1408b9a5725c7d4 Mon Sep 17 00:00:00 2001
From: Philippe Suter <philippe.suter@gmail.com>
Date: Fri, 21 May 2010 13:29:48 +0000
Subject: [PATCH] It works now so fine I will write a short haiku And no long
 Limerick

---
 src/funcheck/CodeExtraction.scala | 33 ++++++++++++++++++++++++++++---
 src/purescala/Definitions.scala   | 20 +++++++++++++++----
 src/purescala/PrettyPrinter.scala |  9 +++++++++
 3 files changed, 55 insertions(+), 7 deletions(-)

diff --git a/src/funcheck/CodeExtraction.scala b/src/funcheck/CodeExtraction.scala
index 9dca1024a..3fd4b0397 100644
--- a/src/funcheck/CodeExtraction.scala
+++ b/src/funcheck/CodeExtraction.scala
@@ -70,21 +70,48 @@ trait CodeExtraction extends Extractors {
 
       val scalaClassSyms: scala.collection.mutable.Map[Symbol,Identifier] =
         scala.collection.mutable.Map.empty[Symbol,Identifier]
+      val scalaClassNames: scala.collection.mutable.Set[Identifier] = 
+        scala.collection.mutable.Set.empty[Identifier]
 
       // we need the new type definitions before we can do anything...
-      tmpl.body.foreach(
-        _ match {
+      tmpl.body.foreach(t =>
+        t match {
           case ExAbstractClass(o2, sym) => {
+            if(scalaClassNames.contains(o2)) {
+              unit.error(t.pos, "A class with the same name already exists.")
+            }
             scalaClassSyms += (sym -> o2)
+            scalaClassNames += o2
           }
           case ExCaseClass(o2, sym) => {
+            if(scalaClassNames.contains(o2)) {
+              unit.error(t.pos, "A class with the same name already exists.")
+            }
             scalaClassSyms += (sym -> o2)
+            scalaClassNames += o2
           }
           case _ => ;
         }
       )
 
-      println(scalaClassSyms)
+      stopIfErrors
+
+      val classesToClasses: scala.collection.mutable.Map[Symbol,ClassTypeDef] =
+        scala.collection.mutable.Map.empty[Symbol,ClassTypeDef]
+
+      scalaClassSyms.foreach(p => {
+          if(p._1.isAbstractClass) {
+            classesToClasses += (p._1 -> new AbstractClassDef(p._2, None))
+          } else if(p._1.isCase) {
+            classesToClasses += (p._1 -> new CaseClassDef(p._2, None))
+          }
+      })
+
+      // TODO
+      // resolve all inheritance links (look at 
+      // add all fields to case classes
+
+      println(classesToClasses)
 
       tmpl.body.foreach(
         _ match {
diff --git a/src/purescala/Definitions.scala b/src/purescala/Definitions.scala
index 6dd35e862..13792638d 100644
--- a/src/purescala/Definitions.scala
+++ b/src/purescala/Definitions.scala
@@ -77,7 +77,8 @@ object Definitions {
    * patterns (of pattern-matching, that is) */
   sealed trait ClassTypeDef extends Definition {
     val id: Identifier
-    val parent: Option[AbstractClassDef]
+    var parent: Option[AbstractClassDef]
+    val isAbstract: Boolean
     // val fields: VarDecls
   }
 
@@ -85,18 +86,29 @@ object Definitions {
    * implicitely define extractors) and explicitely defined unapply methods. */
   sealed trait ExtractorTypeDef
 
+  object AbstractClassDef {
+    def unapply(acd: AbstractClassDef): Option[(Identifier,Option[AbstractClassDef])] = {
+      Some((acd.id, acd.parent))
+    }
+  }
+
   /** Abstract classes. */
-  class AbstractClassDef(val id: Identifier, val parent: Option[AbstractClassDef]) extends ClassTypeDef {
+  class AbstractClassDef(val id: Identifier, var parent: Option[AbstractClassDef]) extends ClassTypeDef {
     var fields: VarDecls = Nil
+    val isAbstract = true
   }
 
   /** Case classes. */
-  class CaseClassDef(val id: Identifier, val parent: Option[AbstractClassDef]) extends ClassTypeDef with ExtractorTypeDef {
+  class CaseClassDef(val id: Identifier, var parent: Option[AbstractClassDef]) extends ClassTypeDef with ExtractorTypeDef {
     var fields: VarDecls = Nil
+    val isAbstract = false
   }
 
   /** "Regular" classes */
-  case class ClassDef(id: Identifier, parent: Option[AbstractClassDef], fields: VarDecls) extends ClassTypeDef
+  class ClassDef(val id: Identifier, var parent: Option[AbstractClassDef]) extends ClassTypeDef {
+    var fields: VarDecls = Nil
+    val isAbstract = false
+  }
   
   /** Values */
   case class ValDef(varDecl: VarDecl, value: Expr) extends Definition {
diff --git a/src/purescala/PrettyPrinter.scala b/src/purescala/PrettyPrinter.scala
index 5442e0c8c..a46028e52 100644
--- a/src/purescala/PrettyPrinter.scala
+++ b/src/purescala/PrettyPrinter.scala
@@ -143,6 +143,15 @@ object PrettyPrinter {
         ind(nsb); nsb.append("}\n")
       }
 
+      case AbstractClassDef(id, parent) => {
+        var nsb = sb
+        ind(nsb)
+        nsb.append("sealed abstract class ")
+        nsb.append(id)
+        parent.foreach(p => nsb.append("extends " + p.id + " "))
+        nsb
+      }
+
       case FunDef(id, rt, args, body, pre, post) => {
         var nsb = sb
 
-- 
GitLab