40579d80ce
not quite done
409 lines
12 KiB
Rust
409 lines
12 KiB
Rust
use std::rc::Rc;
|
|
|
|
use crate::ast::*;
|
|
use crate::symbol_table::{Symbol, SymbolSpec, SymbolTable};
|
|
use crate::builtin::{BinOp, PrefixOp};
|
|
|
|
#[derive(Debug)]
|
|
pub struct ReducedAST(pub Vec<Stmt>);
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum Stmt {
|
|
PreBinding {
|
|
name: Rc<String>,
|
|
func: Func,
|
|
},
|
|
Binding {
|
|
name: Rc<String>,
|
|
constant: bool,
|
|
expr: Expr,
|
|
},
|
|
Expr(Expr),
|
|
Noop,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum Expr {
|
|
Unit,
|
|
Lit(Lit),
|
|
Tuple(Vec<Expr>),
|
|
Func(Func),
|
|
Val(Rc<String>),
|
|
Constructor {
|
|
type_name: Rc<String>,
|
|
name: Rc<String>,
|
|
tag: usize,
|
|
arity: usize,
|
|
},
|
|
Call {
|
|
f: Box<Expr>,
|
|
args: Vec<Expr>,
|
|
},
|
|
Assign {
|
|
val: Box<Expr>,
|
|
expr: Box<Expr>,
|
|
},
|
|
Conditional {
|
|
cond: Box<Expr>,
|
|
then_clause: Vec<Stmt>,
|
|
else_clause: Vec<Stmt>,
|
|
},
|
|
ConditionalTargetSigilValue,
|
|
CaseMatch {
|
|
cond: Box<Expr>,
|
|
alternatives: Vec<Alternative>
|
|
},
|
|
UnimplementedSigilValue
|
|
}
|
|
|
|
pub type BoundVars = Vec<Option<Rc<String>>>; //remember that order matters here
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Alternative {
|
|
pub tag: Option<usize>,
|
|
pub subpatterns: Vec<Option<Subpattern>>,
|
|
pub guard: Option<Expr>,
|
|
pub bound_vars: BoundVars,
|
|
pub item: Vec<Stmt>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Subpattern {
|
|
pub tag: Option<usize>,
|
|
pub subpatterns: Vec<Option<Subpattern>>,
|
|
pub bound_vars: BoundVars,
|
|
pub guard: Option<Expr>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum Lit {
|
|
Nat(u64),
|
|
Int(i64),
|
|
Float(f64),
|
|
Bool(bool),
|
|
StringLit(Rc<String>),
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum Func {
|
|
BuiltIn(Rc<String>),
|
|
UserDefined {
|
|
name: Option<Rc<String>>,
|
|
params: Vec<Rc<String>>,
|
|
body: Vec<Stmt>,
|
|
}
|
|
}
|
|
|
|
impl AST {
|
|
pub fn reduce(&self, symbol_table: &SymbolTable) -> ReducedAST {
|
|
let mut output = vec![];
|
|
for statement in self.0.iter() {
|
|
output.push(statement.node().reduce(symbol_table));
|
|
}
|
|
ReducedAST(output)
|
|
}
|
|
}
|
|
|
|
impl Statement {
|
|
fn reduce(&self, symbol_table: &SymbolTable) -> Stmt {
|
|
use crate::ast::Statement::*;
|
|
match self {
|
|
ExpressionStatement(expr) => Stmt::Expr(expr.node().reduce(symbol_table)),
|
|
Declaration(decl) => decl.reduce(symbol_table),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn reduce_block(block: &Block, symbol_table: &SymbolTable) -> Vec<Stmt> {
|
|
block.iter().map(|stmt| stmt.node().reduce(symbol_table)).collect()
|
|
}
|
|
|
|
impl InvocationArgument {
|
|
fn reduce(&self, symbol_table: &SymbolTable) -> Expr {
|
|
use crate::ast::InvocationArgument::*;
|
|
match self {
|
|
Positional(ex) => ex.reduce(symbol_table),
|
|
Keyword { .. } => Expr::UnimplementedSigilValue,
|
|
Ignored => Expr::UnimplementedSigilValue,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Expression {
|
|
fn reduce(&self, symbol_table: &SymbolTable) -> Expr {
|
|
use crate::ast::ExpressionKind::*;
|
|
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.lookup_by_name(name) {
|
|
Some(Symbol { spec: SymbolSpec::DataConstructor { index, type_args, type_name}, .. }) => Expr::Constructor {
|
|
type_name: type_name.clone(),
|
|
name: name.clone(),
|
|
tag: index.clone(),
|
|
arity: type_args.len(),
|
|
},
|
|
_ => Expr::Val(name.clone()),
|
|
},
|
|
Call { f, arguments } => Expr::Call {
|
|
f: Box::new(f.node().reduce(symbol_table)),
|
|
args: arguments.iter().map(|arg| arg.node().reduce(symbol_table)).collect(),
|
|
},
|
|
TupleLiteral(exprs) => Expr::Tuple(exprs.iter().map(|e| e.node().reduce(symbol_table)).collect()),
|
|
IfExpression { discriminator, body } => reduce_if_expression(discriminator, body, symbol_table),
|
|
Lambda { params, body, .. } => reduce_lambda(params, body, symbol_table),
|
|
NamedStruct { .. } => Expr::UnimplementedSigilValue,
|
|
Index { .. } => Expr::UnimplementedSigilValue,
|
|
WhileExpression { .. } => Expr::UnimplementedSigilValue,
|
|
ForExpression { .. } => Expr::UnimplementedSigilValue,
|
|
ListLiteral { .. } => Expr::UnimplementedSigilValue,
|
|
}
|
|
}
|
|
}
|
|
|
|
fn reduce_lambda(params: &Vec<FormalParam>, body: &Block, symbol_table: &SymbolTable) -> Expr {
|
|
Expr::Func(Func::UserDefined {
|
|
name: None,
|
|
params: params.iter().map(|param| param.0.clone()).collect(),
|
|
body: reduce_block(body, symbol_table),
|
|
})
|
|
}
|
|
|
|
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),
|
|
Discriminator::BinOp(ref _expr, ref _binop) => panic!("Can't yet handle binop discriminators")
|
|
});
|
|
match *body {
|
|
IfExpressionBody::SimpleConditional(ref then_clause, ref else_clause) => {
|
|
let then_clause = reduce_block(then_clause, symbol_table);
|
|
let else_clause = match else_clause {
|
|
None => vec![],
|
|
Some(stmts) => reduce_block(stmts, symbol_table),
|
|
};
|
|
Expr::Conditional { cond, then_clause, else_clause }
|
|
},
|
|
IfExpressionBody::SimplePatternMatch(ref pat, ref then_clause, ref else_clause) => {
|
|
let then_clause = reduce_block(then_clause, symbol_table);
|
|
let else_clause = match else_clause {
|
|
None => vec![],
|
|
Some(stmts) => reduce_block(stmts, symbol_table),
|
|
};
|
|
|
|
let alternatives = vec![
|
|
pat.to_alternative(then_clause, symbol_table),
|
|
Alternative {
|
|
tag: None,
|
|
subpatterns: vec![],
|
|
bound_vars: vec![],
|
|
guard: None,
|
|
item: else_clause
|
|
},
|
|
];
|
|
|
|
Expr::CaseMatch {
|
|
cond,
|
|
alternatives,
|
|
}
|
|
},
|
|
IfExpressionBody::GuardList(ref guard_arms) => {
|
|
let mut alternatives = vec![];
|
|
for arm in guard_arms {
|
|
match arm.guard {
|
|
Guard::Pat(ref p) => {
|
|
let item = reduce_block(&arm.body, symbol_table);
|
|
let alt = p.to_alternative(item, symbol_table);
|
|
alternatives.push(alt);
|
|
},
|
|
Guard::HalfExpr(HalfExpr { op: _, expr: _ }) => {
|
|
return Expr::UnimplementedSigilValue
|
|
}
|
|
}
|
|
}
|
|
Expr::CaseMatch { cond, alternatives }
|
|
}
|
|
}
|
|
}
|
|
/* ig var pat
|
|
* x is SomeBigOldEnum(_, x, Some(t))
|
|
*/
|
|
|
|
fn handle_symbol(symbol: Option<&Symbol>, inner_patterns: &Vec<Pattern>, symbol_table: &SymbolTable) -> Subpattern {
|
|
use self::Pattern::*;
|
|
let tag = symbol.map(|symbol| match symbol.spec {
|
|
SymbolSpec::DataConstructor { index, .. } => index.clone(),
|
|
_ => panic!("Symbol is not a data constructor - this should've been caught in type-checking"),
|
|
});
|
|
let bound_vars = inner_patterns.iter().map(|p| match p {
|
|
Literal(PatternLiteral::VarPattern(var)) => Some(var.clone()),
|
|
_ => None,
|
|
}).collect();
|
|
|
|
let subpatterns = inner_patterns.iter().map(|p| match p {
|
|
Ignored => None,
|
|
Literal(PatternLiteral::VarPattern(_)) => None,
|
|
Literal(other) => Some(other.to_subpattern(symbol_table)),
|
|
tp @ TuplePattern(_) => Some(tp.to_subpattern(symbol_table)),
|
|
ts @ TupleStruct(_, _) => Some(ts.to_subpattern(symbol_table)),
|
|
Record(..) => unimplemented!(),
|
|
}).collect();
|
|
|
|
let guard = None;
|
|
/*
|
|
let guard_equality_exprs: Vec<Expr> = subpatterns.iter().map(|p| match p {
|
|
Literal(lit) => match lit {
|
|
_ => unimplemented!()
|
|
},
|
|
_ => unimplemented!()
|
|
}).collect();
|
|
*/
|
|
|
|
Subpattern {
|
|
tag,
|
|
subpatterns,
|
|
guard,
|
|
bound_vars,
|
|
}
|
|
}
|
|
|
|
impl Pattern {
|
|
fn to_alternative(&self, item: Vec<Stmt>, symbol_table: &SymbolTable) -> Alternative {
|
|
let s = self.to_subpattern(symbol_table);
|
|
Alternative {
|
|
tag: s.tag,
|
|
subpatterns: s.subpatterns,
|
|
bound_vars: s.bound_vars,
|
|
guard: s.guard,
|
|
item
|
|
}
|
|
}
|
|
|
|
fn to_subpattern(&self, symbol_table: &SymbolTable) -> Subpattern {
|
|
use self::Pattern::*;
|
|
match self {
|
|
TupleStruct(name, inner_patterns) => {
|
|
let symbol = symbol_table.lookup_by_name(name).expect(&format!("Symbol {} not found", name));
|
|
handle_symbol(Some(symbol), inner_patterns, symbol_table)
|
|
},
|
|
TuplePattern(inner_patterns) => handle_symbol(None, inner_patterns, symbol_table),
|
|
Record(_name, _pairs) => {
|
|
unimplemented!()
|
|
},
|
|
Ignored => Subpattern { tag: None, subpatterns: vec![], guard: None, bound_vars: vec![] },
|
|
Literal(lit) => lit.to_subpattern(symbol_table),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PatternLiteral {
|
|
fn to_subpattern(&self, symbol_table: &SymbolTable) -> Subpattern {
|
|
use self::PatternLiteral::*;
|
|
match self {
|
|
NumPattern { neg, num } => {
|
|
let comparison = Expr::Lit(match (neg, num) {
|
|
(false, ExpressionKind::NatLiteral(n)) => Lit::Nat(*n),
|
|
(false, ExpressionKind::FloatLiteral(f)) => Lit::Float(*f),
|
|
(true, ExpressionKind::NatLiteral(n)) => Lit::Int(-1*(*n as i64)),
|
|
(true, ExpressionKind::FloatLiteral(f)) => Lit::Float(-1.0*f),
|
|
_ => panic!("This should never happen")
|
|
});
|
|
let guard = Some(Expr::Call {
|
|
f: Box::new(Expr::Func(Func::BuiltIn(Rc::new("==".to_string())))),
|
|
args: vec![comparison, Expr::ConditionalTargetSigilValue],
|
|
});
|
|
Subpattern {
|
|
tag: None,
|
|
subpatterns: vec![],
|
|
guard,
|
|
bound_vars: vec![],
|
|
}
|
|
},
|
|
StringPattern(s) => {
|
|
let guard = Some(Expr::Call {
|
|
f: Box::new(Expr::Func(Func::BuiltIn(Rc::new("==".to_string())))),
|
|
args: vec![Expr::Lit(Lit::StringLit(s.clone())), Expr::ConditionalTargetSigilValue]
|
|
});
|
|
|
|
Subpattern {
|
|
tag: None,
|
|
subpatterns: vec![],
|
|
guard,
|
|
bound_vars: vec![],
|
|
}
|
|
},
|
|
BoolPattern(b) => {
|
|
let guard = Some(if *b {
|
|
Expr::ConditionalTargetSigilValue
|
|
} else {
|
|
Expr::Call {
|
|
f: Box::new(Expr::Func(Func::BuiltIn(Rc::new("!".to_string())))),
|
|
args: vec![Expr::ConditionalTargetSigilValue]
|
|
}
|
|
});
|
|
Subpattern {
|
|
tag: None,
|
|
subpatterns: vec![],
|
|
guard,
|
|
bound_vars: vec![],
|
|
}
|
|
},
|
|
VarPattern(var) => match symbol_table.lookup_by_name(var) {
|
|
Some(symbol) => handle_symbol(Some(symbol), &vec![], symbol_table),
|
|
None => Subpattern {
|
|
tag: None,
|
|
subpatterns: vec![],
|
|
guard: None,
|
|
bound_vars: vec![Some(var.clone())],
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Declaration {
|
|
fn reduce(&self, symbol_table: &SymbolTable) -> Stmt {
|
|
use self::Declaration::*;
|
|
match self {
|
|
Binding {name, constant, expr, .. } => Stmt::Binding { name: name.clone(), constant: *constant, expr: expr.node().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: reduce_block(&statements, symbol_table),
|
|
}
|
|
},
|
|
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<Meta<Expression>>, rhs: &Box<Meta<Expression>>) -> Expr {
|
|
if **self.sigil() == "=" {
|
|
Expr::Assign {
|
|
val: Box::new(lhs.node().reduce(symbol_table)),
|
|
expr: Box::new(rhs.node().reduce(symbol_table)),
|
|
}
|
|
} else {
|
|
let f = Box::new(Expr::Func(Func::BuiltIn(self.sigil().clone())));
|
|
Expr::Call { f, args: vec![lhs.node().reduce(symbol_table), rhs.node().reduce(symbol_table)]}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PrefixOp {
|
|
fn reduce(&self, symbol_table: &SymbolTable, arg: &Box<Meta<Expression>>) -> Expr {
|
|
let f = Box::new(Expr::Func(Func::BuiltIn(self.sigil().clone())));
|
|
Expr::Call { f, args: vec![arg.node().reduce(symbol_table)]}
|
|
}
|
|
}
|