WIP: debugging bugs with polymorphism

Author: antoyo

tiger/src/asm_gen.rs

@@ -98,7 +98,7 @@ impl<F: Frame> Gen<F> {
             // Error cases:
             Exp::Error | Exp::ExpSequence(_, _) | Exp::BinOp { left: box Exp::Error, .. }
                 | Exp::BinOp { right: box Exp::Error, .. } | Exp::BinOp { right: box Exp::Name(_), .. }
-                => unreachable!(),
+                => unreachable!("{:?}", expr),
 
             Exp::BinOp { op: BinOp::Plus, left: box Exp::Name(label), right } => {
                 let instruction = Instruction::Move {

tiger/src/semant.rs

@@ -181,8 +181,11 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
     fn actual_ty(&self, typ: &Type) -> Type {
         match *typ {
             Type::Var(ref type_var) => {
+                println!("1: {:?}: {}", typ, self.symbols.name(type_var.0));
                 if let Some(actual_type) = self.env.look_type(type_var.0) {
+                    println!("2");
                     if typ != actual_type {
+                        println!("3");
                         return self.actual_ty(actual_type);
                     }
                 }
@@ -959,10 +962,16 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                                 }
                                 self.unexpected_field(ident, ident.pos, record_type)
                             },
-                            _ => EXP_TYPE_ERROR,
+                            _ => {
+                                panic!();
+                                EXP_TYPE_ERROR
+                            },
                         }
                     },
-                    Type::Error => EXP_TYPE_ERROR,
+                    Type::Error => {
+                        panic!();
+                        EXP_TYPE_ERROR
+                    },
                     typ => {
                         self.add_error(Error::NotARecordOrClass {
                             pos: this.pos,
@@ -1284,7 +1293,10 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                                     ty: self.actual_ty(&types[0]),
                                 }
                             },
-                            _ => EXP_TYPE_ERROR,
+                            _ => {
+                                panic!();
+                                EXP_TYPE_ERROR
+                            },
                         }
                     },
                     Type::Error => EXP_TYPE_ERROR,

tiger/tests/polymorphism.tig

@@ -3,6 +3,12 @@ let type list<e> = {
     tail: list<e>
 }
 
+    type MyStruct = {
+        a: int,
+        b: int,
+        c: int
+    }
+
     function append<e>(a: list<e>, b: list<e>): list<e> =
         if a = nil then
             b
@@ -37,11 +43,32 @@ let type list<e> = {
         first = 4,
         second = 2
     }
+    var struct_pair := pair::<MyStruct> {
+        first = MyStruct {
+            a = 1,
+            b = 2,
+            c = 3
+        },
+        second = MyStruct {
+            a = 4,
+            b = 5,
+            c = 6
+        }
+    }
+    /* FIXME: this doesn't parse: */
+    /*var nested_list := list<list<int>> {
+        head = two4s,
+        tail = nil
+    }*/
 
 in
     print(string_pair.second);
     print("\n");
-    printi(two4s.head)
+    printi(two4s.head);
+    let var second := struct_pair.second
+    in
+        printi(second.c)
+    end
     /* TODO: correct code generation (monomorphisation) for polymorphic code. */
     /*f(string_pair); /* Should be an error. */ */
     /*f(my_two_some) /* Should be an error. */ */