use std::rc::Rc; use ast::{AST, Statement, Expression, Declaration, Discriminator, IfExpressionBody, Pattern}; use symbol_table::{Symbol, SymbolSpec, SymbolTable}; use builtin::{BinOp, PrefixOp}; #[derive(Debug)] pub struct ReducedAST(pub Vec); #[derive(Debug, Clone)] pub enum Stmt { PreBinding { name: Rc, func: Func, }, Binding { name: Rc, constant: bool, expr: Expr, }, Expr(Expr), Noop, } #[derive(Debug, Clone)] pub enum Expr { Unit, Lit(Lit), Tuple(Vec), Func(Func), Val(Rc), NewConstructor { type_name: Rc, tag: usize, arg: Box, }, Constructor { name: Rc, }, Call { f: Box, args: Vec, }, Assign { val: Box, expr: Box, }, Conditional { cond: Box, then_clause: Vec, else_clause: Vec, }, Match { cond: Box, alternatives: Vec }, UnimplementedSigilValue } #[derive(Debug, Clone)] pub struct Alternative { tag: usize, bound_vars: (), item: Vec, } #[derive(Debug, Clone)] pub enum Lit { Nat(u64), Int(i64), Float(f64), Bool(bool), StringLit(Rc), Custom(Rc, Vec), } #[derive(Debug, Clone)] pub enum Func { BuiltIn(Rc), UserDefined { name: Option>, params: Vec>, body: Vec, } } impl AST { pub fn reduce(&self, symbol_table: &SymbolTable) -> ReducedAST { let mut output = vec![]; for statement in self.0.iter() { output.push(statement.reduce(symbol_table)); } ReducedAST(output) } } impl Statement { fn reduce(&self, symbol_table: &SymbolTable) -> Stmt { use ast::Statement::*; match self { ExpressionStatement(expr) => Stmt::Expr(expr.reduce(symbol_table)), Declaration(decl) => decl.reduce(symbol_table), } } } impl Expression { fn reduce(&self, symbol_table: &SymbolTable) -> Expr { use ast::ExpressionType::*; let ref input = self.0; match input { NatLiteral(n) => Expr::Lit(Lit::Nat(*n)), FloatLiteral(f) => Expr::Lit(Lit::Float(*f)), StringLiteral(s) => Expr::Lit(Lit::StringLit(s.clone())), BoolLiteral(b) => Expr::Lit(Lit::Bool(*b)), BinExp(binop, lhs, rhs) => binop.reduce(symbol_table, lhs, rhs), PrefixExp(op, arg) => op.reduce(symbol_table, arg), Value(name) => { match symbol_table.values.get(name) { Some(Symbol { spec: SymbolSpec::DataConstructor { type_args, .. }, .. }) => { Expr::Constructor { name: name.clone() } }, _ => Expr::Val(name.clone()), } }, Call { f, arguments } => Expr::Call { f: Box::new(f.reduce(symbol_table)), args: arguments.iter().map(|arg| arg.reduce(symbol_table)).collect(), }, TupleLiteral(exprs) => Expr::Tuple(exprs.iter().map(|e| e.reduce(symbol_table)).collect()), IfExpression { discriminator, body } => reduce_if_expression(discriminator, body, symbol_table), _ => Expr::UnimplementedSigilValue, } } } fn reduce_if_expression(discriminator: &Discriminator, body: &IfExpressionBody, symbol_table: &SymbolTable) -> Expr { let cond = Box::new(match *discriminator { Discriminator::Simple(ref expr) => expr.reduce(symbol_table), _ => panic!(), }); match *body { IfExpressionBody::SimpleConditional(ref then_clause, ref else_clause) => { let then_clause = then_clause.iter().map(|expr| expr.reduce(symbol_table)).collect(); let else_clause = match else_clause { None => vec![], Some(stmts) => stmts.iter().map(|expr| expr.reduce(symbol_table)).collect(), }; Expr::Conditional { cond, then_clause, else_clause } }, IfExpressionBody::SimplePatternMatch(ref pat, ref then_clause, ref else_clause) => { let then_clause = then_clause.iter().map(|expr| expr.reduce(symbol_table)).collect(); let else_clause = match else_clause { None => vec![], Some(stmts) => stmts.iter().map(|expr| expr.reduce(symbol_table)).collect(), }; Expr::Match { //TODO this still doesn't work right cond, alternatives: vec![ Alternative { tag: 0, bound_vars: (), item: then_clause, }, Alternative { tag: 1, bound_vars: (), item: else_clause, }, ], } }, IfExpressionBody::GuardList(ref _guard_arms) => panic!(), } } impl Declaration { fn reduce(&self, symbol_table: &SymbolTable) -> Stmt { use self::Declaration::*; use ::ast::Signature; match self { Binding {name, constant, expr } => Stmt::Binding { name: name.clone(), constant: *constant, expr: expr.reduce(symbol_table) }, FuncDecl(Signature { name, params, .. }, statements) => Stmt::PreBinding { name: name.clone(), func: Func::UserDefined { name: Some(name.clone()), params: params.iter().map(|param| param.0.clone()).collect(), body: statements.iter().map(|stmt| stmt.reduce(symbol_table)).collect(), } }, TypeDecl { .. } => Stmt::Noop, TypeAlias(_, _) => Stmt::Noop, Interface { .. } => Stmt::Noop, Impl { .. } => Stmt::Expr(Expr::UnimplementedSigilValue), _ => Stmt::Expr(Expr::UnimplementedSigilValue) } } } impl BinOp { fn reduce(&self, symbol_table: &SymbolTable, lhs: &Box, rhs: &Box) -> Expr { if **self.sigil() == "=" { Expr::Assign { val: Box::new(lhs.reduce(symbol_table)), expr: Box::new(rhs.reduce(symbol_table)), } } else { let f = Box::new(Expr::Func(Func::BuiltIn(self.sigil().clone()))); Expr::Call { f, args: vec![lhs.reduce(symbol_table), rhs.reduce(symbol_table)]} } } } impl PrefixOp { fn reduce(&self, symbol_table: &SymbolTable, arg: &Box) -> Expr { let f = Box::new(Expr::Func(Func::BuiltIn(self.sigil().clone()))); Expr::Call { f, args: vec![arg.reduce(symbol_table)]} } }