More debugging of polymorphism

Author: antoyo

tiger/src/ast.rs

@@ -221,6 +221,7 @@ pub type InnerTypeWithPos = WithPos<InnerType>;
 pub struct TypeDec {
     pub name: SymbolWithPos,
     pub ty: TyWithPos,
+    /// Generic types.
     pub ty_vars: TypeVars,
 }
 

tiger/src/semant.rs

@@ -181,11 +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));
+                //println!("1: {:?}: {}", typ, self.symbols.name(type_var.0));
                 if let Some(actual_type) = self.env.look_type(type_var.0) {
-                    println!("2");
+                    //println!("2");
                     if typ != actual_type {
-                        println!("3");
+                        //println!("3");
                         return self.actual_ty(actual_type);
                     }
                 }
@@ -600,6 +600,7 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                 }
 
                 for &WithPos { node: TypeDec { ref name, ref ty, ref ty_vars, .. }, .. } in type_declarations {
+                    println!("======\nType declaration name: {}", self.symbols.name(name.node));
                     let has_type_args = !ty_vars.idents.is_empty();
                     if has_type_args {
                         self.env.begin_type_scope();
@@ -620,6 +621,7 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                 None
             },
             Declaration::VariableDeclaration { ref init, name, ref typ, .. } => {
+                println!("********\nVar {}", self.symbols.name(name));
                 let exp = self.trans_exp(init, parent_level, done_label, true);
                 let is_collectable = type_is_collectable(&exp.ty);
                 let escape = self.env.look_escape(name);
@@ -641,6 +643,7 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                     self.add_error(Error::RecordType { pos: declaration.pos });
                     return None;
                 }
+                println!("===> ({}) Type: {:?}", self.symbols.name(name), exp.ty);
                 let var = var_dec(&access, exp.exp);
                 self.env.enter_var(name, Entry::Var { access, typ: exp.ty });
                 Some(var)
@@ -727,6 +730,7 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                 }
             },
             Expr::Call { ref args, ref function, ref type_args } => {
+                // TODO: use type_args.
                 match function.node {
                     Expr::Variable(ref func) => {
                         match self.env.look_var(func.node).cloned() { // TODO: remove this clone.
@@ -936,6 +940,7 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                 EXP_TYPE_ERROR
             },
             Expr::Field { ref ident, ref this } => {
+                println!(" | Field {:?}.{:?}", this.node, self.symbols.name(ident.node));
                 let var = self.trans_exp(this, level, done_label, true);
                 match var.ty {
                     Type::App(TypeConstructor::Unique(inner_type, _), _) => {
@@ -954,6 +959,7 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                             TypeConstructor::Record { name: record_type, ref types, .. } => {
                                 for (index, &(name, ref typ)) in types.iter().enumerate() {
                                     if name == ident.node {
+                                        println!("Record field: {}: {:?}", self.symbols.name(name), typ);
                                         return ExpTy {
                                             exp: field_access::<F>(var.exp, index, FieldType::Record),
                                             ty: typ.clone(),
@@ -1195,6 +1201,7 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                 }
             },
             Expr::Record { ref fields, ref typ, ref type_args } => {
+                // TODO: use type_args to replace the generic types in the record type.
                 let ty = self.get_type(typ, AddError);
                 let mut field_exprs = vec![];
                 let data_layout =

tiger/src/types.rs

@@ -62,6 +62,9 @@ pub struct TyVar(pub Symbol);
 
 impl TyVar {
     pub fn from_symbol(symbol: Symbol) -> Self {
+        if symbol == 78 {
+            println!("****************************************************************************************************\nHERE");
+        }
         Self(symbol)
     }
 }

tiger/tests/polymorphism.tig

@@ -65,9 +65,12 @@ in
     print(string_pair.second);
     print("\n");
     printi(two4s.head);
+    /* FIXME: second get the type `a` declared in the type `pair`. It should be resolved to its actual type. */
     let var second := struct_pair.second
     in
-        printi(second.c)
+        printi(second.c) /* FIXME: this line causes the panic.
+            Maybe this is because the type of second is not the correct one.
+            */
     end
     /* TODO: correct code generation (monomorphisation) for polymorphic code. */
     /*f(string_pair); /* Should be an error. */ */