delo 0.1.0

A statically typed, compiled-to-C programming language that can time-travel.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use std::rc::Rc;

use crate::ast::token::Token;
use crate::ast::expr::Expr;
use crate::type_system::types::TypeExpr;

#[derive(Debug, Clone)]
pub enum VariableBinding {
    Identifier(Token),
    Tuple {
        elements: Vec<VariableBinding>,
        left_paren: Token,
    },
}

impl VariableBinding {
    pub fn first_token(&self) -> &Token {
        match self {
            VariableBinding::Identifier(token) => token,
            VariableBinding::Tuple { left_paren, .. } => left_paren,
        }
    }
}

#[derive(Debug, Clone)]
pub enum Stmt {
    Variable {
        binding: VariableBinding,
        type_annotation: Option<TypeExpr>,
        initializer: Option<Expr>
    },
    Enum {
        identifier: Token,
        type_parameters: Vec<Token>,
        variants: Vec<EnumVariant>,
    },
    Struct {
        identifier: Token,
        type_parameters: Vec<Token>,
        fields: Vec<(Token, TypeExpr)>,
    },
    If {
        if_token: Token,
        condition: Expr,
        then_branch: Box<Stmt>,
        else_branch: Option<Box<Stmt>>,
    },
    While {
        while_token: Token,
        condition: Expr,
        body: Box<Stmt>,
    },
    ForIn {
        binding: VariableBinding,
        iterable: Expr,
        body: Box<Stmt>,
    },
    Function(Rc<FunctionStmt>),
    Block(Vec<Stmt>),
    Expression(Expr),
    Break(Token),
    Continue(Token),
}

#[derive(Debug, Clone)]
pub struct FunctionStmt {
    pub identifier: Token,
    pub type_parameters: Vec<Token>,
    pub parameters: Vec<(Token, TypeExpr)>,
    pub return_type: Option<TypeExpr>,
    pub body: Vec<Stmt>,
}

#[derive(Debug, Clone)]
pub struct EnumVariant {
    pub identifier: Token,
    pub payload_types: Vec<TypeExpr>,
}