Start of semantic analysis for polymorphic code

Author: antoyo

tiger/src/env.rs

@@ -127,6 +127,14 @@ impl<F: Clone + Frame> Env<F> {
         self.var_env.end_scope();
     }
 
+    pub fn begin_type_scope(&mut self) {
+        self.type_env.begin_scope();
+    }
+
+    pub fn end_type_scope(&mut self) {
+        self.type_env.end_scope();
+    }
+
     pub fn enter_escape(&mut self, symbol: Symbol, escape: bool) {
         self.escape_env.enter(symbol, DepthEscape {
             depth: 0, // This value is not used anymore.

tiger/src/semant.rs

@@ -596,8 +596,22 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                     self.env.enter_type(name.node, Type::Var(TyVar::from_symbol(name.node)));
                 }
 
-                for &WithPos { node: TypeDec { ref name, ref ty, .. }, .. } in type_declarations {
+                for &WithPos { node: TypeDec { ref name, ref ty, ref ty_vars, .. }, .. } in type_declarations {
+                    let has_type_args = !ty_vars.idents.is_empty();
+                    if has_type_args {
+                        self.env.begin_type_scope();
+                    }
+                    let mut type_vars = vec![];
+                    for var in &ty_vars.idents {
+                        let type_var = self.new_type_var();
+                        type_vars.push(type_var);
+                        self.env.enter_type(var.node, Type::Var(type_var));
+                    }
+
                     let new_type = self.trans_ty(name.node, ty);
+                    if has_type_args {
+                        self.env.end_type_scope();
+                    }
                     self.env.enter_type(name.node, new_type);
                 }
                 None
@@ -1407,6 +1421,7 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
         match ty.node.typ.node {
             InnerType::Array { ref ident } => {
                 let ty = self.get_type(ident, AddError);
+                // FIXME: according to the book, the Unique should be at the outermost.
                 Type::App(TypeConstructor::new_unique(TypeConstructor::Array), vec![ty])
             },
             InnerType::Function { ref parameters, ref return_type } => {
@@ -1506,6 +1521,10 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
         (fields, data_layout, parent_methods)
     }
 
+    fn new_type_var(&mut self) -> TyVar {
+        TyVar::from_symbol(self.symbols.unnamed())
+    }
+
     fn duplicate_param(&mut self, param: &FieldWithPos) {
         let ident = self.env.var_name(param.node.name);
         self.add_error(Error::DuplicateParam {

tiger/src/types.rs

@@ -57,7 +57,7 @@ pub struct ClassMethod {
     pub typ: FunctionType,
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq)]
 pub struct TyVar(pub Symbol);
 
 impl TyVar {

tiger/tests/polymorphism.stdout

@@ -0,0 +1,2 @@
+2
+4

tiger/tests/polymorphism.tig

@@ -33,13 +33,16 @@ let type list<e> = {
         first = "test",
         second = "2"
     }
-    /* FIXME: there's conflict between `var < 12` and `func<int>()`, so find a way to differentiate the syntax. */
     var my_two_some := twosome::<int> {
         first = 4,
         second = 2
     }
 
 in
-    f(string_pair); /* Should be an error. */
-    f(my_two_some) /* Should be an error. */
+    print(string_pair.second);
+    print("\n");
+    printi(two4s.head)
+    /* TODO: correct code generation (monomorphisation) for polymorphic code. */
+    /*f(string_pair); /* Should be an error. */ */
+    /*f(my_two_some) /* Should be an error. */ */
 end

tiger/tests/test.rs

@@ -48,6 +48,7 @@ fn test_execution() {
         "loops",
         "merge",
         "nested",
+        "polymorphism",
         "prettyprint",
         "pureTree",
         "queens",