feat: support recusive type/function.

tigerc/Cargo.toml

@@ -7,3 +7,5 @@ edition = "2021"
 unicode-xid = "0.2.4"
 indexmap = "2.2.6"
 tigerc-macros = { path = "../tigerc-macros" }
+clap = { version = "4.5.27", features = ["derive"] }
+log = "0.4.25"

tigerc/src/escape.rs

@@ -5,7 +5,7 @@ use std::vec;
 use crate::ast;
 use crate::ident_pool::Symbol;
 
-struct Escape {
+pub struct Escape {
     e: Option<Rc<RefCell<bool>>>,
 }
 
@@ -152,7 +152,7 @@ impl Escape {
             ast::LeftValue::Variable(s) => {
                 // escape!(depth, var_depth, s, var, self.e);
                 if let Some(v) = var {
-                    if depth > var_depth && dbg!(v) == s {
+                    if depth > var_depth && v == s {
                         if let Some(e) = &self.e {
                             e.replace(true);
                         }
@@ -238,7 +238,7 @@ mod tests {
         let mut parser = Parser::new(Box::new(it));
         let mut ast = parser.parse();
         Escape::new().escape(&mut ast);
-        let escape = match dbg!(ast) {
+        let escape = match ast {
             ast::Ast::Expr(ast::Expr::Let(ast::Let { decls, .. })) => {
                 let decl = decls.get(1).unwrap();
                 match decl {
@@ -267,7 +267,7 @@ mod tests {
         let mut parser = Parser::new(Box::new(it));
         let mut ast = parser.parse();
         Escape::new().escape(&mut ast);
-        let escape = match dbg!(ast) {
+        let escape = match ast {
             ast::Ast::Expr(ast::Expr::Let(ast::Let { decls, .. })) => {
                 let decl = decls.get(2).unwrap();
                 match decl {

tigerc/src/lib.rs

@@ -8,3 +8,13 @@ pub mod symbol_table;
 pub mod tokenizer;
 pub mod type_ast;
 pub mod type_inference;
+
+pub fn compile_file(f: &str) {
+    let content = std::fs::read_to_string(f).unwrap();
+    let it = tokenizer::tokenize(&content);
+    let mut parser = parser::Parser::new(Box::new(it));
+    let mut e = parser.parse();
+    escape::Escape::new().escape(&mut e);
+    let mut ti = type_inference::TypeInference::new();
+    let _te = ti.infer(&e).unwrap();
+}

tigerc/src/main.rs

@@ -1,3 +1,13 @@
+use clap::Parser as cParser;
+
+use tiger_c;
+
+#[derive(cParser, Debug)]
+struct Args {
+    input: String,
+}
+
 fn main() {
-    println!("Hello, world!");
+    let args = Args::parse();
+    tiger_c::compile_file(&args.input);
 }

tigerc/src/type_ast.rs

@@ -10,9 +10,26 @@ pub enum Type {
     Record(Record),
     Array(Box<Type>),
     Function(Function),
+    // just place holder for recursive type/function
     Name(Symbol),
 }
 
+impl Type {
+    // Can assign to other?
+    pub fn can_assign(&self, other: &Type) -> bool {
+        match self {
+            Type::Nil => {
+                if let Type::Record(_) = other {
+                    true
+                } else {
+                    false
+                }
+            }
+            _ => self == other,
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct Record {
     pub fields: IndexMap<Symbol, Type>,
@@ -200,7 +217,7 @@ pub struct FuncDecl {
 #[derive(Debug, PartialEq, Eq)]
 pub struct TyDecl {
     pub type_name: Symbol,
-    pub ty: Ty,
+    pub ty: Type,
 }
 
 #[derive(Debug, PartialEq, Eq)]