schala/schala-lang/language/src/typechecking.rs

use std::rc::Rc;

use ast::*;

pub type TypeName = Rc<String>;

pub struct TypeContext {

}

type TypeResult<T> = Result<T, TypeError>;

#[derive(Debug, Clone)]
struct TypeError { }

#[derive(Debug, Clone)]
enum MonoType {
  Var(Rc<String>),
  Const(TConst),
  Arrow(Rc<String>)
}

#[derive(Debug, Clone)]
enum TConst {
  User(Rc<String>),
  Unit,
  Nat,
  Int,
  Float,
  StringT,
}

impl TConst {
  fn user(name: &str) -> TConst {
    TConst::User(Rc::new(name.to_string()))
  }
}

#[derive(Debug, Clone)]
struct PolyType {
  vars: Vec<Rc<String>>,
  ty: MonoType
}

impl TypeContext {
  pub fn new() -> TypeContext {
    TypeContext { }
  }

  pub fn typecheck(&mut self, ast: &AST) -> Result<String, String> {
    match self.infer_ast(ast) {
      Ok(t) => Ok(format!("{:?}", t)),
      Err(err) => Err(format!("Type error: {:?}", err))
    }
  }
}

impl TypeContext {
  fn infer_ast(&mut self, ast: &AST) -> TypeResult<MonoType> {
    let mut output = MonoType::Const(TConst::Unit);
    for statement in ast.0.iter() {
      output = match statement {
        Statement::ExpressionStatement(ref expr) => self.infer_expr(expr)?,
        Statement::Declaration(ref decl) => self.infer_decl(decl)?,
      };
    }
    Ok(output)
  }

  fn infer_expr(&mut self, expr: &Expression) -> TypeResult<MonoType> {
    match expr {
      Expression(expr_type, Some(type_anno)) => unimplemented!(),
      Expression(expr_type, None) => self.infer_expr_type(expr_type)
    }
  }

  fn infer_decl(&mut self, expr: &Declaration) -> TypeResult<MonoType> {
    Ok(MonoType::Const(TConst::user("unimplemented")))
  }

  fn infer_expr_type(&mut self, expr_type: &ExpressionType) -> TypeResult<MonoType> {
    use self::ExpressionType::*;
    match expr_type {
      NatLiteral(_) => Ok(MonoType::Const(TConst::Nat)),
      FloatLiteral(_) => Ok(MonoType::Const(TConst::Float)),
      StringLiteral(_) => Ok(MonoType::Const(TConst::StringT)),
      _ => Ok(MonoType::Const(TConst::user("unimplemented")))
    }
  }
}

#[cfg(test)]
mod tests {
  use super::*;

  fn parse(input: &str) -> AST {
    let tokens: Vec<::tokenizing::Token> = ::tokenizing::tokenize(input);
    let mut parser = ::parsing::Parser::new(tokens);
    parser.parse().unwrap()
  }

  macro_rules! type_test {
    ($input:expr, $correct:expr) => {
      {
      let mut tc = TypeContext::new();
      let ast = parse($input);
      tc.add_symbols(&ast);
      assert_eq!($correct, tc.type_check(&ast).unwrap())
      }
    }
  }



  #[test]
  fn basic_inference() {

  }
}