191 lines
4.8 KiB
Rust
191 lines
4.8 KiB
Rust
use std::rc::Rc;
|
|
|
|
use ast::*;
|
|
use util::ScopeStack;
|
|
|
|
pub type TypeName = Rc<String>;
|
|
|
|
pub struct TypeContext<'a> {
|
|
variable_map: ScopeStack<'a, Rc<String>, MonoType>
|
|
}
|
|
|
|
type InferResult<T> = Result<T, TypeError>;
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct TypeError { msg: String }
|
|
|
|
impl TypeError {
|
|
fn new<A>(msg: &str) -> InferResult<A> {
|
|
Err(TypeError { msg: msg.to_string() })
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum MonoType {
|
|
Var(Rc<String>),
|
|
Const(TConst),
|
|
Arrow(Box<MonoType>, Box<MonoType>)
|
|
}
|
|
|
|
impl TypeIdentifier {
|
|
fn to_monotype(&self) -> MonoType {
|
|
match self {
|
|
TypeIdentifier::Tuple(items) => unimplemented!(),
|
|
TypeIdentifier::Singleton(TypeSingletonName { name, .. }) => {
|
|
match &name[..] {
|
|
"Nat" => MonoType::Const(TConst::Nat),
|
|
"Int" => MonoType::Const(TConst::Int),
|
|
"Float" => MonoType::Const(TConst::Float),
|
|
"Bool" => MonoType::Const(TConst::Bool),
|
|
"String" => MonoType::Const(TConst::StringT),
|
|
_ => unimplemented!()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum TConst {
|
|
User(Rc<String>),
|
|
Unit,
|
|
Nat,
|
|
Int,
|
|
Float,
|
|
StringT,
|
|
Bool,
|
|
}
|
|
|
|
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<'a> TypeContext<'a> {
|
|
pub fn new() -> TypeContext<'a> {
|
|
TypeContext {
|
|
variable_map: ScopeStack::new(None),
|
|
}
|
|
}
|
|
|
|
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<'a> TypeContext<'a> {
|
|
fn infer_ast(&mut self, ast: &AST) -> InferResult<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) -> InferResult<MonoType> {
|
|
match expr {
|
|
Expression(expr_type, Some(type_anno)) => {
|
|
let tx = self.infer_expr_type(expr_type)?;
|
|
let ty = type_anno.to_monotype();
|
|
self.unify(&ty, &tx)
|
|
},
|
|
Expression(expr_type, None) => self.infer_expr_type(expr_type)
|
|
}
|
|
}
|
|
|
|
fn infer_decl(&mut self, expr: &Declaration) -> InferResult<MonoType> {
|
|
Ok(MonoType::Const(TConst::user("unimplemented")))
|
|
}
|
|
|
|
fn infer_expr_type(&mut self, expr_type: &ExpressionType) -> InferResult<MonoType> {
|
|
use self::ExpressionType::*;
|
|
Ok(match expr_type {
|
|
NatLiteral(_) => MonoType::Const(TConst::Nat),
|
|
FloatLiteral(_) => MonoType::Const(TConst::Float),
|
|
StringLiteral(_) => MonoType::Const(TConst::StringT),
|
|
BoolLiteral(_) => MonoType::Const(TConst::Bool),
|
|
Value(name) => {
|
|
//TODO handle the distinction between 0-arg constructors and variables at some point
|
|
// need symbol table for that
|
|
match self.variable_map.lookup(name) {
|
|
Some(ty) => ty.clone(),
|
|
None => return TypeError::new(&format!("Variable {} not found", name))
|
|
}
|
|
},
|
|
IfExpression { discriminator, body } => self.infer_if_expr(discriminator, body)?,
|
|
Call { f, arguments } => {
|
|
let tf: MonoType = self.infer_expr(f)?; //has to be an Arrow MonoType
|
|
let targ = self.infer_expr(&arguments[0])?; // TODO make this work with functions with more than one arg
|
|
match tf {
|
|
MonoType::Arrow(t1, t2) => {
|
|
self.unify(&t1, &targ)?;
|
|
*t2.clone()
|
|
},
|
|
_ => return TypeError::new("not a function")
|
|
}
|
|
},
|
|
_ => MonoType::Const(TConst::user("unimplemented"))
|
|
})
|
|
}
|
|
|
|
fn infer_if_expr(&mut self, discriminator: &Discriminator, body: &IfExpressionBody) -> InferResult<MonoType> {
|
|
let test = match discriminator {
|
|
Discriminator::Simple(expr) => expr,
|
|
_ => return TypeError::new("Dame desu")
|
|
};
|
|
|
|
let (then_clause, maybe_else_clause) = match body {
|
|
IfExpressionBody::SimpleConditional(a, b) => (a, b),
|
|
_ => return TypeError::new("Dont work")
|
|
};
|
|
|
|
unimplemented!()
|
|
}
|
|
|
|
fn unify(&mut self, t1: &MonoType, t2: &MonoType) -> InferResult<MonoType> {
|
|
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() {
|
|
|
|
}
|
|
}
|